TMS_STM_Peripher/UKSVEP_23550.2
14
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Что-то работает, но много чего еще надо сделать

Browse Source
This commit is contained in:
Razvalyaev
2025-09-10 16:53:31 +03:00
parent d82a525a82
commit 05e069441c
16 changed files with 2113 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
Core/Bootloader/boot_can.c Normal file
View File

@@ -0,0 +1,128 @@
#include "boot_can.h"
CAN_HandleTypeDef hcan_boot;
/**
* @brief Инициализация CAN для бутлоадера (по defines)
*/
void MX_BOOT_CAN_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
CAN_FilterTypeDef sFilterConfig;
/* Включаем тактирование */
__RCC_CAN_BOOT_CLK_ENABLE();
__RCC_CAN_PORT_CLK_ENABLE();
/* Настройка пинов RX/TX */
GPIO_InitStruct.Pin = CAN_PIN_RX;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(CAN_PORT, &GPIO_InitStruct);
GPIO_InitStruct.Pin = CAN_PIN_TX;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(CAN_PORT, &GPIO_InitStruct);
/* Настройка CAN */
hcan_boot.Instance = CAN_BOOT;
hcan_boot.Init.Prescaler = CAN_SPEED_PRESCALER;
hcan_boot.Init.Mode = CAN_MODE;
hcan_boot.Init.SyncJumpWidth = CAN_SJW_1TQ;
hcan_boot.Init.TimeSeg1 = CAN_SPEED_BS1;
hcan_boot.Init.TimeSeg2 = CAN_SPEED_BS2;
hcan_boot.Init.TimeTriggeredMode = DISABLE;
hcan_boot.Init.AutoBusOff = DISABLE;
hcan_boot.Init.AutoWakeUp = DISABLE;
hcan_boot.Init.AutoRetransmission = ENABLE;
hcan_boot.Init.ReceiveFifoLocked = DISABLE;
hcan_boot.Init.TransmitFifoPriority = DISABLE;
if (HAL_CAN_Init(&hcan_boot) != HAL_OK)
{
Error_Handler();
}
/* Настройка фильтра: пропускать все сообщения */
sFilterConfig.FilterBank = 0;
sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;
sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT;
sFilterConfig.FilterIdHigh = 0x0000;
sFilterConfig.FilterIdLow = 0x0000;
sFilterConfig.FilterMaskIdHigh = 0x0000;
sFilterConfig.FilterMaskIdLow = 0x0000;
sFilterConfig.FilterFIFOAssignment = CAN_FILTER_FIFO0;
sFilterConfig.FilterActivation = ENABLE;
if (HAL_CAN_ConfigFilter(&hcan_boot, &sFilterConfig) != HAL_OK)
{
Error_Handler();
}
/* Запускаем CAN */
if (HAL_CAN_Start(&hcan_boot) != HAL_OK)
{
Error_Handler();
}
}
// -----------------------------
// CAN: приём страницы + CRC с таймаутом
// -----------------------------
void Bootloader_CAN_Receive_Page(Bootloader_t *bl)
{
uint16_t bytes_received = 0;
uint8_t crc_buf[4];
CAN_RxHeaderTypeDef canHeader;
uint8_t canData[8];
uint32_t start_tick = HAL_GetTick();
// Приём данных страницы
while(bytes_received < PAGE_SIZE)
{
if(HAL_CAN_GetRxFifoFillLevel(bl->hcan, CAN_RX_FIFO0) > 0)
{
if(HAL_CAN_GetRxMessage(bl->hcan, CAN_RX_FIFO0, &canHeader, canData) == HAL_OK)
{
uint8_t len = canHeader.DLC;
if(bytes_received + len > PAGE_SIZE)
len = PAGE_SIZE - bytes_received;
memcpy(&bl->fw_buffer[bytes_received], canData, len);
bytes_received += len;
start_tick = HAL_GetTick(); // сброс таймера
}
}
// проверка таймаута
if(HAL_GetTick() - start_tick >= FW_RECEIVE_TIMEOUT_MS)
{
bl->state = BL_STATE_ERROR;
return;
}
}
// Приём CRC (следующий CAN пакет)
while(1)
{
if(HAL_CAN_GetRxFifoFillLevel(bl->hcan, CAN_RX_FIFO0) > 0)
{
if(HAL_CAN_GetRxMessage(bl->hcan, CAN_RX_FIFO0, &canHeader, canData) == HAL_OK)
{
// первые 4 байта = CRC
bl->fw_crc = (canData[0] << 24) | (canData[1] << 16) | (canData[2] << 8) | canData[3];
break;
}
}
if(HAL_GetTick() - start_tick >= FW_RECEIVE_TIMEOUT_MS)
{
bl->state = BL_STATE_ERROR;
return;
}
}
bl->fw_len = bytes_received;
bl->state = BL_STATE_IDLE;
}

