devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

STM32CUBEMX FATFS FREERTOS 读写U盘和SPI-Flash注意事项

作者：Gausst松鼠会 | 2024-04-21 16:38:51

赞

踩

STM32CUBEMX FATFS FREERTOS 读写U盘和SPI-Flash注意事项

任务目标：

        开发环境为STM32F407VET6 和STM32F105RCT6两个DEMO board，USB Host 在U盘实现FATFS，  SPI Flash上FATFS，当插入U盘后，将SPI Flash 上的文件拷贝至U盘。

        这个要求不为过吧，翻烂了CSDN，都找不到一篇详细的教程，大家都是重复的说来说去，却在关键的点上，都闭口不言。让我想起我读高中时期，有一个数学老师，一旦遇到简单的问题就说的特别详细，一旦有难度，就说交给大家了，让大家自行想办法解决问题。

        经过一段时间的尝试，请大家跟着我的脚步一起完成它。如果你还有问题，你可以在我的CSDN上留言，我会及时的回复，我上CSDN的频率一天为2-4次。

详细步骤：

1.STM32CUBEMX 新建工程：

1.1.仿真口，时钟，FreeRTOS的timeBase

        大家都会,不废话，要的是干货。

1.2.SPI接口，WQ25的驱动程序

        大家都会,不废话，要的是干货。

1.3.USB OTG接口

        USB-OTG-FS  选择host only，FS是full speed 的意思，HS需要额外的时钟电路，我没有尝试过。

        注意选择步骤3，如果这个值默认是128 ，被卡在这儿的概率就很高了，建议用512个words,即2K字节。

1.4.FATFS配置，这个非常关键，ST不建议在SPI Flash上使用Fatfs，原因是没有擦写均衡，如果非常频繁的读写，建议用littleFs替代，LittleFs移植较容易。

        步骤1和2没问题。

        步骤3大家也都没有问题。

        步骤4：千万注意，volumes必须选择2个以上，要实现2个文件系统在两个外设上。MAX Sector Size 和Min Sector Size 分别是4096和512。Flash是4096 ，U盘和Sd卡是512 。

        步骤5：本文最大的干货，必须关闭重入功能，否则，你会卡死在一个信号量的释放上，ST的FAE也不打算解决这个问题。在操作系统的环境下，如果MAX_Secotor Size !=MIN Sector Size，就会卡在一个信号量的释放上。

       SPI Flash的MAX sector size 和MIN sector size必须配置为4096才能正常使用f_mout f_open函数，而U盘却的MAX sector size 和MIN sector size必须配置为512才能正常使用f_mout f_open函数。

        ST的Fae说未来逐渐摆脱FreeRTOS，会切换到Thread-X。

1.5操作系统配置和堆栈设置

堆栈调大一点

 1.6总结

        以上步骤可以确保你一路顺利了，接下来，我会附上我的部分代码。

2.关键程序片段

2.1 f_open函数的说明，它太关键了。

        很多人抄来抄去，从来没有人说明这个函数的具体内容。

  1. FRESULT f_open (
  2.   FIL* fp,           /* [OUT] Pointer to the file object structure */
  3.   const TCHAR* path, /* [IN] File name */
  4.   BYTE mode          /* [IN] Mode flags */
  5. );

        第一个和第3个参数大家都很清楚，第二个参数很少有人详细的说清楚，都是抄来抄去的重复内容。

STM32CubeMX学习笔记（25）——FatFs文件系统使用（操作SPI Flash）_fa_open_always_Leung_ManWah的博客-CSDN博客

这篇文章，很多人都在看，但是呢，对特别关键的f_open函数并没有说的很清楚，一旦遇到我们有2个逻辑驱动区的时候，就傻眼了，你发现永远也写不到第二个里面。

上图的表里说的很清楚，必须指定逻辑分区。所以正确的f_open 函数应该这样写：

f_open (&fs,"0:/test.txt",FA_READ);

0:/是非常关键的信息，它指的是逻辑分区，当只有一个逻辑分区的时候，是可以省略，但是当有2个以上的时候，就绝对不能省略。

2.2cubemx生成的函数MX_FATFS_Init

  1. void MX_FATFS_Init(void)
  2. {
  3.   /*## FatFS: Link the USBH driver ###########################*/
  4.   retUSBH = FATFS_LinkDriver(&USBH_Driver, USBHPath);
  5.   /*## FatFS: Link the USER driver ###########################*/
  6.   retUSER = FATFS_LinkDriver(&USER_Driver, USERPath);
  7.  
  8.   /* USER CODE BEGIN Init */
  9.   /* additional user code for init */
  10.   /* USER CODE END Init */
  11. }
  12.

这两句话意义上挂载两个逻辑分区，逻辑分区分别是0:/和1:/

先执行的就是逻辑分区0 ，后执行的就是逻辑分区1 。

所以要想写逻辑分区0的文件，必须用f_open(&fs,0:/test.txt,FA_WRITE);

所以要想写逻辑分区1的文件，必须用f_open(&fs,1:/test.txt,FA_WRITE);

