问题描述：
1、使用MCU：STM32f103RE
2、开发环境：CubeIDE
3、固件版本：STM32Cube FW_F1 V1.8.04、硬件连接：4位共阴极数码管，GPIOA0~7通过100Ω电阻连接数码管7断码和DP位，GPIOC0~3连接NPN三极管基极控制数码管阴极接地实现位选；SPI2（GPIOB端口）连接W25Q64 Flash芯片。
5、问题概述：定时器TIM2更新事件和定时器TIM2通道1比较输出事件，分别触发DMA1_Ch2向GPIOC，DMA1_Ch5向GPIOA，传输数据，驱动数码管动态扫描显示，并且正常工作。但，当运行MX_FATFS_Init()始化FatFs文件后，数码管显示异常，跟踪定位到函数FATFS_LinkDriverEx()中的【disk.drv[disk.nbr] = drv;】，运行该句后数码管显示异常。

希望知道原因的大神不吝赐教，在此万分感谢！！！

主要实现代码如下：//DMA1通道5传输数据volatile uint32_t LDS_Buffer[8]={0x00ff00f0, 0x00ff0000, 0x00ff000f, 0x00ff0000, 0x00ff00f0, 0x00ff0000, 0x00ff000f, 0x00ff0000};
//DMA1通道2传输数据

volatile uint32_t SEG_Buffer[8]={0x000f0008, 0x000f0000, 0x000f0004, 0x000f0000, 0x000f0002, 0x000f0000, 0x000f0001, 0x000f0000};

int main(void)

{

HAL_Init();

SystemClock_Config();

/* Initialize all configured peripherals */

MX_GPIO_Init();

MX_DMA_Init();

W25QXX_Init();

MX_TIM2_Init();

HAL_DMA_Start(&hdma_tim2_ch1, (uint32_t)LDS_Buffer, (uint32_t)(&(GPIOA->BSRR)), 32);

HAL_DMA_Start(&hdma_tim2_up, (uint32_t)SEG_Buffer, (uint32_t)(&(GPIOC->BSRR)), 32);

__HAL_TIM_ENABLE_DMA(&htim2, TIM_DMA_CC1|TIM_DMA_UPDATE);

HAL_TIM_Base_Start(&htim2);

运行完以上代码，数码管正常显示

MX_FATFS_Init();  //运行完该函数，数码管显示异常

while (1)

{

   }

}

代码跟踪：

1. void MX_FATFS_Init(void)
   
2. {
   
3. /*## FatFS: Link the Flash driver ###########################*/
   
4. retFlash = FATFS_LinkDriver(&Flash_Driver, FlashPath);
   
5. }
   
6. 
   
7. uint8_t FATFS_LinkDriver(Diskio_drvTypeDef *drv, char *path)
   
8. {
   
9. return FATFS_LinkDriverEx(drv, path, 0);
   
10. }
    
11. 
    
12. uint8_t FATFS_LinkDriverEx(Diskio_drvTypeDef *drv, char *path, uint8_t lun)
    
13. {
    
14. uint8_t ret = 1;
    
15. uint8_t DiskNum = 0;
    
16. 
    
17. if(disk.nbr <= _VOLUMES)
    
18. {
    
19. disk.is_initialized[disk.nbr] = 0;
    
20. <b style="background-color: red;">disk.drv[disk.nbr] = drv; //跟踪至该句，运行该句后数码管显示异常</b>
    
21. disk.lun[disk.nbr] = lun;
    
22. DiskNum = disk.nbr++;
    
23. path[0] = DiskNum + '0';
    
24. path[1] = ':';
    
25. path[2] = '/';
    
26. path[3] = 0;
    
27. ret = 0;
    
28. }
    
29. 
    
30. return ret;
    
31. }
    

复制代码

Flash驱动移植：

1. Diskio_drvTypeDef Flash_Driver =
   
