robossembler/servo
7
0
Fork 0
Code Issues 27 Pull requests 2 Projects 1 Releases 1 Packages Wiki Activity Actions

Возможна загрузка прошивки, но не переходит в неё

Browse source
This commit is contained in:
lulko 2025-03-19 18:56:00 +03:00
parent 1de6c1bda1
commit 4b543e78ce
3 changed files with 160 additions and 102 deletions
Download patch file Download diff file Expand all files Collapse all files

13
controller/fw/embed/bootloader/flash.h
View file

@ -13,6 +13,8 @@ enum {
addr_id = 0 addr_id = 0
}; };
#define FLASH_RECORD_SIZE sizeof(FLASH_RECORD) //size flash struct #define FLASH_RECORD_SIZE sizeof(FLASH_RECORD) //size flash struct
#define PARAM_COUNT 1 // count data in flash #define PARAM_COUNT 1 // count data in flash
@ -20,10 +22,11 @@ enum {
#define FLAG_BOOT 0x08060000 // Адрес хранения флага для обновления прошивки #define FLAG_BOOT 0x08060000 // Адрес хранения флага для обновления прошивки
#define UPDATE_FLAG 0xDEADBEEF // Уникальное 32-битное значение #define UPDATE_FLAG 0xDEADBEEF // Уникальное 32-битное значение
#define APP_ADDRESS 0x08004000 // Адрес основной прошивки #define APP_ADDRESS 0x08008000 // Адрес основной прошивки
#define BOOT_CAN_ID 0x721 // CAN ID бутлоадера #define BOOT_CAN_ID 0x71 // CAN ID бутлоадера
#define BOOT_CAN_END 0x722 // CAN ID завершения передачи #define BOOT_CAN_END 0x72 // CAN ID завершения передачи
#define DATA_CAN_ID 0x730 // CAN ID данных #define DATA_CAN_ID 0x73 // CAN ID данных
#define ACK_CAN_ID 0x75 // CAN ID подтверждения
#define MAX_FW_SIZE 0x3FFF // Макс. размер прошивки (256KB) #define MAX_FW_SIZE 0x3FFF // Макс. размер прошивки (256KB)
@ -37,7 +40,7 @@ enum {
#define SECTOR_6 0x08040000 // 128KB #define SECTOR_6 0x08040000 // 128KB
#define SECTOR_6_END (SECTOR_6 + 128 * 1024) // sector 6 end #define SECTOR_6_END (SECTOR_6 + 128 * 1024) // sector 6 end
#define SECTOR_7 0x08060000
// Flash keys for unlocking flash memory // Flash keys for unlocking flash memory

74
controller/fw/embed/bootloader/main.cpp
View file

@ -5,11 +5,13 @@
STM32_CAN Can(CAN2, DEF); STM32_CAN Can(CAN2, DEF);
volatile bool fw_update = false; volatile bool fw_update = false;
volatile uint32_t fw_size = 0; volatile uint32_t fw_size = 0;
volatile uint32_t fw_crc = 0; volatile uint32_t fw_crc = 0;
volatile uint32_t write_ptr = APP_ADDRESS;
static FLASH_RECORD flash_record = {0}; static FLASH_RECORD flash_record = {0};
static uint32_t ptr_flash;
// Прототипы функций // Прототипы функций
void jump_to_app(); void jump_to_app();
void process_can_message(const CAN_message_t &msg); void process_can_message(const CAN_message_t &msg);
@ -20,10 +22,18 @@ void send_ack(uint8_t status);
void setup() { void setup() {
// Инициализация периферии // Инициализация периферии
Serial.setRx(HARDWARE_SERIAL_RX_PIN);
Serial.setTx(HARDWARE_SERIAL_TX_PIN);
Serial.begin(115200); Serial.begin(115200);
Can.begin(1000000); // 1 Mbps Can.begin();
Can.setFilter(0,BOOT_CAN_ID,STD); Can.setBaudRate(1000000);
TIM_TypeDef *Instance = TIM2;
HardwareTimer *SendTimer = new HardwareTimer(Instance);
SendTimer->setOverflow(100, HERTZ_FORMAT); // 50 Hz
// SendTimer->attachInterrupt(process_can_message);
SendTimer->resume();
// Разрешить все ID (маска 0x00000000)
Can.setFilter(0, 0, STD);
// Настройка GPIO // Настройка GPIO
RCC->AHB1ENR |= RCC_AHB1ENR_GPIOCEN; RCC->AHB1ENR |= RCC_AHB1ENR_GPIOCEN;
@ -31,17 +41,18 @@ void setup() {
GPIOC->ODR |= GPIO_ODR_OD11; GPIOC->ODR |= GPIO_ODR_OD11;
// Проверка флага обновления // Проверка флага обновления
/*erase_sector(6); /* erase_sector(6);
flash_program_word(FLAG_BOOT,0xDEADBEEF,0); flash_program_word(FLAG_BOOT,0xDEADBEEF,0);
flash_record.data_id = addr_id; flash_record.data_id = addr_id;
flash_record.crc = 0x6933; flash_record.crc = 0x6933;
flash_record.value = 0x69; flash_record.value = 0x69;
flash_record.write_ptr_now = SECTOR_6;*/ flash_record.write_ptr_now = SECTOR_6;
flash_write(SECTOR_6, &flash_record); flash_write(SECTOR_6, &flash_record);*/
flash_record = load_params(); flash_record = load_params();
/* Добавить проверку адреса, т.е во время отправки запроса прошивки по CAN /* Добавить проверку адреса, т.е во время отправки запроса прошивки по CAN
мы сохраняем как флаг, так и аддрес устройства к которому будет обращатлься во мы сохраняем как флаг, так и аддрес устройства к которому будет обращатлься во
время прошивки */ время прошивки */
if(*(volatile uint32_t*)(FLAG_BOOT) == UPDATE_FLAG) { if(*(volatile uint32_t*)(FLAG_BOOT) == UPDATE_FLAG) {
fw_update = true; fw_update = true;
GPIOC->ODR |= GPIO_ODR_OD10; // Индикация обновления GPIOC->ODR |= GPIO_ODR_OD10; // Индикация обновления
@ -54,11 +65,14 @@ void setup() {
void loop() { void loop() {
if(fw_update) { if(fw_update) {
GPIOC->ODR ^= GPIO_ODR_OD10;
HAL_Delay(100);
CAN_message_t msg; CAN_message_t msg;
if(Can.read(msg)) { while(Can.read(msg)) {
process_can_message(msg); process_can_message(msg);
} }
} }
} }
void process_can_message(const CAN_message_t &msg) { void process_can_message(const CAN_message_t &msg) {
@ -66,16 +80,16 @@ void process_can_message(const CAN_message_t &msg) {
case BOOT_CAN_ID: case BOOT_CAN_ID:
if(msg.buf[0] == 0x01) { // Старт передачи if(msg.buf[0] == 0x01) { // Старт передачи
fw_size = *(uint32_t*)&msg.buf[1]; //размер прошивки тип 4 байта fw_size = *(uint32_t*)&msg.buf[1]; //размер прошивки тип 4 байта
fw_crc = *(uint32_t*)&msg.buf[5]; //crc fw_crc = *(uint16_t*)&msg.buf[5]; //crc
write_ptr = APP_ADDRESS; ptr_flash = APP_ADDRESS;
send_ack(0x01); send_ack(0x01);
} }
break; break;
case DATA_CAN_ID: // Пакет данных case DATA_CAN_ID: // Пакет данных
if(write_ptr < (APP_ADDRESS + fw_size)) { if(ptr_flash < (APP_ADDRESS + fw_size)) {
write_flash_page((const uint8_t*)msg.buf, msg.len); write_flash_page((const uint8_t*)msg.buf, msg.len);
write_ptr += msg.len; ptr_flash += msg.len;
send_ack(0x02); send_ack(0x02);
} }
break; break;
@ -86,26 +100,32 @@ void process_can_message(const CAN_message_t &msg) {
send_ack(0xAA); send_ack(0xAA);
NVIC_SystemReset(); NVIC_SystemReset();
} else { } else {
erase_sector(7); // Сброс флага
send_ack(0x55); send_ack(0x55);
NVIC_SystemReset();
} }
break; break;
} }
} }
void jump_to_app() { void jump_to_app() {
volatile uint32_t* addr;
uint32_t appjump_addr;
typedef void (*app_entry_t)(void); typedef void (*app_entry_t)(void);
auto app_entry = (app_entry_t)(*(volatile uint32_t*)(APP_ADDRESS + 4)); addr = (__IO uint32_t*)APP_ADDRESS;
appjump_addr = (uint32_t)addr;
app_entry_t app_entry = (app_entry_t)appjump_addr;
// SCB->VTOR = APP_ADDRESS; // SCB->VTOR = APP_ADDRESS;
__set_MSP(*(volatile uint32_t*)APP_ADDRESS); __set_MSP(appjump_addr);
app_entry(); app_entry();
} }
void erase_flash_pages() { void erase_flash_pages() {
FLASH_EraseInitTypeDef erase; FLASH_EraseInitTypeDef erase;
erase.TypeErase = FLASH_TYPEERASE_SECTORS; erase.TypeErase = FLASH_TYPEERASE_SECTORS;
erase.Sector = FLASH_SECTOR_1; erase.Sector = FLASH_SECTOR_2;
erase.NbSectors = 5; erase.NbSectors = 4;
erase.VoltageRange = FLASH_VOLTAGE_RANGE_3; erase.VoltageRange = FLASH_VOLTAGE_RANGE_3;
uint32_t error; uint32_t error;
@ -117,30 +137,38 @@ void erase_flash_pages() {
// CRC16 implementation for STM32 // CRC16 implementation for STM32
uint16_t CalculateCRC16(const uint8_t* data, uint32_t length) { uint16_t CalculateCRC16(const uint8_t* data, uint32_t length) {
uint16_t crc = 0xFFFF; uint16_t crc = 0xFFFF; // Начальное значение
while (length--) { while (length--) {
crc ^= (uint16_t)(*data++) << 8; crc ^= *data++; // Обрабатываем LSB первым
for(uint8_t i = 0; i < 8; i++) { for (uint8_t i = 0; i < 8; i++) {
crc = crc & 0x8000 ? (crc << 1) ^ 0x8005 : crc << 1; if (crc & 0x0001) { // Проверяем младший бит
crc = (crc >> 1) ^ 0xA001; // Полином 0x8005 (reverse)
} else {
crc >>= 1;
} }
} }
return crc; }
return crc; // Финальный XOR = 0x0000 (не требуется)
} }
bool verify_firmware() { bool verify_firmware() {
uint32_t calculated_crc = 0; uint32_t calculated_crc = 0;
calculated_crc = CalculateCRC16((uint8_t*)fw_crc,fw_size); calculated_crc = CalculateCRC16((uint8_t*)APP_ADDRESS,fw_size);
if(calculated_crc != (uint16_t)fw_crc) if(calculated_crc != (uint16_t)fw_crc)
return false; return false;
// Реализация проверки CRC // Реализация проверки CRC
// ... // ...
// return (calculated_crc == fw_crc); // return (calculated_crc == fw_crc);
else
return true; return true;
} }
void send_ack(uint8_t status) { void send_ack(uint8_t status) {
CAN_message_t ack; CAN_message_t ack;
ack.id = BOOT_CAN_ID + 2; ack.id = ACK_CAN_ID;
ack.len = 1; ack.len = 1;
ack.buf[0] = status; ack.buf[0] = status;
Can.write(ack); Can.write(ack);
} }

107
controller/fw/embed/test/python_test_boot.py
View file

@ -2,94 +2,119 @@ import can
import time import time
from intelhex import IntelHex from intelhex import IntelHex
from crc import Calculator, Crc16 from crc import Calculator, Crc16
# Конфигурация
# Конфигурация CAN
CAN_CHANNEL = 'socketcan' CAN_CHANNEL = 'socketcan'
CAN_INTERFACE = 'can0' CAN_INTERFACE = 'can0'
CAN_BITRATE = 1000000 CAN_BITRATE = 1000000
# Параметры из заголовочного файла BOOT_CAN_ID = 0x71
BOOT_CAN_ID = 0x721 DATA_CAN_ID = 0x73
DATA_CAN_ID = 0x730 BOOT_CAN_END = 0x72
BOOT_CAN_END = 0x722 ACK_CAN_ID = 0x75
ACK_CAN_ID = 0x723
# Конфигурация CRC16 #конфиг для crc16 ibm
CRC16_POLYNOMIAL = 0x8005 # Стандартный полином CRC-16-IBM
CRC16_INIT = 0xFFFF
def debug_print(msg):
print(f"[DEBUG] {msg}")
def send_firmware(hex_file): def send_firmware(hex_file):
bus = can.interface.Bus(channel='can0', try:
bustype='socketcan') debug_print("Инициализация CAN...")
# Чтение и преобразование HEX-файла bus = can.interface.Bus(
channel=CAN_INTERFACE,
bustype=CAN_CHANNEL,
bitrate=CAN_BITRATE
)
debug_print("Чтение HEX-файла...")
ih = IntelHex(hex_file) ih = IntelHex(hex_file)
binary_data = ih.tobinarray() binary_data = ih.tobinstr() # Исправлено на tobinstr()
fw_size = len(binary_data) fw_size = len(binary_data)
debug_print(f"Размер прошивки: {fw_size} байт")
# Расчет CRC16 # Расчет CRC
# calculator = Calculator(Crc16.CCITT, optimize=True) debug_print("Расчёт CRC...")
fw_crc = 0x6933 calculator = Calculator(Crc16.IBM)
fw_crc = calculator.checksum(binary_data)
debug_print(f"CRC: 0x{fw_crc:04X}")
# Отправка команды START # Отправка START
start_data = bytearray([0x01]) start_data = bytearray([0x01])
start_data += fw_size.to_bytes(4, 'little') start_data += fw_size.to_bytes(4, 'little')
start_data += fw_crc.to_bytes(2, 'little') # 2 байта для CRC16 start_data += fw_crc.to_bytes(2, 'little')
debug_print(f"START: {list(start_data)}")
start_msg = can.Message( start_msg = can.Message(
arbitration_id=BOOT_CAN_ID, arbitration_id=BOOT_CAN_ID,
data=start_data, data=bytes(start_data),
is_extended_id=False is_extended_id=False
) )
try:
bus.send(start_msg) bus.send(start_msg)
except can.CanError as e:
# Ожидание подтверждения debug_print(f"Ошибка отправки START: {str(e)}")
ack = wait_for_ack(bus)
if not ack or ack.data[0] != 0x01:
print("Ошибка инициализации!")
bus.shutdown()
return return
# Ожидание ACK
debug_print("Ожидание ACK...")
ack = wait_for_ack(bus)
if not ack:
debug_print("Таймаут ACK START")
return
debug_print(f"Получен ACK: {list(ack.data)}")
# Отправка данных # Отправка данных
packet_size = 8 packet_size = 8
for i in range(0, len(binary_data), packet_size): for i in range(0, len(binary_data), packet_size):
chunk = binary_data[i:i+packet_size] chunk = binary_data[i:i+packet_size]
chunk += b'\x00' * (8 - len(chunk)) # Дополнение до 8 байт
if len(chunk) < 8:
chunk += b'\xFF' * (8 - len(chunk))
debug_print(f"Пакет {i//8}: {list(chunk)}")
data_msg = can.Message( data_msg = can.Message(
arbitration_id=DATA_CAN_ID, arbitration_id=DATA_CAN_ID,
data=chunk, data=chunk,
is_extended_id=False is_extended_id=False
) )
try:
bus.send(data_msg) bus.send(data_msg)
except can.CanError as e:
debug_print(f"Ошибка отправки данных: {str(e)}")
return
ack = wait_for_ack(bus) ack = wait_for_ack(bus)
if not ack or ack.data[0] != 0x02: if not ack:
print("Ошибка передачи данных!") debug_print("Таймаут ACK DATA")
break return
progress = (i + len(chunk)) / fw_size * 100 # Финал
print(f"\rПрогресс: {progress:.1f}%", end='') debug_print("Отправка FINISH...")
# Завершение передачи
finish_msg = can.Message( finish_msg = can.Message(
arbitration_id=BOOT_CAN_END, arbitration_id=BOOT_CAN_END,
data=[0xAA], data=bytes([0xAA]),
is_extended_id=False is_extended_id=False
) )
bus.send(finish_msg) bus.send(finish_msg)
ack = wait_for_ack(bus, timeout=5) ack = wait_for_ack(bus, timeout=5)
if ack and ack.data[0] == 0xAA: if ack == 0xAA:
print("\nПрошивка успешно загружена!") debug_print("Прошивка подтверждена!")
else: else:
print("\nОшибка верификации!") debug_print("Ошибка верификации!")
except Exception as e:
debug_print(f"Критическая ошибка: {str(e)}")
finally:
bus.shutdown() bus.shutdown()
def wait_for_ack(bus, timeout=1.0): def wait_for_ack(bus, timeout=1.0):
start_time = time.time() start_time = time.time()
while time.time() - start_time < timeout: while time.time() - start_time < timeout:
msg = bus.recv(timeout=0.1) msg = bus.recv(timeout=0) # Неблокирующий режим
if msg and msg.arbitration_id == ACK_CAN_ID: if msg and msg.arbitration_id == ACK_CAN_ID:
return msg return msg
return None return None
@ -97,5 +122,7 @@ def wait_for_ack(bus, timeout=1.0):
if __name__ == "__main__": if __name__ == "__main__":
import sys import sys
if len(sys.argv) != 2: if len(sys.argv) != 2:
print("Использование: python can_flasher.py firmware.hex") print("Использование: sudo python3 can_flasher.py firmware.hex")
sys.exit(1) sys.exit(1)
send_firmware(sys.argv[1])