2.3.fatfs.c文件

  1. /* USER CODE BEGIN Header */
  2. /**
  3.  ******************************************************************************
  4.  * @file   fatfs.c
  5.  * @brief  Code for fatfs applications
  6.  ******************************************************************************
  7.  * @attention
  8.  *
  9.  * Copyright (c) 2023 STMicroelectronics.
  10.  * All rights reserved.
  11.  *
  12.  * This software is licensed under terms that can be found in the LICENSE file
  13.  * in the root directory of this software component.
  14.  * If no LICENSE file comes with this software, it is provided AS-IS.
  15.  *
  16.  ******************************************************************************
  17.  */
  18. /* USER CODE END Header */
  19. #include "fatfs.h"
  20.  
  21. uint8_t retUSBH;    /* Return value for USBH */
  22. char USBHPath[4];   /* USBH logical drive path */
  23. FATFS USBHFatFS;    /* File system object for USBH logical drive */
  24. FIL USBHFile;       /* File object for USBH */
  25. uint8_t retUSER;    /* Return value for USER */
  26. char USERPath[4];   /* USER logical drive path */
  27. FATFS USERFatFS;    /* File system object for USER logical drive */
  28. FIL USERFile;       /* File object for USER */
  29.  
  30. /* USER CODE BEGIN Variables */
  31. #include "userDebugCom.h"
  32. extern osMutexId falshMutexHandle;
  33. extern struct systemTime_t sysTime;
  34. static UINT fnum;
  35. static BYTE ReadBuffer[20] = {0};                          /* 读缓冲区 */
  36. static BYTE WriteBuffer_Title[] = "This Is File Test\r\n"; /* 写缓冲区*/
  37. static uint8_t flashFlag = 0;
  38. static uint8_t fileSPIWriteFlag = 0;
  39. /* USER CODE END Variables */
  40.  
  41. void MX_FATFS_Init(void)
  42. {
  43.   /*## FatFS: Link the USBH driver ###########################*/
  44.   retUSBH = FATFS_LinkDriver(&USBH_Driver, USBHPath);    
  45.   /*## FatFS: Link the USER driver ###########################*/
  46.   retUSER = FATFS_LinkDriver(&USER_Driver, USERPath);   
  47.  
  48.   /* USER CODE BEGIN Init */
  49.   /* additional user code for init */
  50.   /* USER CODE END Init */
  51. }
  52.  
  53. /**
  54.   * @brief  Gets Time from RTC
  55.   * @param  None
  56.   * @retval Time in DWORD
  57.   */
  58. DWORD get_fattime(void)
  59. {
  60.   /* USER CODE BEGIN get_fattime */
  61. #if 1
  62.   return ((sysTime.year - 1980) << 25) /* Year = 2010 */
  63.          | (sysTime.month << 21)       /* Month = 11 */
  64.          | (sysTime.day << 16)         /* Day = 2 */
  65.          | (sysTime.hour << 11)        /* Hour = 15 */
  66.          | (sysTime.minute << 5)       /* Min = 0 */
  67.          | (sysTime.second >> 1)       /* Sec = 0 */
  68.       ;
  69. #endif
  70.    return 0;
  71.   /* USER CODE END get_fattime */
  72. }
  73.  
  74. /* USER CODE BEGIN Application */
  75. /**
  76.  * @brief 测试fatfs在SPIFlash是否正常工作
  77.  *
  78.  */
  79. void InitFatFs_SPI_FLASH(void)
  80. {
  81.   
  82.   osMutexWait(falshMutexHandle,osWaitForever);    
  83.   retUSER = f_mount(&USERFatFS, USERPath, 1);
  84.   if (retUSER != FR_OK)
  85.   {
  86.     Debug_Printf("SPI Flash is not formatted\r\n");
  87.     retUSER = f_mkfs(USERPath, 1, 4096); // flash 要格式化1次，不然文件系统记录的不正确
  88.     // 千万注意，f_mkfs函数耗时极长，可能到10分钟左右，和SD卡的容量相关?
  89.     if (retUSER == FR_OK)
  90.     {
  91.       Debug_Printf("The FLASH formats the file system successfully\r\n");
  92.       retUSER = f_mount(NULL, (TCHAR const *)USERPath, 1);
  93.       retUSER = f_mount(&USERFatFS, (TCHAR const *)USERPath, 1);
  94.     }
  95.     else
  96.     {
  97.       Debug_Printf("Formatting failure\r\n");
  98.     }
  99.   }
  100.   if (retUSER == FR_OK)
  101.   {
  102.     Debug_Printf("Fmout OK!\r\n");
  103.     uint32_t total;
  104.     uint32_t free;
  105.     if (exf_getfree((uint8_t *)USERPath, &total, &free) == FR_OK)
  106.     {
  107.       Debug_Printf("Total=%d KB,Free=%d KB\r\n", total, free);
  108.     }
  109.     else
  110.     {
  111.       Debug_Printf("Disk Space Error\r\n");
  112.     }
  113.     flashFlag = 1;
  114.   }
  115.   osMutexRelease(falshMutexHandle);  
  116. }
  117.  
  118. void spiFlashSoundPromt(void)
  119. {
  120.   if (memcmp(ReadBuffer, WriteBuffer_Title, sizeof(WriteBuffer_Title)) == 0)
  121.   {
  122.     for (int i = 0; i < 3; i++)
  123.     {
  124.       HAL_GPIO_WritePin(BEEP_GPIO_Port, BEEP_Pin, GPIO_PIN_SET);
  125.       osDelay(50);
  126.       HAL_GPIO_WritePin(BEEP_GPIO_Port, BEEP_Pin, GPIO_PIN_RESET);
  127.       osDelay(50);
  128.     }
  129.   }
  130. }
  131. /**
  132.  * @brief 读写测试文件系统
  133.  *
  134.  */
  135. void FileReadWriteTest(void)
  136. {
  137.   if (flashFlag > 0)
  138.   {
  139.     osMutexWait(falshMutexHandle,osWaitForever);    
  140.     Debug_Printf("File Write Test\n");
  141. #if 1
  142.     retUSER = f_open(&USERFile, "1:/test.txt", FA_OPEN_ALWAYS | FA_WRITE);
  143.     fileSPIWriteFlag = 1;
  144.     // f_res = f_lseek(&SDFile, f_size(&SDFile));
  145.     if (retUSER == FR_OK)
  146.     {
  147.       Debug_Printf("Write To file\n");
  148.       retUSER = f_write(&USERFile, WriteBuffer_Title, sizeof(WriteBuffer_Title), &fnum);
  149.       if (retUSER == FR_OK)
  150.       {
  151.         Debug_Printf("Write Len=%d\n", fnum);
  152.         Debug_Printf("Write Data:\n%s\n", WriteBuffer_Title);
  153.       }
  154.       else
  155.       {
  156.         Debug_Printf("Write Fail,Error Code(%d)\n", retUSER);
  157.       }
  158.       f_close(&USERFile);
  159.       fileSPIWriteFlag = 0;
  160.     }
  161.     else
  162.     {
  163.       Debug_Printf("打开/创建文件失败。\n");
  164.     }
  165.  
  166.     /*------------------- 文件系统测试：读测试 ------------------------------------*/
  167.     Debug_Printf("File Read Test\n");
  168.     // HAL_IWDG_Refresh(&hiwdg);
  169.     retUSER = f_open(&USERFile, "1:/test.txt", FA_OPEN_EXISTING | FA_READ);
  170.     fileSPIWriteFlag = 1;
  171.     // f_res = f_lseek(&SDFile, 2);
  172.     if (retUSER == FR_OK)
  173.     {
  174.       Debug_Printf("File Opend\r\n");
  175.  
  176.       retUSER = f_read(&USERFile, ReadBuffer, sizeof(ReadBuffer), &fnum);
  177.       if (retUSER == FR_OK)
  178.       {
  179.         Debug_Printf("Read Len=%d\n", fnum);
  180.         Debug_Printf("Read Data:\n%s \n", ReadBuffer);
  181.       }
  182.       else
  183.       {
  184.         Debug_Printf("Read Fail,Error Code(%d)\n", retUSER);
  185.       }
  186.     }
  187.     else
  188.     {
  189.       Debug_Printf("File Open Failed\n");
  190.     }
  191.     f_close(&USERFile);
  192.     fileSPIWriteFlag = 0;
  193. #endif
  194.     osMutexRelease(falshMutexHandle);    
  195.   }
  196. }
  197. /**
  198.  * @brief 得到磁盘剩余容量
  199.  *
  200.  * @param drv 磁盘编号("0:"/"1:")
  201.  * @param total total capacity   (KB)
  202.  * @param free free capacity     （KB)
  203.  * @return uint8_t get status
  204.  */
  205. uint8_t exf_getfree(uint8_t *drv, uint32_t *total, uint32_t *free)
  206. {
  207.   FATFS *fs1;
  208.   uint8_t res;
  209.   DWORD fre_clust = 0;
  210.   uint32_t fre_sect = 0, tot_sect = 0;
  211.   // 得到磁盘信息及空闲簇数量
  212.   res = f_getfree((const TCHAR *)drv, &fre_clust, &fs1);
  213.   if (res == 0)
  214.   {
  215.     tot_sect = (fs1->n_fatent - 2) * fs1->csize; // 得到总扇区数
  216.     fre_sect = fre_clust * fs1->csize;           // 得到空闲扇区????
  217. #if _MAX_SS != 512                               // 扇区大小不是512字节,则转换为512字节
  218.     tot_sect *= fs1->ssize / 512;
  219.     fre_sect *= fs1->ssize / 512;
  220. #endif
  221.     *total = tot_sect >> 1; // 单位为KB
  222.     *free = fre_sect >> 1;  // 单位为KB
  223.   }
  224.   return res;
  225. }
  226.  
  227.  
  228. /* USER CODE END Application */