2. {
   
3. Flash_initialize,
   
4. Flash_status,
   
5. Flash_read,
   
6. #if _USE_WRITE == 1
   
7. Flash_write,
   
8. #endif /* _USE_WRITE == 1 */
   
9. #if _USE_IOCTL == 1
   
10. Flash_ioctl,
    
11. #endif /* _USE_IOCTL == 1 */
    
12. };
    
13. 
    
14. DSTATUS Flash_initialize(BYTE pdrv) /* Physical drive nmuber to identify the drive */
    
15. {
    
16. W25QXX_Init();
    
17. return RES_OK;
    
18. }
    
19. 
    
20. 
    
21. DSTATUS Flash_status(BYTE pdrv) /* Physical drive nmuber to identify the drive */
    
22. {
    
23. /* USER CODE BEGIN STATUS */
    
24. Stat = STA_NOINIT;
    
25. Stat = RES_OK;
    
26. 
    
27. return Stat;
    
28. /* USER CODE END STATUS */
    
29. }
    
30. 
    
31. 
    
32. DRESULT Flash_read (BYTE pdrv, BYTE *buff, DWORD sector, UINT count)
    
33. {
    
34. if (!count)
    
35. return RES_PARERR;
    
36. 
    
37. for(;count>0;count--)
    
38. {
    
39. W25QXX_Read(buff,sector*FLASH_SECTOR_SIZE, FLASH_SECTOR_SIZE);
    
40. sector++;
    
41. buff+=FLASH_SECTOR_SIZE;
    
42. }
    
43. 
    
44. return RES_OK;
    
45. }
    
46. 
    
47. 
    
48. #if _USE_WRITE == 1
    
49. DRESULT Flash_write (BYTE pdrv, const BYTE *buff, DWORD sector, UINT count)
    
50. {
    
51. if (!count)
    
52. {
    
53. return RES_PARERR;
    
54. }
    
55. 
    
56. for(;count>0;count--)
    
57. {
    
58. W25QXX_Erase_Sector(sector);
    
59. W25QXX_Write_NoCheck((uint8_t*)buff,sector*FLASH_SECTOR_SIZE,FLASH_SECTOR_SIZE);
    
60. sector++;
    
61. buff+=FLASH_SECTOR_SIZE;
    
62. }
    
63. 
    
64. return RES_OK;
    
65. }
    
66. #endif /* _USE_WRITE == 1 */
    
67. 
    
68. 
    
69. #if _USE_IOCTL == 1
    
70. DRESULT Flash_ioctl (BYTE pdrv, BYTE cmd, void *buff)
    
71. {
    
72. DRESULT res;
    
73. switch(cmd)
    
74. {
    
75. case CTRL_SYNC:
    
76. res = RES_OK;
    
77. break;
    
78. case GET_SECTOR_SIZE:
    
79. *(WORD*)buff = FLASH_SECTOR_SIZE;
    
80. res = RES_OK;
    
81. break;
    
82. case GET_BLOCK_SIZE:
    
83. *(WORD*)buff = FLASH_BLOCK_SIZE;
    
84. res = RES_OK;
    
85. break;
    
86. case GET_SECTOR_COUNT:
    
87. *(DWORD*)buff = FLASH_SECTOR_COUNT;
    
88. res = RES_OK;
    
89. break;
    
90. default:
    
91. res = RES_PARERR;
    
92. break;
    
93. }
    
94. return res;
    
95. }
    

复制代码

外设初始化：

1. void MX_TIM2_Init(void)
   