11
Core/Bootloader/boot_can.h Normal file
View File

@@ -0,0 +1,11 @@
#ifndef __BOOT_CAN_H
#define __BOOT_CAN_H
#include "bootloader.h"
extern CAN_HandleTypeDef hcan_boot;
void MX_BOOT_CAN_Init(void);
void Bootloader_CAN_Receive_Page(Bootloader_t *bl);
#endif //__BOOT_CAN_H

94
Core/Bootloader/boot_flash.c Normal file
View File

@@ -0,0 +1,94 @@
#include "boot_flash.h"
//uint32_t PAGE_OFFSET = ((uint32_t)((4-1) * 0x0400));
uint32_t PAGE_NUMB = 127;
HAL_StatusTypeDef FLASH_Erase_App(void) //
{
HAL_StatusTypeDef res;
uint32_t PageError = 0x00;
res = HAL_FLASH_Unlock();
if (res != HAL_OK) return res;
FLASH_EraseInitTypeDef EraseInitStruct;
EraseInitStruct.TypeErase = FLASH_TYPEERASE_PAGES;// erase pages
EraseInitStruct.Banks = 1;
EraseInitStruct.PageAddress = MAIN_APP_START_ADR; //address
EraseInitStruct.NbPages = MAIN_APP_NUM_OF_PAGE;// num of erased pages
res = HAL_FLASHEx_Erase(&EraseInitStruct, &PageError);
if (res != HAL_OK) return res;
res = HAL_FLASH_Lock();
return res;
}
uint8_t *FLASH_Read(uint32_t add)
{
return (uint8_t *)add;
}
HAL_StatusTypeDef FLASH_Write_Word(uint32_t Address, uint64_t Data) //Куда записывать
{
HAL_StatusTypeDef res;
res = HAL_FLASH_Unlock();
if (res != HAL_OK) return res;
res = HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, Address, (uint32_t)(Data));
if (res != HAL_OK) return res;
res = HAL_FLASH_Lock();
return res;
}
uint32_t word_data;
HAL_StatusTypeDef FLASH_Write_Page(uint32_t *Address, uint8_t *Data, int Data_size)
{
//GPIOB->ODR^=(0x2000);
// GPIOB->ODR|=0x4000;
HAL_StatusTypeDef res;
int data_cnt = 0;
uint32_t adr;
res = HAL_FLASH_Unlock();
if (res != HAL_OK) return res;
for (adr = *Address; adr < *Address + Data_size; adr = adr+4)
{
word_data = (
Data[data_cnt]|
Data[data_cnt+1]<<8|
Data[data_cnt+2]<<16|
Data[data_cnt+3]<<24);
res = HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, adr, word_data);
if (res != HAL_OK) return res;
data_cnt +=4;
}
*Address += Data_size;
res = HAL_FLASH_Lock();
return res;
}

13
Core/Bootloader/boot_flash.h Normal file
View File

@@ -0,0 +1,13 @@
#ifndef __BOOT_FLASH_H
#define __BOOT_FLASH_H
#include "bootloader.h"
HAL_StatusTypeDef FLASH_Erase_App(void);
HAL_StatusTypeDef FLASH_Write_Page(uint32_t *Address, uint8_t *Data, int Data_size);
HAL_StatusTypeDef FLASH_Write_Word(uint32_t Address, uint64_t Data);
uint8_t *FLASH_Read(uint32_t add);
#endif //__BOOT_FLASH_H

25
Core/Bootloader/boot_main.c Normal file
View File

@@ -0,0 +1,25 @@
#include "bootloader.h"
Bootloader_t boot = {0};
int main()
{
boot.state = BL_STATE_INIT;
while (1)
{
Bootloader_Task(&boot);
}
}
/**
* @brief This function handles System tick timer.
*/
void SysTick_Handler(void)
{
/* USER CODE BEGIN SysTick_IRQn 0 */
/* USER CODE END SysTick_IRQn 0 */
HAL_IncTick();
/* USER CODE BEGIN SysTick_IRQn 1 */
/* USER CODE END SysTick_IRQn 1 */
}