2.4 user_diskio.c

  1. /* USER CODE BEGIN Header */
  2. /**
  3.  ******************************************************************************
  4.   * @file    user_diskio.c
  5.   * @brief   This file includes a diskio driver skeleton to be completed by the user.
  6.   ******************************************************************************
  7.   * @attention
  8.   *
  9.   * Copyright (c) 2023 STMicroelectronics.
  10.   * All rights reserved.
  11.   *
  12.   * This software is licensed under terms that can be found in the LICENSE file
  13.   * in the root directory of this software component.
  14.   * If no LICENSE file comes with this software, it is provided AS-IS.
  15.   *
  16.   ******************************************************************************
  17.   */
  18.  /* USER CODE END Header */
  19.  
  20. #ifdef USE_OBSOLETE_USER_CODE_SECTION_0
  21. /*
  22.  * Warning: the user section 0 is no more in use (starting from CubeMx version 4.16.0)
  23.  * To be suppressed in the future.
  24.  * Kept to ensure backward compatibility with previous CubeMx versions when
  25.  * migrating projects.
  26.  * User code previously added there should be copied in the new user sections before
  27.  * the section contents can be deleted.
  28.  */
  29. /* USER CODE BEGIN 0 */
  30. /* USER CODE END 0 */
  31. #endif
  32.  
  33. /* USER CODE BEGIN DECL */
  34.  
  35. /* Includes ------------------------------------------------------------------*/
  36. #include <string.h>
  37. #include "ff_gen_drv.h"
  38. #include "w25qxx.h"
  39. /* Private typedef -----------------------------------------------------------*/
  40. /* Private define ------------------------------------------------------------*/
  41.  
  42. /* Private variables ---------------------------------------------------------*/
  43. /* Disk status */
  44. static volatile DSTATUS Stat = STA_NOINIT;
  45.  
  46. /* USER CODE END DECL */
  47.  
  48. /* Private function prototypes -----------------------------------------------*/
  49. DSTATUS USER_initialize (BYTE pdrv);
  50. DSTATUS USER_status (BYTE pdrv);
  51. DRESULT USER_read (BYTE pdrv, BYTE *buff, DWORD sector, UINT count);
  52. #if _USE_WRITE == 1
  53.   DRESULT USER_write (BYTE pdrv, const BYTE *buff, DWORD sector, UINT count);
  54. #endif /* _USE_WRITE == 1 */
  55. #if _USE_IOCTL == 1
  56.   DRESULT USER_ioctl (BYTE pdrv, BYTE cmd, void *buff);
  57. #endif /* _USE_IOCTL == 1 */
  58.  
  59. Diskio_drvTypeDef  USER_Driver =
  60. {
  61.   USER_initialize,
  62.   USER_status,
  63.   USER_read,
  64. #if  _USE_WRITE
  65.   USER_write,
  66. #endif  /* _USE_WRITE == 1 */
  67. #if  _USE_IOCTL == 1
  68.   USER_ioctl,
  69. #endif /* _USE_IOCTL == 1 */
  70. };
  71.  
  72. /* Private functions ---------------------------------------------------------*/
  73.  
  74. /**
  75.   * @brief  Initializes a Drive
  76.   * @param  pdrv: Physical drive number (0..)
  77.   * @retval DSTATUS: Operation status
  78.   */
  79. DSTATUS USER_initialize (
  80. 	BYTE pdrv           /* Physical drive nmuber to identify the drive */
  81. )
  82. {
  83.   /* USER CODE BEGIN INIT */
  84.     Stat = STA_NOINIT;
  85.     if(W25QXX_Init() == 0)
  86.     {
  87.       Stat &= ~STA_NOINIT;
  88.     }           
  89.     return Stat;
  90.   /* USER CODE END INIT */
  91. }
  92.  
  93. /**
  94.   * @brief  Gets Disk Status
  95.   * @param  pdrv: Physical drive number (0..)
  96.   * @retval DSTATUS: Operation status
  97.   */
  98. DSTATUS USER_status (
  99. 	BYTE pdrv       /* Physical drive number to identify the drive */
  100. )
  101. {
  102.   /* USER CODE BEGIN STATUS */
  103.     Stat = STA_NOINIT;
  104.     if(W25QXX_Get_State() == W25Q_OK)
  105.     {
  106.       Stat &= ~STA_NOINIT;
  107.     }	            
  108.     return Stat;
  109.   /* USER CODE END STATUS */
  110. }
  111.  
  112. /**
  113.   * @brief  Reads Sector(s)
  114.   * @param  pdrv: Physical drive number (0..)
  115.   * @param  *buff: Data buffer to store read data
  116.   * @param  sector: Sector address (LBA)
  117.   * @param  count: Number of sectors to read (1..128)
  118.   * @retval DRESULT: Operation result
  119.   */
  120. DRESULT USER_read (
  121. 	BYTE pdrv,      /* Physical drive nmuber to identify the drive */
  122. 	BYTE *buff,     /* Data buffer to store read data */
  123. 	DWORD sector,   /* Sector address in LBA */
  124. 	UINT count      /* Number of sectors to read */
  125. )
  126. {
  127.   /* USER CODE BEGIN READ */
  128.     sector+=1;      
  129.     W25QXX_Read(buff, sector <<12, count<<12);      
  130.     return RES_OK;
  131.   /* USER CODE END READ */
  132. }
  133.  
  134. /**
  135.   * @brief  Writes Sector(s)
  136.   * @param  pdrv: Physical drive number (0..)
  137.   * @param  *buff: Data to be written
  138.   * @param  sector: Sector address (LBA)
  139.   * @param  count: Number of sectors to write (1..128)
  140.   * @retval DRESULT: Operation result
  141.   */
  142. #if _USE_WRITE == 1
  143. DRESULT USER_write (
  144. 	BYTE pdrv,          /* Physical drive nmuber to identify the drive */
  145. 	const BYTE *buff,   /* Data to be written */
  146. 	DWORD sector,       /* Sector address in LBA */
  147. 	UINT count          /* Number of sectors to write */
  148. )
  149. {
  150.   /* USER CODE BEGIN WRITE */
  151.   /* USER CODE HERE */
  152.     sector+=1;      
  153.     W25QXX_Write((void *)(buff),sector<<12,count<<12 );        
  154.     return RES_OK;
  155.   /* USER CODE END WRITE */
  156. }
  157. #endif /* _USE_WRITE == 1 */
  158.  
  159. /**
  160.   * @brief  I/O control operation
  161.   * @param  pdrv: Physical drive number (0..)
  162.   * @param  cmd: Control code
  163.   * @param  *buff: Buffer to send/receive control data
  164.   * @retval DRESULT: Operation result
  165.   */
  166. #if _USE_IOCTL == 1
  167. DRESULT USER_ioctl (
  168. 	BYTE pdrv,      /* Physical drive nmuber (0..) */
  169. 	BYTE cmd,       /* Control code */
  170. 	void *buff      /* Buffer to send/receive control data */
  171. )
  172. {
  173.   /* USER CODE BEGIN IOCTL */
  174.     DRESULT res = RES_OK;
  175.     switch(cmd){
  176.         case GET_SECTOR_COUNT:
  177.             *(DWORD *)buff = 4095;
  178.         break;
  179.         case GET_SECTOR_SIZE:
  180.             *(DWORD *)buff = 4096;
  181.         break;
  182.         case GET_BLOCK_SIZE:
  183.             *(DWORD *)buff = 1;
  184.         break;       
  185.     } 
  186.     return res;
  187.   /* USER CODE END IOCTL */
  188. }
  189. #endif /* _USE_IOCTL == 1 */
  190.

