【嵌入式实战-11】RT-Thread + STM32 外部SRAM调试终极指南（附避坑手册+可直接编译代码）-编程实验室

前言：在RT-Thread项目开发中，外部SRAM（常用FSMC/FMC接口）是扩展STM32内存的核心方案，常用于LCD显存、大数据缓存等场景。但调试过程中极易遇到“读写失败、HardFault、数据错乱、系统崩溃”等问题，本文按“硬件→配置→裸机→系统→异常定位”的流程，拆解可直接落地的调试技巧，汇总高频坑点，新手也能快速上手，老手可直接对照排错，建议收藏备用！

适用场景：STM32F4/F7/H7系列 + RT-Thread 4.0+ + 外部SRAM（如IS62WV51216、AS6C4008等），覆盖FSMC（F4系列）、FMC（F7/H7系列）接口调试。

一、前置准备：先避“硬件底层坑”（最易忽略，却最关键）

外部SRAM调试失败，80%的问题出在硬件，先花10分钟排查，能节省后续90%的调试时间！

1. 引脚与原理图核对（必做步骤）

核心是确保FSMC/FMC引脚与外部SRAM一一对应，重点核对以下信号（以16bit SRAM为例）：

数据线（D0~D15）：STM32的FSMC_D0~D15必须与SRAM的D0~D15对应，不能错位（错位会导致数据读写完全错乱）；
地址线（A0~An）：根据SRAM容量确定地址线数量（如1MB SRAM需A0~A19），重点注意：多数16bit SRAM无A0引脚，需按芯片手册对应STM32的A0（避免地址映射错误）；
控制信号：
- 片选（NEx）：对应FSMC/FMC的Bank1~Bank4，地址范围固定（NE1: 0x60000000，NE2: 0x64000000，NE3: 0x68000000，NE4: 0x6C000000），需确认原理图中SRAM接的是哪个NE引脚；
- 读使能（NOE）、写使能（NWE）：直接对应STM32的FSMC_NOE、FSMC_NWE，不能接反；
- 字节使能（BL0/BL1）：16bit SRAM必用，对应FSMC_BL0、FSMC_BL1，用于字节/半字读写控制，接错会导致读写数据错位；
电源与滤波：外部SRAM的VCC需与STM32供电匹配（常用3.3V），必须在VCC引脚旁并联10μF电解电容+0.1μF陶瓷电容（靠近SRAM引脚），否则电源纹波会导致读写不稳定（偶发错误、死机）；
地引脚：SRAM的GND必须与STM32的GND共地，避免地电位差导致信号干扰。

2. 硬件快速验证（用万用表/逻辑分析仪）

无需编译代码，先通过工具验证硬件连通性：

万用表测量：复位后、FSMC/FMC初始化前，NOE、NWE、NEx引脚应为高电平（低电平表示异常，可能是引脚配置错误或硬件短路）；
地址/数据线检查：上电后，地址线、数据线不应有乱跳现象（若乱跳，说明引脚浮空、驱动能力不足或硬件虚焊）；
逻辑分析仪验证（有条件优先做）：抓取写时序（地址线输出→NWE拉低→数据线输出数据→NWE拉高），对比SRAM芯片手册的时序参数，确认波形符合要求（重点看数据建立时间、地址保持时间）。

小技巧：若没有逻辑分析仪，可先焊接好硬件，后续通过裸机读写测试验证，若读写失败，再回头排查硬件。

二、FSMC/FMC配置调试（时序是重灾区，必看！）

硬件没问题后，重点调试FSMC/FMC的时序配置——时序太紧会导致偶发错误，太松会影响读写速度，需找到“稳定边界”。以下以STM32F4（FSMC）+ IS62WV51216（1MB 16bit SRAM）为例，给出可直接复用的配置代码及调试技巧。

1. 核心时序参数配置（关键！）

FSMC/FMC的时序参数需匹配SRAM芯片手册，核心参数包括地址建立时间、地址保持时间、数据建立时间，以下是典型可用配置（HCLK=168MHz）：

