def unlock(protocol): try: log.info('Disabling readout protection') protocol.unlock() log.info('Successful') except TimeoutError as e: raise ConnectionError('Disabling error: ' + str(e))
def speed(protocol, bps): try: log.info('Setting speed to %d bps' % (bps, )) protocol.speed(bps) log.info('Command sent') except TimeoutError as e: raise ConnectionError('Writing error: ' + str(e))
def erase(protocol, pages): try: log.info('Erasing memory. Please wait...') protocol.erase(pages) log.info('Successful') except TimeoutError as e: raise ConnectionError('Erasing error: ' + str(e))
def disconnect(protocol): try: log.info('Disconnecting target') protocol.disconnect() log.info('Disconnected') except TimeoutError as e: raise ConnectionError('Disconnecting error: ' + str(e))
def go(protocol, address): try: log.info('Starting application') protocol.go(address) log.info('Successful') except TimeoutError as e: raise ConnectionError('Starting error: ' + str(e))
def write(protocol, address, data): try: log.info('Writing memory at 0x{address:08X}:{size}'.format( address=address, size=len(data))) protocol.write(address, data) log.info('Successful') except TimeoutError as e: raise ConnectionError('Writing error: ' + str(e))
def main(): parser = config_parser() params = parser.parse_args() if params.verbose: canprog.logger.set_level(canprog.logger.logging.DEBUG) if params.interface == 'socketcan': iface = can.interface.Bus(channel=params.name, bustype='socketcan_native') datafile = file.FileManager() protocol_class = protocols.get_protocol_class_by_name(params.protocol) protocol = protocol_class(iface) try: connect(protocol) if params.command == 'go': go(protocol, params.address) elif params.command == 'erase': erase(protocol, params.pages) elif params.command == 'write': if params.erase: erase(protocol, params.pages) datafile.load(params.input, params.format, params.address) for address, data in datafile.get_segments(): write(protocol, address, data) if params.verify: for address, data in datafile.get_segments(): verify(protocol, address, data) if params.go: go(protocol, params.address) elif params.command == 'read': data = read(protocol, params.address, params.size) datafile.set_segment(params.address, data) datafile.save(params.output, params.format) elif params.command == 'lock': lock(protocol) elif params.command == 'unlock': unlock(protocol) elif params.command == 'speed': speed(protocol, params.bps) else: log.info('Nothing to do...') disconnect(protocol) sys.exit(0) except ValueError as e: log.error(e) except ConnectionError as e: log.error(e)
def read(protocol, address, size): try: log.info('Reading memory at 0x{address:08X}:{size}'.format( address=address, size=size)) d = protocol.read(address, size) log.info('Successful') return d except TimeoutError as e: raise ConnectionError('Reading error: ' + str(e))
def _erase(self, pages): if len(pages) == 0: log.info('Mass erasing. Please wait..') self._erase_page(0xFF) else: for p in pages: log.info('Erasing sector {:02X}'.format(p)) self._send_data(CMD_ERASE, (0, )) self._wait_for_ack(CMD_ERASE) self._erase_page(p)
def _write(self, address, data): size = len(data) last_p = -1 for i in range(0, size, 256): p = int(100.0 * i / size) if (last_p == -1) or (p - last_p >= 10): log.info('Progress: {}%'.format(p)) last_p = p self._write_page(address + i, data[i:i + 256]) log.info('Progress: 100%')
def _wait_ack(self, cmd, seconds=30): i = 1 while True: try: self._wait_for_ack(cmd, timeout=1.0) break except TimeoutError as e: log.info('Waiting... {}s'.format(i)) if i >= seconds: raise else: i += 1
def _connect(self): self._init() log.info('Bootloader initialized') self._get_commands() log.info('Bootloader version: {version}'.format( version=self._bootloader_version)) try: self._get_version() log.info('Read protection: {bytes}'.format( bytes=self._read_protection_bytes)) except NotImplementedError as e: pass try: self._get_id() try: name = CHIP_ID[int(self._chip_id, 0)] except KeyError: name = 'Unknown CHIP ID' log.info('Chip ID: {hexid} - {name}'.format(hexid=self._chip_id, name=name)) except NotImplementedError as e: pass
def verify(protocol, address, data): try: log.info('Verifying memory at 0x{address:08X}:{size}'.format( address=address, size=len(data))) data_readed = protocol.read(address, len(data)) if len(data_readed) != len(data): raise ValueError('Size mismatch {} != {}'.format( len(data_readed), len(data))) for (a, b), i in zip(zip(data_readed, data), range(address, address + len(data))): if a != b: raise ValueError( 'Mismatch at 0x{address:08X} 0x{:02X}!=0x{:02X}'.format( a, b, address=i)) log.info('Successful') except TimeoutError as e: raise ConnectionError('Verifying error: ' + str(e)) except ValueError as e: raise ConnectionError('Verifying error: ' + str(e))
def _read(self, address, size): total = size last_p = -1 data = bytearray() while size > 0: p = int(100.0 * (total - size) / total) if (last_p == -1) or (p - last_p >= 10): log.info('Progress: {}%'.format(p)) last_p = p to_read = min(256, size) page = self._read_page(address, to_read) data += page address += to_read size -= to_read log.info('Progress: 100%') return data