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
