cbb
9c7145ef99
- 添加AES128加密解密功能支持安全固件传输 - 实现基于随机数握手的安全会话密钥协商机制 - 集成CRC32带密钥校验确保数据完整性 - 重构OTA状态机支持握手、数据传输和验证流程 - 添加CANFD数据长度规范处理和安全跳转逻辑 - 移除调试打印语句优化性能 refactor(can): 优化CANFD发送和OTA确认处理逻辑 - 重构CANFD_AsyncSend函数支持规范数据长度 - 重命名sendACK为sendDATA_ACK并添加重载函数 - 修复数据长度处理和缓冲区填充逻辑 - 优化CAN消息发送的数据复制和验证流程 - 移除未使用的联合体类型定义 chore(project): 添加AES加密模块和系统初始化配置 - 在项目配置中添加AES128加密解密文件 - 在main.cpp中初始化CRC外设模块 - 添加安全十六进制打印调试函数 - 集成AES加密库到OTA处理流程中 - 优化系统时钟初始化配置
412 lines
13 KiB
C++
412 lines
13 KiB
C++
#include "Can.h"
|
|
#include "OTA.h"
|
|
#include "config.h"
|
|
#include "flash.h"
|
|
#include "gd32c10x.h"
|
|
#include "gd32c10x_can.h"
|
|
#include "gd32c10x_dma.h"
|
|
#include "gd32c10x_gpio.h"
|
|
#include "main.h"
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
constexpr u16 CANX = CAN0;
|
|
constexpr u16 DEV_CAN0_ID = 0x0000;
|
|
constexpr u16 DEV_CAN0_MASK = 0x0000;
|
|
constexpr u16 DEV_CAN_LOOPBACK_ID = 0x0000;
|
|
|
|
CAN_transmiter CAN0_transmiter; // CAN初始化
|
|
extern BootloaderSystem sys;
|
|
extern OTAHandler ota;
|
|
extern FlashEEPROM flashEEP;
|
|
|
|
// 添加DMA相关变量
|
|
dma_parameter_struct dma_rx_parameter;
|
|
dma_parameter_struct dma_tx_parameter;
|
|
uint8_t can_rx_buffer[8]; // CAN接收缓冲区
|
|
uint8_t can_tx_buffer[8]; // CAN发送缓冲区
|
|
|
|
/*!
|
|
\brief initialize CAN GPIO
|
|
\param[in] none
|
|
\param[out] none
|
|
\retval ErrStatus: SUCCESS or ERROR
|
|
*/
|
|
u8 can_gpio_init() {
|
|
/* enable CAN clock */
|
|
rcu_periph_clock_enable(RCU_CAN0);
|
|
rcu_periph_clock_enable(RCU_GPIOB);
|
|
rcu_periph_clock_enable(RCU_AF);
|
|
|
|
/* configure CAN0 GPIO */
|
|
gpio_init(GPIOB, GPIO_MODE_IPU, GPIO_OSPEED_50MHZ, GPIO_PIN_8); // rx
|
|
gpio_init(GPIOB, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_9); // tx
|
|
gpio_pin_remap_config(GPIO_CAN0_PARTIAL_REMAP, ENABLE);
|
|
/* enable the EN GPIO clock */
|
|
gpio_init(GPIOB, GPIO_MODE_OUT_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_13);
|
|
gpio_bit_reset(GPIOB, GPIO_PIN_13);
|
|
return 0;
|
|
}
|
|
|
|
/*!
|
|
\brief 初始化CAN DMA
|
|
\param[in] none
|
|
\param[out] none
|
|
\retval none
|
|
*/
|
|
void can_dma_init(void) {
|
|
// 使能DMA时钟
|
|
rcu_periph_clock_enable(RCU_DMA0);
|
|
|
|
// 配置接收DMA
|
|
dma_struct_para_init(&dma_rx_parameter);
|
|
dma_rx_parameter.periph_addr =
|
|
(uint32_t)(&CAN_RFIFOMDATA0(CAN0, CAN_FIFO0)); // CAN接收数据寄存器地址
|
|
dma_rx_parameter.memory_addr = (uint32_t)can_rx_buffer; // 接收缓冲区地址
|
|
dma_rx_parameter.direction = DMA_PERIPHERAL_TO_MEMORY; // 外设到内存
|
|
dma_rx_parameter.memory_width = DMA_MEMORY_WIDTH_8BIT; // 内存宽度8位
|
|
dma_rx_parameter.periph_width = DMA_PERIPHERAL_WIDTH_8BIT; // 外设宽度8位
|
|
dma_rx_parameter.priority = DMA_PRIORITY_HIGH; // 高优先级
|
|
dma_rx_parameter.number = 8; // 传输字节数
|
|
dma_rx_parameter.periph_inc = DMA_PERIPH_INCREASE_DISABLE; // 外设地址不递增
|
|
dma_rx_parameter.memory_inc = DMA_MEMORY_INCREASE_ENABLE; // 内存地址递增
|
|
dma_init(DMA0, DMA_CH4, &dma_rx_parameter); // 使用DMA通道4
|
|
|
|
// 配置发送DMA
|
|
dma_struct_para_init(&dma_tx_parameter);
|
|
dma_tx_parameter.periph_addr =
|
|
(uint32_t)(&CAN_TMI0(CAN0)); // CAN发送数据寄存器地址
|
|
dma_tx_parameter.memory_addr = (uint32_t)can_tx_buffer; // 发送缓冲区地址
|
|
dma_tx_parameter.direction = DMA_MEMORY_TO_PERIPHERAL; // 内存到外设
|
|
dma_tx_parameter.memory_width = DMA_MEMORY_WIDTH_8BIT; // 内存宽度8位
|
|
dma_tx_parameter.periph_width = DMA_PERIPHERAL_WIDTH_8BIT; // 外设宽度8位
|
|
dma_tx_parameter.priority = DMA_PRIORITY_HIGH; // 高优先级
|
|
dma_tx_parameter.number = 8; // 传输字节数
|
|
dma_tx_parameter.periph_inc = DMA_PERIPH_INCREASE_DISABLE; // 外设地址不递增
|
|
dma_tx_parameter.memory_inc = DMA_MEMORY_INCREASE_ENABLE; // 内存地址递增
|
|
dma_init(DMA0, DMA_CH5, &dma_tx_parameter); // 使用DMA通道5
|
|
|
|
// 使能DMA通道
|
|
dma_channel_enable(DMA0, DMA_CH4);
|
|
dma_channel_enable(DMA0, DMA_CH5);
|
|
|
|
// 使能CAN接收DMA
|
|
// can_dma_enable(CAN0, CAN_DMA_RECEIVE);
|
|
}
|
|
|
|
/*!
|
|
\brief 初始化CAN0 CANFD模式
|
|
\param[in] none
|
|
\param[out] none
|
|
\retval none
|
|
*/
|
|
void canfd_config(void) {
|
|
can_gpio_init();
|
|
can_dma_init();
|
|
can_parameter_struct can_parameter;
|
|
can_fdframe_struct can_fd_parameter;
|
|
can_fd_tdc_struct can_fd_tdc_parameter;
|
|
can_filter_parameter_struct can_filter;
|
|
|
|
/* initialize CAN register */
|
|
can_deinit(CAN0);
|
|
|
|
/* initialize CAN */
|
|
can_parameter.time_triggered = DISABLE;
|
|
can_parameter.auto_bus_off_recovery = DISABLE;
|
|
can_parameter.auto_wake_up = DISABLE;
|
|
can_parameter.auto_retrans = ENABLE;
|
|
can_parameter.rec_fifo_overwrite = ENABLE;
|
|
can_parameter.trans_fifo_order = ENABLE;
|
|
can_parameter.working_mode = CAN_NORMAL_MODE;
|
|
/* baudrate 1Mbps, sample piont at 80% */
|
|
can_parameter.resync_jump_width = CAN_BT_SJW_1TQ;
|
|
can_parameter.time_segment_1 = CAN_BT_BS1_7TQ;
|
|
can_parameter.time_segment_2 = CAN_BT_BS2_2TQ;
|
|
can_parameter.prescaler = 6;
|
|
can_init(CAN0, &can_parameter);
|
|
|
|
can_struct_para_init(CAN_FD_FRAME_STRUCT, &can_fd_parameter);
|
|
can_fd_parameter.fd_frame = ENABLE;
|
|
can_fd_parameter.excp_event_detect = ENABLE;
|
|
can_fd_parameter.delay_compensation = ENABLE;
|
|
can_fd_tdc_parameter.tdc_filter = 0x04;
|
|
can_fd_tdc_parameter.tdc_mode = CAN_TDCMOD_CALC_AND_OFFSET;
|
|
can_fd_tdc_parameter.tdc_offset = 0x04;
|
|
can_fd_parameter.p_delay_compensation = &can_fd_tdc_parameter;
|
|
can_fd_parameter.iso_bosch = CAN_FDMOD_ISO;
|
|
can_fd_parameter.esi_mode = CAN_ESIMOD_HARDWARE;
|
|
/* FD mode data baudrate 2Mbps, sample piont at 80% */
|
|
can_fd_parameter.data_resync_jump_width = CAN_BT_SJW_1TQ;
|
|
can_fd_parameter.data_time_segment_1 = CAN_BT_BS1_3TQ;
|
|
can_fd_parameter.data_time_segment_2 = CAN_BT_BS2_1TQ;
|
|
/* CAN-FD data segement prescaler should be the same as non-data segement
|
|
* prescaler */
|
|
can_fd_parameter.data_prescaler = 6;
|
|
can_fd_init(CAN0, &can_fd_parameter);
|
|
|
|
/* initialize filter */
|
|
can_filter.filter_mode = CAN_FILTERMODE_MASK;
|
|
can_filter.filter_bits = CAN_FILTERBITS_32BIT;
|
|
/* configure filter ID */
|
|
can_filter.filter_list_high = 0x0000;
|
|
can_filter.filter_list_low = 0x0000;
|
|
/* configure filter mask */
|
|
can_filter.filter_mask_high = 0x0000;
|
|
can_filter.filter_mask_low = 0x0000;
|
|
/* select receiver fifo */
|
|
can_filter.filter_fifo_number = CAN_FIFO0;
|
|
can_filter.filter_enable = ENABLE;
|
|
/* configure filter number */
|
|
can_filter.filter_number = 0;
|
|
can_filter_init(&can_filter);
|
|
|
|
/* configure CAN0 NVIC */
|
|
nvic_irq_enable(CAN0_RX0_IRQn, 1, 0);
|
|
/* enable can receive FIFO0 not empty interrupt */
|
|
can_interrupt_enable(CAN0, CAN_INTEN_RFNEIE0);
|
|
// 使能DMA中断
|
|
nvic_irq_enable(DMA0_Channel4_IRQn, 1, 1);
|
|
dma_interrupt_enable(DMA0, DMA_CH4, DMA_INT_FTF);
|
|
}
|
|
|
|
/*!
|
|
\brief CAN_transmiter构造函数
|
|
\note 初始化CAN通信相关参数和硬件配置
|
|
*/
|
|
u8 CAN_transmiter::init() {
|
|
// 初始化CAN硬件
|
|
canfd_config();
|
|
|
|
// 初始化发送消息结构体
|
|
can_struct_para_init(CAN_TX_MESSAGE_STRUCT, &transmit_message);
|
|
/* initialize receive message */
|
|
can_struct_para_init(CAN_RX_MESSAGE_STRUCT, &receive_message);
|
|
|
|
// 初始化DMA缓冲区
|
|
memset(can_rx_buffer, 0, sizeof(can_rx_buffer));
|
|
memset(can_tx_buffer, 0, sizeof(can_tx_buffer));
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief CAN通信检查函数
|
|
* @retval 0: 无新消息
|
|
* 1: 有新消息
|
|
*/
|
|
void CAN_transmiter::communication_check() {
|
|
// CAN0 发送数据标志
|
|
if (SET == can0_send_flag) {
|
|
// printf("\r\n can0 %X receive data:", receive_message.rx_efid);
|
|
// CAN0_transmiter.CAN_all_Send();
|
|
// CANFD_all_Send();
|
|
can0_send_flag = RESET;
|
|
}
|
|
|
|
// CAN0 接收数据标志
|
|
if (SET == can0_receive_flag) {
|
|
// printf("can0 %X receive data,length%d:", receive_message.rx_efid,
|
|
// receive_message.rx_dlen);
|
|
// for (int i = 0; i < receive_message.rx_dlen; i++) {
|
|
// printf(" 0x%02x", receive_message.rx_data[i]);
|
|
// }
|
|
// printf("\n");
|
|
if (receive_message.rx_efid == CANFD_OTA_DATA_ID or
|
|
receive_message.rx_efid == CANFD_OTA_REQ_ID) {
|
|
ota.handleOTAMessage(receive_message.rx_efid,
|
|
receive_message.rx_data,
|
|
receive_message.rx_dlen);
|
|
} else {
|
|
printf("Unknown CAN ID: %X\n", receive_message.rx_efid);
|
|
}
|
|
can0_receive_flag = RESET;
|
|
}
|
|
}
|
|
|
|
u8 CAN_transmiter::sendDATA_ACK(u32 packet_num, u8 *data) { // 握手的时候
|
|
memset(transmit_data, 0, sizeof(transmit_data));
|
|
transmit_data[0] = 0xBA;
|
|
transmit_data[1] = 0xC0;
|
|
// 修复原始代码中不完整的循环
|
|
for (int i = 2; i < 6; i++) {
|
|
transmit_data[i] = data[i-2];
|
|
}
|
|
|
|
return CANFD_AsyncSend(CANFD_OTA_ACK_ID, 6, transmit_data);
|
|
}
|
|
|
|
u8 CAN_transmiter::sendDATA_ACK(u32 packet_num,
|
|
bool if_success) { // 发送数据的时候
|
|
memset(transmit_data, 0, 4);
|
|
if (if_success) {
|
|
transmit_data[0] = 0x01;
|
|
transmit_data[1] = 0x00;
|
|
}
|
|
|
|
return CANFD_AsyncSend(CANFD_OTA_ACK_ID, 4, transmit_data);
|
|
}
|
|
|
|
/**
|
|
* @brief CAN0中断服务程序
|
|
* @retval 无
|
|
*/
|
|
void CAN0_RX0_IRQHandler(void) {
|
|
// 检查是否是FIFO0消息挂起中断
|
|
if (can_interrupt_flag_get(CAN0, CAN_INT_FLAG_RFL0) != RESET) {
|
|
// 清除中断标志
|
|
can_interrupt_flag_clear(CAN0, CAN_INT_FLAG_RFL0);
|
|
|
|
// 使用DMA读取接收到的数据
|
|
dma_channel_disable(DMA0, DMA_CH4);
|
|
dma_rx_parameter.number =
|
|
can_receive_message_length_get(CAN0, CAN_FIFO0);
|
|
dma_init(DMA0, DMA_CH4, &dma_rx_parameter);
|
|
dma_channel_enable(DMA0, DMA_CH4);
|
|
|
|
// 读取接收到的数据
|
|
can_message_receive(CAN0, CAN_FIFO0, &CAN0_transmiter.receive_message);
|
|
|
|
// 接收标志位置1
|
|
CAN0_transmiter.can0_receive_flag = SET;
|
|
}
|
|
|
|
// 检查其他可能的中断源
|
|
if (can_interrupt_flag_get(CAN0, CAN_INT_FLAG_RFF0) != RESET) {
|
|
// FIFO0满中断
|
|
can_interrupt_flag_clear(CAN0, CAN_INT_FLAG_RFF0);
|
|
printf("CAN FIFO0 full\n");
|
|
}
|
|
|
|
if (can_interrupt_flag_get(CAN0, CAN_INT_FLAG_RFO0) != RESET) {
|
|
// FIFO0溢出中断
|
|
can_interrupt_flag_clear(CAN0, CAN_INT_FLAG_RFO0);
|
|
printf("CAN FIFO0 overflow\n");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief DMA通道4中断服务程序(CAN接收DMA)
|
|
* @retval 无
|
|
*/
|
|
void DMA0_Channel4_IRQHandler(void) {
|
|
if (dma_interrupt_flag_get(DMA0, DMA_CH4, DMA_INT_FLAG_FTF)) {
|
|
// 清除DMA传输完成中断标志
|
|
dma_interrupt_flag_clear(DMA0, DMA_CH4, DMA_INT_FLAG_G);
|
|
|
|
// 将DMA缓冲区的数据复制到接收消息结构体
|
|
for (int i = 0; i < CAN0_transmiter.receive_message.rx_dlen && i < 8;
|
|
i++) {
|
|
CAN0_transmiter.receive_message.rx_data[i] = can_rx_buffer[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief DMA通道5中断服务程序(CAN/CANFD发送DMA)
|
|
* @retval 无
|
|
*/
|
|
void DMA0_Channel5_IRQHandler(void) {
|
|
if (dma_interrupt_flag_get(DMA0, DMA_CH5, DMA_INT_FLAG_FTF)) {
|
|
// DMA传输完成，可以在此处执行后续处理
|
|
// 清除DMA传输完成中断标志
|
|
dma_interrupt_flag_clear(DMA0, DMA_CH5, DMA_INT_FLAG_FTF);
|
|
// 可以在此添加后续处理逻辑，如发送下一个数据包等
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief 异步CANFD数据发送(使用DMA和中断机制)
|
|
* @param id CAN消息ID
|
|
* @param length CAN消息长度
|
|
* @param data CAN消息数据
|
|
*/
|
|
u8 CAN_transmiter::CANFD_AsyncSend(u32 id, u8 length, u8 *data) {
|
|
u8 valid_length = length;
|
|
// 检查CANFD模式是否启用
|
|
if (!(CAN_CTL(CAN0) & CAN_CTL_DFZ)) {
|
|
printf("CANFD mode not enabled\r\n");
|
|
return 0;
|
|
}
|
|
|
|
// 检查数据指针是否有效
|
|
if (data == nullptr) {
|
|
printf("Invalid data pointer\r\n");
|
|
return 0;
|
|
}
|
|
|
|
// 检查数据长度是否符合CANFD规范
|
|
if (length > 8) {
|
|
if (length > 8 and length < 13) {
|
|
valid_length = 12;
|
|
} else if (length > 12 and length < 17) {
|
|
valid_length = 16;
|
|
} else if (length > 16 and length < 21) {
|
|
valid_length = 20;
|
|
} else if (length > 20 and length < 24) {
|
|
valid_length = 24;
|
|
} else if (length > 28 and length < 33) {
|
|
valid_length = 32;
|
|
} else if (length > 32 and length < 49) {
|
|
valid_length = 48;
|
|
} else if (length > 48 and length < 65) {
|
|
valid_length = 64;
|
|
} else {
|
|
printf("CANFD data length error\r\n");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* 配置发送消息参数 */
|
|
transmit_message.tx_ft = CAN_FT_DATA; // 数据帧
|
|
transmit_message.tx_ff = CAN_FF_EXTENDED; // 扩展帧格式
|
|
transmit_message.tx_efid = id; // 扩展帧ID
|
|
transmit_message.tx_dlen = valid_length; // 设置数据长度
|
|
|
|
// 设置CANFD特定参数
|
|
transmit_message.fd_flag = CAN_FDF_FDFRAME; // CANFD帧格式
|
|
transmit_message.fd_brs = ENABLE; // 使能比特率切换
|
|
transmit_message.fd_esi = DISABLE; // 错误状态指示
|
|
// 复制数据到发送缓冲区
|
|
for (int i = 0; i < valid_length; i++) {
|
|
if (i < length) {
|
|
transmit_message.tx_data[i] = *(data + i);
|
|
} else {
|
|
transmit_message.tx_data[i] = 0;
|
|
}
|
|
}
|
|
|
|
// 自动选择空闲mailbox发送消息
|
|
transmit_mailbox = can_message_transmit(CAN0, &transmit_message);
|
|
|
|
// 检查是否成功获取mailbox
|
|
if (transmit_mailbox == CAN_NOMAILBOX) {
|
|
// 没有可用的mailbox，启用发送中断以便在邮箱可用时重试
|
|
printf("No available mailbox for CANFD transmission, enabling TX "
|
|
"interrupt\r\n");
|
|
return 0;
|
|
}
|
|
|
|
// 启用CAN发送中断以检测传输完成
|
|
can_interrupt_enable(CAN0, CAN_INTEN_TMEIE);
|
|
return 1;
|
|
}
|
|
|
|
// 添加CAN传输中断处理函数
|
|
void CAN0_TX_IRQHandler(void) {
|
|
// 检查是否有发送邮箱空闲
|
|
if (can_flag_get(CAN0, CAN_FLAG_TME0) != RESET ||
|
|
can_flag_get(CAN0, CAN_FLAG_TME1) != RESET ||
|
|
can_flag_get(CAN0, CAN_FLAG_TME2) != RESET) {
|
|
// 邮箱已空闲，可以发送新消息
|
|
// 可以在这里处理待发送队列中的消息
|
|
// 清除发送中断标志
|
|
can_flag_clear(CAN0, CAN_FLAG_TME0);
|
|
can_flag_clear(CAN0, CAN_FLAG_TME1);
|
|
can_flag_clear(CAN0, CAN_FLAG_TME2);
|
|
}
|
|
}
|