213 lines
8.8 KiB
Python
213 lines
8.8 KiB
Python
import serial
|
||
import time
|
||
import argparse
|
||
from sys import exit
|
||
|
||
TIMEOUT_DEFAULT = 0.1 # sec
|
||
ACK = 0x0F # МК подтвердил 0b00001111
|
||
NACK = 0xF0 # МК отверг 0b11110000
|
||
COMMAND_PACKAGE_SIZE = b'\x30' # Команда размера пакета
|
||
COMMAND_SEND_PACKAGE = b'\x60' # Команда отправить пакет
|
||
COMMAND_FULL_ERASE = 0xBADC0FEE # Команда очистить чип
|
||
|
||
|
||
def cmd_full_erase():
|
||
ser.write(COMMAND_FULL_ERASE.to_bytes(4, "big"))
|
||
read_byte = ser.read(1) # Прочесть подтверждение получения команды
|
||
if int.from_bytes(read_byte, "big") == NACK:
|
||
print("NACK. COMMAND_FULL_ERASE")
|
||
exit()
|
||
ser.timeout = None # Выключить таймаут, чтобы дождаться завершения процесса стирания чипа
|
||
read_byte = ser.read(1) # Прочесть байт ACK/NACK от контроллера
|
||
ser.timeout = TIMEOUT_DEFAULT # Включить таймаут обратно
|
||
|
||
if int.from_bytes(read_byte, "big") == NACK:
|
||
print("NACK. FULL_ERASE FAILED")
|
||
exit()
|
||
|
||
# Задать размер пакета
|
||
def cmd_package_size(package_size):
|
||
ser.write(COMMAND_PACKAGE_SIZE) # Отправить команду размера передаваемого пакета
|
||
read_byte = ser.read(1) # Прочесть байт ACK/NACK от контроллера
|
||
if int.from_bytes(read_byte, "big") == NACK:
|
||
print("NACK. COMMAND_PACKAGE_SIZE")
|
||
exit()
|
||
ser.write((package_size - 1).to_bytes(1, "big")) # Если контроллер ответил на команду, послать количество передаваемых байт
|
||
read_byte = ser.read(1) # Прочесть байт ACK/NACK
|
||
if int.from_bytes(read_byte, "big") == NACK:
|
||
print("NACK. COMMAND_PACKAGE_SIZE")
|
||
exit()
|
||
return read_byte == b'\x0f'
|
||
|
||
# Отправить пакет
|
||
def cmd_send_package(data_package):
|
||
# Команда загрузить пакет
|
||
ser.write(COMMAND_SEND_PACKAGE)
|
||
read_byte = ser.read(1) # Прочесть байт ACK/NACK
|
||
if int.from_bytes(read_byte, "big") == NACK:
|
||
print("NACK. COMMAND_SEND_PACKAGE")
|
||
exit()
|
||
# Отправка пакета
|
||
ser.write(bytes(data_package)) # Если контроллер ответил на команду, послать пакет
|
||
read_byte = ser.read(1) # Прочесть байт ACK/NACK
|
||
if int.from_bytes(read_byte, "big") == NACK:
|
||
print("NACK. SEND_PACKAGE")
|
||
exit()
|
||
|
||
def printProgressBar (iteration, total, prefix = '', suffix = '', decimals = 1, length = 100, fill = '_', printEnd = "\r"):
|
||
percent = ("{0:." + str(decimals) + "f}").format(100 * (iteration / float(total)))
|
||
filledLength = int(length * iteration // total)
|
||
bar = fill * filledLength + '-' * (length - filledLength)
|
||
print(f'\r{prefix} |{bar}| {percent}% {suffix}', end = printEnd)
|
||
if iteration == total:
|
||
print()
|
||
|
||
DEFAULT_BAUDRATE = 230400
|
||
|
||
def createParser():
|
||
parser = argparse.ArgumentParser(
|
||
prog='bootloader.py',
|
||
description='''Script for writing to external flash on SPIFI interface'''
|
||
)
|
||
|
||
parser.add_argument(
|
||
'hexpath',
|
||
default=None,
|
||
nargs='?',
|
||
help='Path to hex file'
|
||
)
|
||
parser.add_argument(
|
||
'--mappath',
|
||
dest='mappath',
|
||
default=None, #'firmware.map',
|
||
help=f"Path to map-file. None by default. If specified, the script filters unused memory from hex."
|
||
)
|
||
parser.add_argument(
|
||
'--no-cache-section-name',
|
||
dest='ncsn',
|
||
default='no-cache',
|
||
help=f"Name of non-cachable memory section in spifi. 'no-cache' by default. If specified, the script filters unused memory from hex."
|
||
)
|
||
parser.add_argument(
|
||
'--com',
|
||
dest='com',
|
||
default=None,
|
||
help=f"COM name. None by default."
|
||
)
|
||
parser.add_argument(
|
||
'--baudrate',
|
||
dest='baudrate',
|
||
default=DEFAULT_BAUDRATE,
|
||
help=f"COM speed. By default: {DEFAULT_BAUDRATE}"
|
||
)
|
||
|
||
parser.add_argument(
|
||
'--full-erase',
|
||
dest='fullerase',
|
||
action='store_true',
|
||
default=False
|
||
)
|
||
return parser
|
||
|
||
parser = createParser()
|
||
namespace = parser.parse_args()
|
||
|
||
REC_TYPE_DATA = 0
|
||
REC_TYPE_EXT_LIN_ADDR = 4
|
||
|
||
if namespace.hexpath:
|
||
# читаем хекс
|
||
with open(f"{namespace.hexpath}", "r", encoding='utf-8') as f:
|
||
hex_lines = f.readlines()
|
||
|
||
# убираем двоеточие в начале каждой сроки и \n в конце
|
||
for i in range(0, len(hex_lines)):
|
||
hex_lines[i] = hex_lines[i][1:-1]
|
||
|
||
# лежат те же данные, что и в lines, но не в виде строки, а в виде интов
|
||
data_lines = []
|
||
for line in hex_lines:
|
||
data = []
|
||
# разбиваем строки по 2 символа - 1 байт
|
||
for i in range(0,len(line), 2):
|
||
data.append(int(line[i:i+2], 16))
|
||
data_lines.append(data)
|
||
|
||
# убираем из отправки неиспользуемое место, которое сделал *fill*
|
||
if namespace.mappath and namespace.ncsn:
|
||
with open(f"{namespace.mappath}", "r", encoding='utf-8') as f:
|
||
map_lines = f.readlines()
|
||
|
||
# находим строку, где впервые упоминается некешируемая область
|
||
for i in range(0, len(map_lines)):
|
||
if namespace.ncsn in map_lines[i]:
|
||
no_cache_line_idx = i
|
||
break
|
||
|
||
# от нее поднимаемся выше, пока не наткнемся на *fill*
|
||
for i in range(no_cache_line_idx, 0, -1):
|
||
if '*fill*' in map_lines[i]:
|
||
fill_cmd_str = map_lines[i]
|
||
fill_cmd_str = fill_cmd_str.split()
|
||
fill_start_addr = int(fill_cmd_str[1], base=16)
|
||
fill_size = int(fill_cmd_str[2], base=16)
|
||
# рассчитываем начальный и конечный адреса, которые можно удалить
|
||
filter_start_addr = (fill_start_addr//16 + 1) * 16
|
||
diff = filter_start_addr - fill_start_addr
|
||
filter_stop_addr = filter_start_addr + fill_size - diff - 0x10
|
||
break
|
||
|
||
# опять пербираем все строки в data_lines и удаляем те, у которых адреса попали между началом и концом филла
|
||
i = 0
|
||
while i < len(data_lines):
|
||
if data_lines[i][3] == REC_TYPE_EXT_LIN_ADDR:
|
||
ext_lin_addr = (data_lines[i][4] << 24) + (data_lines[i][5] << 16)
|
||
if data_lines[i][3] == REC_TYPE_DATA:
|
||
addr = ext_lin_addr + (data_lines[i][1] << 8) + data_lines[i][2]
|
||
if addr >= filter_start_addr and addr <= filter_stop_addr:
|
||
data_lines.remove(data_lines[i])
|
||
i -= 1 # текущая строчка удалилась, следующая будет с тем же индексом
|
||
i += 1
|
||
|
||
ser = serial.Serial(port = namespace.com, baudrate = namespace.baudrate, timeout = TIMEOUT_DEFAULT)
|
||
|
||
ping = False
|
||
for i in range(10): # вместо задержки забрасываем запросами
|
||
ping = cmd_package_size(15)
|
||
if ping:
|
||
break
|
||
|
||
if ping:
|
||
print("Device connected")
|
||
else:
|
||
print("Device not responding")
|
||
exit()
|
||
|
||
if namespace.fullerase:
|
||
print('Erasing memory')
|
||
cmd_full_erase()
|
||
print('Erasing done')
|
||
|
||
# перебираем все строчки в прочитанном файле и отправляем
|
||
timestart = time.time()
|
||
resolution = 1 # секунды - период выплевывани инфы о прогрессе в терминал
|
||
all_showed = False
|
||
for line in data_lines:
|
||
cmd_package_size(len(line))
|
||
cmd_send_package(bytes(line))
|
||
|
||
progress = (data_lines.index(line) + 1) / len(data_lines) * 100
|
||
# printProgressBar(progress, 100, prefix = 'Upload:', suffix = 'Complete', length = 50)
|
||
if time.time() > timestart + resolution:
|
||
timestart += resolution
|
||
print(f'Uploaded {int(progress)}%')
|
||
if progress == 100:
|
||
all_showed = True
|
||
|
||
if all_showed ==False:
|
||
print(f'Uploaded 100%')
|
||
print("Uploaded successfully.")
|
||
else:
|
||
print("Nothing to upload.")
|
||
|