使用memheap内存管理算法对片内RAM和片外SDRAM进行管理的方法

  在开发中由于单片机自带的 RAM 空间比较小，有时候需要扩展片外的 RAM 以供使用，RT-Thread 提供了 memheap 管理算法来管理多块不相邻的内存空间，本文以正点原子的 STM32F429 阿波罗开发板为例，讲解使用 memheap 内存管理算法对内部 RAM 和片外的 SDRAM 进行管理的方法，使用的软件包为基于开发板的 STM32F429-ATK-APOLLO v0.1.0 软件包。

1 memheap 管理算法简介

  本部分来源于 RT-Thread 的 [memheap 管理算法官方文档](https://www.rt-thread.org/document/site/#/rt-thread-version/rt-thread-standard/programming-manual/memory/memory?id=memheap-%e7%ae%a1%e7%90%86%e7%ae%97%e6%b3%95)。
  memheap 管理算法适用于系统含有多个地址可不连续的内存堆。使用 memheap 内存管理可以简化系统存在多个内存堆时的使用：当系统中存在多个内存堆的时候，用户只需要在系统初始化时将多个所需的 memheap 初始化，并开启 memheap 功能就可以很方便地把多个 memheap（地址可不连续）粘合起来用于系统的 heap 分配。
注：在开启 memheap 之后原来的 heap 功能将被关闭，两者只可以通过打开或关闭 RT_USING_MEMHEAP_AS_HEAP 来选择其一。memheap 工作机制如下图所示，首先将多块内存加入 memheap_item 链表进行粘合。当分配内存块时，会先从默认内存堆去分配内存，当分配不到时会查找 memheap_item 链表，尝试从其他的内存堆上分配内存块。应用程序不用关心当前分配的内存块位于哪个内存堆上，就像是在操作一个内存堆。

2 只使用片内 RAM 的示例

平时用的就是从片内申请内存，写这部分主要是为了和从片外 SDRAN 申请内存进行对比。选择以开发板创建工程后，选择 STM32F429-ATK-APOLLO 开发板，工程创建后默认是没有开启片外的 SDRAM 的，此时工程中只配置了片内的 RAM 作为内存堆，我们编写一个 sram 内存堆的申请测试函数进行内存堆的测试，测试代码如下所示（示例仅作为测试使用，目的是了解原理，均没有写内存堆的释放函数，下面的测试函数一样）。

void sram_test(void)
{
   int size = 50 * 1024;  // 50KBytes
   rt_uint8_t * ptr = RT_NULL;
   ptr = rt_malloc(size);
   if(ptr != RT_NULL)
   {
       LOG_D("ptr = %p", ptr); // 打印申请到的空间的首地址
   }
   else
   {
       LOG_E("malloc failed");
   }
}
MSH_CMD_EXPORT(sram_test, sram test)

  编译烧写后我们使用定义的 sram_test 命令来进行内存堆的申请测试，测试结果如下。根据测试的日志信息我们可以看出系统复位后内存堆的空间为 183400 字节，我们设定的是每次申请 50KB = 51200 字节的空间，每次申请后打印出剩余的内存堆空间的大小。从结果可以看出，每次申请的内存空间的地址都是 0x2000****，这是因为 STM32 的内部 RAM 空间的起始地址为 0x20000000，等到第四次申请时内部 RAM 的剩余空间大小不够导致申请失败。

\ | /
- RT -     Thread Operating System
/ | \     4.0.4 build May 10 2022 21:04:03
2006 - 2021 Copyright by rt-thread team
msh >list_memheap    /* 初始时，打印内存堆空间的信息 */
memheap   pool size  max used size available size
-------- ---------- ------------- --------------
heap     190756     7356          183400
msh >sram_test
[D/main] ptr = 20003380
msh >list_memheap    /* 第 1 次申请后，打印内存堆空间的信息 */
memheap   pool size  max used size available size
-------- ---------- ------------- --------------
heap     190756     58580         132176
msh >sram_test
[D/main] ptr = 2000fb98
msh >list_memheap    /* 第 2 次申请后，打印内存堆空间的信息 */
memheap   pool size  max used size available size
-------- ---------- ------------- --------------
heap     190756     109804        80952
msh >sram_test
[D/main] ptr = 2001c3b0
msh >list_memheap    /* 第 3 次申请后，打印内存堆空间的信息 */
memheap   pool size  max used size available size
-------- ---------- ------------- --------------
heap     190756     161028        29728
msh >sram_test
[E/main] malloc failed
msh >sram_test
[E/main] malloc failed
msh >list_memheap    /* 申请失败后，打印内存堆空间的信息 */
memheap   pool size  max used size available size
-------- ---------- ------------- --------------
heap     190756     161028        29728

3 配置片外 SDRAM 和 内存管理算法

  在 RT-Thread Settings 里面可以配置使能片外的 SDRAM，配置方式如下图所示，配置后 SDRAM 的驱动代码位于路径 libraries/HAL_Drivers/drv_sdram.c 下。SDRAM 外设的配置讲解可以参考文章 [RT Thread Studio RGB屏幕之 SDRAM 配置](https://club.rt-thread.org/ask/article/47789c36753224f8.html)

  配置好了片外的 SDRAM 后，我们还需要选择相应的内存管理算法，同样在 RT-Thread Settings 里面进行配置，配置界面如下图所示。

4 SDRAM 的读写测试

  配置完 SDRAM 和内存管理算法后，我们需要将片外的 SDRAM 加入到 memheap_item 链表中进行管理，添加的方法如下：

struct rt_memheap sdram_heap;                  // memheap 控制块
#define SDRAM_BANK_ADDR ((uint32_t)0XC0000000) // SDRAM 的起始地址
#define SDRAM_SIZE      ((uint32_t)0x2000000)  // SDRAM 的大小
/* SDRAM 内存堆的初始化 */
rt_memheap_init(&sdram_heap, "sdram", (void *)SDRAM_BANK_ADDR, SDRAM_SIZE);
  将 SDRAM 内存堆进行初始化后，编译下载置开发板可以后，使用 list_memheap 可以看到新增加的 sdram 内存堆，如下所示。我们可以看到片外的 SDRAM 初始化之后我们并没有使用，但是在 max used size 字段中确显示已经使用了 48 字节的空间，这部分空间是内存堆的数据头，用于 magic、used 信息及链表节点使用。
c
\ | /
- RT -     Thread Operating System
/ | \     4.0.4 build May 10 2022 21:24:46
2006 - 2021 Copyright by rt-thread team
msh >list_memheap
memheap   pool size  max used size available size
-------- ---------- ------------- --------------
sdram    33554432   48            33554384   /* 新增加的 SDRAM */
heap     190584     7356          183228     /* 片内的 RAM */

  为了测试我们初始化的 SDRAM 是否可以正常使用，通常我们会首先写一个 SDRAM 的读写测试函数，对 SDRAM 的每个字节进行读写测试，根据写入和读出的结果是否一致来判断 SDRAM 是否配置正确，读写测试代码如下。正点原子 F429 阿波罗开发板的 SDRAM 使用的是 16 根地址线，因此读写测试时数据位的宽度定义为 16。

#define SDRAM_DATA_WIDTH 16  // 数据位的宽度
#define SDRAM_BANK_ADDR  ((uint32_t)0XC0000000)  // SDRAM 的起始地址
int sdram_test(void)
{
   int i = 0;
   uint32_t start_time = 0, time_cast = 0;
#if SDRAM_DATA_WIDTH == 8
   char data_width = 1;
   uint8_t data = 0;
#elif SDRAM_DATA_WIDTH == 16
   char data_width = 2;
   uint16_t data = 0;
#else
   char data_width = 4;
   uint32_t data = 0;
#endif
   /* write data */
   LOG_D("Writing the %ld bytes data, waiting....", SDRAM_SIZE);
   start_time = rt_tick_get();
   for (i = 0; i < SDRAM_SIZE / data_width; i++)
   {
#if SDRAM_DATA_WIDTH == 8
       *(__IO uint8_t *)(SDRAM_BANK_ADDR + i * data_width) = (uint8_t)0x55;
#elif SDRAM_DATA_WIDTH == 16
       *(__IO uint16_t *)(SDRAM_BANK_ADDR + i * data_width) = (uint16_t)(i % 65535);
#else
       *(__IO uint32_t *)(SDRAM_BANK_ADDR + i * data_width) = (uint32_t)0x55555555;
#endif
   }
   time_cast = rt_tick_get() - start_time;
   LOG_D("Write data success, total time: %d.%03dS.", time_cast / RT_TICK_PER_SECOND,
         time_cast % RT_TICK_PER_SECOND / ((RT_TICK_PER_SECOND * 1 + 999) / 1000));
   /* read data */
   LOG_D("start Reading and verifying data, waiting....");
   for (i = 0; i < SDRAM_SIZE / data_width; i++)
   {
#if SDRAM_DATA_WIDTH == 8
       data = *(__IO uint8_t *)(SDRAM_BANK_ADDR + i * data_width);
       if (data != 0x55)
       {
           LOG_E("SDRAM test failed!");
           break;
       }
#elif SDRAM_DATA_WIDTH == 16
       data = *(__IO uint16_t *)(SDRAM_BANK_ADDR + i * data_width);
       if (data != (i % 65535))
       {
           LOG_E("SDRAM test failed!");
           break;
       }
#else
       data = *(__IO uint32_t *)(SDRAM_BANK_ADDR + i * data_width);
       if (data != 0x55555555)
       {
           LOG_E("SDRAM test failed!");
           break;
       }
#endif
   }
   if (i >= SDRAM_SIZE / data_width)
   {
       LOG_D("SDRAM test success!");
   }
   return RT_EOK;
}
MSH_CMD_EXPORT(sdram_test, sdram test)

  执行读写测试函数后，如果测试成功，日志信息如下。需要注意的是，读写测试函数是对片外 SDRAM 的整片的测试，执行完读写测试代码后，如果申请片外 SDRAM 的空间会直接导致硬件错误，因为我们对 SDRAM 整片的读写测试破坏了 SDRAM 中保存的数据头的信息，所以申请会出错。测试 SDRAM 的读写没有问题后我们应该重启开发板进行内存的申请测试。

\ | /
- RT -     Thread Operating System
/ | \     4.0.4 build May 10 2022 21:24:46
2006 - 2021 Copyright by rt-thread team
msh >list_memheap
memheap   pool size  max used size available size
-------- ---------- ------------- --------------
sdram    33554432   48            33554384
heap     190584     7356          183228
msh >sdram_test
[D/drv.sdram] Writing the 33554432 bytes data, waiting....
[D/drv.sdram] Write data success, total time: 4.393S.
[D/drv.sdram] start Reading and verifying data, waiting....
[D/drv.sdram] SDRAM test success!

5 内存堆申请测试

5.1 内部 RAM 和 片外 SDRAM 顺序申请测试

  同样的，我们编写一个函数对添加 SDRAM 后 menheap 管理的内存堆进行测试，测试代码如下

void malloc_test(void)
{
   int size = 50 * 1024;  // 50KBytes
   rt_uint8_t * ptr = RT_NULL;
   ptr = rt_malloc(size);
   if(ptr != RT_NULL)
   {
       LOG_D("ptr = %p", ptr); // 打印申请到的空间的首地址
   }
   else
   {
       LOG_E("malloc failed");
   }
}
MSH_CMD_EXPORT(malloc_test, malloc test)

  下载程序到开发板后，根据测试结果我们可以看到使用 rt_malloc 函数进行申请是首先申请的是片内的 RAM 的空间，等到片内 RAM 的剩余空间不够时系统会去另一块内存堆(SDRAM)上申请空间。

\ | /
- RT -     Thread Operating System
/ | \     4.0.4 build May 10 2022 20:11:53
2006 - 2021 Copyright by rt-thread team
msh >list_memheap    /* 初始时，打印内存堆空间的信息 */
memheap   pool size  max used size available size
-------- ---------- ------------- --------------
sdram    33554432   48            33554384
heap     190584     7356          183228
msh >sdram_malloc_test
[D/drv.sdram] ptr = 2000342c /* 申请到的是片内 RAM 的空间 */
msh >list_memheap    /* 第 1 次申请后，打印内存堆空间的信息 */
memheap   pool size  max used size available size
-------- ---------- ------------- --------------
sdram    33554432   48            33554384
heap     190584     58580         132004
msh >sdram_malloc_test
[D/drv.sdram] ptr = 2000fc44 /* 申请到的是片内 RAM 的空间 */
msh >list_memheap    /* 第 2 次申请后，打印内存堆空间的信息 */
memheap   pool size  max used size available size
-------- ---------- ------------- --------------
sdram    33554432   48            33554384
heap     190584     109804        80780
msh >sdram_malloc_test
[D/drv.sdram] ptr = 2001c45c /* 申请到的是片内 RAM 的空间 */
msh >list_memheap    /* 第 3 次申请后，打印内存堆空间的信息 */
memheap   pool size  max used size available size
-------- ---------- ------------- --------------
sdram    33554432   48            33554384
heap     190584     161028        29556
msh >sdram_malloc_test
[D/drv.sdram] ptr = c0000018 /* 片内 RAM 剩余空间不够，申请到的是片外 SDRAM 的空间 */
msh >list_memheap    /* 第 4 次申请后，打印内存堆空间的信息 */
memheap   pool size  max used size available size
-------- ---------- ------------- --------------
sdram    33554432   51272         33503160
heap     190584     161028        29556
msh >sdram_malloc_test
[D/drv.sdram] ptr = c000c830 /* 片内 RAM 剩余空间不够，申请到的是片外 SDRAM 的空间 */

5.2 直接申请片外 SDRAM 内存测试

  如果想直接从片外的 SDRAM 内存空间进行申请时，我们可以使用 rt_memheap_alloc 进行操作，同样我们也编写一个直接从片外 SDRAM 申请空间的测试函数，如下所示。其中 sdram_heap 控制块需要和上文对 SDRAM 初始化 rt_memheap_init(&sdram_heap, ...) 时的控制块的变量保持一致。

void sdram_malloc_test(void)
{
   int size = 50 * 1024;  // 50KBytes
   uint8_t *ptr;
   ptr = rt_memheap_alloc(&sdram_heap, size);
   if(ptr != RT_NULL)
   {
       LOG_D("ptr = %p", ptr); // 打印申请到的空间的首地址
   }
   else
   {
       LOG_E("sdram malloc failed");
   }
}
MSH_CMD_EXPORT(sdram_malloc_test, sdram malloc test)

  直接从片外 SDRAM 申请空间的测试结果如下，从结果中可以看出每次申请的都是片外 SDRAM 中的空间，且此时片内 RAM 的剩余空间大于要申请的空间的大小。

\ | /
- RT -     Thread Operating System
/ | \     4.0.4 build May 10 2022 20:11:53
2006 - 2021 Copyright by rt-thread team
msh >list_memheap    /* 初始时，打印内存堆空间的信息 */
memheap   pool size  max used size available size
-------- ---------- ------------- --------------
sdram    33554432   48            33554384
heap     190584     7356          183228
msh >sdram_malloc_test
[D/drv.sdram] ptr = c0000018  /* 申请到的是片外 SDRAM 的空间 */
msh >list_memheap    /* 第 1 次申请后，打印内存堆空间的信息 */
memheap   pool size  max used size available size
-------- ---------- ------------- --------------
sdram    33554432   51272         33503160
heap     190584     7356          183228
msh >sdram_malloc_test
[D/drv.sdram] ptr = c000c830  /* 申请到的是片外 SDRAM 的空间 */
msh >list_memheap    /* 第 2 次申请后，打印内存堆空间的信息 */
memheap   pool size  max used size available size
-------- ---------- ------------- --------------
sdram    33554432   102496        33451936
heap     190584     7356          183228
msh >sdram_malloc_test
[D/drv.sdram] ptr = c0019048  /* 申请到的是片外 SDRAM 的空间 */
msh >list_memheap    /* 第 3 次申请后，打印内存堆空间的信息 */
memheap   pool size  max used size available size
-------- ---------- ------------- --------------
sdram    33554432   153720        33400712
heap     190584     7356          183228

6 补充

6.1 为什么 rt_malloc 优先申请片内 RAM 的内存

  rt_malloc() 的源码(rt-thread/src/memheap.c)如下所示。

void *rt_malloc(rt_size_t size)
{
   void *ptr;
   /* try to allocate in system heap */
   ptr = rt_memheap_alloc(&_heap, size);   // 先从 _heap 控制块中申请内存
   if (ptr == RT_NULL)                     // _heap 控制块申请失败，查找其他的 memheap 控制块
   {
       struct rt_object *object;
       struct rt_list_node *node;
       struct rt_memheap *heap;
       struct rt_object_information *information;
       /* try to allocate on other memory heap 尝试从其他的内存堆中进行申请 */
       information = rt_object_get_information(RT_Object_Class_MemHeap);  // 获取类型为内存堆的对象信息
       RT_ASSERT(information != RT_NULL);
       for (node  = information->object_list.next;
            node != &(information->object_list);
            node  = node->next)  // 遍历 memheap_item 链表
       {
           object = rt_list_entry(node, struct rt_object, list); // 获取结构体的首地址 container_of
           heap   = (struct rt_memheap *)object;
           RT_ASSERT(heap);
           RT_ASSERT(rt_object_get_type(&heap->parent) == RT_Object_Class_MemHeap);
           /* not allocate in the default system heap */
           if (heap == &_heap) // 如果找到的控制块和 _heap 相同则继续查找其他控制块
               continue;
           ptr = rt_memheap_alloc(heap, size); // 找到了其他的内存堆，就从该内存堆上申请空间
           if (ptr != RT_NULL)
               break;
       }
   }
   ... ... // 省去分析无关代码
   
   return ptr;
}

  分析上述源码我们可以看到首先调用了 rt_memheap_alloc(&_heap, size) 从 _heap 控制块中申请内存，如果从 _heap 控制块中申请失败的话，就从 memheap_list 链表中查找其他的内存堆，如果有其他的内存堆就从找到的内存堆中申请空间，如果没有其他的内存堆则返回 RT_NULL。

  那么 _heap 是在哪里定义和初始化的呢，继续分析源码我们可以发现，在文件 rt-thread/src/memheap.c 中对 _heap 进行了定义和初始化，代码如下。

static struct rt_memheap _heap;
void rt_system_heap_init(void *begin_addr, void *end_addr)
{
   RT_ASSERT((rt_uint32_t)end_addr > (rt_uint32_t)begin_addr);
   /* initialize a default heap in the system */
   rt_memheap_init(&_heap,
                   "heap",
                   begin_addr,
                   (rt_uint32_t)end_addr - (rt_uint32_t)begin_addr);
}

  在 [RT-Thread 自动初始化](https://club.rt-thread.org/ask/article/4548d81e7237255a.html)的代码中对片内的内存堆进行了初始化，代码如下

void rt_hw_board_init()
{
   rt_system_heap_init((void *)HEAP_BEGIN, (void *)HEAP_END);  // 初始化内部 RAM 的内存堆
   
   // #define HEAP_BEGIN       (&__bss_end)
   // #define HEAP_END         STM32_SRAM_END
   // #define STM32_SRAM_END   (0x20000000 + STM32_SRAM_SIZE * 1024)
   // #define STM32_SRAM_SIZE  (192) 
}

  根据上面的两段代码，分析后我们可以看出 [RT-Thread 自动初始化](https://club.rt-thread.org/ask/article/4548d81e7237255a.html)的代码首先将未使用的片内 RAM 的空间都当做系统的内存堆空间进行初始化，对应的控制块的名称为 _heap，所以在使用 rt_malloc 进行空间的申请时会先申请片内的 RAM。
  除此之外分析 rt_malloc 的源码我们还可以得到申请空间实际调用的是 rt_memheap_alloc，该函数的第一个参数决定了是从哪里申请的空间，所以我们可以直接使用该函数来确定从哪里来申请空间。如果我们想有先从片外的 SDRAM 申请，然后再从片内的 RAM 申请，也可以修改 rt_malloc 的源码，将 ptr = rt_memheap_alloc(&_heap, size); 的第一个参数修改为自己定义的外部 SDRAM 的控制块的名称，对应的将 if (heap == &_heap) 中的 _heap 也修改为自己定义的外部 SDRAM 的控制块的名称。

7 完整代码

  在基于芯片创建的工程的技术上将 drv_sdram.c 的代码进行了部分的修改，修改后的完整代码如下

#include 
#ifdef BSP_USING_SDRAM
#include 
#define DRV_DEBUG
#define LOG_TAG             "drv.sdram"
#include 
static SDRAM_HandleTypeDef hsdram1;
static FMC_SDRAM_CommandTypeDef command;
#ifdef RT_USING_MEMHEAP_AS_HEAP
static struct rt_memheap sdram_heap;
#endif
/**
 * @brief  Perform the SDRAM exernal memory inialization sequence
 * @param  hsdram: SDRAM handle
 * @param  Command: Pointer to SDRAM command structure
 * @retval None
 */
static void SDRAM_Initialization_Sequence(SDRAM_HandleTypeDef *hsdram, FMC_SDRAM_CommandTypeDef *Command)
{
   __IO uint32_t tmpmrd = 0;
   uint32_t target_bank = 0;
#if SDRAM_TARGET_BANK == 1
   target_bank = FMC_SDRAM_CMD_TARGET_BANK1;
#else
   target_bank = FMC_SDRAM_CMD_TARGET_BANK2;
#endif
   /* Configure a clock configuration enable command */
   Command->CommandMode           = FMC_SDRAM_CMD_CLK_ENABLE;
   Command->CommandTarget         = target_bank;
   Command->AutoRefreshNumber     = 1;
   Command->ModeRegisterDefinition = 0;
   /* Send the command */
   HAL_SDRAM_SendCommand(hsdram, Command, 0x1000);
   /* Insert 100 ms delay */
   /* interrupt is not enable, just to delay some time. */
   for (tmpmrd = 0; tmpmrd < 0xffffff; tmpmrd ++)
       ;
   /* Configure a PALL (precharge all) command */
   Command->CommandMode            = FMC_SDRAM_CMD_PALL;
   Command->CommandTarget          = target_bank;
   Command->AutoRefreshNumber      = 1;
   Command->ModeRegisterDefinition = 0;
   /* Send the command */
   HAL_SDRAM_SendCommand(hsdram, Command, 0x1000);
   /* Configure a Auto-Refresh command */
   Command->CommandMode            = FMC_SDRAM_CMD_AUTOREFRESH_MODE;
   Command->CommandTarget          = target_bank;
   Command->AutoRefreshNumber      = 8;
   Command->ModeRegisterDefinition = 0;
   /* Send the command */
   HAL_SDRAM_SendCommand(hsdram, Command, 0x1000);
   /* Program the external memory mode register */
#if SDRAM_DATA_WIDTH == 8
   tmpmrd = (uint32_t)SDRAM_MODEREG_BURST_LENGTH_1     |
#elif SDRAM_DATA_WIDTH == 16
   tmpmrd = (uint32_t)SDRAM_MODEREG_BURST_LENGTH_2     |
#else
   tmpmrd = (uint32_t)SDRAM_MODEREG_BURST_LENGTH_4     |
#endif
            SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL        |
#if SDRAM_CAS_LATENCY == 3
            SDRAM_MODEREG_CAS_LATENCY_3                |
#else
            SDRAM_MODEREG_CAS_LATENCY_2                |
#endif
            SDRAM_MODEREG_OPERATING_MODE_STANDARD      |
            SDRAM_MODEREG_WRITEBURST_MODE_SINGLE;
   Command->CommandMode            = FMC_SDRAM_CMD_LOAD_MODE;
   Command->CommandTarget          = target_bank;
   Command->AutoRefreshNumber      = 1;
   Command->ModeRegisterDefinition = tmpmrd;
   /* Send the command */
   HAL_SDRAM_SendCommand(hsdram, Command, 0x1000);
   /* Set the device refresh counter */
   HAL_SDRAM_ProgramRefreshRate(hsdram, SDRAM_REFRESH_COUNT);
}
static int SDRAM_Init(void)
{
   int result = RT_EOK;
   FMC_SDRAM_TimingTypeDef SDRAM_Timing;
   /* SDRAM device configuration */
   hsdram1.Instance = FMC_SDRAM_DEVICE;
   SDRAM_Timing.LoadToActiveDelay    = LOADTOACTIVEDELAY;
   SDRAM_Timing.ExitSelfRefreshDelay = EXITSELFREFRESHDELAY;
   SDRAM_Timing.SelfRefreshTime      = SELFREFRESHTIME;
   SDRAM_Timing.RowCycleDelay        = ROWCYCLEDELAY;
   SDRAM_Timing.WriteRecoveryTime    = WRITERECOVERYTIME;
   SDRAM_Timing.RPDelay              = RPDELAY;
   SDRAM_Timing.RCDDelay             = RCDDELAY;
#if SDRAM_TARGET_BANK == 1
   hsdram1.Init.SDBank             = FMC_SDRAM_BANK1;
#else
   hsdram1.Init.SDBank             = FMC_SDRAM_BANK2;
#endif
#if SDRAM_COLUMN_BITS == 8
   hsdram1.Init.ColumnBitsNumber   = FMC_SDRAM_COLUMN_BITS_NUM_8;
#elif SDRAM_COLUMN_BITS == 9
   hsdram1.Init.ColumnBitsNumber   = FMC_SDRAM_COLUMN_BITS_NUM_9;
#elif SDRAM_COLUMN_BITS == 10
   hsdram1.Init.ColumnBitsNumber   = FMC_SDRAM_COLUMN_BITS_NUM_10;
#else
   hsdram1.Init.ColumnBitsNumber   = FMC_SDRAM_COLUMN_BITS_NUM_11;
#endif
#if SDRAM_ROW_BITS == 11
   hsdram1.Init.RowBitsNumber      = FMC_SDRAM_ROW_BITS_NUM_11;
#elif SDRAM_ROW_BITS == 12
   hsdram1.Init.RowBitsNumber      = FMC_SDRAM_ROW_BITS_NUM_12;
#else
   hsdram1.Init.RowBitsNumber      = FMC_SDRAM_ROW_BITS_NUM_13;
#endif
#if SDRAM_DATA_WIDTH == 8
   hsdram1.Init.MemoryDataWidth    = FMC_SDRAM_MEM_BUS_WIDTH_8;
#elif SDRAM_DATA_WIDTH == 16
   hsdram1.Init.MemoryDataWidth    = FMC_SDRAM_MEM_BUS_WIDTH_16;
#else
   hsdram1.Init.MemoryDataWidth    = FMC_SDRAM_MEM_BUS_WIDTH_32;
#endif
   hsdram1.Init.InternalBankNumber = FMC_SDRAM_INTERN_BANKS_NUM_4;
#if SDRAM_CAS_LATENCY == 1
   hsdram1.Init.CASLatency         = FMC_SDRAM_CAS_LATENCY_1;
#elif SDRAM_CAS_LATENCY == 2
   hsdram1.Init.CASLatency         = FMC_SDRAM_CAS_LATENCY_2;
#else
   hsdram1.Init.CASLatency         = FMC_SDRAM_CAS_LATENCY_3;
#endif
   hsdram1.Init.WriteProtection    = FMC_SDRAM_WRITE_PROTECTION_DISABLE;
#if SDCLOCK_PERIOD == 2
   hsdram1.Init.SDClockPeriod      = FMC_SDRAM_CLOCK_PERIOD_2;
#else
   hsdram1.Init.SDClockPeriod      = FMC_SDRAM_CLOCK_PERIOD_3;
#endif
   hsdram1.Init.ReadBurst          = FMC_SDRAM_RBURST_ENABLE;
#if SDRAM_RPIPE_DELAY == 0
   hsdram1.Init.ReadPipeDelay      = FMC_SDRAM_RPIPE_DELAY_0;
#elif SDRAM_RPIPE_DELAY == 1
   hsdram1.Init.ReadPipeDelay      = FMC_SDRAM_RPIPE_DELAY_1;
#else
   hsdram1.Init.ReadPipeDelay      = FMC_SDRAM_RPIPE_DELAY_2;
#endif
   /* Initialize the SDRAM controller */
   if (HAL_SDRAM_Init(&hsdram1, &SDRAM_Timing) != HAL_OK)
   {
       LOG_E("SDRAM init failed!");
       result = -RT_ERROR;
   }
   else
   {
       /* Program the SDRAM external device */
       SDRAM_Initialization_Sequence(&hsdram1, &command);
       LOG_D("sdram init success, mapped at 0x%X, size is %d bytes, data width is %d", SDRAM_BANK_ADDR, SDRAM_SIZE, SDRAM_DATA_WIDTH);
#ifdef RT_USING_MEMHEAP_AS_HEAP
       /* If RT_USING_MEMHEAP_AS_HEAP is enabled, SDRAM is initialized to the heap */
       rt_memheap_init(&sdram_heap, "sdram", (void *)SDRAM_BANK_ADDR, SDRAM_SIZE);
#endif
   }
   return result;
}
INIT_BOARD_EXPORT(SDRAM_Init);
#ifdef DRV_DEBUG
#ifdef FINSH_USING_MSH
int sdram_test(void)
{
   int i = 0;
   uint32_t start_time = 0, time_cast = 0;
#if SDRAM_DATA_WIDTH == 8
   char data_width = 1;
   uint8_t data = 0;
#elif SDRAM_DATA_WIDTH == 16
   char data_width = 2;
   uint16_t data = 0;
#else
   char data_width = 4;
   uint32_t data = 0;
#endif
   /* write data */
   LOG_D("Writing the %ld bytes data, waiting....", SDRAM_SIZE);
   start_time = rt_tick_get();
   for (i = 0; i < SDRAM_SIZE / data_width; i++)
   {
#if SDRAM_DATA_WIDTH == 8
       *(__IO uint8_t *)(SDRAM_BANK_ADDR + i * data_width) = (uint8_t)0x55;
#elif SDRAM_DATA_WIDTH == 16
       *(__IO uint16_t *)(SDRAM_BANK_ADDR + i * data_width) = (uint16_t)(i % 65535);
#else
       *(__IO uint32_t *)(SDRAM_BANK_ADDR + i * data_width) = (uint32_t)0x55555555;
#endif
   }
   time_cast = rt_tick_get() - start_time;
   LOG_D("Write data success, total time: %d.%03dS.", time_cast / RT_TICK_PER_SECOND,
         time_cast % RT_TICK_PER_SECOND / ((RT_TICK_PER_SECOND * 1 + 999) / 1000));
   /* read data */
   LOG_D("start Reading and verifying data, waiting....");
   for (i = 0; i < SDRAM_SIZE / data_width; i++)
   {
#if SDRAM_DATA_WIDTH == 8
       data = *(__IO uint8_t *)(SDRAM_BANK_ADDR + i * data_width);
       if (data != 0x55)
       {
           LOG_E("SDRAM test failed!");
           break;
       }
#elif SDRAM_DATA_WIDTH == 16
       data = *(__IO uint16_t *)(SDRAM_BANK_ADDR + i * data_width);
       if (data != (i % 65535))
       {
           LOG_E("SDRAM test failed!");
           break;
       }
#else
       data = *(__IO uint32_t *)(SDRAM_BANK_ADDR + i * data_width);
       if (data != 0x55555555)
       {
           LOG_E("SDRAM test failed!");
           break;
       }
#endif
   }
   if (i >= SDRAM_SIZE / data_width)
   {
       LOG_D("SDRAM test success!");
   }
   return RT_EOK;
}
MSH_CMD_EXPORT(sdram_test, sdram test)
/* 直接从片外 SDRAM 申请空间测试 */
void sdram_malloc_test(void)
{
   int size = 50 * 1024;  // 50KBytes
   uint8_t *ptr;
   ptr = rt_memheap_alloc(&sdram_heap, size);
   if(ptr != RT_NULL)
   {
       LOG_D("ptr = %p", ptr); // 打印申请到的空间的首地址
   }
   else
   {
       LOG_E("malloc failed");
   }
}
MSH_CMD_EXPORT(sdram_malloc_test, sdram malloc test)
/* 从片内 RAM 和 片外 SDRAM 顺序申请测试 */
void malloc_test(void)
{
   int size = 50 * 1024;  // 50KBytes
   rt_uint8_t * ptr = RT_NULL;
   ptr = rt_malloc(size);
   if(ptr != RT_NULL)
   {
       LOG_D("ptr = %p", ptr); // 打印申请到的空间的首地址
   }
   else
   {
       LOG_E("malloc failed");
   }
}
MSH_CMD_EXPORT(malloc_test, malloc test)
#endif /* FINSH_USING_MSH */
#endif /* DRV_DEBUG */
#endif /* BSP_USING_SDRAM */

sdram_port.h
c
#ifndef __SDRAM_PORT_H__
#define __SDRAM_PORT_H__
/* parameters for sdram peripheral */
/* Bank1 or Bank2 */
#define SDRAM_TARGET_BANK               1
/* stm32f4 Bank1:0XC0000000  Bank2:0XD0000000 */
#define SDRAM_BANK_ADDR                 ((uint32_t)0XC0000000)
/* data width: 8, 16, 32 */
#define SDRAM_DATA_WIDTH                16
/* column bit numbers: 8, 9, 10, 11 */
#define SDRAM_COLUMN_BITS               9
/* row bit numbers: 11, 12, 13 */
#define SDRAM_ROW_BITS                  13
/* cas latency clock number: 1, 2, 3 */
#define SDRAM_CAS_LATENCY               3
/* read pipe delay: 0, 1, 2 */
#define SDRAM_RPIPE_DELAY               1
/* clock divid: 2, 3 */
#define SDCLOCK_PERIOD                  2
/* refresh rate counter */
#define SDRAM_REFRESH_COUNT             ((uint32_t)0x02AB)
#define SDRAM_SIZE                      ((uint32_t)0x2000000)
/* Timing configuration for W9825G6KH-6 */
/* 90 MHz of SD clock frequency (180MHz/2) */
/* TMRD: 2 Clock cycles */
#define LOADTOACTIVEDELAY               2
/* TXSR: 7x11.90ns */
#define EXITSELFREFRESHDELAY            8
/* TRAS: 4x11.90ns */
#define SELFREFRESHTIME                 6
/* TRC:  7x11.90ns */
#define ROWCYCLEDELAY                   6
/* TWR:  2 Clock cycles */
#define WRITERECOVERYTIME               2
/* TRP:  2x11.90ns */
#define RPDELAY                         2
/* TRCD: 2x11.90ns */
#define RCDDELAY                        2
/* memory mode register */
#define SDRAM_MODEREG_BURST_LENGTH_1             ((uint16_t)0x0000)
#define SDRAM_MODEREG_BURST_LENGTH_2             ((uint16_t)0x0001)
#define SDRAM_MODEREG_BURST_LENGTH_4             ((uint16_t)0x0002)
#define SDRAM_MODEREG_BURST_LENGTH_8             ((uint16_t)0x0004)
#define SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL      ((uint16_t)0x0000)
#define SDRAM_MODEREG_BURST_TYPE_INTERLEAVED     ((uint16_t)0x0008)
#define SDRAM_MODEREG_CAS_LATENCY_2              ((uint16_t)0x0020)
#define SDRAM_MODEREG_CAS_LATENCY_3              ((uint16_t)0x0030)
#define SDRAM_MODEREG_OPERATING_MODE_STANDARD    ((uint16_t)0x0000)
#define SDRAM_MODEREG_WRITEBURST_MODE_PROGRAMMED ((uint16_t)0x0000)
#define SDRAM_MODEREG_WRITEBURST_MODE_SINGLE     ((uint16_t)0x0200)
#endif


审核编辑：汤梓红