2.4 usb_host.c

  1. /* USER CODE BEGIN Header */
  2. /**
  3.   ******************************************************************************
  4.   * @file            : usb_host.c
  5.   * @version         : v2.0_Cube
  6.   * @brief           : This file implements the USB Host
  7.   ******************************************************************************
  8.   * @attention
  9.   *
  10.   * Copyright (c) 2023 STMicroelectronics.
  11.   * All rights reserved.
  12.   *
  13.   * This software is licensed under terms that can be found in the LICENSE file
  14.   * in the root directory of this software component.
  15.   * If no LICENSE file comes with this software, it is provided AS-IS.
  16.   *
  17.   ******************************************************************************
  18.   */
  19. /* USER CODE END Header */
  20.  
  21. /* Includes ------------------------------------------------------------------*/
  22.  
  23. #include "usb_host.h"
  24. #include "usbh_core.h"
  25. #include "usbh_msc.h"
  26.  
  27. /* USER CODE BEGIN Includes */
  28. #include "usart.h"
  29. #include "usb_host.h"
  30. #include "fatfs.h"
  31. #include "userDebugCom.h"
  32. /* USER CODE END Includes */
  33.  
  34. /* USER CODE BEGIN PV */
  35. /* Private variables ---------------------------------------------------------*/
  36. static uint8_t status = 0;
  37. static char FileWriteBuff[] = "Hello,This is U-Disk\r\n";
  38. static char FileReadBuff[23] = "";
  39. static UINT bw;
  40. static uint8_t fileWriteFlag = 0;
  41. /* USER CODE END PV */
  42.  
  43. /* USER CODE BEGIN PFP */
  44. /* Private function prototypes -----------------------------------------------*/
  45.  
  46. /* USER CODE END PFP */
  47.  
  48. /* USB Host core handle declaration */
  49. USBH_HandleTypeDef hUsbHostFS;
  50. ApplicationTypeDef Appli_state = APPLICATION_IDLE;
  51.  
  52. /*
  53.  * -- Insert your variables declaration here --
  54.  */
  55. /* USER CODE BEGIN 0 */
  56.  
  57. /* USER CODE END 0 */
  58.  
  59. /*
  60.  * user callback declaration
  61.  */
  62. static void USBH_UserProcess(USBH_HandleTypeDef *phost, uint8_t id);
  63.  
  64. /*
  65.  * -- Insert your external function declaration here --
  66.  */
  67. /* USER CODE BEGIN 1 */
  68. /**
  69.  * @brief USB 文件测试
  70.  *
  71.  */
  72. void UdiskBeginTest(void)
  73. {
  74.   if (Appli_state == APPLICATION_READY) // U盘已经加轿
  75.   {
  76.     if (status == 0)
  77.     {
  78.       status = 1;
  79.       fileWriteFlag = 0;
  80.       memset(FileReadBuff, 0x00, sizeof(FileReadBuff));
  81.       retUSBH = f_mount(NULL, (TCHAR const *)USBHPath, 1);
  82.       retUSBH = f_mount(&USBHFatFS, (TCHAR const *)USBHPath, 1);     
  83.       if (retUSBH == FR_OK)
  84.       {
  85.         osDelay(100);   
  86.         f_close(&USBHFile);
  87.         if (retUSBH == FR_OK)
  88.         {
  89.           Debug_Printf("Closed OK\r\n");
  90.         }
  91.         Debug_Printf("Udisk fmount OK\r\n");
  92. #if 1          
  93.         uint32_t total;
  94.         uint32_t free;
  95.         if (exf_getfree((uint8_t *)USBHPath, &total, &free) == FR_OK)
  96.         {
  97.           Debug_Printf("Total=%d MB,Free=%d MB\r\n", total / 1024, free / 1024);
  98.         }
  99.         else
  100.         {
  101.           Debug_Printf("Udisk fmount error\r\n");
  102.         }
  103. #endif 
  104.         //USBHFile.fs=&USBHFatFS;
  105.           retUSBH = f_open(&USBHFile, (const char *)"0:/testUdisk.txt", FA_OPEN_ALWAYS | FA_WRITE);
  106.         if (retUSBH == FR_OK)
  107.         {
  108.           Debug_Printf("Opened OK\r\n");
  109.           retUSBH = f_write(&USBHFile, FileWriteBuff, sizeof(FileWriteBuff), &bw);
  110.           if (retUSBH == FR_OK)
  111.           {
  112.             Debug_Printf("Writed Udisk Test File OK\r\n");
  113.             retUSBH = f_close(&USBHFile);
  114.           }
  115.         }
  116.         retUSBH = f_open(&USBHFile, "0:/testUdisk.txt", FA_OPEN_EXISTING | FA_READ);
  117.         // f_res = f_lseek(&SDFile, 2);
  118.         if (retUSBH == FR_OK)
  119.         {
  120.           Debug_Printf("Udisk File Opend\r\n");
  121.  
  122.           retUSBH = f_read(&USBHFile, FileReadBuff, sizeof(FileReadBuff), &bw);
  123.           if (retUSBH == FR_OK)
  124.           {
  125.             Debug_Printf("Udisk Read Len=%d\n", bw);
  126.             Debug_Printf("Udisk Read Data:\n%s \n", FileReadBuff);
  127.           }
  128.           else
  129.           {
  130.             Debug_Printf("Udisk Read Fail,Error Code(%d)\n", retUSER);
  131.           }
  132.         }
  133.         else
  134.         {
  135.           Debug_Printf("Udisk File Open Failed\n");
  136.         }
  137.         f_close(&USBHFile);
  138.       }
  139.       udiskSoundPromt();
  140.     }
  141.   }
  142. }
  143. /**
  144.  * @brief 测试U盘提示音
  145.  *
  146.  */
  147. void udiskSoundPromt(void)
  148. {
  149.   if (memcmp(FileReadBuff, FileWriteBuff, sizeof(FileWriteBuff)) == 0)
  150.   {
  151.     for (int i = 0; i < 2; i++)
  152.     {
  153.       HAL_GPIO_WritePin(BEEP_GPIO_Port, BEEP_Pin, GPIO_PIN_SET);
  154.       osDelay(50);
  155.       HAL_GPIO_WritePin(BEEP_GPIO_Port, BEEP_Pin, GPIO_PIN_RESET);
  156.       osDelay(50);
  157.     }
  158.     fileWriteFlag = 1;
  159.     //sendQueenToCopyFiles();
  160.   }
  161. }
  162.  
  163. /* USER CODE END 1 */
  164.  
  165. /**
  166.   * Init USB host library, add supported class and start the library
  167.   * @retval None
  168.   */
  169. void MX_USB_HOST_Init(void)
  170. {
  171.   /* USER CODE BEGIN USB_HOST_Init_PreTreatment */
  172.  
  173.   /* USER CODE END USB_HOST_Init_PreTreatment */
  174.  
  175.   /* Init host Library, add supported class and start the library. */
  176.   if (USBH_Init(&hUsbHostFS, USBH_UserProcess, HOST_FS) != USBH_OK)
  177.   {
  178.     Error_Handler();
  179.   }
  180.   if (USBH_RegisterClass(&hUsbHostFS, USBH_MSC_CLASS) != USBH_OK)
  181.   {
  182.     Error_Handler();
  183.   }
  184.   if (USBH_Start(&hUsbHostFS) != USBH_OK)
  185.   {
  186.     Error_Handler();
  187.   }
  188.   /* USER CODE BEGIN USB_HOST_Init_PostTreatment */
  189.  
  190.   /* USER CODE END USB_HOST_Init_PostTreatment */
  191. }
  192.  
  193. /*
  194.  * user callback definition
  195.  */
  196. static void USBH_UserProcess  (USBH_HandleTypeDef *phost, uint8_t id)
  197. {
  198.   /* USER CODE BEGIN CALL_BACK_1 */
  199.   switch(id)
  200.   {
  201.   case HOST_USER_SELECT_CONFIGURATION:
  202.   break;
  203.  
  204.   case HOST_USER_DISCONNECTION:
  205.   Appli_state = APPLICATION_DISCONNECT;
  206.   status=0;
  207.   break;
  208.  
  209.   case HOST_USER_CLASS_ACTIVE:
  210.   Appli_state = APPLICATION_READY;
  211.   break;
  212.  
  213.   case HOST_USER_CONNECTION:
  214.   Appli_state = APPLICATION_START;
  215.   break;
  216.  
  217.   default:
  218.   break;
  219.   }
  220.   /* USER CODE END CALL_BACK_1 */
  221. }
  222.  
  223. /**
  224.   * @}
  225.   */
  227. /**
  228.   * @}
  229.   */