63
Core/Bootloader/boot_project_setup.h Normal file
View File

@@ -0,0 +1,63 @@
#ifndef __BOOT_SETUP_H
#define __BOOT_SETUP_H
#include "stm32f1xx_hal.h"
// === BOOTLOADER defines ===
// KEY defines
#define BOOTLOADER_KEY_ADR (uint32_t)0x08009800
#define BOOTLOADER_KEY_PAGE 20
// MAIN APP defines
#define MAIN_APP_START_ADR (uint32_t)0x0800C000
#define MAIN_APP_PAGE 21
#define MAIN_APP_NUM_OF_PAGE 250-MAIN_APP_PAGE
#define FW_RECEIVE_TIMEOUT_MS 5000 // таймаут приёма страницы
#define PAGE_SIZE 2048
typedef enum {
CMD_ERASE = 0x01, ///< Команда на стирание прошивки
CMD_START_RECEIVE, ///< Команда на старт приема прошивки
CMD_WRITE, ///< Команда на запись блока прошивки
CMD_VERIFY, ///< Команда на проверку прошивки
CMD_GOTOAPP, ///< Команда на переход в приложение
CMD_RESET, ///< Команда на переход в приложение
CMD_GO_TO_BOOT, ///< Команда на переход в приложение
}BootloaderCommand_t;
// === RCC defines ===
#define __RCC_UART_BOOT_CLK_ENABLE() __HAL_RCC_USART3_CLK_ENABLE()
#define __RCC_UART_PORT_CLK_ENABLE() __HAL_RCC_GPIOB_CLK_ENABLE()
#define __RCC_CAN_BOOT_CLK_ENABLE() __HAL_RCC_CAN1_CLK_ENABLE()
#define __RCC_CAN_PORT_CLK_ENABLE() __HAL_RCC_GPIOA_CLK_ENABLE()
// === UART defines ===
#define UART_BOOT USART3
#define UART_SPEED 256000
#define UART_BOOT_IRQn USART3_IRQn
#define UART_PORT GPIOB // usart port
#define UART_PIN_TX GPIO_PIN_10
#define UART_PIN_RX GPIO_PIN_11
// === CAN defines ===
#define CAN_BOOT CAN1
#define CAN_MODE CAN_MODE_NORMAL
// Presacler = 1: 500 kbps при 8 MHz
#define CAN_SPEED_PRESCALER 2
#define CAN_SPEED_BS1 CAN_BS1_13TQ
#define CAN_SPEED_BS2 CAN_BS2_2TQ
#define CAN_PORT GPIOA // can port
#define CAN_PIN_RX GPIO_PIN_11
#define CAN_PIN_TX GPIO_PIN_12
#define CAN_BOOT_IRQn USB_LP_CAN1_RX0_IRQn
#endif //__BOOT_SETUP_H

95
Core/Bootloader/boot_uart.c Normal file
View File

@@ -0,0 +1,95 @@
#include "boot_uart.h"
UART_HandleTypeDef huart_boot;
/**
* @brief Инициализация UART для бутлоадера
* @note Использует USART3, PB10 (TX), PB11 (RX)
*/
void MX_BOOT_UART_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
/* Включаем тактирование */
__RCC_UART_BOOT_CLK_ENABLE();
__RCC_UART_PORT_CLK_ENABLE();
/* Настройка GPIO TX/RX */
GPIO_InitStruct.Pin = UART_PIN_TX | UART_PIN_RX;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(UART_PORT, &GPIO_InitStruct);
/* Настройка UART */
huart_boot.Instance = UART_BOOT;
huart_boot.Init.BaudRate = UART_SPEED;
huart_boot.Init.WordLength = UART_WORDLENGTH_8B;
huart_boot.Init.StopBits = UART_STOPBITS_1;
huart_boot.Init.Parity = UART_PARITY_NONE;
huart_boot.Init.Mode = UART_MODE_TX_RX;
huart_boot.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart_boot.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart_boot) != HAL_OK)
{
Error_Handler(); // твоя функция обработки ошибок
}
}
// -----------------------------
// UART: приём страницы + CRC
// -----------------------------
void Bootloader_UART_Receive_Page(Bootloader_t *bl)
{
uint16_t bytes_received = 0;
uint8_t crc_buf[4];
HAL_StatusTypeDef res;
uint32_t start_tick = HAL_GetTick(); // старт таймера
// Приём данных страницы
while(bytes_received < PAGE_SIZE)
{
uint8_t byte = 0;
res = HAL_UART_Receive(bl->huart, &byte, 1, 100); // блокирующий приём 100ms
if(res == HAL_OK)
{
bl->fw_buffer[bytes_received++] = byte;
start_tick = HAL_GetTick(); // сброс таймера при успешном приёме
}
else
{
// проверка таймаута
if(HAL_GetTick() - start_tick >= FW_RECEIVE_TIMEOUT_MS)
{
bl->state = BL_STATE_ERROR; // превышен таймаут
return;
}
// иначе просто ждем следующего байта
}
}
// Приём CRC (4 байта)
for(uint8_t i = 0; i < 4; i++)
{
res = HAL_UART_Receive(bl->huart, &crc_buf[i], 1, 100);
if(res == HAL_OK)
{
start_tick = HAL_GetTick(); // сброс таймера
}
else
{
if(HAL_GetTick() - start_tick >= FW_RECEIVE_TIMEOUT_MS)
{
bl->state = BL_STATE_ERROR;
return;
}
}
}
// Сохраняем CRC в структуру
bl->fw_crc = (crc_buf[0] << 24) | (crc_buf[1] << 16) | (crc_buf[2] << 8) | crc_buf[3];
bl->fw_len = bytes_received;
bl->state = BL_STATE_IDLE;
}

