hm/lishanpi
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: 工程清理，打造基础模板

Browse Source 
- 删除冗余文件：main_backup/main_minimal/main_full、GD32F4xx_AddOn_Temp/、GD32F4xx_Custom_Backup/、GD32F4xx_Official/
- 删除无关工具：read_pdf.py、openocd_test.txt、version.txt
- 重构 main.cpp：去除 STEP 机制，简化为线性启动流程
- 清理 CMakeLists.txt：移除 usart0.c 引用、死代码、冗余 REMOVE_ITEM
- 修正 config.h SystemCoreClock 为 168MHz
- 修复 gd32f4xx_it.cpp 中已删除的 main.h 引用
This commit is contained in:
hm-thinkbook14p
2026-04-26 16:38:14 +08:00
parent fc10ef2e10
commit 851c3db56e
20 changed files with 211 additions and 2324 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/main.cpp
+208 -356
View File
@@ -1,5 +1,4 @@
#include "gd32f4xx.h"
#include "gd32f4xx_exmc.h"
#include "hardware_init.h"
#include "led_driver.h"
#include "uart_driver.h"
@@ -10,43 +9,30 @@
#include <cstdio>
#include <cstring>
/* SDRAM 中分配的测试变量 */
// SDRAM 中分配的测试缓冲区
__attribute__((section(".sdram"))) uint8_t sdram_big_buffer[1024 * 1024];
/*
* 增量恢复版本
*
* STEP 控制当前启用的功能：
* STEP 0: LED 闪烁 + 直接 UART 输出（16MHz 下验证基础功能）
* STEP 1: + hardware_init（配到 168MHz）
* STEP 2: + LedManager
* STEP 3: + UartBus（C++ 驱动 + printf）
* STEP 4: + SysTick（精确延时）
* STEP 5: + SDRAM / Flash / LCD 测试
*
* 每步都有 LED 模式指示状态。
* 修改 STEP 值来逐步启用功能
*/
// =============================================================
// 板级引脚定义
// =============================================================
#define LED1_PORT GPIOE
#define LED1_PIN GPIO_PIN_3
#define LED2_PORT GPIOD
#define LED2_PIN GPIO_PIN_7
#define LED3_PORT GPIOG
#define LED3_PIN GPIO_PIN_3
#define LED4_PORT GPIOA
#define LED4_PIN GPIO_PIN_5
#define STEP 5
// =============================================================
// 早期启动函数（16MHz，无 SysTick）
// =============================================================
#define LED1_PORT GPIOE
#define LED1_PIN GPIO_PIN_3
#define LED2_PORT GPIOD
#define LED2_PIN GPIO_PIN_7
#define LED3_PORT GPIOG
#define LED3_PIN GPIO_PIN_3
#define LED4_PORT GPIOA
#define LED4_PIN GPIO_PIN_5
/* ---- 16MHz 延时 (ms*4000 ≈ 1ms) ---- */
static void delay_16m(uint32_t ms)
{
for (volatile uint32_t i = 0; i < ms * 4000U; i++)
;
for (volatile uint32_t i = 0; i < ms * 4000U; i++);
}
/* ---- 直接 LED 控制 ---- */
static void led_on(uint32_t port, uint32_t pin)
{
gpio_bit_set(port, pin);
@@ -63,14 +49,10 @@ static void led_pattern(uint8_t p)
led_off(LED2_PORT, LED2_PIN);
led_off(LED3_PORT, LED3_PIN);
led_off(LED4_PORT, LED4_PIN);
if (p & 0x01)
led_on(LED1_PORT, LED1_PIN);
if (p & 0x02)
led_on(LED2_PORT, LED2_PIN);
if (p & 0x04)
led_on(LED3_PORT, LED3_PIN);
if (p & 0x08)
led_on(LED4_PORT, LED4_PIN);
if (p & 0x01) led_on(LED1_PORT, LED1_PIN);
if (p & 0x02) led_on(LED2_PORT, LED2_PIN);
if (p & 0x04) led_on(LED3_PORT, LED3_PIN);
if (p & 0x08) led_on(LED4_PORT, LED4_PIN);
}
static void init_leds(void)
@@ -95,7 +77,6 @@ static void init_leds(void)
led_off(LED4_PORT, LED4_PIN);
}
/* ---- 直接 UART 控制 (USART0, PA9/PA10, 9600) ---- */
static void init_usart0(void)
{
rcu_periph_clock_enable(RCU_GPIOA);
@@ -115,202 +96,24 @@ static void init_usart0(void)
static void uart_putchar(char c)
{
usart_data_transmit(USART0, (uint8_t)c);
while (RESET == usart_flag_get(USART0, USART_FLAG_TBE))
;
while (RESET == usart_flag_get(USART0, USART_FLAG_TBE));
}
static void uart_puts(const char *s)
{
while (*s)
uart_putchar(*s++);
while (*s) uart_putchar(*s++);
}
static void uart_putdec(uint32_t val)
{
char buf[16];
int idx = 0;
if (val == 0)
{
uart_puts("0");
return;
}
while (val > 0)
{
buf[idx++] = '0' + (val % 10);
val /= 10;
}
while (idx > 0)
uart_putchar(buf[--idx]);
if (val == 0) { uart_puts("0"); return; }
while (val > 0) { buf[idx++] = '0' + (val % 10); val /= 10; }
while (idx > 0) uart_putchar(buf[--idx]);
}
/* ---- 测试函数 ---- */
static void test_sdram_driver(void)
{
printf("SDRAM 驱动测试开始...\r\n");
SdramManager &sdram = SdramManager::instance();
RetCode ret = sdram.init();
if (ret != RET_OK)
{
printf(" SDRAM 初始化失败: 错误码=%d\r\n", ret);
return;
}
/* ---- 诊断测试1: 直接16位指针访问 ---- */
printf(" 诊断1: 直接16位指针读写...\r\n");
volatile uint16_t *sram16 = (volatile uint16_t *)0xC0000000;
for (uint32_t i = 0; i < 8; i++)
{
sram16[i] = (uint16_t)(0xAA00 + i);
}
__DSB();
delay_1ms(1);
bool diag1_ok = true;
for (uint32_t i = 0; i < 8; i++)
{
uint16_t val = sram16[i];
uint16_t expected = (uint16_t)(0xAA00 + i);
if (val != expected)
{
printf(" 16位错误 @ [%lu]: 期望=0x%04X, 读取=0x%04X\r\n", i, expected, val);
diag1_ok = false;
}
}
printf(" 诊断1: %s\r\n", diag1_ok ? "通过" : "失败");
/* ---- 诊断测试2: 直接32位指针访问(非零值) ---- */
printf(" 诊断2: 直接32位指针非零值测试...\r\n");
volatile uint32_t *sram32 = (volatile uint32_t *)0xC0000000;
sram32[0] = 0xDEADBEEF;
sram32[1] = 0xCAFEBABE;
sram32[2] = 0x12345678;
sram32[3] = 0x87654321;
__DSB();
delay_1ms(1);
bool diag2_ok = true;
for (uint32_t i = 0; i < 4; i++)
{
uint32_t val = sram32[i];
uint32_t expected = (i == 0) ? 0xDEADBEEF : (i == 1) ? 0xCAFEBABE
: (i == 2) ? 0x12345678
: 0x87654321;
if (val != expected)
{
printf(" 32位错误 @ [%lu]: 期望=0x%08lX, 读取=0x%08lX\r\n", i, expected, val);
diag2_ok = false;
}
}
printf(" 诊断2: %s\r\n", diag2_ok ? "通过" : "失败");
/* ---- 诊断测试3: 通过驱动接口写/读 ---- */
printf(" 诊断3: 驱动接口读写...\r\n");
uint32_t write_val = 0xA5A55A5A;
uint32_t read_val = 0;
ret = sdram.write(64, &write_val, sizeof(write_val));
if (ret != RET_OK)
{
printf(" 驱动写入失败: %d\r\n", ret);
}
else
{
__DSB();
ret = sdram.read(64, &read_val, sizeof(read_val));
if (ret != RET_OK)
{
printf(" 驱动读取失败: %d\r\n", ret);
}
else
{
printf(" 写入=0x%08lX, 读取=0x%08lX, %s\r\n",
write_val, read_val,
(write_val == read_val) ? "通过" : "失败");
}
}
printf("SDRAM 驱动测试完成\r\n");
}
static void test_flash_driver(void)
{
printf("Flash 驱动测试开始...\r\n");
FlashManager &flash = FlashManager::instance();
RetCode ret = flash.init();
if (ret != RET_OK)
{
printf(" Flash 初始化失败: %d\r\n", ret);
return;
}
printf(" Flash 信息: 总大小=%lu KB, 扇区大小=%lu KB\r\n",
flash.total_size() / 1024, flash.sector_size() / 1024);
uint32_t test_address = 0x08000000U +
flash.total_size() -
flash.sector_size();
printf(" 测试地址: 0x%08lX\r\n", test_address);
uint8_t write_buffer[256];
uint8_t read_buffer[256];
for (int i = 0; i < 256; i++)
write_buffer[i] = (uint8_t)((i + 0x80) & 0xFF);
printf(" 擦除 Flash 扇区...\r\n");
ret = flash.erase(test_address, flash.sector_size());
if (ret != RET_OK)
{
printf(" Flash 擦除失败: 错误码=%d\r\n", ret);
return;
}
printf(" Flash 擦除成功\r\n");
printf(" 写入 Flash 数据...\r\n");
ret = flash.write(test_address, write_buffer, sizeof(write_buffer));
if (ret != RET_OK)
{
printf(" Flash 写入失败: %d\r\n", ret);
return;
}
printf(" Flash 写入成功\r\n");
printf(" 读取 Flash 数据...\r\n");
ret = flash.read(test_address, read_buffer, sizeof(read_buffer));
if (ret != RET_OK)
{
printf(" Flash 读取失败: %d\r\n", ret);
return;
}
printf(" Flash 读取成功\r\n");
bool verify_ok = true;
for (int i = 0; i < 256; i++)
{
if (read_buffer[i] != write_buffer[i])
{
verify_ok = false;
printf(" 数据错误 @ %d: 写入=%02X, 读取=%02X\r\n", i, write_buffer[i], read_buffer[i]);
break;
}
}
if (verify_ok)
printf(" Flash 数据验证成功\r\n");
ret = flash.self_test(256);
if (ret == RET_OK)
printf(" Flash 自测试通过\r\n");
else
printf(" Flash 自测试失败: %d\r\n", ret);
printf("Flash 驱动测试完成\r\n");
}
/* 时钟切换后重新配置USART0波特率（168MHz下9600） */
// 时钟切换到 168MHz 后重新配置 UART 波特率
static void reinit_usart0_168m(void)
{
usart_deinit(USART0);
@@ -320,43 +123,162 @@ static void reinit_usart0_168m(void)
usart_enable(USART0);
}
// =============================================================
// 外设测试函数
// =============================================================
static void test_sdram_driver(void)
{
printf("SDRAM 驱动测试开始...\r\n");
SdramManager &sdram = SdramManager::instance();
RetCode ret = sdram.init();
if (ret != RET_OK) {
printf(" SDRAM 初始化失败: 错误码=%d\r\n", ret);
return;
}
printf(" 诊断1: 直接16位指针读写...\r\n");
volatile uint16_t *sram16 = (volatile uint16_t *)0xC0000000;
for (uint32_t i = 0; i < 8; i++)
sram16[i] = (uint16_t)(0xAA00 + i);
__DSB();
delay_1ms(1);
bool diag1_ok = true;
for (uint32_t i = 0; i < 8; i++) {
uint16_t val = sram16[i];
uint16_t expected = (uint16_t)(0xAA00 + i);
if (val != expected) {
printf(" 16位错误 @ [%lu]: 期望=0x%04X, 读取=0x%04X\r\n", i, expected, val);
diag1_ok = false;
}
}
printf(" 诊断1: %s\r\n", diag1_ok ? "通过" : "失败");
printf(" 诊断2: 直接32位指针非零值测试...\r\n");
volatile uint32_t *sram32 = (volatile uint32_t *)0xC0000000;
sram32[0] = 0xDEADBEEF;
sram32[1] = 0xCAFEBABE;
sram32[2] = 0x12345678;
sram32[3] = 0x87654321;
__DSB();
delay_1ms(1);
bool diag2_ok = true;
for (uint32_t i = 0; i < 4; i++) {
uint32_t val = sram32[i];
uint32_t expected = (i == 0) ? 0xDEADBEEF : (i == 1) ? 0xCAFEBABE
: (i == 2) ? 0x12345678 : 0x87654321;
if (val != expected) {
printf(" 32位错误 @ [%lu]: 期望=0x%08lX, 读取=0x%08lX\r\n", i, expected, val);
diag2_ok = false;
}
}
printf(" 诊断2: %s\r\n", diag2_ok ? "通过" : "失败");
printf(" 诊断3: 驱动接口读写...\r\n");
uint32_t write_val = 0xA5A55A5A;
uint32_t read_val = 0;
ret = sdram.write(64, &write_val, sizeof(write_val));
if (ret != RET_OK) {
printf(" 驱动写入失败: %d\r\n", ret);
} else {
__DSB();
ret = sdram.read(64, &read_val, sizeof(read_val));
if (ret != RET_OK)
printf(" 驱动读取失败: %d\r\n", ret);
else
printf(" 写入=0x%08lX, 读取=0x%08lX, %s\r\n",
write_val, read_val,
(write_val == read_val) ? "通过" : "失败");
}
printf("SDRAM 驱动测试完成\r\n");
}
static void test_flash_driver(void)
{
printf("Flash 驱动测试开始...\r\n");
FlashManager &flash = FlashManager::instance();
RetCode ret = flash.init();
if (ret != RET_OK) {
printf(" Flash 初始化失败: %d\r\n", ret);
return;
}
printf(" Flash 信息: 总大小=%lu KB, 扇区大小=%lu KB\r\n",
flash.total_size() / 1024, flash.sector_size() / 1024);
uint32_t test_address = 0x08000000U + flash.total_size() - flash.sector_size();
printf(" 测试地址: 0x%08lX\r\n", test_address);
uint8_t write_buffer[256];
uint8_t read_buffer[256];
for (int i = 0; i < 256; i++)
write_buffer[i] = (uint8_t)((i + 0x80) & 0xFF);
printf(" 擦除 Flash 扇区...\r\n");
ret = flash.erase(test_address, flash.sector_size());
if (ret != RET_OK) { printf(" Flash 擦除失败: 错误码=%d\r\n", ret); return; }
printf(" Flash 擦除成功\r\n");
printf(" 写入 Flash 数据...\r\n");
ret = flash.write(test_address, write_buffer, sizeof(write_buffer));
if (ret != RET_OK) { printf(" Flash 写入失败: %d\r\n", ret); return; }
printf(" Flash 写入成功\r\n");
printf(" 读取 Flash 数据...\r\n");
ret = flash.read(test_address, read_buffer, sizeof(read_buffer));
if (ret != RET_OK) { printf(" Flash 读取失败: %d\r\n", ret); return; }
printf(" Flash 读取成功\r\n");
bool verify_ok = true;
for (int i = 0; i < 256; i++) {
if (read_buffer[i] != write_buffer[i]) {
verify_ok = false;
printf(" 数据错误 @ %d: 写入=%02X, 读取=%02X\r\n", i, write_buffer[i], read_buffer[i]);
break;
}
}
if (verify_ok) printf(" Flash 数据验证成功\r\n");
ret = flash.self_test(256);
if (ret == RET_OK) printf(" Flash 自测试通过\r\n");
else printf(" Flash 自测试失败: %d\r\n", ret);
printf("Flash 驱动测试完成\r\n");
}
static void test_lcd(void)
{
printf("\r\n===== LCD 完整功能测试 =====\r\n");
printf("\r\n===== LCD 功能测试 =====\r\n");
printf("[Step 0] LCD_Init (SDRAM 保持活跃)...\r\n");
printf(" LCD_Init...\r\n");
LCD_Init();
printf("[Step 0] LCD ID: %s\r\n", lcd_id);
printf(" LCD ID: %s\r\n", lcd_id);
delay_1ms(500);
// ----- 4条水平色带: 每条200行, 全屏800行 -----
uint16_t bands[4] = {RED, GREEN, BLUE, WHITE};
for (int i = 0; i < 4; i++)
{
for (int i = 0; i < 4; i++) {
int y0 = i * 200;
int y1 = y0 + 199;
printf("[色带%d] y=%d~%d color=0x%04X\r\n", i, y0, y1, bands[i]);
BlockWrite(0, 479, y0, y1);
LCD_WriteRAM_Prepare();
for (int p = 0; p < 480 * 200; p++)
LCD_WriteRAM(bands[i]);
__DSB();
}
delay_1ms(3000);
// 全屏黑色清除
printf("[测试] LCD_Clear(BLACK)\r\n");
printf(" LCD_Clear(BLACK)\r\n");
LCD_Clear(BLACK);
delay_1ms(1000);
delay_1ms(500);
// 全屏红色
printf("[测试] LCD_Clear(RED)\r\n");
printf(" LCD_Clear(RED)\r\n");
LCD_Clear(RED);
delay_1ms(1000);
printf("LCD 测试完成!\r\n");
delay_1ms(500);
printf("LCD 测试完成\r\n");
delay_1ms(2000);
}
@@ -364,174 +286,124 @@ static void test_sdram_after_lcd(void)
{
printf("\r\n===== SDRAM 数据保持验证 (LCD 操作后) =====\r\n");
volatile uint16_t *sram16 = (volatile uint16_t *)0xC0000000;
bool ok = true;
for (uint32_t i = 0; i < 8; i++)
{
volatile uint16_t *sram16 = (volatile uint16_t *)0xC0000000;
for (uint32_t i = 0; i < 8; i++) {
uint16_t val = sram16[i];
uint16_t expected = (uint16_t)(0xAA00 + i);
if (val != expected)
{
printf(" SDRAM 数据错误 @ [%lu]: 期望=0x%04X, 读取=0x%04X\r\n", i, expected, val);
if (val != expected) {
printf(" 16位错误 @ [%lu]: 期望=0x%04X, 读取=0x%04X\r\n", i, expected, val);
ok = false;
}
}
printf(" SDRAM 数据保持: %s\r\n", ok ? "通过 ? (LCD 未影响 SDRAM)" : "失败 ?");
volatile uint32_t *sram32 = (volatile uint32_t *)0xC0000000;
ok = true;
uint32_t expected_32[4] = {0xDEADBEEF, 0xCAFEBABE, 0x12345678, 0x87654321};
for (uint32_t i = 0; i < 4; i++)
{
for (uint32_t i = 0; i < 4; i++) {
uint32_t val = sram32[i];
if (val != expected_32[i])
{
printf(" SDRAM 32位数据错误 @ [%lu]: 期望=0x%08lX, 读取=0x%08lX\r\n", i, expected_32[i], val);
if (val != expected_32[i]) {
printf(" 32位错误 @ [%lu]: 期望=0x%08lX, 读取=0x%08lX\r\n", i, expected_32[i], val);
ok = false;
}
}
printf(" SDRAM 32位数据保持: %s\r\n", ok ? "通过 ?" : "失败 ?");
printf("SDRAM 验证完成\r\n");
printf(" SDRAM 数据保持: %s\r\n", ok ? "通过 (LCD 未影响 SDRAM)" : "失败");
}
static void concurrent_loop(void)
{
printf("\r\n===== 全部外设并发运行 =====\r\n");
printf("LED 闪烁 + UART 输出 + SDRAM 读写 + LCD 显示\r\n");
LCD_Clear(GREEN);
delay_1ms(500);
uint32_t counter = 0;
volatile uint16_t *sram16 = (volatile uint16_t *)0xC0000000;
for (int iter = 0; iter < 10; iter++)
{
for (int iter = 0; iter < 10; iter++) {
led_on(LED1_PORT, LED1_PIN);
led_off(LED2_PORT, LED2_PIN);
sram16[100 + iter] = (uint16_t)(iter * 0x1111);
__DSB();
uint16_t val = sram16[100 + iter];
printf("[并发] iter=%d, SDRAM[%d]=0x%04X, LED1=ON\r\n", iter, 100 + iter, val);
delay_1ms(500);
led_off(LED1_PORT, LED1_PIN);
led_on(LED2_PORT, LED2_PIN);
sram16[200 + iter] = (uint16_t)(iter * 0x2222);
__DSB();
val = sram16[200 + iter];
printf("[并发] iter=%d, SDRAM[%d]=0x%04X, LED2=ON\r\n", iter, 200 + iter, val);
delay_1ms(500);
counter += 2;
}
printf("\r\n===== 并发测试完成 =====\r\n");
printf("SDRAM 写入 %lu 个值, LCD 持续显示绿色\r\n", counter);
printf("所有外设 (Flash/SDRAM/LCD/UART/LED) 同时运行成功!\r\n");
LCD_Clear(BLUE);
delay_1ms(1000);
}
/* ============================================================== */
// =============================================================
// 主函数
// =============================================================
int main(void)
{
/* ============ STEP 0: 验证基础功能 ============ */
// ---- 早期启动: 16MHz，原始寄存器操作 ----
init_leds();
led_pattern(0x01);
init_usart0();
led_pattern(0x03);
uart_puts("\r\n===== STEP 0: Basic Functions =====\r\n");
uart_puts("LED + UART at 16MHz working\r\n");
uart_puts("\r\n===== LSPi Board Bring-Up =====\r\n");
uart_puts("Early boot: LED + UART at 16MHz\r\n");
uint32_t cs = RCU_CFG0 & RCU_CFG0_SCS;
uart_puts("Clock: ");
if (cs == RCU_SCSS_IRC16M)
uart_puts("IRC16M (16MHz)\r\n");
else if (cs == RCU_SCSS_HXTAL)
uart_puts("HXTAL (25MHz)\r\n");
else if (cs == RCU_SCSS_PLLP)
uart_puts("PLL (168MHz)\r\n");
else
uart_puts("UNKNOWN\r\n");
uart_puts("Clock source: ");
if (cs == RCU_SCSS_IRC16M) uart_puts("IRC16M (16MHz)\r\n");
else if (cs == RCU_SCSS_HXTAL) uart_puts("HXTAL (25MHz)\r\n");
else if (cs == RCU_SCSS_PLLP) uart_puts("PLL (168MHz)\r\n");
else uart_puts("UNKNOWN\r\n");
uart_puts("SystemCoreClock: ");
uart_putdec(SystemCoreClock);
uart_puts(" Hz\r\n");
/* LED 闪烁验证 */
uart_puts("Blinking LED2 3 times...\r\n");
for (int i = 0; i < 3; i++)
{
// LED 闪烁验证
for (int i = 0; i < 3; i++) {
led_on(LED2_PORT, LED2_PIN);
delay_16m(200);
led_off(LED2_PORT, LED2_PIN);
delay_16m(200);
}
uart_puts("Blink OK\r\n");
uart_puts("LED blink OK\r\n");
led_pattern(0x03);
// ---- 硬件初始化: 切换到 168MHz ----
uart_puts("Initializing hardware...\r\n");
led_pattern(0x05);
#if STEP >= 1
/* ============ STEP 1: hardware_init ============ */
uart_puts("\r\n===== STEP 1: hardware_init() =====\r\n");
led_pattern(0x04);
hardware_init();
ret_code_t hw_ret = hardware_init();
/* 时钟已切换到168MHz，重新配置UART波特率 */
reinit_usart0_168m();
uart_puts("Return code: ");
uart_putdec((uint32_t)hw_ret);
uart_puts("\r\n");
cs = RCU_CFG0 & RCU_CFG0_SCS;
uart_puts("Clock after: ");
if (cs == RCU_SCSS_IRC16M)
uart_puts("IRC16M (16MHz)\r\n");
else if (cs == RCU_SCSS_HXTAL)
uart_puts("HXTAL (25MHz)\r\n");
else if (cs == RCU_SCSS_PLLP)
uart_puts("PLL (168MHz)\r\n");
else
uart_puts("UNKNOWN\r\n");
uart_puts("Clock after init: ");
if (cs == RCU_SCSS_PLLP) uart_puts("PLL (168MHz)\r\n");
else uart_puts("UNKNOWN\r\n");
uart_puts("SystemCoreClock: ");
uart_putdec(SystemCoreClock);
uart_puts(" Hz\r\n");
led_pattern(0x05);
delay_16m(500);
#endif
#if STEP >= 2
/* ============ STEP 2: LedManager ============ */
uart_puts("\r\n===== STEP 2: LedManager =====\r\n");
led_pattern(0x06);
// ---- C++ 驱动初始化 ----
led_pattern(0x07);
LedManager::instance().init_all();
LedManager::instance().led(1).on();
delay_16m(200);
delay_16m(100);
LedManager::instance().led(1).off();
uart_puts("LedManager OK\r\n");
led_pattern(0x07);
#endif
#if STEP >= 3
/* ============ STEP 3: UartBus ============ */
uart_puts("\r\n===== STEP 3: UartBus =====\r\n");
led_pattern(0x08);
led_pattern(0x09);
{
UartConfig cfg;
cfg.baudrate = 9600;
@@ -539,58 +411,40 @@ int main(void)
}
uart_puts("UartBus init OK\r\n");
led_pattern(0x09);
#endif
#if STEP >= 4
/* ============ STEP 4: SysTick ============ */
uart_puts("\r\n===== STEP 4: SysTick =====\r\n");
led_pattern(0x0A);
systick_config();
uart_puts("systick_config() OK\r\n");
delay_1ms(500);
uart_puts("delay_1ms(500) OK\r\n");
// ---- SysTick 配置 ----
led_pattern(0x0B);
#endif
systick_config();
delay_1ms(500);
uart_puts("SysTick OK, delay_1ms available\r\n");
#if STEP >= 5
/* ============ STEP 5: Full tests ============ */
uart_puts("\r\n===== STEP 5: 全部外设测试 =====\r\n");
// ---- 外设测试 ----
led_pattern(0x0C);
printf("\r\n========================================\r\n");
printf(" LSPi 全外设测试\r\n");
printf("========================================\r\n");
/* SDRAM 测试 */
test_sdram_driver();
delay_1ms(500);
/* Flash 测试 */
test_flash_driver();
delay_1ms(500);
/* LCD 测试 (SDRAM 保持活跃, 不移除 SDRAM 初始化) */
test_lcd();
delay_1ms(500);
/* 验证 SDRAM 数据在 LCD 操作后仍然保持 */
test_sdram_after_lcd();
delay_1ms(500);
/* 全部外设并发运行: SDRAM + LCD + Flash + UART + LED */
concurrent_loop();
delay_1ms(500);
led_pattern(0x0D);
#endif
/* ============ 主循环 ============ */
uart_puts("\r\n===== Main Loop =====\r\n");
uart_puts("All hardware tests passed! System running at 168MHz\r\n");
// ---- 主循环 ----
led_pattern(0x0F);
printf("\r\n===== 所有外设测试完成 =====\r\n");
printf("系统运行于 168MHz, Flash/SDRAM/LCD/UART/LED 全部正常\r\n");
uint32_t tick = 0;
while (1)
{
while (1) {
led_on(LED4_PORT, LED4_PIN);
delay_1ms(250);
led_off(LED4_PORT, LED4_PIN);
@@ -598,8 +452,6 @@ int main(void)
tick++;
if (tick % 4 == 0)
{
printf(".");
}
}
}