2.5 freeRTOS.c

  1. /* USER CODE BEGIN Header */
  2. /**
  3.   ******************************************************************************
  4.   * File Name          : freertos.c
  5.   * Description        : Code for freertos applications
  6.   ******************************************************************************
  7.   * @attention
  8.   *
  9.   * Copyright (c) 2023 STMicroelectronics.
  10.   * All rights reserved.
  11.   *
  12.   * This software is licensed under terms that can be found in the LICENSE file
  13.   * in the root directory of this software component.
  14.   * If no LICENSE file comes with this software, it is provided AS-IS.
  15.   *
  16.   ******************************************************************************
  17.   */
  18. /* USER CODE END Header */
  19.  
  20. /* Includes ------------------------------------------------------------------*/
  21. #include "FreeRTOS.h"
  22. #include "task.h"
  23. #include "main.h"
  24. #include "cmsis_os.h"
  25.  
  26. /* Private includes ----------------------------------------------------------*/
  27. /* USER CODE BEGIN Includes */
  28. #include "usb_host.h"
  29. #include "fatfs.h"
  30. #include "iwdg.h"
  31. /* USER CODE END Includes */
  32.  
  33. /* Private typedef -----------------------------------------------------------*/
  34. /* USER CODE BEGIN PTD */
  35.  
  36. /* USER CODE END PTD */
  37.  
  38. /* Private define ------------------------------------------------------------*/
  39. /* USER CODE BEGIN PD */
  40.  
  41. /* USER CODE END PD */
  42.  
  43. /* Private macro -------------------------------------------------------------*/
  44. /* USER CODE BEGIN PM */
  45.  
  46. /* USER CODE END PM */
  47.  
  48. /* Private variables ---------------------------------------------------------*/
  49. /* USER CODE BEGIN Variables */
  50. extern struct systemTime_t sysTime;
  51. /* USER CODE END Variables */
  52. osThreadId fileRecordHandle;
  53. osThreadId readRTCHandle;
  54. osThreadId lcdDisplayHandle;
  55. osThreadId keyTaskHandle;
  56. osTimerId softwareTimerHandle;
  57. osMutexId usart1PrintHandle;
  58. osMutexId SetingParameterHandle;
  59. osMutexId falshMutexHandle;
  60. osSemaphoreId TenSecTimeupHandle;
  61.  
  62. /* Private function prototypes -----------------------------------------------*/
  63. /* USER CODE BEGIN FunctionPrototypes */
  64.  
  65. /* USER CODE END FunctionPrototypes */
  66.  
  67. void StartFileRecordTask(void const * argument);
  68. extern void StartReadRTCTask(void const * argument);
  69. extern void StartTasklcdDisplay(void const * argument);
  70. extern void StartkeyTask(void const * argument);
  71. extern void Callback01(void const * argument);
  72.  
  73. extern void MX_USB_HOST_Init(void);
  74. void MX_FREERTOS_Init(void); /* (MISRA C 2004 rule 8.1) */
  75.  
  76. /**
  77.   * @brief  FreeRTOS initialization
  78.   * @param  None
  79.   * @retval None
  80.   */
  81. void MX_FREERTOS_Init(void) {
  82.   /* USER CODE BEGIN Init */
  83.  
  84.   /* USER CODE END Init */
  85.   /* Create the mutex(es) */
  86.   /* definition and creation of usart1Print */
  87.   osMutexDef(usart1Print);
  88.   usart1PrintHandle = osMutexCreate(osMutex(usart1Print));
  89.  
  90.   /* definition and creation of SetingParameter */
  91.   osMutexDef(SetingParameter);
  92.   SetingParameterHandle = osMutexCreate(osMutex(SetingParameter));
  93.  
  94.   /* definition and creation of falshMutex */
  95.   osMutexDef(falshMutex);
  96.   falshMutexHandle = osMutexCreate(osMutex(falshMutex));
  97.  
  98.   /* USER CODE BEGIN RTOS_MUTEX */
  99.   /* add mutexes, ... */
  100.   /* USER CODE END RTOS_MUTEX */
  101.  
  102.   /* Create the semaphores(s) */
  103.   /* definition and creation of TenSecTimeup */
  104.   osSemaphoreDef(TenSecTimeup);
  105.   TenSecTimeupHandle = osSemaphoreCreate(osSemaphore(TenSecTimeup), 1);
  106.  
  107.   /* USER CODE BEGIN RTOS_SEMAPHORES */
  108.   /* add semaphores, ... */
  109.   /* USER CODE END RTOS_SEMAPHORES */
  110.  
  111.   /* Create the timer(s) */
  112.   /* definition and creation of softwareTimer */
  113.   osTimerDef(softwareTimer, Callback01);
  114.   softwareTimerHandle = osTimerCreate(osTimer(softwareTimer), osTimerOnce, NULL);
  115.  
  116.   /* USER CODE BEGIN RTOS_TIMERS */
  117.   /* start timers, add new ones, ... */
  118.   /* USER CODE END RTOS_TIMERS */
  119.  
  120.   /* USER CODE BEGIN RTOS_QUEUES */
  121.   /* add queues, ... */
  122.   /* USER CODE END RTOS_QUEUES */
  123.  
  124.   /* Create the thread(s) */
  125.   /* definition and creation of fileRecord */
  126.   osThreadDef(fileRecord, StartFileRecordTask, osPriorityNormal, 0, 1536);
  127.   fileRecordHandle = osThreadCreate(osThread(fileRecord), NULL);
  128.  
  129.   /* definition and creation of readRTC */
  130.   osThreadDef(readRTC, StartReadRTCTask, osPriorityIdle, 0, 256);
  131.   readRTCHandle = osThreadCreate(osThread(readRTC), NULL);
  132.  
  133.   /* definition and creation of lcdDisplay */
  134.   osThreadDef(lcdDisplay, StartTasklcdDisplay, osPriorityLow, 0, 256);
  135.   lcdDisplayHandle = osThreadCreate(osThread(lcdDisplay), NULL);
  136.  
  137.   /* definition and creation of keyTask */
  138.   osThreadDef(keyTask, StartkeyTask, osPriorityLow, 0, 256);
  139.   keyTaskHandle = osThreadCreate(osThread(keyTask), NULL);
  140.  
  141.   /* USER CODE BEGIN RTOS_THREADS */
  142.   /* add threads, ... */
  143.   /* USER CODE END RTOS_THREADS */
  144.  
  145. }
  146.  
  147. /* USER CODE BEGIN Header_StartFileRecordTask */
  148. /**
  149.   * @brief  Function implementing the fileRecord thread.
  150.   * @param  argument: Not used
  151.   * @retval None
  152.   */
  153. /* USER CODE END Header_StartFileRecordTask */
  154. void StartFileRecordTask(void const * argument)
  155. {
  156.   /* init code for USB_HOST */
  157.  
  158.   /* USER CODE BEGIN StartFileRecordTask */
  159.   osDelay(100);
  160.   InitFatFs_SPI_FLASH();
  161.   osDelay(100);
  162.   FileReadWriteTest();    
  163.   spiFlashSoundPromt();       
  164.   osDelay(1000);  
  165.   MX_USB_HOST_Init();      
  166.   /* Infinite loop */
  167.   for(;;)
  168.   {
  169.     osDelay(10);
  170.     UdiskBeginTest();  
  171.     HAL_IWDG_Refresh(&hiwdg);      
  172.   }
  173.   /* USER CODE END StartFileRecordTask */
  174. }
  175.  
  176. /* Private application code --------------------------------------------------*/
  177. /* USER CODE BEGIN Application */
  178.  
  179. /* USER CODE END Application */

