野火视频教程：https://www.bilibili.com/video/BV1yW411Y7Gw?p=69

FSMC初始化结构体

时序结构体

  1. typedef struct
  2. {
  3.      uint32_t FSMC_AddressSetupTime;         // 地址建立时间，0-0xF个HCLK周期
  4.     uint32_t FSMC_AddressHoldTime;         // 地址保持时间，0-0xF个HCLK周期
  5.     uint32_t FSMC_DataSetupTime;         // 地址建立时间，0-0xF个HCLK周期
  6.     uint32_t FSMC_BusTurnAroundDuration; // 总线转换周期，0-0xF个HCLK周期，在NOR FLASH
  7.     uint32_t FSMC_CLKDivision;    // 时钟分频因子，1-0xF，若控制异步存储器，本参数无效
  8.     uint32_t FSMC_DataLatency;  // 数据延迟时间，若控制异步存储器，本参数无效
  9.     uint32_t FSMC_AccessMode;    // 设置访问模式
  10. }FSMC_NORSRAMTimingInitTypeDef;
  • FSMC_AddressSetupTime：本成员设置地址建立时间，它可以被设置为0-0xF个HCLK周期数，按STM32标准库的默认配置，HCLK的时钟频率为72MHz，即一个HCLK周期为1/72us。
  • FSMC_AddressHoldTime：本成员设置地址保持时间，它可以被设置为0-0xF个HCLK周期数。
  • FSMC_DataSetupTime：本成员设置数据建立时间，它可以被设置为0-0xF个HCLK周期数。
  • FSMC_BusTurnAroundDuration：本成员设置总线转换周期，在NOR FLASH存储器中，地址线与数据线可以分时复用，总线转换周期就是指总线在这两种状态间切换需要的延时，防止冲突。控制其他存储器时这个参数无效，配置为0即可。
  • FSMC_CLKDivision：本成员用于设置时钟分频，它可以HCLK时钟作为输入，经过FSMC_CLKDivision分频后输出到FSMC_CLK引脚作为通讯使用的同步时钟。控制其他异步通讯的存储器时这个参数无效，配置为0即可。
  • FSMC_DataLatency：本成员设置数据保持时间，它表示在读取第一个数据之前要等待的周期数，该周期指同步时钟的周期，本参数仅用于同步NOR FLASH类的存储器，控制其他类型的存储器时，本参数无效。
  • FSMC_AccessMode：本成员设置存储器访问模式，不同的模式下FSMC访问存储器地址时引脚输出的时序不一样，可选FSMC_AccessMode_A/B/C/D模式，一般来说控制SRAM时使用A模式。

这个FSMC_NORSRAMTimingInitTypeDef时序结构体配置的延时参数，将作为下一节的FSMC SRAM初始化结构体的一个成员。

FSMC的SRAM初始化结构体

  1. typedef struct
  2. {
  3.     uint32_t FSMC_Bank;                /*设置要控制的 Bank 区域 */
  4.     uint32_t FSMC_DataAddressMux;    /*设置地址总线与数据总线是否复用 */
  5.     uint32_t FSMC_MemoryType;        /*设置存储器的类型 */
  6.     uint32_t FSMC_MemoryDataWidth;  /*设置存储器的数据宽度*/
  7.     uint32_t FSMC_BurstAccessMode;  /*设置是否支持突发访问模式，只支持同步类型的存储器 */
  8.     uint32_t FSMC_AsynchronousWait;    /*设置是否使能在同步传输时的等待信号， */
  9.     uint32_t FSMC_WaitSignalPolarity; /*设置等待信号的极性*/
  10.     uint32_t FSMC_WrapMode;            /*设置是否支持对齐的突发模式 */
  11.     uint32_t FSMC_WaitSignalActive;    /*配置等待信号在等待前有效还是等待期间有效 */
  12.     uint32_t FSMC_WriteOperation;    // 设置是否写使能
  13.     uint32_t FSMC_WaitSignal;        // 设置是否使能等待状态插入
  14.     uint32_t FSMC_ExtendedMode;        // 设置是否使能扩展模式
  15.     uint32_t FSMC_WriteBurst;        // 设置是否使能写突发操作
  17.     // 当不使用扩展模式时，本参数用于配置读写时序，否则用于配置读时序
  18.     FSMC_NORSRAMTimingInitTypeDef* FSMC_ReadWriteTimingStruct;
  19.     // 当使用扩展模式时，本参数用于配置写时序
  20.     FSMC_NORSRAMTimingInitTypeDef* FSMC_WriteTimingStruct;
  21. }FSMC_NORSRAMInitTypeDef;

这个结构体，除最后两个成员是上一小节讲解的时序配置外，其它结构体成员的配置都对应到 FSMC_BCR 中的寄存器位。各个成员意义介绍如下，括号中的是 STM32 标准库
定义的宏：

  • FSMC_Bank：本成员用于选择 FSMC 映射的存储区域， 它的可选参数以及相应的内核地址映射范围 | 可以输入的宏 | 对应的地址区域 | | —- | —- | | FSMC_Bank1_NORSRAM1 | 0x60000000-0x63FFFFFF | | FSMC_Bank1_NORSRAM2 | 0x64000000-0x67FFFFFF | | FSMC_Bank1_NORSRAM3 | 0x68000000-0x6BFFFFFF | | FSMC_Bank1_NORSRAM4 | 0x6C000000-0x6FFFFFFF |

  • FSMC_DataAddressMux：本成员用于设置地址总线与数据总线是否复用(FSMC_DataAddressMux_Enable/Disable)，在控制 NOR FLASH 时，可以地址总线与数据总线可以分时复用，以减少使用 STM32 信号线的数量。

  • FSMC_MemoryType：本成员用于设置要控制的存储器类型，它支持控制的存储器类型为 SRAM、PSRAM以及 NOR FLASH(FSMC_MemoryType_SRAM/PSRAM/NOR)。
  • FSMC_MemoryDataWidth：本成员用于设置要控制的存储器的数据宽度，可选择设置成 8 或 16 位(FSMC_MemoryDataWidth_8b /16b)。
  • FSMC_BurstAccessMode：本成员用于设置是否使用突发访问模式(FSMC_BurstAccessMode_Enable/Disable)，突发访问模式是指发送一个地址后连续访问多个数据，非突发模式下每访问一个数据都需要输入一个地址，仅在控制同步类型的存储器时才能使用突发模式。
  • FSMC_AsynchronousWait：本成员用于设置是否使能在同步传输时使用的等待信号(FSMC_AsynchronousWait_Enable/Disable)，在控制同步类型的 NOR 或 PSRAM 时，存储器可以使用 FSMC_NWAIT 引脚通知 STM32 需要等待。
  • FSMC_WaitSignalPolarity：本成员用于设置等待信号的有效极性，即要求等待时，使用高电平还是低电平(FSMC_WaitSignalPolarity_High/Low)。
  • FSMC_WrapMode：本成员用于设置是否支持把非对齐的AHB 突发操作分割成 2 次线性操作(FSMC_WrapMode_Enable/Disable)，该配置仅在突发模式下有效。
  • FSMC_WaitSignalActive：本成员用于配置在突发传输模式时，决定存储器是在等待状态之前的一个数据周期有效还是在等待状态期间有效(FSMC_WaitSignalActive_BeforeWaitState/DuringWaitState)。
  • FSMC_WriteOperation：这个成员用于设置是否写使能(FSMCWriteOperation Enable /Disable)，禁止写使能的话 FSMC 只能从存储器中读取数据，不能写入。
  • FSMC_WaitSignal：本成员用于设置当存储器处于突发传输模式时，是否允许通过 NWAIT 信号插入等待
    状态(FSMC_WaitSignal_Enable/Disable)。
  • FSMC_ExtendedMode：本成员用于设置是否使用扩展模式(FSMC_ExtendedMode_Enable/Disable)，在非扩展模式下，对存储器读写的时序都只使用 FSMC_BCR 寄存器中的配置，即下面的FSMC_ReadWriteTimingStruct 结构体成员；在扩展模式下，对存储器的读写时序可以分开配置，读时序使用 FSMC_BCR 寄存器，写时序使用FSMC_BWTR 寄存器的配置，即下面的 FSMC_WriteTimingStruct 结构体。
  • FSMC_ReadWriteTimingStruct：本成员是一个指针，赋值时使用上一小节中讲解的时序结构体FSMC_NORSRAMInitTypeDef 设置，当不使用扩展模式时，读写时序都使用本成员的参数配置。
  • FSMC_WriteTimingStruct：同样地，本成员也是一个时序结构体的指针，只有当使用扩展模式时，本配置才有效，它是写操作使用的时序。