2. {
   
3. TIM_ClockConfigTypeDef sClockSourceConfig = {0};
   
4. TIM_MasterConfigTypeDef sMasterConfig = {0};
   
5. TIM_OC_InitTypeDef sConfigOC = {0};
   
6. 
   
7. htim2.Instance = TIM2;
   
8. htim2.Init.Prescaler = 7199;
   
9. htim2.Init.CounterMode = TIM_COUNTERMODE_UP; //向上计数
   
10. htim2.Init.Period = 5;
    
11. htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    
12. htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE; //自动重载
    
13. if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
    
14. {
    
15. Error_Handler();
    
16. }
    
17. sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
    
18. if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
    
19. {
    
20. Error_Handler();
    
21. }
    
22. sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
    
23. sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
    
24. if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
    
25. {
    
26. Error_Handler();
    
27. }
    
28. 
    
29. sConfigOC.OCMode = TIM_OCMODE_TIMING;
    
30. sConfigOC.Pulse = 5;
    
31. sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
    
32. sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
    
33. if (HAL_TIM_OC_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
    
34. {
    
35. Error_Handler();
    
36. }
    
37. }
    
38. 
    
39. void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle)
    
40. {
    
41. 
    
42. if(tim_baseHandle->Instance==TIM2)
    
43. {
    
44. /* TIM2 clock enable */
    
45. __HAL_RCC_TIM2_CLK_ENABLE();
    
46. 
    
47. /* TIM2 DMA Init */
    
48. /* TIM2_UP Init */
    
49. hdma_tim2_up.Instance = DMA1_Channel2;
    
50. hdma_tim2_up.Init.Direction = DMA_MEMORY_TO_PERIPH;
    
51. hdma_tim2_up.Init.PeriphInc = DMA_PINC_DISABLE;
    
52. hdma_tim2_up.Init.MemInc = DMA_MINC_ENABLE;
    
53. hdma_tim2_up.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; //WORD
    
54. hdma_tim2_up.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
    
55. hdma_tim2_up.Init.Mode = DMA_CIRCULAR;
    
56. hdma_tim2_up.Init.Priority = DMA_PRIORITY_LOW;
    
57. if (HAL_DMA_Init(&hdma_tim2_up) != HAL_OK)
    
58. {
    
59. Error_Handler();
    
60. }
    
61. 
    
62. __HAL_LINKDMA(tim_baseHandle,hdma[TIM_DMA_ID_UPDATE],hdma_tim2_up);
    
63. 
    
64. /* TIM2_CH1 Init */
    
65. hdma_tim2_ch1.Instance = DMA1_Channel5;
    
66. hdma_tim2_ch1.Init.Direction = DMA_MEMORY_TO_PERIPH;
    
67. hdma_tim2_ch1.Init.PeriphInc = DMA_PINC_DISABLE;
    
68. hdma_tim2_ch1.Init.MemInc = DMA_MINC_ENABLE;
    
69. hdma_tim2_ch1.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
    
70. hdma_tim2_ch1.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
    
71. hdma_tim2_ch1.Init.Mode = DMA_CIRCULAR;
    
72. hdma_tim2_ch1.Init.Priority = DMA_PRIORITY_LOW;
    
73. if (HAL_DMA_Init(&hdma_tim2_ch1) != HAL_OK)
    
74. {
    
75. Error_Handler();
    
76. }
    
77. 
    
78. __HAL_LINKDMA(tim_baseHandle,hdma[TIM_DMA_ID_CC1],hdma_tim2_ch1);
    
79. }
    
80. }
    
81. 
    
82. 
    
83. void MX_DMA_Init(void)
    
84. {
    
85. /* DMA controller clock enable */
    
86. __HAL_RCC_DMA1_CLK_ENABLE();
    
87. }
    
88. 
    
89. void W25QXX_Init(void)
    
90. {
    
91. //        uint8_t temp = 0;
    
92. GPIO_InitTypeDef GPIO_InitStruct = {0};
    
93. __HAL_RCC_GPIOB_CLK_ENABLE();
    
94. 
    
95. /**SPI2 GPIO Configuration
    
96. PB12 ------> SPI2_CS
    
97. PB13 ------> SPI2_SCK
    
98. PB14 ------> SPI2_MISO
    
99. PB15 ------> SPI2_MOSI
    
100. */
     
101. 
     
102. //PB12
     
103. HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, GPIO_PIN_SET);
     