7
Core/Bootloader/boot_uart.h Normal file
View File

@@ -0,0 +1,7 @@
#ifndef __BOOT_UART_H
#define __BOOT_UART_H
#include "bootloader.h"
extern UART_HandleTypeDef huart_boot;
void MX_BOOT_UART_Init(void);
#endif //__BOOT_UART_H

306
Core/Bootloader/bootloader.c Normal file
View File

@@ -0,0 +1,306 @@
#include "bootloader.h"
#include "boot_flash.h"
#include "boot_uart.h"
#include "boot_can.h"
CAN_TxHeaderTypeDef TxHeader;
CAN_RxHeaderTypeDef RxHeader;
uint32_t TxMailBox = 0; // num of used mail
void SetKey(void);
uint32_t ReadKey(void);
void ResetKey(void);
void Boot_SystemClock_Config(void);
void JumpToApplocation(void);
void Bootloader_UART_Receive_Page(Bootloader_t *bl);
void Bootloader_CAN_Receive_Page(Bootloader_t *bl);
void Bootloader_Init(void)
{
HAL_Init();
Boot_SystemClock_Config();
MX_BOOT_UART_Init();
MX_BOOT_CAN_Init();
}
HAL_StatusTypeDef res_hal;
void Bootloader_Task(Bootloader_t *bl)
{
switch (bl->state)
{
case BL_STATE_INIT:
// Проверяем ключ, чтобы понять запускать приложение или программирование
if (ReadKey() == BL_KEY_APP_WRITTEN)
{
bl->state = BL_STATE_JUMP_TO_APP;
break; // не инициализируем, а сразу прыгаем в приложение
}
else
{
bl->state = BL_STATE_IDLE;
}
// Инициализация периферии
Bootloader_Init();
bl->huart = &huart_boot;
bl->hcan = &hcan_boot;
bl->addr = MAIN_APP_START_ADR;
break;
case BL_STATE_IDLE:
// Ждем команды по UART или CAN
if(bl->state != bl->prev_state)
{
static uint8_t Data[8] = {0};
static uint32_t TxMail = {0};
Data[0] = 0xFA;
HAL_CAN_AddTxMessage(bl->hcan, &bl->TxHeader, Data, &TxMail);
HAL_UART_Transmit()
}
if (Receive_FW_Command(bl) == 0xFF) // функция обработки команд, возвращает 1 если ошибка
{
bl->state = BL_STATE_ERROR;
}
break;
case BL_STATE_ERASE:
ResetKey();
if (FLASH_Erase_App() == HAL_OK) // твоя функция стирания MAIN_APP_PAGE..NUM
{
bl->state = BL_STATE_IDLE;
}
else
{
bl->state = BL_STATE_ERROR;
}
break;
case BL_STATE_RECEIVE_UART:
// В этом состоянии мы просто принимаем страницу + CRC
Bootloader_UART_Receive_Page(bl);
break;
case BL_STATE_RECEIVE_CAN:
Bootloader_CAN_Receive_Page(bl);
break;
case BL_STATE_WRITE:
if (FLASH_Write_Page(&bl->addr, bl->fw_buffer, bl->fw_len) == HAL_OK) // запись блока во Flash
{
bl->state = BL_STATE_IDLE; // ждём следующего блока
}
else
{
bl->state = BL_STATE_ERROR;
}
break;
case BL_STATE_VERIFY:
if (/*Verify_Flash_CRC(bl->fw_crc)*/0 == HAL_OK)
{
ResetKey();
SetKey(); // отметка, что прошивка записана
bl->state = BL_STATE_IDLE;
}
else
{
bl->state = BL_STATE_ERROR;
}
break;
case BL_STATE_JUMP_TO_APP:
JumpToApplocation();
break;
case BL_STATE_ERROR:
// обработка ошибок (можно светодиод, повторная инициализация, лог по UART)
Error_Handler();
break;
default:
bl->state = BL_STATE_ERROR;
break;
}
bl->prev_state = bl->state;
}
/**
* @brief Обработка команд прошивки по UART или CAN
* @param bl: указатель на структуру бутлоадера
* @retval 0x00 - команда принята и обработана, 0xFF - ошибка
*/
uint8_t Receive_FW_Command(Bootloader_t *bl)
{
BootloaderCommand_t cmd = 0;
HAL_StatusTypeDef res = HAL_ERROR;
// ---------------------------
// Чтение команды по UART
// ---------------------------
res = HAL_UART_Receive(bl->huart, &cmd, 1, 10); // таймаут 10 ms
if (res == HAL_OK)
{
switch(cmd)
{
case CMD_ERASE: // команда: стереть Flash
bl->state = BL_STATE_ERASE;
return 0x00;
case CMD_START_RECEIVE: // команда: принять блок
bl->state = BL_STATE_RECEIVE_UART;
return 0x00;
case CMD_WRITE: // команда: записать блок
bl->state = BL_STATE_WRITE;
return 0x00;
case CMD_VERIFY: // команда: проверка прошивки
bl->state = BL_STATE_VERIFY;
return 0x00;
case CMD_GOTOAPP: // команда: прыжок в приложение
bl->state = BL_STATE_JUMP_TO_APP;
return 0x00;
default:
return 0xFF; // неизвестная команда
}
}
// ---------------------------
// Чтение команды по CAN
// ---------------------------
CAN_RxHeaderTypeDef canHeader;
uint8_t canData[8];
if (HAL_CAN_GetRxFifoFillLevel(bl->hcan, CAN_RX_FIFO0) > 0)
{
if (HAL_CAN_GetRxMessage(bl->hcan, CAN_RX_FIFO0, &canHeader, canData) == HAL_OK)
{
cmd = canData[0]; // предполагаем, что команда в первом байте
switch(cmd)
{
case CMD_ERASE:
bl->state = BL_STATE_ERASE;
return 0x00;
case CMD_START_RECEIVE:
// запускаем прием первой страницы + crc, затем после приема всего массива ждем следующей комманды
bl->state = BL_STATE_RECEIVE_CAN;
return 0x00;
case CMD_WRITE: // команда: записать блок
bl->state = BL_STATE_WRITE;
return 0x00;
case CMD_VERIFY:
bl->state = BL_STATE_VERIFY;
return 0x00;
case CMD_GOTOAPP:
bl->state = BL_STATE_JUMP_TO_APP;
return 0x00;
default:
return 0xFF;
}
}
}
#ifdef TEST_CAN
TxHeader.StdId = 0x200; // ID OF MESSAGE
TxHeader.ExtId = 0; // STANDART FRAME (NOT EXTENTED)
TxHeader.RTR = CAN_RTR_DATA; // TRANSMIT DATA OR
TxHeader.IDE = CAN_ID_STD; // STANDART FRAME
TxHeader.DLC = 8; // DATA SIZE
TxHeader.TransmitGlobalTime = DISABLE; //THIS MODE IS NOT USED, SO DISABLE
uint8_t asd[8] = "ABCDEFGL";
res_hal = HAL_CAN_AddTxMessage(&hcan_boot, &TxHeader, asd, &TxMailBox); // add to mail for transmit
HAL_Delay(1000);
#endif
return 0x00; // если команды нет, ничего не делаем, остаёмся в BL_STATE_IDLE
}
// reset/set key function
void SetKey(void)
{
HAL_FLASH_Unlock();
HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, BOOTLOADER_KEY_ADR, BL_KEY_APP_WRITTEN);
HAL_FLASH_Lock();
}
uint32_t ReadKey(void)
{
return (*(__IO uint32_t*)BOOTLOADER_KEY_ADR);
}
void ResetKey(void)
{
FLASH_EraseInitTypeDef EraseInitStruct;
HAL_FLASH_Unlock();
uint32_t PageError = 0x00;
EraseInitStruct.TypeErase = FLASH_TYPEERASE_PAGES;// erase pages
EraseInitStruct.PageAddress = BOOTLOADER_KEY_ADR; //address
EraseInitStruct.NbPages = 0x01;// num of erased pages
HAL_FLASHEx_Erase(&EraseInitStruct, &PageError);
HAL_FLASH_Lock();
}
void JumpToApplocation(void)
{
// jump to main app
//Задаётся адрес программы со смещением от начала вектора прерываний
uint32_t app_jump_adr;
app_jump_adr=*((volatile uint32_t*)(MAIN_APP_START_ADR+4));
void(*GoToApp)(void);
//Деинициализация HAL
HAL_DeInit();
GoToApp = (void (*) (void)) app_jump_adr;
//Перенос вектора прерываний на начало зашитой программы
__disable_irq();
__set_MSP(*((volatile uint32_t*)MAIN_APP_START_ADR));
__enable_irq();
//Переход к выполнению зашитой программы
GoToApp();
}
void Boot_SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
/* Включаем внутренний генератор HSI */
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_OFF; // без PLL
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
/* Настройка шин AHB/APB */
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI; // HSI = 8 MHz
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1; // HCLK = 8 MHz
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1; // PCLK1 = 8 MHz
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1; // PCLK2 = 8 MHz
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
{
Error_Handler();
}
}
void Error_Handler(void)
{
NVIC_SystemReset();
}