对本结构体赋值完成后，调用 FSMC_NORSRAMInit 库函数即可把配置参数写入到FSMC_BCR 及 FSMC_BTR/BWTR 寄存器中。

读写时序要求

  • 读

ADDSET+1+DATAST+1 > 55ns
DATAS+1 > 40ns
ADDSET+1 > 0ns

  • 写

ADDSET+1+DATAST+1 +2HCLK > 55ns
DATAS+1 > 22ns
ADDSET+1 > 0ns

FSMC—外部SRAM实例

bsp_sram.h

  1. #ifndef __BSP_SRAM_H
  2. #define __BSP_SRAM_H                                                                
  5. #include "stm32f10x.h"
  6. #include "./usart/bsp_usart.h"
  8. //使用NOR/SRAM的 Bank1.sector3,地址位HADDR[27,26]=10 
  9. //对IS61LV25616/IS62WV25616,地址线范围为A0~A17 
  10. //对IS61LV51216/IS62WV51216,地址线范围为A0~A18
  11. #define Bank1_SRAM3_ADDR    ((uint32_t)(0x68000000))        
  13. #define IS62WV51216_SIZE 0x100000  //512*16/2bits = 0x100000  ，1M字节
  17. /*A地址信号线*/    
  18. #define FSMC_A0_GPIO_PORT        GPIOF
  19. #define FSMC_A0_GPIO_CLK         RCC_APB2Periph_GPIOF
  20. #define FSMC_A0_GPIO_PIN         GPIO_Pin_0
  22. #define FSMC_A1_GPIO_PORT        GPIOF
  23. #define FSMC_A1_GPIO_CLK         RCC_APB2Periph_GPIOF
  24. #define FSMC_A1_GPIO_PIN         GPIO_Pin_1
  26. #define FSMC_A2_GPIO_PORT        GPIOF
  27. #define FSMC_A2_GPIO_CLK         RCC_APB2Periph_GPIOF
  28. #define FSMC_A2_GPIO_PIN         GPIO_Pin_2
  30. #define FSMC_A3_GPIO_PORT        GPIOF
  31. #define FSMC_A3_GPIO_CLK         RCC_APB2Periph_GPIOF
  32. #define FSMC_A3_GPIO_PIN         GPIO_Pin_3
  34. #define FSMC_A4_GPIO_PORT        GPIOF
  35. #define FSMC_A4_GPIO_CLK         RCC_APB2Periph_GPIOF
  36. #define FSMC_A4_GPIO_PIN         GPIO_Pin_4
  38. #define FSMC_A5_GPIO_PORT        GPIOF
  39. #define FSMC_A5_GPIO_CLK         RCC_APB2Periph_GPIOF
  40. #define FSMC_A5_GPIO_PIN         GPIO_Pin_5
  42. #define FSMC_A6_GPIO_PORT        GPIOF
  43. #define FSMC_A6_GPIO_CLK         RCC_APB2Periph_GPIOF
  44. #define FSMC_A6_GPIO_PIN         GPIO_Pin_12
  46. #define FSMC_A7_GPIO_PORT        GPIOF
  47. #define FSMC_A7_GPIO_CLK         RCC_APB2Periph_GPIOF
  48. #define FSMC_A7_GPIO_PIN         GPIO_Pin_13
  50. #define FSMC_A8_GPIO_PORT        GPIOF
  51. #define FSMC_A8_GPIO_CLK         RCC_APB2Periph_GPIOF
  52. #define FSMC_A8_GPIO_PIN         GPIO_Pin_14
  54. #define FSMC_A9_GPIO_PORT        GPIOF
  55. #define FSMC_A9_GPIO_CLK         RCC_APB2Periph_GPIOF
  56. #define FSMC_A9_GPIO_PIN         GPIO_Pin_15
  58. #define FSMC_A10_GPIO_PORT        GPIOG
  59. #define FSMC_A10_GPIO_CLK         RCC_APB2Periph_GPIOG
  60. #define FSMC_A10_GPIO_PIN         GPIO_Pin_0
  62. #define FSMC_A11_GPIO_PORT        GPIOG
  63. #define FSMC_A11_GPIO_CLK         RCC_APB2Periph_GPIOG
  64. #define FSMC_A11_GPIO_PIN         GPIO_Pin_1
  66. #define FSMC_A12_GPIO_PORT        GPIOG
  67. #define FSMC_A12_GPIO_CLK         RCC_APB2Periph_GPIOG
  68. #define FSMC_A12_GPIO_PIN         GPIO_Pin_2
  70. #define FSMC_A13_GPIO_PORT        GPIOG
  71. #define FSMC_A13_GPIO_CLK         RCC_APB2Periph_GPIOG
  72. #define FSMC_A13_GPIO_PIN         GPIO_Pin_3
  74. #define FSMC_A14_GPIO_PORT        GPIOG
  75. #define FSMC_A14_GPIO_CLK         RCC_APB2Periph_GPIOG
  76. #define FSMC_A14_GPIO_PIN         GPIO_Pin_4
  78. #define FSMC_A15_GPIO_PORT        GPIOG
  79. #define FSMC_A15_GPIO_CLK         RCC_APB2Periph_GPIOG
  80. #define FSMC_A15_GPIO_PIN         GPIO_Pin_5
  82. #define FSMC_A16_GPIO_PORT        GPIOD
  83. #define FSMC_A16_GPIO_CLK         RCC_APB2Periph_GPIOD
  84. #define FSMC_A16_GPIO_PIN         GPIO_Pin_11
  86. #define FSMC_A17_GPIO_PORT        GPIOD
  87. #define FSMC_A17_GPIO_CLK         RCC_APB2Periph_GPIOD
  88. #define FSMC_A17_GPIO_PIN         GPIO_Pin_12
  90. #define FSMC_A18_GPIO_PORT        GPIOD
  91. #define FSMC_A18_GPIO_CLK         RCC_APB2Periph_GPIOD
  92. #define FSMC_A18_GPIO_PIN         GPIO_Pin_13
  94. /*D 数据信号线*/
  95. #define FSMC_D0_GPIO_PORT        GPIOD
  96. #define FSMC_D0_GPIO_CLK         RCC_APB2Periph_GPIOD
  97. #define FSMC_D0_GPIO_PIN         GPIO_Pin_14
  99. #define FSMC_D1_GPIO_PORT        GPIOD
  100. #define FSMC_D1_GPIO_CLK         RCC_APB2Periph_GPIOD
  101. #define FSMC_D1_GPIO_PIN         GPIO_Pin_15
  103. #define FSMC_D2_GPIO_PORT        GPIOD
  104. #define FSMC_D2_GPIO_CLK         RCC_APB2Periph_GPIOD
  105. #define FSMC_D2_GPIO_PIN         GPIO_Pin_0
  107. #define FSMC_D3_GPIO_PORT        GPIOD
  108. #define FSMC_D3_GPIO_CLK         RCC_APB2Periph_GPIOD
  109. #define FSMC_D3_GPIO_PIN         GPIO_Pin_1
  111. #define FSMC_D4_GPIO_PORT        GPIOE
  112. #define FSMC_D4_GPIO_CLK         RCC_APB2Periph_GPIOE
  113. #define FSMC_D4_GPIO_PIN         GPIO_Pin_7
  115. #define FSMC_D5_GPIO_PORT        GPIOE
  116. #define FSMC_D5_GPIO_CLK         RCC_APB2Periph_GPIOE
  117. #define FSMC_D5_GPIO_PIN         GPIO_Pin_8
  119. #define FSMC_D6_GPIO_PORT        GPIOE
  120. #define FSMC_D6_GPIO_CLK         RCC_APB2Periph_GPIOE
  121. #define FSMC_D6_GPIO_PIN         GPIO_Pin_9
  123. #define FSMC_D7_GPIO_PORT        GPIOE
  124. #define FSMC_D7_GPIO_CLK         RCC_APB2Periph_GPIOE
  125. #define FSMC_D7_GPIO_PIN         GPIO_Pin_10
  127. #define FSMC_D8_GPIO_PORT        GPIOE
  128. #define FSMC_D8_GPIO_CLK         RCC_APB2Periph_GPIOE
  129. #define FSMC_D8_GPIO_PIN         GPIO_Pin_11
  131. #define FSMC_D9_GPIO_PORT        GPIOE
  132. #define FSMC_D9_GPIO_CLK         RCC_APB2Periph_GPIOE
  133. #define FSMC_D9_GPIO_PIN         GPIO_Pin_12
  135. #define FSMC_D10_GPIO_PORT        GPIOE
  136. #define FSMC_D10_GPIO_CLK         RCC_APB2Periph_GPIOE
  137. #define FSMC_D10_GPIO_PIN         GPIO_Pin_13
  139. #define FSMC_D11_GPIO_PORT        GPIOE
  140. #define FSMC_D11_GPIO_CLK         RCC_APB2Periph_GPIOE
  141. #define FSMC_D11_GPIO_PIN         GPIO_Pin_14
  143. #define FSMC_D12_GPIO_PORT        GPIOE
  144. #define FSMC_D12_GPIO_CLK         RCC_APB2Periph_GPIOE
  145. #define FSMC_D12_GPIO_PIN         GPIO_Pin_15
  147. #define FSMC_D13_GPIO_PORT        GPIOD
  148. #define FSMC_D13_GPIO_CLK         RCC_APB2Periph_GPIOD
  149. #define FSMC_D13_GPIO_PIN         GPIO_Pin_8
  151. #define FSMC_D14_GPIO_PORT        GPIOD
  152. #define FSMC_D14_GPIO_CLK         RCC_APB2Periph_GPIOD
  153. #define FSMC_D14_GPIO_PIN         GPIO_Pin_9
  155. #define FSMC_D15_GPIO_PORT        GPIOD
  156. #define FSMC_D15_GPIO_CLK         RCC_APB2Periph_GPIOD
  157. #define FSMC_D15_GPIO_PIN         GPIO_Pin_10
  160. /*控制信号线*/  
  161. /*CS片选*/
  162. /*NE3 ,对应的基地址0x68000000*/
  163. #define FSMC_CS_GPIO_PORT        GPIOG
  164. #define FSMC_CS_GPIO_CLK         RCC_APB2Periph_GPIOG
  165. #define FSMC_CS_GPIO_PIN         GPIO_Pin_10
  167. /*WE写使能*/
  168. #define FSMC_WE_GPIO_PORT        GPIOD
  169. #define FSMC_WE_GPIO_CLK         RCC_APB2Periph_GPIOD
  170. #define FSMC_WE_GPIO_PIN         GPIO_Pin_5
  172. /*OE读使能*/
  173. #define FSMC_OE_GPIO_PORT        GPIOD
  174. #define FSMC_OE_GPIO_CLK         RCC_APB2Periph_GPIOD
  175. #define FSMC_OE_GPIO_PIN         GPIO_Pin_4
  178. /*UB数据掩码*/
  179. #define FSMC_UDQM_GPIO_PORT        GPIOE
  180. #define FSMC_UDQM_GPIO_CLK         RCC_APB2Periph_GPIOE
  181. #define FSMC_UDQM_GPIO_PIN         GPIO_Pin_1
  183. /*LB数据掩码*/
  184. #define FSMC_LDQM_GPIO_PORT        GPIOE
  185. #define FSMC_LDQM_GPIO_CLK         RCC_APB2Periph_GPIOE
  186. #define FSMC_LDQM_GPIO_PIN         GPIO_Pin_0
  190. /*信息输出*/
  191. #define SRAM_DEBUG_ON         1
  193. #define SRAM_INFO(fmt,arg...)   printf("<<-SRAM-INFO->> "fmt"\n",##arg)
  194. #define SRAM_ERROR(fmt,arg...)  printf("<<-SRAM-ERROR->> "fmt"\n",##arg)
  195. #define SRAM_DEBUG(fmt,arg...)  do{\
  196.                                   if(SRAM_DEBUG_ON)\
  197.                                     printf("<<-SRAM-DEBUG->> [%d]"fmt"\n",__LINE__, ##arg);\
  198.                                  }while(0)
  204. void FSMC_SRAM_Init(void);
  205. void FSMC_SRAM_WriteBuffer(uint8_t* pBuffer,uint32_t WriteAddr,uint32_t NumHalfwordToWrite);
  206. void FSMC_SRAM_ReadBuffer(uint8_t* pBuffer,uint32_t ReadAddr,uint32_t NumHalfwordToRead);
  208. uint8_t SRAM_Test(void);
  210. #endif // BSP_SRAM