2.6 user_Debug.c

  1. #include "userDebugCom.h"
  2. #include <stdarg.h>
  3. #include "fatfs.h"
  4.  
  5. extern osMutexId usart1PrintHandle;
  6.  
  7. #ifdef __cplusplus
  8. extern "C"
  9. {
  10. #endif
  11.  
  12. #ifdef __GNUC__
  13. #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
  14. #else
  15. #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
  16. #endif
  17.     PUTCHAR_PROTOTYPE
  18.     {
  19.         HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xFFFF);
  20.         return ch;
  21.     }
  22. #ifdef __cplusplus
  23. }
  24. #endif
  25.  
  26. /**
  27.  * @brief 重写printf函数，加上互斥锁
  28.  *
  29.  * @param format
  30.  * @param ...
  31.  */
  32. void Debug_Printf(char *format, ...)
  33. {
  34.     char buf_str[128];
  35.     va_list v_args;
  36.  
  37.     va_start(v_args, format);
  38.     (void)vsnprintf((char *)&buf_str[0],
  39.                     (size_t)sizeof(buf_str),
  40.                     (char const *)format,
  41.                     v_args);
  42.     va_end(v_args);
  43.  
  44.     /* 互斥信号量 */
  45.     osMutexWait(usart1PrintHandle, osWaitForever);
  46.     printf("%s", buf_str);
  47.     osMutexRelease(usart1PrintHandle);
  48. }
  49. #define CPU_FREQUENCY_MHZ 72 // STM32时钟主频
  50. void delay_us(__IO uint32_t delay)
  51. {
  52.     int last, curr, val;
  53.     int temp;
  54.  
  55.     while (delay != 0)
  56.     {
  57.         temp = delay > 900 ? 900 : delay;
  58.         last = SysTick->VAL;
  59.         curr = last - CPU_FREQUENCY_MHZ * temp;
  60.         if (curr >= 0)
  61.         {
  62.             do
  63.             {
  64.                 val = SysTick->VAL;
  65.             } while ((val < last) && (val >= curr));
  66.         }
  67.         else
  68.         {
  69.             curr += CPU_FREQUENCY_MHZ * 1000;
  70.             do
  71.             {
  72.                 val = SysTick->VAL;
  73.             } while ((val <= last) || (val > curr));
  74.         }
  75.         delay -= temp;
  76.     }
  77. }
  78.

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/464026
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号