/* FSMC 时序配置（IS62WV51216 专用）*/ static void fsmc_sram_timing_config(void) { FSMC_NORSRAM_TimingTypeDef SRAM_Timing = {0}; // 地址建立时间（Address Setup Time）：2个HCLK周期 SRAM_Timing.AddressSetupTime = 2; // 地址保持时间（Address Hold Time）：0个HCLK周期（多数SRAM可设0） SRAM_Timing.AddressHoldTime = 0; // 数据建立时间（Data Setup Time）：7个HCLK周期（最影响稳定性，重点调试） SRAM_Timing.DataSetupTime = 7; // 总线周转时间：0（无需配置） SRAM_Timing.BusTurnAroundDuration = 0; // 访问模式：模式A（通用模式） SRAM_Timing.AccessMode = FSMC_ACCESS_MODE_A; // 初始化FSMC Bank1（NE1，地址0x60000000） FSMC_NORSRAM_InitTypeDef FSMC_NORSRAM_InitStruct = {0}; FSMC_NORSRAM_InitStruct.NORSRAMBank = FSMC_NORSRAM_BANK1; FSMC_NORSRAM_InitStruct.DataAddressMux = FSMC_DATA_ADDRESS_MUX_DISABLE; FSMC_NORSRAM_InitStruct.MemoryType = FSMC_MEMORY_TYPE_SRAM; FSMC_NORSRAM_InitStruct.MemoryDataWidth = FSMC_NORSRAM_MEM_BUS_WIDTH_16; // 16bit SRAM FSMC_NORSRAM_InitStruct.BurstAccessMode = FSMC_BURST_ACCESS_MODE_DISABLE; FSMC_NORSRAM_InitStruct.WaitSignalPolarity = FSMC_WAIT_SIGNAL_POLARITY_LOW; FSMC_NORSRAM_InitStruct.WaitSignalActive = FSMC_WAIT_TIMING_BEFORE_WS; FSMC_NORSRAM_InitStruct.WriteOperation = FSMC_WRITE_OPERATION_ENABLE; // 允许写操作 FSMC_NORSRAM_InitStruct.WaitSignal = FSMC_WAIT_SIGNAL_DISABLE; FSMC_NORSRAM_InitStruct.ExtendedMode = FSMC_EXTENDED_MODE_DISABLE; FSMC_NORSRAM_InitStruct.AsynchronousWait = FSMC_ASYNCHRONOUS_WAIT_DISABLE; FSMC_NORSRAM_InitStruct.WriteBurst = FSMC_WRITE_BURST_DISABLE; FSMC_NORSRAM_Init(&FSMC_NORSRAM_InitStruct, &SRAM_Timing, &SRAM_Timing); // 使能FSMC Bank1 FSMC_NORSRAM_Enable(FSMC_NORSRAM_BANK1); }

2. 时序调试技巧（快速找到稳定配置）

先松后紧：调试初期，将DataSetupTime改大（如8~15），先保证读写稳定，再逐步减小该值，直到出现读写错误，取错误前的一个值作为最终配置（兼顾稳定性和速度）；
地址线验证：配置完成后，写死指针测试地址映射是否正确（避免Bank选错）：

#define SRAM_BASE 0x60000000 // NE1对应地址
volatile uint16_t *sram_ptr = (uint16_t*)SRAM_BASE; // 16bit指针，匹配SRAM位宽

不同系列适配：STM32F7/H7用FMC接口，配置逻辑与FSMC一致，仅结构体名称不同（如FMC_NORSRAM_TimingTypeDef），时序参数可参考上述配置，适当调整DataSetupTime；
寄存器在线调试：MDK中，可在“Memory”窗口直接修改FSMC/FMC的时序寄存器（如FSMC_BTR1），无需重编译，快速验证时序参数的合理性。

三、RT-Thread环境适配：先裸机测试，再上系统（避坑关键）

很多开发者直接将外部SRAM加入RT-Thread内存管理，一旦出现问题，无法区分是“FSMC配置问题”还是“系统配置问题”。正确做法是：先脱离RTOS，做裸机读写测试；验证通过后，再加入RT-Thread内存堆管理。

第一步：裸机读写测试（最小验证单元）

在board.c或单独的drv_sram_ex.c中，初始化FSMC/FMC后，立即运行以下测试函数，验证SRAM读写稳定性（可直接复制编译）：

/** * @brief 外部SRAM裸机读写测试（脱离RT-Thread，仅依赖HAL库） * @retval 0：测试通过，-1：测试失败 */ int sram_bare_test(void) { volatile uint16_t *sram_ptr = (uint16_t*)0x60000000; // SRAM起始地址 uint32_t i; uint16_t write_data, read_data; // 打印测试信息（需初始化串口） rt_kprintf("External SRAM bare test start...\n"); // 1. 单地址读写测试（验证基本连通性） write_data = 0x55AA; sram_ptr[0] = write_data; read_data = sram_ptr[0]; if(read_data != write_data) { rt_kprintf("Error: Single address r/w failed! Write:0x%x, Read:0x%x\n", write_data, read_data); return -1; } // 2. 全地址0x5555写入测试（验证地址线完整性） for(i = 0; i < (1*1024*1024)/2; i++) // 1MB SRAM，16bit读写，循环次数=容量/2 { sram_ptr[i] = 0x5555; } for(i = 0; i < (1*1024*1024)/2; i++) { if(sram_ptr[i] != 0x5555) { rt_kprintf("Error: 0x5555 write failed at address 0x%x\n", (uint32_t)&sram_ptr[i]); return -1; } } // 3. 全地址0xAAAA反写测试（验证数据稳定性） for(i = 0; i < (1*1024*1024)/2; i++) { sram_ptr[i] = 0xAAAA; } for(i = 0; i < (1*1024*1024)/2; i++) { if(sram_ptr[i] != 0xAAAA) { rt_kprintf("Error: 0xAAAA write failed at address 0x%x\n", (uint32_t)&sram_ptr[i]); return -1; } } // 4. 随机地址读写测试（模拟实际使用场景） for(i = 0; i < 1000; i++) { uint32_t rand_addr = rand() % ((1*1024*1024)/2); // 随机地址 write_data = rand() % 0xFFFF; // 随机数据 sram_ptr[rand_addr] = write_data; read_data = sram_ptr[rand_addr]; if(read_data != write_data) { rt_kprintf("Error: Random r/w failed at address 0x%x\n", (uint32_t)&sram_ptr[rand_addr]); return -1; } } rt_kprintf("External SRAM bare test OK!\n"); return 0; } // 在main函数或board初始化中调用 int main(void) { // 1. 初始化HAL库、串口 HAL_Init(); SystemClock_Config(); MX_USART1_UART_Init(); // 2. 初始化FSMC/FMC fsmc_sram_timing_config(); // 3. 裸机测试 sram_bare_test(); while(1) { // 测试通过后，可加入其他逻辑 } }

裸机测试现象判断（快速定位问题）

测试现象	大概率原因	解决方向
读回数据全为0x00或0xFF	硬件未连通、片选引脚接错、FSMC未初始化	重新核对引脚、检查FSMC初始化代码、测量片选电平
部分地址读写错误	地址线接错、虚焊，或时序太紧	重新焊接地址线、增大DataSetupTime
第一次测试通过，第二次死机	电源不稳、时序太紧、SRAM发热	加强电源滤波、增大时序参数、检查SRAM散热
随机地址测试失败	信号干扰、时序不稳定	优化PCB布线（缩短信号线）、增大DataSetupTime

第二步：加入RT-Thread内存堆管理（多堆配置）

裸机测试通过后，将外部SRAM注册为RT-Thread的内存堆，供系统和应用程序申请使用，步骤如下：

1. 开启RT-Thread多内存堆功能

通过menuconfig配置（在RT-Thread Studio或MDK中操作）：

RT-Thread Components → Memory Management →
[*] Enable multiple memory heap # 开启多内存堆
[*] Enable memory heap statistic # 开启堆统计（方便调试）

配置完成后，重新生成工程（RT-Thread Studio）或重新编译（MDK）。

2. 注册外部SRAM为内存堆（board.c中添加）

在board.c的末尾，添加外部SRAM堆初始化代码，注册到RT-Thread系统中：

#include <rtmemheap.h> // 外部SRAM配置（根据实际硬件修改） #define EX_SRAM_START 0x60000000 // SRAM起始地址（对应NE1） #define EX_SRAM_SIZE (1*1024*1024) // SRAM容量（1MB） static struct rt_memheap ex_sram_heap; // 外部SRAM堆结构体 /** * @brief 外部SRAM堆初始化（注册到RT-Thread） * @retval RT_EOK：初始化成功，-RT_ERROR：初始化失败 */ int rt_hw_sram_init(void) { // 1. 先初始化FSMC/FMC（调用之前写的时序配置函数） fsmc_sram_timing_config(); // 2. 注册外部SRAM堆 rt_err_t ret = rt_memheap_init(&ex_sram_heap, "extsram", // 堆名称（可自定义） (void*)EX_SRAM_START, // 堆起始地址 EX_SRAM_SIZE); // 堆大小 if(ret != RT_EOK) { rt_kprintf("External SRAM heap init failed!\n"); return -RT_ERROR; } rt_kprintf("External SRAM heap init OK! Size: %d KB\n", EX_SRAM_SIZE/1024); return RT_EOK; } // 注册为板级初始化函数（在系统启动时自动执行） INIT_BOARD_EXPORT(rt_hw_sram_init);

3. 外部SRAM使用示例（应用层调用）

注册完成后，可通过以下方式使用外部SRAM的内存：

// 方式1：从外部SRAM堆中申请内存（推荐） void *ex_mem_ptr = rt_memheap_alloc(&ex_sram_heap, 1024*256); // 申请256KB内存 if(ex_mem_ptr != RT_NULL) { rt_kprintf("Allocate 256KB from external SRAM OK!\n"); // 使用内存... rt_memheap_free(&ex_sram_heap, ex_mem_ptr); // 释放内存 } else { rt_kprintf("Allocate external SRAM failed!\n"); } // 方式2：将全局变量指定到外部SRAM（适合固定大小的缓存，如LCD显存） uint8_t g_lcd_buf[512*1024] __attribute__((section(".extsram"))); // 512KB LCD显存

注意：若使用方式2，需修改链接脚本（如stm32f4xx_flash.ld），添加.extsram段，指定外部SRAM地址范围，否则变量会被分配到内部Flash/ram中。

四、RT-Thread下典型异常与调试方案（高频坑点）

加入RT-Thread后，可能会出现HardFault、数据错乱、堆申请失败等问题，以下是高频异常的原因及解决方案，直接对照排查即可。

异常1：HardFault（硬件错误）/ unaligned access（非对齐访问）

最常见的异常，多出现于STM32F7/H7系列，原因及解决方法如下：

核心原因：
- F7/H7系列对外部RAM有严格的对齐要求，使用char/uint16_t指针乱访问（如32bit地址访问16bit数据），会触发非对齐访问异常；
- MPU（内存保护单元）未配置，外部SRAM被设为“不可访问”或“不可缓存”，导致CPU访问时触发HardFault。
解决方案：
- 开启MPU，配置外部SRAM区域为“可缓存、可缓冲”，具体配置（以H7为例）：// MPU配置外部SRAM区域（0x60000000~0x60FFFFFF，1MB）

// MPU配置外部SRAM区域（0x60000000~0x60FFFFFF，1MB） void mpu_config_ex_sram(void) { MPU_Region_InitTypeDef MPU_InitStruct = {0}; // 禁用MPU HAL_MPU_Disable(); // 配置外部SRAM区域 MPU_InitStruct.Enable = MPU_REGION_ENABLE; MPU_InitStruct.BaseAddress = EX_SRAM_START; MPU_InitStruct.Size = MPU_REGION_SIZE_1MB; // 匹配SRAM容量 MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS; // 全访问权限 MPU_InitStruct.IsBufferable = MPU_ACCESS_BUFFERABLE; // 可缓冲 MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE; // 可缓存 MPU_InitStruct.IsShareable = MPU_ACCESS_SHAREABLE; // 可共享 MPU_InitStruct.Number = MPU_REGION_NUMBER0; MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0; MPU_InitStruct.SubRegionDisable = 0x00; MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_DISABLE; HAL_MPU_ConfigRegion(&MPU_InitStruct); // 启用MPU HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT); }

在rt_hw_sram_init()中调用mpu_config_ex_sram()，即可完成MPU配置。

强制变量/指针按4字节对齐，避免非对齐访问：// 强制4字节对齐uint32_t ex_buf[256] __attribute__((aligned(4)));// 指针强制对齐volatile uint32_t *ex_ptr = (volatile uint32_t*)EX_SRAM_START;

定位异常代码：RT-Thread报错“unaligned access”时，查看调试器的LR（返回地址）、PC（程序计数器），定位到具体的代码行，修改指针访问方式。

异常2：数据偶尔错乱、系统莫名崩溃

多为“资源竞争”或“配置遗漏”导致，排查方向如下：

DMA与CPU同时访问外部SRAM：若外部SRAM同时被DMA（如LCD显示DMA）和CPU读写，会导致数据冲突、错乱。解决方案：使用RT-Thread的互斥锁，保护外部SRAM的访问；或合理规划DMA和CPU的访问时序，避免同时访问。
中断优先级问题：FSMC/FMC相关中断（如有）优先级太高，会打断SRAM读写过程，导致数据错乱。解决方案：降低FSMC/FMC中断优先级，确保SRAM读写过程不被打断。
任务栈溢出：若将任务栈放到外部SRAM，未保证8字节对齐，或栈大小设置不足，会导致任务栈溢出，系统崩溃。解决方案：任务栈强制8字节对齐，适当增大栈大小（如设置为2048字节以上）。

异常3：memheap申请失败、free死机

核心是“堆配置错误”，检查以下几点：

rt_memheap_init()的起始地址、大小是否正确（需与SRAM实际容量、地址匹配，不能超出SRAM地址范围）；
链接脚本是否占用了外部SRAM地址（若链接脚本中已将部分地址分配给其他段，会导致堆初始化失败）；
开启堆调试日志：在rtconfig.h中添加以下定义，查看堆的使用情况，定位问题：

#define DBG_TAG "memheap"#define DBG_LVL DBG_LOG // 开启日志输出

五、RT-Thread调试工具与命令（高效排错）

利用RT-Thread的调试命令和工具，可快速定位外部SRAM的问题，无需反复重编译。

list_memheap 命令：在RT-Thread控制台输入该命令，查看所有内存堆的信息，包括外部SRAM堆的总大小、已用大小、最大空闲块，判断堆是否正常初始化、是否有足够的内存可申请。示例输出：

msh > list_memheapmemheap list:heap[0]: name:heap, start:0x20000000, size:81920(79K), used:0(0K), max_free:81920(79K)heap[1]: name:extsram, start:0x60000000, size:1048576(1024K), used:0(0K), max_free:1048576(1024K)

在线修改时序：MDK中，打开“Memory”窗口，输入FSMC/FMC寄存器地址（如FSMC_BTR1），直接修改时序参数（如DataSetupTime），点击“写入”，无需重编译，快速验证时序的稳定性。
内存窗口观察：MDK中，打开“Memory”窗口，输入外部SRAM起始地址（如0x60000000），查看数据是否正确写入、是否有乱码，快速判断读写是否正常。
逻辑分析仪抓总线：抓取NE（片选）、NOE（读使能）、NWE（写使能）、A0（地址线）、D0（数据线）的波形，对比SRAM芯片手册的时序要求，定位时序问题（最精准的排错方式）。

六、快速排错流程（建议收藏，调试时直接对照）

按以下顺序排查，可快速定位90%的外部SRAM调试问题，避免盲目调试：

硬件排查：引脚接线、电源滤波、地电位 → 用万用表测量关键信号电平；
时序配置：放宽DataSetupTime，做裸机单地址读写测试 → 逐步优化时序；
裸机全测试：运行裸机全地址读写、随机读写测试，确保SRAM本身无问题；
系统适配：注册外部SRAM堆，用list_memheap命令验证堆初始化；
异常定位：若出现HardFault、数据错乱，对照“异常调试方案”，排查对齐、MPU、DMA冲突等问题。

七、高频坑点总结（避坑手册，新手必看）

坑点1：地址线A0接错 → 读回数据完全乱（最常见，尤其是16bit SRAM）；
坑点2：时序太紧（DataSetupTime太小） → 偶发错误、死机，尤其是高主频（如168MHz）场景；
坑点3：F7/H7系列未配置MPU → 访问外部SRAM触发HardFault；
坑点4：非对齐访问 → F7/H7必触发unaligned access异常；
坑点5：堆初始化太晚 → 在INIT_BOARD_EXPORT之前使用外部内存，导致堆未初始化就被访问；
坑点6：DMA与CPU同时访问 → 数据损坏、系统崩溃；
坑点7：链接脚本未配置.extsram段 → 全局变量无法分配到外部SRAM；
坑点8：电源滤波不足 → 读写不稳定、偶发错误。

八、附录：可直接编译的完整代码（适配STM32F4+IS62WV51216）

以下代码整合了FSMC初始化、裸机测试、RT-Thread堆注册，复制到board.c中，修改引脚定义后即可编译使用（需根据实际硬件调整引脚）：

#include<rtthread.h> #include <rtdevice.h> #include <board.h> #include <rtmemheap.h> #include "stm32f4xx_hal.h" // 外部SRAM配置（根据实际硬件修改） #define EX_SRAM_START 0x60000000 #define EX_SRAM_SIZE (1*1024*1024) static struct rt_memheap ex_sram_heap; // FSMC引脚定义（以STM32F407为例，需根据实际引脚修改） #define FSMC_DATA_PORT GPIOE #define FSMC_ADDR_PORT GPIOF #define FSMC_CTRL_PORT GPIOG #define FSMC_D0_PIN GPIO_PIN_7 #define FSMC_D1_PIN GPIO_PIN_8 #define FSMC_D2_PIN GPIO_PIN_9 #define FSMC_D3_PIN GPIO_PIN_10 #define FSMC_D4_PIN GPIO_PIN_11 #define FSMC_D5_PIN GPIO_PIN_12 #define FSMC_D6_PIN GPIO_PIN_13 #define FSMC_D7_PIN GPIO_PIN_14 #define FSMC_D8_PIN GPIO_PIN_15 #define FSMC_D9_PIN GPIO_PIN_0 #define FSMC_D10_PIN GPIO_PIN_1 #define FSMC_D11_PIN GPIO_PIN_2 #define FSMC_D12_PIN GPIO_PIN_3 #define FSMC_D13_PIN GPIO_PIN_4 #define FSMC_D14_PIN GPIO_PIN_5 #define FSMC_D15_PIN GPIO_PIN_6 #define FSMC_A0_PIN GPIO_PIN_0 #define FSMC_A1_PIN GPIO_PIN_1 #define FSMC_A2_PIN GPIO_PIN_2 #define FSMC_A3_PIN GPIO_PIN_3 #define FSMC_A4_PIN GPIO_PIN_4 #define FSMC_A5_PIN GPIO_PIN_5 #define FSMC_A6_PIN GPIO_PIN_12 #define FSMC_A7_PIN GPIO_PIN_13 #define FSMC_A8_PIN GPIO_PIN_14 #define FSMC_A9_PIN GPIO_PIN_15 #define FSMC_A10_PIN GPIO_PIN_0 #define FSMC_A11_PIN GPIO_PIN_1 #define FSMC_A12_PIN GPIO_PIN_2 #define FSMC_A13_PIN GPIO_PIN_3 #define FSMC_A14_PIN GPIO_PIN_4 #define FSMC_A15_PIN GPIO_PIN_5 #define FSMC_A16_PIN GPIO_PIN_6 #define FSMC_A17_PIN GPIO_PIN_7 #define FSMC_A18_PIN GPIO_PIN_8 #define FSMC_A19_PIN GPIO_PIN_9 #define FSMC_NE1_PIN GPIO_PIN_9 #define FSMC_NOE_PIN GPIO_PIN_10 #define FSMC_NWE_PIN GPIO_PIN_11 #define FSMC_BL0_PIN GPIO_PIN_12 #define FSMC_BL1_PIN GPIO_PIN_13 /** * @brief FSMC引脚初始化 */ static void fsmc_gpio_init(void) { GPIO_InitTypeDef GPIO_InitStruct = {0}; // 使能GPIO时钟 __HAL_RCC_GPIOE_CLK_ENABLE(); __HAL_RCC_GPIOF_CLK_ENABLE(); __HAL_RCC_GPIOG_CLK_ENABLE(); __HAL_RCC_FSMC_CLK_ENABLE(); // 数据线D0~D15 GPIO_InitStruct.Pin = FSMC_D0_PIN | FSMC_D1_PIN | FSMC_D2_PIN | FSMC_D3_PIN | FSMC_D4_PIN | FSMC_D5_PIN | FSMC_D6_PIN | FSMC_D7_PIN; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Alternate = GPIO_AF12_FSMC; HAL_GPIO_Init(FSMC_DATA_PORT, &GPIO_InitStruct); GPIO_InitStruct.Pin = FSMC_D8_PIN | FSMC_D9_PIN | FSMC_D10_PIN | FSMC_D11_PIN | FSMC_D12_PIN | FSMC_D13_PIN | FSMC_D14_PIN | FSMC_D15_PIN; HAL_GPIO_Init(FSMC_ADDR_PORT, &GPIO_InitStruct); // 地址线A0~A19 GPIO_InitStruct.Pin = FSMC_A0_PIN | FSMC_A1_PIN | FSMC_A2_PIN | FSMC_A3_PIN | FSMC_A4_PIN | FSMC_A5_PIN | FSMC_A6_PIN | FSMC_A7_PIN | FSMC_A8_PIN | FSMC_A9_PIN; HAL_GPIO_Init(FSMC_ADDR_PORT, &GPIO_InitStruct); GPIO_InitStruct.Pin = FSMC_A10_PIN | FSMC_A11_PIN | FSMC_A12_PIN | FSMC_A13_PIN | FSMC_A14_PIN | FSMC_A15_PIN | FSMC_A16_PIN | FSMC_A17_PIN | FSMC_A18_PIN | FSMC_A19_PIN; HAL_GPIO_Init(FSMC_CTRL_PORT, &GPIO_InitStruct); // 控制信号 GPIO_InitStruct.Pin = FSMC_NE1_PIN | FSMC_NOE_PIN | FSMC_NWE_PIN | FSMC_BL0_PIN | FSMC_BL1_PIN; HAL_GPIO_Init(FSMC_CTRL_PORT, &GPIO_InitStruct); } /** * @brief FSMC时序配置 */ static void fsmc_sram_timing_config(void) { fsmc_gpio_init(); FSMC_NORSRAM_TimingTypeDef SRAM_Timing = {0}; SRAM_Timing.AddressSetupTime = 2; SRAM_Timing.AddressHoldTime = 0; SRAM_Timing.DataSetupTime = 7; SRAM_Timing.BusTurnAroundDuration = 0; SRAM_Timing.AccessMode = FSMC_ACCESS_MODE_A; FSMC_NORSRAM_InitTypeDef FSMC_NORSRAM_InitStruct = {0}; FSMC_NORSRAM_InitStruct.NORSRAMBank = FSMC_NORSRAM_BANK1; FSMC_NORSRAM_InitStruct.DataAddressMux = FSMC_DATA_ADDRESS_MUX_DISABLE; FSMC_NORSRAM_InitStruct.MemoryType = FSMC_MEMORY_TYPE_SRAM; FSMC_NORSRAM_InitStruct.MemoryDataWidth = FSMC_NORSRAM_MEM_BUS_WIDTH_16; FSMC_NORSRAM_InitStruct.BurstAccessMode = FSMC_BURST_ACCESS_MODE_DISABLE; FSMC_NORSRAM_InitStruct.WaitSignalPolarity = FSMC_WAIT_SIGNAL_POLARITY_LOW; FSMC_NORSRAM_InitStruct.WaitSignalActive = FSMC_WAIT_TIMING_BEFORE_WS; FSMC_NORSRAM_InitStruct.WriteOperation = FSMC_WRITE_OPERATION_ENABLE; FSMC_NORSRAM_InitStruct.WaitSignal = FSMC_WAIT_SIGNAL_DISABLE; FSMC_NORSRAM_InitStruct.ExtendedMode = FSMC_EXTENDED_MODE_DISABLE; FSMC_NORSRAM_InitStruct.AsynchronousWait = FSMC_ASYNCHRONOUS_WAIT_DISABLE; FSMC_NORSRAM_InitStruct.WriteBurst = FSMC_WRITE_BURST_DISABLE; FSMC_NORSRAM_Init(&FSMC_NORSRAM_InitStruct, &SRAM_Timing, &SRAM_Timing); FSMC_NORSRAM_Enable(FSMC_NORSRAM_BANK1); } /** * @brief 裸机读写测试 */ int sram_bare_test(void) { volatile uint16_t *sram_ptr = (uint16_t*)EX_SRAM_START; uint32_t i; uint16_t write_data, read_data; rt_kprintf("External SRAM bare test start...\n"); // 单地址测试 write_data = 0x55AA; sram_ptr[0] = write_data; read_data = sram_ptr[0]; if(read_data != write_data) { rt_kprintf("Single address r/w failed! Write:0x%x, Read:0x%x\n", write_data, read_data); return -1; } // 全地址0x5555测试 for(i = 0; i < EX_SRAM_SIZE/2; i++) { sram_ptr[i] = 0x5555; } for(i = 0; i< EX_SRAM_SIZE/2; i++) { if(sram_ptr[i] != 0x5555) { rt_kprintf("0x5555 write failed at address 0x%x\n", (uint32_t)&sram_ptr[i]); return -1; } } // 全地址0xAAAA测试 for(i = 0; i < EX_SRAM_SIZE/2; i++) { sram_ptr[i] = 0xAAAA; } for(i = 0; i < EX_SRAM_SIZE/2; i++) { if(sram_ptr[i] != 0xAAAA) { rt_kprintf("0xAAAA write failed at address 0x%x\n", (uint32_t)&sram_ptr[i]); return -1; } } rt_kprintf("External SRAM bare test OK!\n"); return 0; } /** * @brief 外部SRAM堆初始化 */ int rt_hw_sram_init(void) { fsmc_sram_timing_config(); sram_bare_test(); // 裸机测试，验证通过后再注册堆 rt_err_t ret = rt_memheap_init(&ex_sram_heap, "extsram", (void*)EX_SRAM_START, EX_SRAM_SIZE); if(ret != RT_EOK) { rt_kprintf("External SRAM heap init failed!\n"); return -RT_ERROR; } rt_kprintf("External SRAM heap init OK! Size: %d KB\n", EX_SRAM_SIZE/1024); return RT_EOK; } INIT_BOARD_EXPORT(rt_hw_sram_init);