bsp_sram.c

  1. /**
  2.   ******************************************************************************
  3.   * @file    bsp_sram.c
  4.   * @author  fire
  5.   * @version V1.0
  6.   * @date    2015-xx-xx
  7.   * @brief   sram应用函数接口
  8.   ******************************************************************************
  9.   * @attention
  10.   *
  11.   * 实验平台:野火 F103-霸道 STM32  开发板  
  12.   * 论坛    :http://www.firebbs.cn
  13.   * 淘宝    :https://fire-stm32.taobao.com
  14.   *
  15.   ******************************************************************************
  16.   */
  20. #include "./sram/bsp_sram.h"      
  24. /**
  25.   * @brief  初始化控制SRAM的IO
  26.   * @param  无
  27.   * @retval 无
  28.   */
  29. static void SRAM_GPIO_Config(void)
  30. {
  31.     GPIO_InitTypeDef  GPIO_InitStructure;
  33.   /* 使能SRAM相关的GPIO时钟 */
  35.                          /*地址信号线*/
  36.   RCC_APB2PeriphClockCmd(FSMC_A0_GPIO_CLK | FSMC_A1_GPIO_CLK | FSMC_A2_GPIO_CLK | 
  37.                          FSMC_A3_GPIO_CLK | FSMC_A4_GPIO_CLK | FSMC_A5_GPIO_CLK |
  38.                          FSMC_A6_GPIO_CLK | FSMC_A7_GPIO_CLK | FSMC_A8_GPIO_CLK |
  39.                          FSMC_A9_GPIO_CLK | FSMC_A10_GPIO_CLK| FSMC_A11_GPIO_CLK| 
  40.                          FSMC_A12_GPIO_CLK| FSMC_A13_GPIO_CLK|FSMC_A14_GPIO_CLK|
  41.                          FSMC_A15_GPIO_CLK|FSMC_A16_GPIO_CLK|FSMC_A17_GPIO_CLK|
  42.                          FSMC_A18_GPIO_CLK|
  43.                          /*数据信号线*/
  44.                          FSMC_D0_GPIO_CLK | FSMC_D1_GPIO_CLK | FSMC_D2_GPIO_CLK | 
  45.                          FSMC_D3_GPIO_CLK | FSMC_D4_GPIO_CLK | FSMC_D5_GPIO_CLK |
  46.                          FSMC_D6_GPIO_CLK | FSMC_D7_GPIO_CLK | FSMC_D8_GPIO_CLK |
  47.                          FSMC_D9_GPIO_CLK | FSMC_D10_GPIO_CLK| FSMC_D11_GPIO_CLK|
  48.                          FSMC_D12_GPIO_CLK| FSMC_D13_GPIO_CLK| FSMC_D14_GPIO_CLK|
  49.                          FSMC_D15_GPIO_CLK|  
  50.                          /*控制信号线*/
  51.                          FSMC_CS_GPIO_CLK  | FSMC_WE_GPIO_CLK | FSMC_OE_GPIO_CLK |
  52.                          FSMC_UDQM_GPIO_CLK|FSMC_LDQM_GPIO_CLK, ENABLE);
  56.      /*-- GPIO 配置 -----------------------------------------------------*/
  58.   /* 通用 GPIO 配置 */
  59.   GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;       //配置为复用功能
  60.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;     
  62.   /*A地址信号线 针对引脚配置*/
  63.   GPIO_InitStructure.GPIO_Pin = FSMC_A0_GPIO_PIN; 
  64.   GPIO_Init(FSMC_A0_GPIO_PORT, &GPIO_InitStructure);
  66.   GPIO_InitStructure.GPIO_Pin = FSMC_A1_GPIO_PIN; 
  67.   GPIO_Init(FSMC_A1_GPIO_PORT, &GPIO_InitStructure);
  69.   GPIO_InitStructure.GPIO_Pin = FSMC_A2_GPIO_PIN; 
  70.   GPIO_Init(FSMC_A2_GPIO_PORT, &GPIO_InitStructure);
  72.   GPIO_InitStructure.GPIO_Pin = FSMC_A3_GPIO_PIN; 
  73.   GPIO_Init(FSMC_A3_GPIO_PORT, &GPIO_InitStructure);
  75.   GPIO_InitStructure.GPIO_Pin = FSMC_A4_GPIO_PIN; 
  76.   GPIO_Init(FSMC_A4_GPIO_PORT, &GPIO_InitStructure);
  78.   GPIO_InitStructure.GPIO_Pin = FSMC_A5_GPIO_PIN; 
  79.   GPIO_Init(FSMC_A5_GPIO_PORT, &GPIO_InitStructure);
  81.   GPIO_InitStructure.GPIO_Pin = FSMC_A6_GPIO_PIN; 
  82.   GPIO_Init(FSMC_A6_GPIO_PORT, &GPIO_InitStructure);
  84.   GPIO_InitStructure.GPIO_Pin = FSMC_A7_GPIO_PIN; 
  85.   GPIO_Init(FSMC_A7_GPIO_PORT, &GPIO_InitStructure);
  87.   GPIO_InitStructure.GPIO_Pin = FSMC_A8_GPIO_PIN; 
  88.   GPIO_Init(FSMC_A8_GPIO_PORT, &GPIO_InitStructure);
  90.   GPIO_InitStructure.GPIO_Pin = FSMC_A9_GPIO_PIN; 
  91.   GPIO_Init(FSMC_A9_GPIO_PORT, &GPIO_InitStructure);
  93.   GPIO_InitStructure.GPIO_Pin = FSMC_A10_GPIO_PIN; 
  94.   GPIO_Init(FSMC_A10_GPIO_PORT, &GPIO_InitStructure);
  96.   GPIO_InitStructure.GPIO_Pin = FSMC_A11_GPIO_PIN; 
  97.   GPIO_Init(FSMC_A11_GPIO_PORT, &GPIO_InitStructure);
  99.     GPIO_InitStructure.GPIO_Pin = FSMC_A12_GPIO_PIN; 
  100.   GPIO_Init(FSMC_A12_GPIO_PORT, &GPIO_InitStructure);
  102.   GPIO_InitStructure.GPIO_Pin = FSMC_A13_GPIO_PIN; 
  103.   GPIO_Init(FSMC_A13_GPIO_PORT, &GPIO_InitStructure);
  105.   GPIO_InitStructure.GPIO_Pin = FSMC_A14_GPIO_PIN; 
  106.   GPIO_Init(FSMC_A14_GPIO_PORT, &GPIO_InitStructure);
  108.   GPIO_InitStructure.GPIO_Pin = FSMC_A15_GPIO_PIN; 
  109.   GPIO_Init(FSMC_A15_GPIO_PORT, &GPIO_InitStructure);    
  111.     GPIO_InitStructure.GPIO_Pin = FSMC_A16_GPIO_PIN; 
  112.   GPIO_Init(FSMC_A16_GPIO_PORT, &GPIO_InitStructure);
  114.   GPIO_InitStructure.GPIO_Pin = FSMC_A17_GPIO_PIN; 
  115.   GPIO_Init(FSMC_A17_GPIO_PORT, &GPIO_InitStructure);
  117.   GPIO_InitStructure.GPIO_Pin = FSMC_A18_GPIO_PIN; 
  118.   GPIO_Init(FSMC_A18_GPIO_PORT, &GPIO_InitStructure);
  120.   /*DQ数据信号线 针对引脚配置*/
  121.   GPIO_InitStructure.GPIO_Pin = FSMC_D0_GPIO_PIN; 
  122.   GPIO_Init(FSMC_D0_GPIO_PORT, &GPIO_InitStructure);
  124.   GPIO_InitStructure.GPIO_Pin = FSMC_D1_GPIO_PIN; 
  125.   GPIO_Init(FSMC_D1_GPIO_PORT, &GPIO_InitStructure);
  127.   GPIO_InitStructure.GPIO_Pin = FSMC_D2_GPIO_PIN; 
  128.   GPIO_Init(FSMC_D2_GPIO_PORT, &GPIO_InitStructure);
  130.   GPIO_InitStructure.GPIO_Pin = FSMC_D3_GPIO_PIN; 
  131.   GPIO_Init(FSMC_D3_GPIO_PORT, &GPIO_InitStructure);
  133.   GPIO_InitStructure.GPIO_Pin = FSMC_D4_GPIO_PIN; 
  134.   GPIO_Init(FSMC_D4_GPIO_PORT, &GPIO_InitStructure);
  136.   GPIO_InitStructure.GPIO_Pin = FSMC_D5_GPIO_PIN; 
  137.   GPIO_Init(FSMC_D5_GPIO_PORT, &GPIO_InitStructure);
  139.   GPIO_InitStructure.GPIO_Pin = FSMC_D6_GPIO_PIN; 
  140.   GPIO_Init(FSMC_D6_GPIO_PORT, &GPIO_InitStructure);
  142.   GPIO_InitStructure.GPIO_Pin = FSMC_D7_GPIO_PIN; 
  143.   GPIO_Init(FSMC_D7_GPIO_PORT, &GPIO_InitStructure);
  145.   GPIO_InitStructure.GPIO_Pin = FSMC_D8_GPIO_PIN; 
  146.   GPIO_Init(FSMC_D8_GPIO_PORT, &GPIO_InitStructure);
  148.   GPIO_InitStructure.GPIO_Pin = FSMC_D9_GPIO_PIN; 
  149.   GPIO_Init(FSMC_D9_GPIO_PORT, &GPIO_InitStructure);
  151.   GPIO_InitStructure.GPIO_Pin = FSMC_D10_GPIO_PIN; 
  152.   GPIO_Init(FSMC_D10_GPIO_PORT, &GPIO_InitStructure);
  154.   GPIO_InitStructure.GPIO_Pin = FSMC_D11_GPIO_PIN; 
  155.   GPIO_Init(FSMC_D11_GPIO_PORT, &GPIO_InitStructure);
  157.   GPIO_InitStructure.GPIO_Pin = FSMC_D12_GPIO_PIN; 
  158.   GPIO_Init(FSMC_D12_GPIO_PORT, &GPIO_InitStructure);
  160.   GPIO_InitStructure.GPIO_Pin = FSMC_D13_GPIO_PIN; 
  161.   GPIO_Init(FSMC_D13_GPIO_PORT, &GPIO_InitStructure);
  163.   GPIO_InitStructure.GPIO_Pin = FSMC_D14_GPIO_PIN; 
  164.   GPIO_Init(FSMC_D14_GPIO_PORT, &GPIO_InitStructure);
  166.   GPIO_InitStructure.GPIO_Pin = FSMC_D15_GPIO_PIN; 
  167.   GPIO_Init(FSMC_D15_GPIO_PORT, &GPIO_InitStructure);
  169.   /*控制信号线*/
  170.   GPIO_InitStructure.GPIO_Pin = FSMC_CS_GPIO_PIN; 
  171.   GPIO_Init(FSMC_CS_GPIO_PORT, &GPIO_InitStructure);
  173.   GPIO_InitStructure.GPIO_Pin = FSMC_WE_GPIO_PIN; 
  174.   GPIO_Init(FSMC_WE_GPIO_PORT, &GPIO_InitStructure);
  176.   GPIO_InitStructure.GPIO_Pin = FSMC_OE_GPIO_PIN; 
  177.   GPIO_Init(FSMC_OE_GPIO_PORT, &GPIO_InitStructure);    
  179.   GPIO_InitStructure.GPIO_Pin = FSMC_UDQM_GPIO_PIN; 
  180.   GPIO_Init(FSMC_UDQM_GPIO_PORT, &GPIO_InitStructure);
  182.   GPIO_InitStructure.GPIO_Pin = FSMC_LDQM_GPIO_PIN; 
  183.   GPIO_Init(FSMC_LDQM_GPIO_PORT, &GPIO_InitStructure);    
  184. }                              
  188. //写时序的要求
  190. //1.  ADDSET+1+DATAST+1  >55ns
  191. //2.  DATAST+1  > 40ns
  192. //3.  ADDSET+1 > 0ns
  194. //读时序的要求
  195. //1.  ADDSET+1+DATAST+1 +2 >55ns
  196. //2.  DATAST+1  > 25ns
  197. //3.  ADDSET+1 > 0ns    
  199. //1 个HCLK时钟周期:
  200. //T = 1/72MHz = 1.38*10^-8 s = 13.8 ns
  202. //读时序的要求
  203. //ADDSET = 0 
  204. //DATAST =1 (经测试，DATAST配置成1是不能正常工作的)
  206. //1.  ADDSET+1+DATAST+1 +2 >55ns  ------- 0+1+1+1+2 = 69 ns > 55ns
  207. //2.  DATAST+1  > 25ns  ------ 1+1 = 27.6 >25 ns
  208. //3.  ADDSET+1 > 0ns    ------  0+1 = 13.8ns >0 ns 
  210. //写时序的要求
  211. //ADDSET = 0 
  212. //DATAST = 2
  214. //1.  ADDSET+1+DATAST+1  >55ns  ------ 0+1+2+1 =55.2 >55ns 
  215. //2.  DATAST+1  > 40ns ------ 2+1 = 41.4 >40 ns
  216. //3.  ADDSET+1 > 0ns   ------  0+1 = 13.8ns >0 ns 
  218. /**
  219.   * @brief  初始化FSMC外设
  220.   * @param  None. 
  221.   * @retval None.
  222.   */
  223. void FSMC_SRAM_Init(void)
  224. {    
  225.     FSMC_NORSRAMInitTypeDef  FSMC_NORSRAMInitStructure;
  226.     FSMC_NORSRAMTimingInitTypeDef  readWriteTiming;
  228.     /*初始化SRAM相关的GPIO*/
  229.     SRAM_GPIO_Config();
  231.     /*使能FSMC外设时钟*/
  232.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC,ENABLE);
  234.     //地址建立时间（ADDSET）为1个HCLK 1/72M=14ns
  235.     readWriteTiming.FSMC_AddressSetupTime = 0x00;    
  237.     //地址保持时间（ADDHLD）模式A未用到
  238.     readWriteTiming.FSMC_AddressHoldTime = 0x00;     
  240.     //数据保持时间（DATAST）+ 1个HCLK = 3/72M=42ns(对EM的SRAM芯片)    
  241.     readWriteTiming.FSMC_DataSetupTime = 0x02;    // 2是经验值，理论值为1      
  243.     //设置总线转换周期，仅用于复用模式的NOR操作
  244.     readWriteTiming.FSMC_BusTurnAroundDuration = 0x00;
  246.     //设置时钟分频，仅用于同步类型的存储器
  247.     readWriteTiming.FSMC_CLKDivision = 0x00;    
  249.     //数据保持时间，仅用于同步型的NOR
  250.     readWriteTiming.FSMC_DataLatency = 0x00;        
  252.     //选择匹配SRAM的模式
  253.     readWriteTiming.FSMC_AccessMode = FSMC_AccessMode_A;     
  256.     // 选择FSMC映射的存储区域： Bank1 sram3
  257.     FSMC_NORSRAMInitStructure.FSMC_Bank = FSMC_Bank1_NORSRAM3;
  259.     //设置地址总线与数据总线是否复用，仅用于NOR
  260.     FSMC_NORSRAMInitStructure.FSMC_DataAddressMux = FSMC_DataAddressMux_Disable; 
  262.     //设置要控制的存储器类型：SRAM类型
  263.     FSMC_NORSRAMInitStructure.FSMC_MemoryType =FSMC_MemoryType_SRAM;   
  265.     //存储器数据宽度：16位
  266.     FSMC_NORSRAMInitStructure.FSMC_MemoryDataWidth = FSMC_MemoryDataWidth_16b; 
  268.     //设置是否使用突发访问模式，仅用于同步类型的存储器
  269.     FSMC_NORSRAMInitStructure.FSMC_BurstAccessMode =FSMC_BurstAccessMode_Disable;
  271.     //设置是否使能等待信号，仅用于同步类型的存储器
  272.     FSMC_NORSRAMInitStructure.FSMC_AsynchronousWait=FSMC_AsynchronousWait_Disable;
  274.     //设置等待信号的有效极性，仅用于同步类型的存储器
  275.     FSMC_NORSRAMInitStructure.FSMC_WaitSignalPolarity = FSMC_WaitSignalPolarity_Low;
  277.     //设置是否支持把非对齐的突发操作，仅用于同步类型的存储器
  278.     FSMC_NORSRAMInitStructure.FSMC_WrapMode = FSMC_WrapMode_Disable; 
  280.     //设置等待信号插入的时间，仅用于同步类型的存储器
  281.     FSMC_NORSRAMInitStructure.FSMC_WaitSignalActive = FSMC_WaitSignalActive_BeforeWaitState;
  283.     //存储器写使能 
  284.     FSMC_NORSRAMInitStructure.FSMC_WriteOperation = FSMC_WriteOperation_Enable;
  286.     //不使用等待信号
  287.     FSMC_NORSRAMInitStructure.FSMC_WaitSignal = FSMC_WaitSignal_Disable;          
  289.     // 不使用扩展模式，读写使用相同的时序
  290.     FSMC_NORSRAMInitStructure.FSMC_ExtendedMode = FSMC_ExtendedMode_Disable; 
  292.     //突发写操作
  293.     FSMC_NORSRAMInitStructure.FSMC_WriteBurst = FSMC_WriteBurst_Disable;  
  295.     //读写时序配置
  296.     FSMC_NORSRAMInitStructure.FSMC_ReadWriteTimingStruct = &readWriteTiming;
  298.     //读写同样时序，使用扩展模式时这个配置才有效
  299.     FSMC_NORSRAMInitStructure.FSMC_WriteTimingStruct = &readWriteTiming; 
  301.     FSMC_NORSRAMInit(&FSMC_NORSRAMInitStructure);  //初始化FSMC配置
  303.     FSMC_NORSRAMCmd(FSMC_Bank1_NORSRAM3, ENABLE);  // 使能BANK                                          
  305. }
  310. /**
  311.   * @brief  以“字”为单位向sdram写入数据 
  312.   * @param  pBuffer: 指向数据的指针 
  313.   * @param  uwWriteAddress: 要写入的SRAM内部地址
  314.   * @param  uwBufferSize: 要写入数据大小
  315.   * @retval None.
  316.   */
  317. void SRAM_WriteBuffer(uint32_t* pBuffer, uint32_t uwWriteAddress, uint32_t uwBufferSize)
  318. {
  319.   __IO uint32_t write_pointer = (uint32_t)uwWriteAddress;
  322.   /* 循环写入数据 */
  323.   for (; uwBufferSize != 0; uwBufferSize--) 
  324.   {
  325.     /* 发送数据到SRAM */
  326.     *(uint32_t *) (Bank1_SRAM3_ADDR + write_pointer) = *pBuffer++;
  328.     /* 地址自增*/
  329.     write_pointer += 4;
  330.   }
  332. }
  334. /**
  335.   * @brief  从SRAM中读取数据 
  336.   * @param  pBuffer: 指向存储数据的buffer
  337.   * @param  ReadAddress: 要读取数据的地十
  338.   * @param  uwBufferSize: 要读取的数据大小
  339.   * @retval None.
  340.   */
  341. void SRAM_ReadBuffer(uint32_t* pBuffer, uint32_t uwReadAddress, uint32_t uwBufferSize)
  342. {
  343.   __IO uint32_t write_pointer = (uint32_t)uwReadAddress;
  346.   /*读取数据 */
  347.   for(; uwBufferSize != 0x00; uwBufferSize--)
  348.   {
  349.    *pBuffer++ = *(__IO uint32_t *)(Bank1_SRAM3_ADDR + write_pointer );
  351.    /* 地址自增*/
  352.     write_pointer += 4;
  353.   } 
  354. }
  357. /**
  358.   * @brief  测试SRAM是否正常 
  359.   * @param  None
  360.   * @retval 正常返回1，异常返回0
  361.   */
  362. uint8_t SRAM_Test(void)
  363. {
  364.   /*写入数据计数器*/
  365.   uint32_t counter=0;
  367.   /* 8位的数据 */
  368.   uint8_t ubWritedata_8b = 0, ubReaddata_8b = 0;  
  370.   /* 16位的数据 */
  371.   uint16_t uhWritedata_16b = 0, uhReaddata_16b = 0; 
  373.   SRAM_INFO("正在检测SRAM，以8位、16位的方式读写sram...");
  376.   /*按8位格式读写数据，并校验*/
  378.   /* 把SRAM数据全部重置为0 ，IS62WV51216_SIZE是以8位为单位的 */
  379.   for (counter = 0x00; counter < IS62WV51216_SIZE; counter++)
  380.   {
  381.     *(__IO uint8_t*) (Bank1_SRAM3_ADDR + counter) = (uint8_t)0x0;
  382.   }
  384.   /* 向整个SRAM写入数据  8位 */
  385.   for (counter = 0; counter < IS62WV51216_SIZE; counter++)
  386.   {
  387.     *(__IO uint8_t*) (Bank1_SRAM3_ADDR + counter) = (uint8_t)(ubWritedata_8b + counter);
  388.   }
  390.   /* 读取 SRAM 数据并检测*/
  391.   for(counter = 0; counter<IS62WV51216_SIZE;counter++ )
  392.   {
  393.     ubReaddata_8b = *(__IO uint8_t*)(Bank1_SRAM3_ADDR + counter);  //从该地址读出数据
  395.     if(ubReaddata_8b != (uint8_t)(ubWritedata_8b + counter))      //检测数据，若不相等，跳出函数,返回检测失败结果。
  396.     {
  397.       SRAM_ERROR("8位数据读写错误！");
  398.       return 0;
  399.     }
  400.   }
  403.   /*按16位格式读写数据，并检测*/
  405.   /* 把SRAM数据全部重置为0 */
  406.   for (counter = 0x00; counter < IS62WV51216_SIZE/2; counter++)
  407.   {
  408.     *(__IO uint16_t*) (Bank1_SRAM3_ADDR + 2*counter) = (uint16_t)0x00;
  409.   }
  411.   /* 向整个SRAM写入数据  16位 */
  412.   for (counter = 0; counter < IS62WV51216_SIZE/2; counter++)
  413.   {
  414.     *(__IO uint16_t*) (Bank1_SRAM3_ADDR + 2*counter) = (uint16_t)(uhWritedata_16b + counter);
  415.   }
  417.     /* 读取 SRAM 数据并检测*/
  418.   for(counter = 0; counter<IS62WV51216_SIZE/2;counter++ )
  419.   {
  420.     uhReaddata_16b = *(__IO uint16_t*)(Bank1_SRAM3_ADDR + 2*counter);  //从该地址读出数据
  422.     if(uhReaddata_16b != (uint16_t)(uhWritedata_16b + counter))      //检测数据，若不相等，跳出函数,返回检测失败结果。
  423.     {
  424.       SRAM_ERROR("16位数据读写错误！");
  426.       return 0;
  427.     }
  428.   }
  430.   SRAM_INFO("SRAM读写测试正常！"); 
  431.   /*检测正常，return 1 */
  432.   return 1;
  434. }
  437. /*********************************************END OF FILE**********************/