104. GPIO_InitStruct.Pin=GPIO_PIN_12; //PB12
     
105. GPIO_InitStruct.Mode=GPIO_MODE_OUTPUT_PP; //推挽输出
     
106. GPIO_InitStruct.Pull=GPIO_PULLUP; //上拉
     
107. GPIO_InitStruct.Speed=GPIO_SPEED_FREQ_HIGH;//高速
     
108. HAL_GPIO_Init(GPIOB,&GPIO_InitStruct); //初始化
     
109. 
     
110. 
     
111. hspi2.Instance = SPI2;
     
112. hspi2.Init.Mode = SPI_MODE_MASTER; //设置SPI工作模式:设置为主SPI
     
113. 
     
114. hspi2.Init.Direction = SPI_DIRECTION_2LINES;
     
115. hspi2.Init.DataSize = SPI_DATASIZE_8BIT; //设置SPI的数据大小:SPI发送接收8位帧结构
     
116. hspi2.Init.CLKPolarity = SPI_POLARITY_HIGH; //选择了串行时钟的稳态:时钟悬空高
     
117. hspi2.Init.CLKPhase = SPI_PHASE_2EDGE; //数据捕获(采样)于第二个时钟沿
     
118. hspi2.Init.NSS = SPI_NSS_SOFT;
     
119. hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
     
120. 
     
121. hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB;
     
122. hspi2.Init.TIMode = SPI_TIMODE_DISABLE;
     
123. hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
     
124. hspi2.Init.CRCPolynomial = 10; //CRC值计算的多项式
     
125. if (HAL_SPI_Init(&hspi2) != HAL_OK)
     
126. {
     
127. Error_Handler();
     
128. }
     
129. 
     
130. __HAL_SPI_ENABLE(&hspi2); //使能SPI2
     
131. SPI2_ReadWriteByte(0Xff); //启动传输
     
132. 
     
133. }

复制代码

是不是MX_FATFS_Init处理完毕跑到异常处理中断里面去了 ，显示异常是什么异常，是只显示一段了 还是全部黑了，还是全部显示一样的，还是全部不一样乱码了，建议开启串口在异常中断中打印消息

楼主可能是溢出了。Flash_Driver定义的内容是否都是有效的？

你若安好_清风徐来 发表于 2020-3-10 09:52
是不是MX_FATFS_Init处理完毕跑到异常处理中断里面去了 ，显示异常是什么异常，是只显示一段了 还是全部黑 ...

程序正常运行，没有进入异常中断，加过串口，通信也都是正常，所谓显示异常是指不按设定的值显示，我设定显示1234，在运行MX_FATFS_Init之前都是正常显示1234，运行MX_FATFS_Init之后就变成了1288

安 发表于 2020-3-10 15:19
楼主可能是溢出了。Flash_Driver定义的内容是否都是有效的？

程序没有进入HardFault，应该不是溢出，我堆和栈都设的挺大的0x2000；Flash这块能够正常模拟u盘的并且读写也都每天，Flash_Driver定义的内容应该不会有问题吧

百度跳到这里了，跟楼主遇到同样的问题，多次插拔SD卡，当执行disk.drv[disk.nbr] = drv语句之后disk.nbr变大了，导致挂载SD卡失败，正在排查为啥disk.nbr会变大，不知道哪里的内存溢出，如果楼主还经常逛这里的话可以回答一下吗:)

冬子 发表于 2024-11-25 13:53
百度跳到这里了，跟楼主遇到同样的问题，多次插拔SD卡，当执行disk.drv[disk.nbr] = drv语句之后disk.n ...

[md]问题已找到，是偶尔在特殊情况下没有调用FATFS_UnLinkDriverEx函数，导致disk.nbr一直等于1的情况下，再次调用FATFS_LinkDriverEx函数，从而导致disk.drv[disk.nbr] = drv时，相当于disk.drv[1]= drv，内存溢出；这是因为_VOLUMES定义为1，disk.drv[1]是不存在的数组变量