49
Core/Bootloader/bootloader.h Normal file
View File

@@ -0,0 +1,49 @@
#ifndef __BOOTLOADER_H
#define __BOOTLOADER_H
#include "boot_project_setup.h"
#include "string.h"
#define BL_KEY_APP_WRITTEN 0xAAAA5555
// ERROR DEFINES
/**
* @brief Состояние бутлоадера
*/
typedef enum {
BL_STATE_INIT = 0, ///< Состояние: инициализация
BL_STATE_JUMP_TO_APP, ///< Состояние: запуск приложения
BL_STATE_IDLE, ///< Состояние: ожидание команд
BL_STATE_ERASE, ///< Состояние: стирание флеша
BL_STATE_RECEIVE_UART, ///< Состояние: прием прошивки по UART
BL_STATE_RECEIVE_CAN, ///< Состояние: прием прошивки по CAN
BL_STATE_WRITE, ///< Состояние: запись данных
BL_STATE_VERIFY, ///< Состояние: проверка прошивки
BL_STATE_ERROR ///< Состояние: ошибка
} BootloaderState_t;
typedef struct {
BootloaderState_t state; ///< текущее состояние бутлоадера
uint32_t addr; ///< текущий адрес прошивки
uint8_t fw_size; ///< размер прошивки
uint8_t fw_buffer[PAGE_SIZE]; ///< буфер для приема прошивки (UART/CAN)
uint32_t fw_len; ///< длина принятого пакета
uint32_t fw_crc; ///< контрольная сумма прошивки
UART_HandleTypeDef *huart; ///< хендлер UART
CAN_HandleTypeDef *hcan; ///< хендер CAN
CAN_TxHeaderTypeDef TxHeader; ///< Заголовок CAN сообщения для отправки
BootloaderState_t prev_state; ///< предыдущее состояние бутлоадера
} Bootloader_t;
void Bootloader_Task(Bootloader_t *bl);
uint8_t Receive_FW_Command(Bootloader_t *bl);
void Error_Handler(void);
#endif //__BOOTLOADER_H

6
Core/Src/main.c
View File

@@ -85,6 +85,10 @@ int main(void)
static int cancount[2]={1,2},cancell[2]={0,0},candid[2]={0,0};
static unsigned int masca[8];
static uint16_t precom=0;
__disable_irq();
SCB->VTOR = 0x0800C000;
__enable_irq();
/* USER CODE END 1 */
/* MCU Configuration--------------------------------------------------------*/
@@ -100,7 +104,7 @@ int main(void)
SystemClock_Config();
/* USER CODE BEGIN SysInit */
MX_IWDG_Init();
//MX_IWDG_Init();
/* USER CODE END SysInit */
/* Initialize all configured peripherals */