main.c

  1. /**
  2.   ******************************************************************************
  3.   * @file    FSMC—外部SRAM
  4.   * @author  fire
  5.   * @version V1.0
  6.   * @date    2015-xx-xx
  7.   * @brief   sram应用例程
  8.   ******************************************************************************
  9.   * @attention
  10.   *
  11.   * 实验平台:野火 F103-霸道 STM32  开发板  
  12.   * 论坛    :http://www.firebbs.cn
  13.   * 淘宝    :https://fire-stm32.taobao.com
  14.   *
  15.   ******************************************************************************
  16.   */
  18. #include "stm32f10x.h"
  19. #include "./usart/bsp_usart.h"
  20. #include "./led/bsp_led.h"  
  21. #include "./sram/bsp_sram.h"
  25. /*绝对定位方式访问SRAM,这种方式必须定义成全局变量*/
  26. uint8_t testValue __attribute__((at(Bank1_SRAM3_ADDR)));
  30.  /**
  31.   * @brief  主函数
  32.   * @param  无
  33.   * @retval 无
  34.   */
  35.  int main(void)
  36.  {         
  38.     LED_GPIO_Config();
  39.     //串口初始化  
  40.     USART_Config();                                    
  41.     //初始化外部SRAM  
  42.     FSMC_SRAM_Init();                 
  44.     printf ( "\r\n野火外部 SRAM 测试\r\n" );
  47.      /*蓝灯亮，表示正在读写SRAM测试*/
  48.      LED_BLUE;
  50.      /*对SRAM进行读写测试，检测SRAM是否正常*/
  51.      if(SRAM_Test()==1)
  52.      {
  53.          //测试正常 绿灯亮
  54.          LED_GREEN;              
  55.      }
  56.     else
  57.     {
  58.         //测试失败 红灯亮
  59.         LED_RED;
  60.     }
  62.     /*指针方式访问SRAM*/
  63.     {    
  64.      uint32_t temp;
  66.      printf("\r\n指针方式访问SRAM\r\n");
  67.     /*向SRAM写入8位数据*/
  68.      *( uint8_t*) (Bank1_SRAM3_ADDR ) = (uint8_t)0xAA;
  69.      printf("\r\n指针访问SRAM，写入数据0xAA \r\n");
  71.      /*从SRAM读取数据*/
  72.      temp =  *( uint8_t*) (Bank1_SRAM3_ADDR );
  73.      printf("读取数据：0x%X \r\n",temp);
  75.      /*写/读 16位数据*/
  76.      *( uint16_t*) (Bank1_SRAM3_ADDR+10 ) = (uint16_t)0xBBBB;
  77.      printf("指针访问SRAM，写入数据0xBBBB \r\n");
  79.      temp =  *( uint16_t*) (Bank1_SRAM3_ADDR+10 );
  80.      printf("读取数据：0x%X \r\n",temp);
  83.      /*写/读 32位数据*/
  84.      *( uint32_t*) (Bank1_SRAM3_ADDR+20 ) = (uint32_t)0xCCCCCCCC;
  85.      printf("指针访问SRAM，写入数据0xCCCCCCCC \r\n");     
  86.      temp =  *( uint32_t*) (Bank1_SRAM3_ADDR+20 );
  87.      printf("读取数据：0x%X \r\n",temp);
  89.     }
  91.     /*绝对定位方式访问SRAM,这种方式必须定义成全局变量*/
  92.     {
  93.         testValue = 0xDD;
  94.         printf("\r\n绝对定位访问SRAM，写入数据0xDD,读出数据0x%X,变量地址为%X\r\n",testValue,(uint32_t )&testValue);     
  95.     }
  97. }
  100. /*********************************************END OF FILE**********************/

