def execute(self, capability, *args, **kwargs):
"""Flash a firmware image to a device using pyOCD.
In this implementation we don't seem to care what the capability name is.
Args:
capability: Capability name.
args: Additional arguments.
kwargs: Additional arguments.
Returns:
True if flashing succeeded, otherwise False.
"""
if not PYOCD_PRESENT:
self.print_plugin_error(
'The "pyocd" feature is not installed. Please run '
'"pip install mbed-os-tools[pyocd]" to enable the "pyocd" copy plugin.'
)
return False
if not self.check_parameters(capability, *args, **kwargs):
return False
if not kwargs["image_path"]:
self.print_plugin_error("Error: image path not specified")
return False
if not kwargs["target_id"]:
self.print_plugin_error("Error: Target ID")
return False
target_id = kwargs["target_id"]
image_path = os.path.normpath(kwargs["image_path"])
with ConnectHelper.session_with_chosen_probe(
unique_id=target_id, resume_on_disconnect=False
) as session:
# Performance hack!
# Eventually pyOCD will know default clock speed
# per target
test_clock = 10000000
target_type = session.board.target_type
if target_type == "nrf51":
# Override clock since 10MHz is too fast
test_clock = 1000000
if target_type == "ncs36510":
# Override clock since 10MHz is too fast
test_clock = 1000000
# Configure link
session.probe.set_clock(test_clock)
# Program the file
programmer = FileProgrammer(session)
programmer.program(image_path, format=kwargs["format"])
return True
def execute(self, capability, *args, **kwargs):
"""! Executes capability by name
@param capability Capability name
@param args Additional arguments
@param kwargs Additional arguments
@return Capability call return value
"""
if not PYOCD_PRESENT:
self.print_plugin_error(
'The "pyocd" feature is not installed. Please run '
'"pip install mbed-os-tools[pyocd]" to enable the "pyocd" copy plugin.'
)
return False
if not self.check_parameters(capability, *args, **kwargs):
return False
if not kwargs['image_path']:
self.print_plugin_error("Error: image path not specified")
return False
if not kwargs['target_id']:
self.print_plugin_error("Error: Target ID")
return False
target_id = kwargs['target_id']
image_path = os.path.normpath(kwargs['image_path'])
with ConnectHelper.session_with_chosen_probe(unique_id=target_id, resume_on_disconnect=False) as session:
# Performance hack!
# Eventually pyOCD will know default clock speed
# per target
test_clock = 10000000
target_type = session.board.target_type
if target_type == "nrf51":
# Override clock since 10MHz is too fast
test_clock = 1000000
if target_type == "ncs36510":
# Override clock since 10MHz is too fast
test_clock = 1000000
# Configure link
session.probe.set_clock(test_clock)
# Program the file
programmer = FileProgrammer(session)
programmer.program(image_path, format=kwargs['format'])
return True
def program(self, filename, file_format=None, address=None):
"""
Programs a file into flash.
:param filename: Path to a file.
:param file_format: File format. Default is to use the file's
extension.
:param address: Base address used for the address where to
flash a binary.
:return: True if programmed successfully, otherwise False.
"""
if self.session is None:
raise ValueError('Debug session is not initialized.')
programmer = FileProgrammer(self.session, chip_erase='sector')
logger.debug(f'program {filename}')
programmer.program(filename,
base_address=address,
file_format=file_format)
def flash_loader_test(board_id):
with ConnectHelper.session_with_chosen_probe(unique_id=board_id, **get_session_options()) as session:
board = session.board
target = session.target
target_type = board.target_type
test_params = get_target_test_params(session)
session.probe.set_clock(test_params['test_clock'])
memory_map = board.target.get_memory_map()
boot_region = memory_map.get_boot_memory()
print(boot_region)
boot_start_addr = boot_region.start
boot_end_addr = boot_region.end
boot_blocksize = boot_region.blocksize
num_test_sectors = min(2, boot_region.length // boot_blocksize)
binary_file = os.path.join(parentdir, 'binaries', board.test_binary)
# Generate an Intel hex file from the binary test file.
temp_test_hex_name = binary_to_hex_file(binary_file, boot_region.start)
test_pass_count = 0
test_count = 0
result = FlashLoaderTestResult()
with open(binary_file, "rb") as f:
data = list(bytearray(f.read()))
data_length = len(data)
print("\n------ Test Basic Load ------")
loader = FlashLoader(session, chip_erase="sector")
loader.add_data(boot_start_addr, data)
loader.commit()
verify_data = target.read_memory_block8(boot_start_addr, data_length)
if same(verify_data, data):
print("TEST PASSED")
test_pass_count += 1
else:
print("TEST FAILED")
test_count += 1
print("\n------ Test Load Sector Erase ------")
test_data = [0x55] * boot_blocksize
addr = (boot_end_addr + 1) - (boot_blocksize * num_test_sectors)
if addr < (boot_start_addr + data_length):
orig_data_length = addr - boot_start_addr
else:
orig_data_length = data_length
loader = FlashLoader(session, chip_erase="sector")
loader.add_data(addr, test_data)
loader.add_data(addr + boot_blocksize, test_data)
loader.commit()
verify_data = target.read_memory_block8(addr, boot_blocksize * num_test_sectors)
verify_data2 = target.read_memory_block8(boot_start_addr, orig_data_length)
if same(verify_data, test_data * num_test_sectors) and same(verify_data2, data[:orig_data_length]):
print("TEST PASSED")
test_pass_count += 1
else:
print("TEST FAILED")
test_count += 1
print("\n------ Test Basic Sector Erase ------")
addr = (boot_end_addr + 1) - (boot_blocksize * num_test_sectors)
eraser = FlashEraser(session, FlashEraser.Mode.SECTOR)
eraser.erase(["0x%x+0x%x" % (addr, boot_blocksize)])
verify_data = target.read_memory_block8(addr, boot_blocksize)
if target.memory_map.get_region_for_address(addr).is_data_erased(verify_data):
print("TEST PASSED")
test_pass_count += 1
else:
print("TEST FAILED")
test_count += 1
print("\n------ Test Load Chip Erase ------")
loader = FlashLoader(session, chip_erase="chip")
loader.add_data(boot_start_addr, data)
loader.commit()
verify_data = target.read_memory_block8(boot_start_addr, data_length)
if same(verify_data, data):
print("TEST PASSED")
test_pass_count += 1
else:
print("TEST FAILED")
test_count += 1
print("\n------ Test Binary File Load ------")
programmer = FileProgrammer(session)
programmer.program(binary_file, file_format='bin', base_address=boot_start_addr)
verify_data = target.read_memory_block8(boot_start_addr, data_length)
if same(verify_data, data):
print("TEST PASSED")
test_pass_count += 1
else:
print("TEST FAILED")
test_count += 1
print("\n------ Test Intel Hex File Load ------")
programmer = FileProgrammer(session)
programmer.program(temp_test_hex_name, file_format='hex')
verify_data = target.read_memory_block8(boot_start_addr, data_length)
if same(verify_data, data):
print("TEST PASSED")
test_pass_count += 1
else:
print("TEST FAILED")
test_count += 1
print("\n\nTest Summary:")
print("Pass count %i of %i tests" % (test_pass_count, test_count))
if test_pass_count == test_count:
print("FLASH TEST SCRIPT PASSED")
else:
print("FLASH TEST SCRIPT FAILED")
target.reset()
result.passed = test_count == test_pass_count
return result