409 lines
12 KiB
C++
409 lines
12 KiB
C++
#include "initial.h"
|
|
#include "OTA.h"
|
|
#include "config.h"
|
|
#include "core_cmFunc.h"
|
|
#include "gd32c10x.h"
|
|
#include "gd32c10x_gpio.h"
|
|
#include "gd32c10x_rcu.h"
|
|
#include "main.h"
|
|
#include "systick.h"
|
|
#include <cstdio>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
|
|
extern BootloaderSystem sys;
|
|
|
|
/* retarget the C library printf function to the USART */
|
|
u8 USART0_init() {
|
|
gd_eval_com_init(EVAL_COM0);
|
|
return 1;
|
|
}
|
|
|
|
int fputc(int ch, FILE *f) throw() {
|
|
usart_data_transmit(EVAL_COM0, (uint8_t)ch);
|
|
while (RESET == usart_flag_get(EVAL_COM0, USART_FLAG_TBE))
|
|
;
|
|
return ch;
|
|
}
|
|
|
|
void unused_pin_init() {
|
|
rcu_periph_clock_enable(RCU_GPIOA); // 使能GPIOA时钟
|
|
rcu_periph_clock_enable(RCU_GPIOB); // 使能GPIOB时钟
|
|
rcu_periph_clock_enable(RCU_GPIOC); // 使能GPIOC时钟
|
|
gpio_init(GPIOA, GPIO_MODE_IPU, GPIO_OSPEED_2MHZ,
|
|
GPIO_PIN_8 | GPIO_PIN_11 | GPIO_PIN_12);
|
|
gpio_init(GPIOB, GPIO_MODE_IPU, GPIO_OSPEED_2MHZ,
|
|
GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_15);
|
|
gpio_init(GPIOC, GPIO_MODE_IPU, GPIO_OSPEED_2MHZ,
|
|
GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15);
|
|
gpio_bit_reset(GPIOA, GPIO_PIN_8 | GPIO_PIN_11 | GPIO_PIN_12);
|
|
gpio_bit_reset(GPIOB, GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_15);
|
|
gpio_bit_reset(GPIOC, GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15);
|
|
}
|
|
|
|
/**
|
|
* @brief 扫描APP地址范围内的Flash内容
|
|
* @param print_content 是否打印Flash内容，默认为true
|
|
* @param page_count 扫描的页数，默认为0表示扫描整个APP区域
|
|
* @retval 无
|
|
*/
|
|
void scanAppFlashContent(bool print_content, u32 page_count) {
|
|
u32 start_addr = APPLATEST_START_ADDR;
|
|
u32 total_size = 0xC000;
|
|
|
|
// 如果指定了页数，则按页数计算大小
|
|
if (page_count > 0) {
|
|
total_size = page_count * FMC_PAGE_SIZE;
|
|
}
|
|
|
|
u32 end_addr = start_addr + total_size;
|
|
|
|
#if DEBUG_OTA
|
|
printf("Scanning Flash from 0x%08X to 0x%08X (%d bytes)\r\n", start_addr,
|
|
end_addr, total_size);
|
|
#endif
|
|
|
|
u32 page_count_scanned = 0;
|
|
u32 empty_pages = 0;
|
|
u32 data_pages = 0;
|
|
|
|
for (u32 addr = start_addr; addr < end_addr; addr += FMC_PAGE_SIZE) {
|
|
bool page_empty = true;
|
|
|
|
// 检查当前页是否全为0xFF（空页）
|
|
for (u32 offset = 0; offset < FMC_PAGE_SIZE; offset += 4) {
|
|
u32 data = *(u32 *)(addr + offset);
|
|
|
|
if (data != 0xFFFFFFFF) {
|
|
page_empty = false;
|
|
break; // 找到非空数据，立即退出检查
|
|
}
|
|
}
|
|
|
|
if (page_empty) {
|
|
empty_pages++;
|
|
} else {
|
|
data_pages++;
|
|
|
|
// // 只有在非空页面且需要打印时才输出内容
|
|
// if (print_content) {
|
|
// printf("Page 0x%08X: \r\n", addr);
|
|
|
|
// // 打印所有内容
|
|
// for (u32 offset = 0; offset < FMC_PAGE_SIZE;
|
|
// offset += 16) { // 每行打印16字节
|
|
// // 打印地址偏移
|
|
// printf(" +%03X: ", offset);
|
|
|
|
// // 打印十六进制数据
|
|
// for (u32 byte_idx = 0; byte_idx < 16; byte_idx++) {
|
|
// if ((offset + byte_idx) < FMC_PAGE_SIZE) {
|
|
// u8 data = *(__IO u8 *)(addr + offset + byte_idx);
|
|
// printf("%02X ", data);
|
|
// } else {
|
|
// printf(" "); // 空白填充
|
|
// }
|
|
|
|
// // 每8字节加个小空格，便于阅读
|
|
// if (byte_idx == 7) {
|
|
// printf(" ");
|
|
// }
|
|
// }
|
|
|
|
// // 打印可打印字符
|
|
// printf("|");
|
|
// for (u32 byte_idx = 0; byte_idx < 16; byte_idx++) {
|
|
// if ((offset + byte_idx) < FMC_PAGE_SIZE) {
|
|
// u8 data = *(__IO u8 *)(addr + offset + byte_idx);
|
|
// if (data >= 32 && data <= 126) { // 可打印字符范围
|
|
// printf("%c", data);
|
|
// } else {
|
|
// printf(".");
|
|
// }
|
|
// } else {
|
|
// printf(" "); // 空白填充
|
|
// }
|
|
// }
|
|
// printf("|\r\n");
|
|
// }
|
|
// }
|
|
}
|
|
|
|
page_count_scanned++;
|
|
}
|
|
|
|
#if DEBUG_OTA
|
|
printf("Scan complete: %d pages scanned, %d empty pages, %d data pages\r\n",
|
|
page_count_scanned, empty_pages, data_pages);
|
|
#endif
|
|
}
|
|
|
|
/*!
|
|
\brief prepare system to enter deep sleep mode
|
|
\param[in] none
|
|
\param[out] none
|
|
\retval none
|
|
*/
|
|
void enter_deep_sleep() {
|
|
// 关闭不必要的外设时钟
|
|
rcu_periph_clock_disable(RCU_TIMER0); // 关闭定时器时钟
|
|
rcu_periph_clock_disable(RCU_TIMER1);
|
|
rcu_periph_clock_disable(RCU_SPI0); // 关闭SPI时钟
|
|
rcu_periph_clock_disable(RCU_I2C0); // 关闭I2C时钟
|
|
rcu_periph_clock_disable(RCU_ADC0); // 关闭ADC时钟
|
|
// 注意不要关闭GPIOB和AF的时钟，因为需要它们来处理唤醒中断
|
|
|
|
// 设置深睡眠模式下的电压以进一步降低功耗
|
|
rcu_deepsleep_voltage_set(RCU_DEEPSLEEP_V_0_8); // 设置最低电压
|
|
|
|
// 配置PB8为输入模式，用于外部中断
|
|
rcu_periph_clock_enable(RCU_GPIOB);
|
|
rcu_periph_clock_enable(RCU_AF);
|
|
gpio_init(GPIOB, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_8);
|
|
|
|
// 配置EXTI中断（连接到PB8引脚）
|
|
gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOB,
|
|
GPIO_PIN_SOURCE_8); // 配置GPIOB的PIN8作为EXTI8的源
|
|
exti_init(EXTI_8, EXTI_INTERRUPT, EXTI_TRIG_RISING); // 边沿触发
|
|
exti_interrupt_enable(EXTI_8);
|
|
nvic_irq_enable(EXTI5_9_IRQn, 0, 0); //
|
|
|
|
// 确保中断标志已被清除
|
|
exti_interrupt_flag_clear(EXTI_8);
|
|
__enable_irq();
|
|
delay_1ms(10);
|
|
// 进入深度睡眠
|
|
pmu_to_deepsleepmode(PMU_LDO_LOWPOWER, WFI_CMD);
|
|
}
|
|
|
|
/**
|
|
* @brief 写地址
|
|
* @return fmc_state_enum
|
|
*/
|
|
fmc_state_enum write_ADDRESS(u32 address, u32 data) {
|
|
fmc_unlock();
|
|
fmc_flag_clear(FMC_FLAG_PGERR | FMC_FLAG_PGAERR | FMC_FLAG_WPERR);
|
|
|
|
// 确保使用对齐地址
|
|
fmc_state_enum fmc_status = fmc_word_program(address, data);
|
|
|
|
fmc_lock();
|
|
return fmc_status;
|
|
}
|
|
|
|
/**
|
|
* @brief EXTI5_9中断处理函数
|
|
* @param 无
|
|
* @retval 无
|
|
*/
|
|
void EXTI5_9_IRQHandler(void) {
|
|
if (exti_interrupt_flag_get(EXTI_8) != RESET) {
|
|
// 清除中断标志
|
|
exti_interrupt_flag_clear(EXTI_8);
|
|
// 禁用EXTI线8的中断，防止重复触发
|
|
exti_interrupt_disable(EXTI_8);
|
|
#if SLEEP_DEBUG
|
|
printf("MCU wake up\r\n");
|
|
#endif
|
|
OTA_SET(n_APP_LATEST_EN_ADDR, OTA_AVAL); // 设置APP为不激活
|
|
// 遍历睡眠存储区
|
|
for (u32 address = SLEEP_CONFIG_END - SIZE_U32;
|
|
address >= SLEEP_CONFIG_START; address -= SIZE_U32) {
|
|
volatile u32 *flash_ptr = (volatile u32 *)address;
|
|
u32 sleep_check = *flash_ptr;
|
|
if (sleep_check == FLASH_EMPTY and
|
|
address > SLEEP_CONFIG_START) { // 空则跳过该次循环
|
|
continue;
|
|
} else if (
|
|
sleep_check == SLEEP_ENABLE and
|
|
address >
|
|
SLEEP_CONFIG_START) { // 如果检查到睡眠启用，写入非启用
|
|
#if SLEEP_DEBUG
|
|
printf("boot sleep found %08x at %08x\r\n", sleep_check,
|
|
address);
|
|
#endif
|
|
if (address == SLEEP_CONFIG_END - SIZE_U32) {
|
|
fmc_unlock();
|
|
fmc_state_enum fmc_status =
|
|
fmc_page_erase(SLEEP_CONFIG_START); // 擦除已满的页
|
|
if (fmc_status != FMC_READY) { // 擦除失败报错
|
|
fmc_lock();
|
|
return;
|
|
}
|
|
address = SLEEP_CONFIG_START - SIZE_U32; // 重新开始写入
|
|
}
|
|
fmc_state_enum fmc_status =
|
|
write_ADDRESS(address + SIZE_U32, SLEEP_DISABLE);
|
|
if (fmc_status != FMC_READY) { // 写入失败报错
|
|
;
|
|
}
|
|
break; // 完成，跳出遍历
|
|
} else if (sleep_check == SLEEP_DISABLE) { // 已经是非休眠则跳出遍历
|
|
break;
|
|
} else {
|
|
fmc_state_enum fmc_status =
|
|
write_ADDRESS(address, SLEEP_DISABLE);
|
|
if (fmc_status != FMC_READY) { // 写入失败报错
|
|
;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
// 唤醒后软重启，确保正常初始化
|
|
system_soft_reset();
|
|
}
|
|
}
|
|
|
|
int check_sleep() {
|
|
#if SLEEP_DEBUG
|
|
printf("sleep check\r\n");
|
|
#endif
|
|
for (u32 address = SLEEP_CONFIG_END - SIZE_U32;
|
|
address >= SLEEP_CONFIG_START; address -= SIZE_U32) { // 遍历睡眠存储区
|
|
volatile u32 *flash_ptr = (volatile u32 *)address;
|
|
u32 sleep_check = *flash_ptr;
|
|
#if SLEEP_DEBUG
|
|
printf("sleep check %8x-----%x\r\n", address, sleep_check);
|
|
#endif
|
|
if (sleep_check == FLASH_EMPTY) { // 空则跳过
|
|
continue;
|
|
} else if (sleep_check == SLEEP_ENABLE) { // 睡眠使能则继续休眠
|
|
#if SLEEP_DEBUG
|
|
printf("sleep enable\r\n");
|
|
#endif
|
|
enter_deep_sleep();
|
|
return 0;
|
|
} else if (sleep_check == SLEEP_DISABLE) { // 禁用睡眠则跳出
|
|
#if SLEEP_DEBUG
|
|
printf("sleep disable\r\n");
|
|
#endif
|
|
return 0;
|
|
}
|
|
}
|
|
// 遍历到头都未找到，写入第一次的数据
|
|
#if SLEEP_DEBUG
|
|
printf("boot sleep not found\r\n");
|
|
#endif
|
|
fmc_state_enum fmc_status =
|
|
write_ADDRESS(SLEEP_CONFIG_START, SLEEP_DISABLE);
|
|
if (fmc_status != FMC_READY) { // 写入失败报错
|
|
#if SLEEP_DEBUG
|
|
printf("boot sleep write error\r\n");
|
|
#endif
|
|
return 1;
|
|
}
|
|
return 2; // 第一次启动
|
|
}
|
|
|
|
// // 发送单个字节到串口 (用于调试)
|
|
// void uart_send_byte(uint8_t data) {
|
|
// // 实际的串口发送代码
|
|
// while (RESET == usart_flag_get(USART0, USART_FLAG_TBE))
|
|
// ;
|
|
// usart_data_transmit(USART0, data);
|
|
// }
|
|
|
|
// // 以十六进制格式打印数据
|
|
// // 安全的十六进制打印函数，不使用sprintf，不使用大缓冲区
|
|
// void safe_print_hex(const char *prefix, const uint8_t *data, size_t length) {
|
|
// // 1. 先打印前缀
|
|
// const char *p = prefix;
|
|
// while (*p) {
|
|
// while (RESET == usart_flag_get(USART0, USART_FLAG_TBE))
|
|
// ;
|
|
// usart_data_transmit(USART0, *p++);
|
|
// }
|
|
|
|
// while (RESET == usart_flag_get(USART0, USART_FLAG_TBE))
|
|
// ;
|
|
// usart_data_transmit(USART0, ':');
|
|
// while (RESET == usart_flag_get(USART0, USART_FLAG_TBE))
|
|
// ;
|
|
// usart_data_transmit(USART0, ' ');
|
|
|
|
// // 2. 逐字节打印数据，每16字节换行
|
|
// for (size_t i = 0; i < length; i++) {
|
|
// uint8_t byte = data[i];
|
|
|
|
// // 打印高4位
|
|
// uint8_t high = (byte >> 4) & 0x0F;
|
|
// char high_char = (high < 10) ? ('0' + high) : ('A' + high - 10);
|
|
// while (RESET == usart_flag_get(USART0, USART_FLAG_TBE))
|
|
// ;
|
|
// usart_data_transmit(USART0, high_char);
|
|
|
|
// // 打印低4位
|
|
// uint8_t low = byte & 0x0F;
|
|
// char low_char = (low < 10) ? ('0' + low) : ('A' + low - 10);
|
|
// while (RESET == usart_flag_get(USART0, USART_FLAG_TBE))
|
|
// ;
|
|
// usart_data_transmit(USART0, low_char);
|
|
|
|
// // 打印空格
|
|
// while (RESET == usart_flag_get(USART0, USART_FLAG_TBE))
|
|
// ;
|
|
// usart_data_transmit(USART0, ' ');
|
|
|
|
// // 每16字节换行
|
|
// if ((i + 1) % 16 == 0 && i < length - 1) {
|
|
// // 换行
|
|
// while (RESET == usart_flag_get(USART0, USART_FLAG_TBE))
|
|
// ;
|
|
// usart_data_transmit(USART0, '\r');
|
|
// while (RESET == usart_flag_get(USART0, USART_FLAG_TBE))
|
|
// ;
|
|
// usart_data_transmit(USART0, '\n');
|
|
|
|
// // 缩进（4个空格）
|
|
// for (int j = 0; j < 4; j++) {
|
|
// while (RESET == usart_flag_get(USART0, USART_FLAG_TBE))
|
|
// ;
|
|
// usart_data_transmit(USART0, ' ');
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// // 3. 打印换行
|
|
// while (RESET == usart_flag_get(USART0, USART_FLAG_TBE))
|
|
// ;
|
|
// usart_data_transmit(USART0, '\r');
|
|
// while (RESET == usart_flag_get(USART0, USART_FLAG_TBE))
|
|
// ;
|
|
// usart_data_transmit(USART0, '\n');
|
|
// }
|
|
|
|
// void test_decrypt() {
|
|
// printf("AES Encryption Verification Starting...\r\n");
|
|
|
|
// // 定义48字节测试数据
|
|
// uint8_t plaintext[48] = {
|
|
// 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
|
|
// 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
|
|
// 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23,
|
|
// 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F};
|
|
|
|
// // 定义128位密钥 (16字节)
|
|
// uint8_t key[16] = {0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
|
|
// 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c};
|
|
|
|
// // 创建AES上下文
|
|
// aes128_context ctx;
|
|
|
|
// // 设置密钥
|
|
// aes128_set_key(&ctx, key);
|
|
|
|
// // 打印原始数据
|
|
// safe_print_hex("Original Data", plaintext, 48);
|
|
|
|
// uint8_t ciphertext[48];
|
|
// uint8_t decrypted[48];
|
|
|
|
// // 加密
|
|
// aes128_ecb_encrypt_48bytes(&ctx, plaintext, ciphertext);
|
|
// safe_print_hex("Encrypted Data", ciphertext, 48);
|
|
|
|
// // 解密
|
|
// aes128_ecb_decrypt_48bytes(&ctx, ciphertext, decrypted);
|
|
// safe_print_hex("Decrypted Data", decrypted, 48);
|
|
// }
|