可执行程序：FSMC—外部SRAM.zip

FSMC—外部SRAM（内存管理）

bsp_malloc.h

  1. #ifndef __BSP_MALLOC_H
  2. #define __BSP_MALLOC_H
  5. #include "stm32f10x.h"
  8. #ifndef NULL
  9. #define NULL 0
  10. #endif
  12. //定义两个内存池
  13. #define SRAMIN     0        //内部内存池
  14. #define SRAMEX   1        //外部内存池 
  16. #define SRAMBANK     2      //定义支持的SRAM块数.    
  19. //mem1内存参数设定.mem1完全处于内部SRAM里面.
  20. #define MEM1_BLOCK_SIZE            32                    //内存块大小为32字节
  21. #define MEM1_MAX_SIZE            40*1024              //最大管理内存 40K
  22. #define MEM1_ALLOC_TABLE_SIZE    MEM1_MAX_SIZE/MEM1_BLOCK_SIZE     //内存表大小
  25. //mem2内存参数设定.mem2的内存池处于外部SRAM里面
  26. #define MEM2_BLOCK_SIZE            32            //内存块大小为32字节
  27. #define MEM2_MAX_SIZE            960 *1024   //最大管理内存960K
  28. #define MEM2_ALLOC_TABLE_SIZE    MEM2_MAX_SIZE/MEM2_BLOCK_SIZE     //内存表大小 
  32. //内存管理控制器
  33. struct _m_mallco_dev
  34. {
  35.     void    ( * init ) ( uint8_t );                 //初始化
  36.     uint8_t ( * perused ) ( uint8_t );         //内存使用率
  37.     uint8_t  * membase [ SRAMBANK ];           //内存池 管理SRAMBANK个区域的内存
  38.     uint16_t * memmap [ SRAMBANK ];            //内存管理状态表
  39.     uint8_t    memrdy [ SRAMBANK ];              //内存管理是否就绪
  40. };
  41. extern struct _m_mallco_dev mallco_dev;     //在mallco.c里面定义
  44. void mymemset(void *s,uint8_t c,uint32_t count);      //设置内存
  45. void mymemcpy(void *des,void *src,uint32_t n);        //复制内存     
  46. void my_mem_init(uint8_t memx);                          //内存管理初始化函数(外/内部调用)
  47. uint32_t my_mem_malloc(uint8_t memx,uint32_t size);      //内存分配(内部调用)
  48. uint8_t my_mem_free(uint8_t memx,uint32_t offset);      //内存释放(内部调用)
  49. uint8_t my_mem_perused(uint8_t memx);                  //获得内存使用率(外/内部调用) 
  52. //用户调用函数
  53. void myfree(uint8_t memx,void *ptr);                         //内存释放(外部调用)
  54. void *mymalloc(uint8_t memx,uint32_t size);                   //内存分配(外部调用)
  55. void *myrealloc(uint8_t memx,void *ptr,uint32_t size);     //重新分配内存(外部调用)
  58. #endif // __BSP_MALLOC_H

bsp_malloc.c

  1. #include "bsp_malloc.h"        
  5. //内存池(32字节对齐)
  6. __align(32) uint8_t mem1base[MEM1_MAX_SIZE];                                                    //内部SRAM内存池
  7. __align(32) uint8_t mem2base[MEM2_MAX_SIZE] __attribute__((at(0X68000000)));                    //外部SRAM内存池
  10. //内存管理表
  11. uint16_t mem1mapbase[MEM1_ALLOC_TABLE_SIZE];                                                    //内部SRAM内存池MAP
  12. uint16_t mem2mapbase[MEM2_ALLOC_TABLE_SIZE] __attribute__((at(0X68000000+MEM2_MAX_SIZE)));    //外部SRAM内存池MAP
  15. //内存管理参数       
  16. const uint32_t memtblsize[SRAMBANK]={MEM1_ALLOC_TABLE_SIZE,MEM2_ALLOC_TABLE_SIZE};            //内存表大小
  17. const uint32_t memblksize[SRAMBANK]={MEM1_BLOCK_SIZE,MEM2_BLOCK_SIZE};                              //内存分块大小
  18. const uint32_t memsize[SRAMBANK]={MEM1_MAX_SIZE,MEM2_MAX_SIZE};                                          //内存总大小
  21. //内存管理控制器
  22. struct _m_mallco_dev mallco_dev=
  23. {
  24.     my_mem_init,                             //内存初始化
  25.     my_mem_perused,                           //内存使用率
  26.     mem1base,mem2base,                     //内存池
  27.     mem1mapbase,mem2mapbase,           //内存管理状态表
  28.     0,0,                                          //内存管理未就绪
  29. };
  33. //复制内存
  34. //*des:目的地址
  35. //*src:源地址
  36. //n:需要复制的内存长度(字节为单位)
  37. void mymemcpy(void *des,void *src,uint32_t n)  
  38. {  
  39.     uint8_t *xdes=des;
  40.     uint8_t *xsrc=src; 
  43.     while(n--)*xdes++=*xsrc++;  
  45. }  
  48. //设置内存
  49. //*s:内存首地址
  50. //c :要设置的值
  51. //count:需要设置的内存大小(字节为单位)
  52. void mymemset(void *s,uint8_t c,uint32_t count)  
  53. {  
  54.     uint8_t *xs = s;  
  57.     while(count--)*xs++=c;  
  59. }       
  62. //内存管理初始化  
  63. //memx:所属内存块
  64. void my_mem_init(uint8_t memx)  
  65. {  
  66.     mymemset(mallco_dev.memmap[memx], 0,memtblsize[memx]*2);//内存状态表数据清零  
  67.     mymemset(mallco_dev.membase[memx], 0,memsize[memx]);    //内存池所有数据清零  
  68.     mallco_dev.memrdy[memx]=1;                                //内存管理初始化OK  
  69. }  
  72. //获取内存使用率
  73. //memx:所属内存块
  74. //返回值:使用率(0~100)
  75. uint8_t my_mem_perused(uint8_t memx)  
  76. {  
  77.     uint32_t used=0;  
  78.     uint32_t i;  
  81.     for(i=0;i<memtblsize[memx];i++)  
  82.     {  
  83.             if(mallco_dev.memmap[memx][i])used++; 
  84.     } 
  86.     return (used*100)/(memtblsize[memx]);  
  88. }  
  91. //内存分配(内部调用)
  92. //memx:所属内存块
  93. //size:要分配的内存大小(字节)
  94. //返回值:0XFFFFFFFF,代表错误;其他,内存偏移地址 
  95. uint32_t my_mem_malloc(uint8_t memx,uint32_t size)  
  96. {  
  97.     signed long offset=0;  
  98.     uint32_t nmemb;    //需要的内存块数  
  99.     uint32_t cmemb=0;//连续空内存块数
  100.     uint32_t i;  
  103.     if(!mallco_dev.memrdy[memx])mallco_dev.init(memx);//未初始化,先执行初始化 
  105.     if(size==0)
  106.         return 0XFFFFFFFF;//不需要分配
  108.     nmemb=size/memblksize[memx];      //获取需要分配的连续内存块数
  110.     if(size%memblksize[memx])nmemb++; 
  112.     for(offset=memtblsize[memx]-1;offset>=0;offset--)//搜索整个内存控制区  
  113.     {     
  114.         if(!mallco_dev.memmap[memx][offset])cmemb++;//连续空内存块数增加
  115.         else cmemb=0;                                //连续内存块清零
  117.         if(cmemb==nmemb)                            //找到了连续nmemb个空内存块
  118.         {
  119.             for(i=0;i<nmemb;i++)                      //标注内存块非空 
  120.             {  
  121.                     mallco_dev.memmap[memx][offset+i]=nmemb;  
  122.             }  
  123.             return (offset*memblksize[memx]);//返回偏移地址  
  124.         }
  126.     }  
  128.     return 0XFFFFFFFF;//未找到符合分配条件的内存块  
  130. }  
  133. //释放内存(内部调用) 
  134. //memx:所属内存块
  135. //offset:内存地址偏移
  136. //返回值:0,释放成功;1,释放失败;  
  137. uint8_t my_mem_free(uint8_t memx,uint32_t offset)  
  138. {  
  139.     int i;  
  142.     if(!mallco_dev.memrdy[memx])//未初始化,先执行初始化
  143.     {
  144.     mallco_dev.init(memx);    
  145.             return 1;//未初始化  
  146.     }  
  148.     if(offset<memsize[memx])//偏移在内存池内. 
  149.     {  
  150.             int index=offset/memblksize[memx];            //偏移所在内存块号码  
  151.             int nmemb=mallco_dev.memmap[memx][index];    //内存块数量
  152.             for(i=0;i<nmemb;i++)                          //内存块清零
  153.             {  
  154.                 mallco_dev.memmap[memx][index+i]=0;  
  155.             }  
  156.             return 0;  
  157.     }
  158.     else 
  159.         return 2;//偏移超区了.  
  161. }  
  164. //释放内存(外部调用) 
  165. //memx:所属内存块
  166. //ptr:内存首地址 
  167. void myfree(uint8_t memx,void *ptr)  
  168. {  
  169.     uint32_t offset;   
  172.     if(ptr==NULL)return;//地址为0.  
  173.     offset=(uint32_t)ptr-(uint32_t)mallco_dev.membase[memx];     
  174.     my_mem_free(memx,offset);    //释放内存     
  176. }  
  179. //分配内存(外部调用)
  180. //memx:所属内存块
  181. //size:内存大小(字节)
  182. //返回值:分配到的内存首地址.
  183. void *mymalloc(uint8_t memx,uint32_t size)  
  184. {  
  185.     uint32_t offset;   
  188.     offset=my_mem_malloc(memx,size);              
  190.     if(offset==0XFFFFFFFF)return NULL;  
  191.     else return (void*)((uint32_t)mallco_dev.membase[memx]+offset);  
  193. }  
  196. //重新分配内存(外部调用)
  197. //memx:所属内存块
  198. //*ptr:旧内存首地址
  199. //size:要分配的内存大小(字节)
  200. //返回值:新分配到的内存首地址.
  201. void *myrealloc(uint8_t memx,void *ptr,uint32_t size)  
  202. {  
  203.     uint32_t offset;    
  206.     offset=my_mem_malloc(memx,size);       
  207.     if(offset==0XFFFFFFFF)return NULL;     
  208.     else  
  209.     {      //拷贝旧内存内容到新内存                                      
  210.         mymemcpy((void*)((uint32_t)mallco_dev.membase[memx]+offset),ptr,size);    
  212.         //释放旧内存
  213.         myfree(memx,ptr);                                                        
  215.         //返回新内存首地址
  216.         return (void*)((uint32_t)mallco_dev.membase[memx]+offset);                  
  217.     }  
  219. }

main.c

  1. /**
  2.   ******************************************************************************
  3.   * @file    FSMC—外部SRAM(内存管理)
  4.   * @author  fire
  5.   * @version V1.0
  6.   * @date    2015-xx-xx
  7.   * @brief   sram应用例程
  8.   ******************************************************************************
  9.   * @attention
  10.   *
  11.   * 实验平台:野火 F103-霸道 STM32  开发板  
  12.   * 论坛    :http://www.firebbs.cn
  13.   * 淘宝    :https://fire-stm32.taobao.com
  14.   *
  15.   ******************************************************************************
  16.   */
  17. #include "stm32f10x.h"
  18. #include "./usart/bsp_usart.h"
  19. #include "./led/bsp_led.h"  
  20. #include "./sram/bsp_sram.h"
  21. #include "bsp_malloc.h"
  25. int main(void)
  26.  {       
  27.     u8 *p=0;
  28.     u8 sramx=0;                //默认为内部sram
  31.     USART_Config();                 //串口初始化为115200 
  32.      FSMC_SRAM_Init();            //初始化外部SRAM  
  33.     my_mem_init(SRAMIN);        //初始化内部内存池
  34.     my_mem_init(SRAMEX);        //初始化外部内存池
  37.     printf ( "\r\n野火内存管理\r\n" );
  40.     printf ( "\r\n分配内存\r\n" );
  42.     p = mymalloc ( sramx, 1024 *2 );//申请2K字节
  44.     sprintf((char*)p,"Memory Malloc");//使用申请空间存储内容
  46.     printf ( "SRAMIN USED:%d%%\r\n", my_mem_perused(SRAMIN) );//显示内部内存使用率
  47.     printf ( "SRAMEX USED:%d%%\r\n", my_mem_perused(SRAMEX) );//显示外部内存使用率
  49.     myfree(sramx,p);  //释放内存
  50.     p=0;              //指向空地址
  52.     printf ( "\r\n释放内存\r\n" );
  53.     printf ( "SRAMIN USED:%d%%\r\n", my_mem_perused(SRAMIN) );//显示内部内存使用率
  54.     printf ( "SRAMEX USED:%d%%\r\n", my_mem_perused(SRAMEX) );//显示外部内存使用率
  57.   while(1);
  60. }
  62. /*********************************************END OF FILE**********************/

可执行程序：FSMC—外部SRAM（内存管理）.zip