21ic电子技术开发论坛 › 单片机与嵌入式系统 › 合泰HT32 MCU › 【ESK32-30519 + ESK32-21001测评】03.I2C+EEPROM & SPI ...
返回列表 发新帖我要提问

[开发板与模块] 【ESK32-30519 + ESK32-21001测评】03.I2C+EEPROM & SPI+SPI FLASH

[复制链接]
 楼主| xld0932 发表于 2022-10-10 17:26 | 显示全部楼层 |阅读模式
<
HT32F54253, I2c, spi, EEPROM, SPI_FLASH
本帖最后由 xld0932 于 2022-10-10 17:30 编辑

HT32F54253 MCU带有3个硬件I2C接口和2个硬件SPI接口，具体的特性如下所示：

内部集成电路——I2C
▆ 支持高达 1 MHz 频率的主从模式
▆ 提供仲裁功能和时钟同步功能
▆ 支持 7-bit 和 10-bit 寻址模式和广播呼叫寻址
▆ 可屏蔽地址功能支持多种从机寻址模式
I2C 模块是一个允许与外部 I2C 接口通信的内部电路，此外部 I2C 接口是一个符合工业标准的用于连接外部硬件的两线串行接口。这两条串行线被称为串行数据线 SDA 和串行时钟线 SCL。 I2C
模块提供三种数据传输速率：即标准模式下的 100 kHz、快速模式下的 400 kHz 和高速模式下的1 MHz。 SCL 周期产生寄存器用于设置不同的占空比得到不同的 SCL 脉冲。
SDA 线是一条双向数据线，它连接整个 I2C 总线，在主机和从机之间用于数据的发送和接收。 I2C模块还具有仲裁检测功能和时钟同步，可防止多个主机试图同时传送数据到 I2C 总线的情况。

串行外设接口——SPI
▆ 支持主机和从机模式
▆ 主机模式频率高达 (fPCLK/2) MHz，从机模式频率高达 (fPCLK/3) MHz
▆ FIFO 深度： 8 级
▆ 多个主机和多个从机工作模式
串行外设接口 SPI 使用 SPI 协议可在主机和从机模式下进行数据发送和接收。 SPI 接口使用 4 个引脚，其中有串行数据输入和输出线， MISO 和 MOSI，时钟线 SCK 和从机选择线 SEL。 SPI 作为主机使用，用 SEL 和 SCK 信号控制数据流来说明数据通信启动和数据采样率。要接收数据字节，数据流在特定的时钟边沿时被锁存且存储在数据寄存器或 RX FIFO。数据发送也是通过类似的方式，但以相反的顺序。模式故障检测功能使其适用于多主机应用。


原理图
  • ESK32-30519
5.png
  • ESK32-21001
6.png


实现功能
通过硬件I2C读写扩展板板载的EEPROM芯片，写入随机数据后再进行回读，比较写入数据和读出数据是否相一致；通过硬件SPI操作扩展板板载的SPI FLASH芯片，移植SFUD软件包组件实现对SPI FLASH的读、写、擦除等操作。


实现代码
  • EEPROM
复制
  1. /* Define to prevent recursive inclusion -------------------------------------*/
    

  2. #define __EEPROM_C__
    


  3. 


  4. 

  5. /* Includes ------------------------------------------------------------------*/
    

  6. #include "EEPROM.h"
    


  7. 


  8. 

  9. /* Private typedef -----------------------------------------------------------*/
    

  10. /* Private define ------------------------------------------------------------*/
    

  11. /* Private macro -------------------------------------------------------------*/
    

  12. /* Private variables ---------------------------------------------------------*/
    

  13. /* Private function prototypes -----------------------------------------------*/
    

  14. /* Private functions ---------------------------------------------------------*/
    


  15. 


  16. 

  17. /* Exported variables --------------------------------------------------------*/
    

  18. /* Exported function prototypes ----------------------------------------------*/
    


  19. 


  20. 

  21. /*******************************************************************************
    

  22.  * [url=home.php?mod=space&uid=247401]@brief[/url]       
    

  23.  * @param       
    

  24.  * @retval      
    

  25.  * [url=home.php?mod=space&uid=93590]@Attention[/url]   
    

  26. *******************************************************************************/
    

  27. void _I2C_EEPROM_AckPolling(void)
    

  28. {
    

  29.     uint32_t reg;
    


  30. 

  31.     /* wait if bus busy */
    

  32.     while(I2C_GetFlagStatus(HT_I2C1, I2C_FLAG_BUSBUSY));
    


  33. 

  34.     while(1)
    

  35.     {
    

  36.         /* send slave address */
    

  37.         I2C_TargetAddressConfig(HT_I2C1, I2C_EEPROM_DEV_ADDR, I2C_MASTER_WRITE);
    


  38. 

  39.         /* check status */
    

  40.         while(1)
    

  41.         {
    

  42.             reg = HT_I2C1->SR;
    


  43. 

  44.             if(reg & I2C_FLAG_ADRS)
    

  45.             {
    

  46.                 return;
    

  47.             }
    


  48. 

  49.             if(reg & I2C_FLAG_RXNACK)
    

  50.             {
    

  51.                 I2C_ClearFlag(HT_I2C1, I2C_FLAG_RXNACK);
    

  52.                 break;
    

  53.             }
    

  54.         }
    

  55.     }
    

  56. }
    


  57. 


  58. 

  59. /*******************************************************************************
    

  60.  * [url=home.php?mod=space&uid=247401]@brief[/url]       
    

  61.  * @param       
    

  62.  * @retval      
    

  63.  * [url=home.php?mod=space&uid=93590]@Attention[/url]   
    

  64. *******************************************************************************/
    

  65. void I2C_EEPROM_BufferRead(uint8_t* pBuffer, uint8_t ReadAddr, uint16_t NumByteToRead)
    

  66. {
    

  67.     /* check parameters */
    

  68.     Assert_Param(NumByteToRead > 0);
    


  69. 

  70.     /* acknowledge polling */
    

  71.     _I2C_EEPROM_AckPolling();
    


  72. 

  73.     /* set EEPROM address */
    

  74.     while (!I2C_CheckStatus(HT_I2C1, I2C_MASTER_TX_EMPTY));
    

  75.     I2C_SendData(HT_I2C1, ReadAddr);
    


  76. 

  77.     /* send read command */
    

  78.     I2C_TargetAddressConfig(HT_I2C1, I2C_EEPROM_DEV_ADDR, I2C_MASTER_READ);
    

  79.     while(!I2C_CheckStatus( HT_I2C1, I2C_MASTER_SEND_START));
    

  80.     while(!I2C_CheckStatus( HT_I2C1, I2C_MASTER_RECEIVER_MODE));
    


  81. 

  82.     /* enable master receiver ACK */
    

  83.     if(NumByteToRead > 1)
    

  84.     {
    

  85.         I2C_AckCmd(HT_I2C1, ENABLE);
    

  86.     }
    


  87. 

  88.     /* sequential read */
    

  89.     while(NumByteToRead)
    

  90.     {
    

  91.         while(!I2C_CheckStatus(HT_I2C1, I2C_MASTER_RX_NOT_EMPTY));
    


  92. 

  93.         *pBuffer++ = I2C_ReceiveData(HT_I2C1);
    


  94. 

  95.         if(--NumByteToRead == 1)
    

  96.         {
    

  97.             I2C_AckCmd(HT_I2C1, DISABLE);
    

  98.         }
    

  99.     }
    


  100. 

  101.     /* end of read */
    

  102.     I2C_GenerateSTOP(HT_I2C1);
    

  103. }
    


  104. 


  105. 

  106. /*******************************************************************************
    

  107.  * @brief       
    

  108.  * @param       
    

  109.  * @retval      
    

  110.  * @attention   
    

  111. *******************************************************************************/
    

  112. void I2C_EEPROM_PageWrite(uint8_t* pBuffer, uint8_t WriteAddr, uint16_t NumByteToWrite)
    

  113. {
    

  114.     /* check parameters */
    

  115.     Assert_Param((NumByteToWrite > 0) && 
    

  116.                 ((NumByteToWrite <= (I2C_EEPROM_PAGE_SIZE - (WriteAddr & I2C_EEPROM_PAGE_MASK)))));
    


  117. 

  118.     /* acknowledge polling */
    

  119.     _I2C_EEPROM_AckPolling();
    


  120. 

  121.     /* set EEPROM address */
    

  122.     while(!I2C_CheckStatus(HT_I2C1, I2C_MASTER_TX_EMPTY));
    

  123.     I2C_SendData(HT_I2C1, WriteAddr);
    


  124. 

  125.     /* page write */
    

  126.     while(NumByteToWrite--)
    

  127.     {
    

  128.         while(!I2C_CheckStatus(HT_I2C1, I2C_MASTER_TX_EMPTY));
    

  129.         I2C_SendData(HT_I2C1, *pBuffer++);
    

  130.     }
    


  131. 

  132.     /* end of write */
    

  133.     while(!I2C_CheckStatus(HT_I2C1, I2C_MASTER_TX_EMPTY));
    

  134.     I2C_GenerateSTOP(HT_I2C1);
    

  135. }
    


  136. 


  137. 

  138. /*******************************************************************************
    

  139.  * @brief       
    

  140.  * @param       
    

  141.  * @retval      
    

  142.  * @attention   
    

  143. *******************************************************************************/
    

  144. void I2C_EEPROM_BufferWrite(uint8_t* pBuffer, uint8_t WriteAddr, uint16_t NumByteToWrite)
    

  145. {
    

  146.     uint16_t Byte2Wr, AvailableByte;
    


  147. 

  148.     /* check parameters */
    

  149.     Assert_Param(NumByteToWrite <= I2C_EEPROM_CAPACITY);
    


  150. 

  151.     /* sequential write */
    

  152.     while (NumByteToWrite)
    

  153.     {
    

  154.         AvailableByte = I2C_EEPROM_PAGE_SIZE - (WriteAddr & I2C_EEPROM_PAGE_MASK);
    

  155.         Byte2Wr       = (NumByteToWrite > AvailableByte)?(AvailableByte):(NumByteToWrite);
    


  156. 

  157.         I2C_EEPROM_PageWrite(pBuffer, WriteAddr, Byte2Wr);
    


  158. 

  159.         pBuffer        += Byte2Wr;
    

  160.         WriteAddr       = (WriteAddr + Byte2Wr) & I2C_EEPROM_ADDR_MASK;
    

  161.         NumByteToWrite -= Byte2Wr;
    

  162.     }
    

  163. }
    


  164. 


  165. 

  166. /*******************************************************************************
    

  167.  * @brief       
    

  168.  * @param       
    

  169.  * @retval      
    

  170.  * @attention   
    

  171. *******************************************************************************/
    

  172. void EEPROM_Init(void)
    

  173. {
    

  174.     I2C_InitTypeDef I2C_InitStructure;
    


  175. 

  176.     CKCU_PeripClockConfig_TypeDef CKCUClock = {{0}};
    

  177.     CKCUClock.Bit.PB   = 1;
    

  178.     CKCUClock.Bit.PC   = 1;
    

  179.     CKCUClock.Bit.I2C1 = 1;
    

  180.     CKCUClock.Bit.AFIO = 1;
    

  181.     CKCU_PeripClockConfig(CKCUClock, ENABLE);
    


  182. 

  183.     AFIO_GPxConfig(GPIO_PB, AFIO_PIN_15, AFIO_FUN_I2C);
    

  184.     AFIO_GPxConfig(GPIO_PC, AFIO_PIN_0,  AFIO_FUN_I2C);
    


  185. 

  186.     I2C_InitStructure.I2C_GeneralCall    = I2C_GENERALCALL_DISABLE;
    

  187.     I2C_InitStructure.I2C_AddressingMode = I2C_ADDRESSING_7BIT;
    

  188.     I2C_InitStructure.I2C_Acknowledge    = I2C_ACK_DISABLE;
    

  189.     I2C_InitStructure.I2C_OwnAddress     = 0x00;
    

  190.     I2C_InitStructure.I2C_Speed          = 400000;  //---400k
    

  191.     I2C_InitStructure.I2C_SpeedOffset    = 0;
    

  192.     I2C_Init(HT_I2C1, &I2C_InitStructure);
    


  193. 

  194.     I2C_Cmd(HT_I2C1, ENABLE);
    

  195. }
    


  196. 


  197. 

  198. /*******************************************************************************
    

  199.  * @brief       
    

  200.  * @param       
    

  201.  * @retval      
    

  202.  * @attention   
    

  203. *******************************************************************************/
    

  204. void EEPROM_Demo(void)
    

  205. {
    

  206.     uint8_t wBuffer[I2C_EEPROM_PAGE_SIZE];
    

  207.     uint8_t rBuffer[I2C_EEPROM_PAGE_SIZE];
    


  208. 

  209.     for(uint32_t j = 0; j < (I2C_EEPROM_CAPACITY / I2C_EEPROM_PAGE_SIZE); j++)
    

  210.     {
    

  211.         memset(rBuffer, 0, sizeof(rBuffer));
    

  212.         memset(wBuffer, 0, sizeof(wBuffer));
    


  213. 

  214.         for(uint32_t i = 0; i < I2C_EEPROM_PAGE_SIZE; i++)
    

  215.         {
    

  216.             wBuffer[i] = rand();
    

  217.         }
    


  218. 

  219.         I2C_EEPROM_BufferWrite((uint8_t *)wBuffer, I2C_EEPROM_PAGE_SIZE * j, I2C_EEPROM_PAGE_SIZE);
    


  220. 

  221.         printf("\r\nEEPROM Write...[Page%d]", j+1);
    


  222. 

  223.         for(uint32_t i = 0; i < I2C_EEPROM_PAGE_SIZE; i++)
    

  224.         {
    

  225.             if((i % 10) == 0) printf("\r\n");
    

  226.             printf("0x%02x ", wBuffer[i]);
    

  227.         }
    


  228. 

  229.         I2C_EEPROM_BufferRead((uint8_t  *)rBuffer, I2C_EEPROM_PAGE_SIZE * j, I2C_EEPROM_PAGE_SIZE);
    


  230. 

  231.         printf("\r\nEEPROM Read....[Page%d]", j+1);
    


  232. 

  233.         for(uint32_t i = 0; i < I2C_EEPROM_PAGE_SIZE; i++)
    

  234.         {
    

  235.             if((i % 10) == 0) printf("\r\n");
    

  236.             printf("0x%02x ", rBuffer[i]);
    

  237.         }
    


  238. 

  239.         for(uint32_t i = 0; i < I2C_EEPROM_PAGE_SIZE; i++)
    

  240.         {
    

  241.             if(rBuffer[i] != wBuffer[i])
    

  242.             {
    

  243.                 printf("\r\n\r\nEEPROM Read & Write Test Failed!!!"); while(1);
    

  244.             }
    

  245.         }
    


  246. 

  247.         printf("\t\tCompare Success : %d%%\r\n", (int)((j + 1) * 100) / (I2C_EEPROM_CAPACITY / I2C_EEPROM_PAGE_SIZE));
    

  248.     }
    


  249. 

  250.     printf("\r\n\r\nEEPROM Read & Write Test Pass!!!");
    

  251. }
  • SPI FLASH
复制
  1. /* Define to prevent recursive inclusion -------------------------------------*/
    

  2. #define __SPI_FLASH_C__
    


  3. 


  4. 

  5. /* Includes ------------------------------------------------------------------*/
    

  6. #include "SPI_FLASH.h"
    

  7. #include <sfud.h>
    


  8. 


  9. 

  10. /* Private typedef -----------------------------------------------------------*/
    


  11. 


  12. 

  13. /* Private define ------------------------------------------------------------*/
    

  14. #define SFUD_DEMO_BUFFER_SIZE      (512)
    


  15. 


  16. 

  17. /* Private macro -------------------------------------------------------------*/
    


  18. 


  19. 

  20. /* Private variables ---------------------------------------------------------*/
    

  21. uint8_t sfud_demo_buf[SFUD_DEMO_BUFFER_SIZE];
    


  22. 


  23. 

  24. /* Private function prototypes -----------------------------------------------*/
    

  25. /* Private functions ---------------------------------------------------------*/
    


  26. 


  27. 

  28. /* Exported variables --------------------------------------------------------*/
    

  29. /* Exported function prototypes ----------------------------------------------*/
    


  30. 


  31. 

  32. /*******************************************************************************
    

  33.  * @brief       SFUD demo for the first flash device test
    

  34.  * @param       addr flash start address
    

  35.  * @param       size test flash size
    

  36.  * @param       size test flash data buffer
    

  37.  * @retval      
    

  38.  * @attention   
    

  39. *******************************************************************************/
    

  40. void sfud_demo(uint32_t addr, size_t size, uint8_t *data)
    

  41. {
    

  42.     sfud_err result = SFUD_SUCCESS;
    


  43. 

  44.     const sfud_flash *flash = sfud_get_device_table() + 0;
    


  45. 

  46.     size_t i;
    


  47. 

  48.     /* prepare write data */
    

  49.     for(i = 0; i < size; i++)
    

  50.     {
    

  51.         data[i] = i;
    

  52.     }
    


  53. 

  54.     /* erase test */
    

  55.     result = sfud_erase(flash, addr, size);
    


  56. 

  57.     if(result == SFUD_SUCCESS)
    

  58.     {
    

  59.         printf("\r\nErase the %s flash data finish. Start from 0x%08X, size is %d.\r\n", flash->name, addr, size);
    

  60.     }
    

  61.     else
    

  62.     {
    

  63.         printf("\r\nErase the %s flash data failed.\r\n", flash->name);
    

  64.         return;
    

  65.     }
    


  66. 

  67.     /* write test */
    

  68.     result = sfud_write(flash, addr, size, data);
    


  69. 

  70.     if(result == SFUD_SUCCESS)
    

  71.     {
    

  72.         printf("\r\nWrite the %s flash data finish. Start from 0x%08X, size is %d.\r\n", flash->name, addr, size);
    

  73.     }
    

  74.     else
    

  75.     {
    

  76.         printf("\r\nWrite the %s flash data failed.\r\n", flash->name);
    

  77.         return;
    

  78.     }
    


  79. 

  80.     /* read test */
    

  81.     result = sfud_read(flash, addr, size, data);
    


  82. 

  83.     if(result == SFUD_SUCCESS)
    

  84.     {
    

  85.         printf("\r\nRead the %s flash data success. Start from 0x%08X, size is %d. The data is:\r\n", flash->name, addr, size);
    


  86. 

  87.         printf("Offset (h) 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F\r\n");
    


  88. 

  89.         for(i = 0; i < size; i++)
    

  90.         {
    

  91.             if((i % 16) == 0)
    

  92.             {
    

  93.                 printf("[%08X] ", addr + i);
    

  94.             }
    


  95. 

  96.             printf("%02X ", data[i]);
    


  97. 

  98.             if(((i + 1) % 16 == 0) || (i == size - 1))
    

  99.             {
    

  100.                 printf("\r\n");
    

  101.             }
    

  102.         }
    


  103. 

  104.         printf("\r\n");
    

  105.     }
    

  106.     else
    

  107.     {
    

  108.         printf("\r\nRead the %s flash data failed.\r\n", flash->name);
    

  109.     }
    


  110. 

  111.     /* data check */
    

  112.     for(i = 0; i < size; i++)
    

  113.     {
    

  114.         if(data[i] != i % 256)
    

  115.         {
    

  116.             printf("\r\nRead and check write data has an error. Write the %s flash data failed.\r\n", flash->name);
    

  117.             break;
    

  118.         }
    

  119.     }
    


  120. 

  121.     if(i == size)
    

  122.     {
    

  123.         printf("\r\nThe %s flash test is success.\r\n", flash->name);
    

  124.     }
    

  125. }
    


  126. 


  127. 

  128. /*******************************************************************************
    

  129.  * @brief       
    

  130.  * @param       
    

  131.  * @retval      
    

  132.  * @attention   
    

  133. *******************************************************************************/
    

  134. void SPI_FLASH_Init(void)
    

  135. {
    

  136.     printf("\r\n");
    


  137. 

  138.     if(sfud_init() == SFUD_SUCCESS)
    

  139.     {
    

  140.         sfud_demo(0, sizeof(sfud_demo_buf), sfud_demo_buf);
    

  141.     }
    

  142. }
  • SFUD移植接口
复制
  1. #include <sfud.h>
    

  2. #include <stdarg.h>
    

  3. #include "config.h"
    


  4. 

  5. static char log_buf[256];
    


  6. 

  7. void sfud_log_debug(const char *file, const long line, const char *format, ...);
    


  8. 

  9. /**
    

  10.  * SPI write data then read data
    

  11.  */
    

  12. static sfud_err spi_write_read(const sfud_spi *spi, const uint8_t *write_buf, size_t write_size, uint8_t *read_buf,
    

  13.         size_t read_size) {
    

  14.     sfud_err result = SFUD_SUCCESS;
    

  15.     uint8_t send_data, read_data;
    


  16. 

  17.     if (write_size) {
    

  18.         SFUD_ASSERT(write_buf);
    

  19.     }
    


  20. 

  21.     if (read_size) {
    

  22.         SFUD_ASSERT(read_buf);
    

  23.     }
    


  24. 

  25.     /**
    

  26.      * add your spi write and read code
    

  27.      */
    

  28.     GPIO_ClearOutBits(HT_GPIOA, GPIO_PIN_8);
    


  29. 

  30.     for (size_t i = 0; i < (write_size + read_size); i++) {
    

  31.         if (i < write_size) {
    

  32.             send_data = *write_buf++;
    

  33.         } else {
    

  34.             send_data = SFUD_DUMMY_DATA;
    

  35.         }
    


  36. 

  37.         while(!SPI_GetFlagStatus(HT_SPI1, SPI_FLAG_TXBE));
    

  38.         SPI_SendData(HT_SPI1, send_data);
    


  39. 

  40.         while(!SPI_GetFlagStatus(HT_SPI1, SPI_FLAG_RXBNE));
    

  41.         read_data = SPI_ReceiveData(HT_SPI1);
    


  42. 

  43.         if (i >= write_size) {
    

  44.             *read_buf++ = read_data;
    

  45.         }
    

  46.     }
    


  47. 

  48.     GPIO_SetOutBits(HT_GPIOA, GPIO_PIN_8);
    


  49. 

  50.     return result;
    

  51. }
    


  52. 

  53. #ifdef SFUD_USING_QSPI
    

  54. /**
    

  55.  * read flash data by QSPI
    

  56.  */
    

  57. static sfud_err qspi_read(const struct __sfud_spi *spi, uint32_t addr, sfud_qspi_read_cmd_format *qspi_read_cmd_format,
    

  58.         uint8_t *read_buf, size_t read_size) {
    

  59.     sfud_err result = SFUD_SUCCESS;
    


  60. 

  61.     /**
    

  62.      * add your qspi read flash data code
    

  63.      */
    


  64. 

  65.     return result;
    

  66. }
    

  67. #endif /* SFUD_USING_QSPI */
    


  68. 

  69. static void rcc_initialize(void) {
    

  70.     CKCU_PeripClockConfig_TypeDef CKCUClock = {{0}};
    

  71.     CKCUClock.Bit.PA   = 1;
    

  72.     CKCUClock.Bit.PB   = 1;
    

  73.     CKCUClock.Bit.PC   = 1;
    

  74.     CKCUClock.Bit.SPI1 = 1;
    

  75.     CKCUClock.Bit.AFIO = 1;
    

  76.     CKCU_PeripClockConfig(CKCUClock, ENABLE);
    

  77. }
    


  78. 

  79. static void gpio_initialize(void) {
    

  80.     AFIO_GPxConfig(GPIO_PA, GPIO_PIN_8,  AFIO_FUN_GPIO);
    

  81.     AFIO_GPxConfig(GPIO_PA, GPIO_PIN_15, AFIO_FUN_SPI);
    

  82.     AFIO_GPxConfig(GPIO_PB, GPIO_PIN_6,  AFIO_FUN_SPI);
    

  83.     AFIO_GPxConfig(GPIO_PC, GPIO_PIN_3,  AFIO_FUN_SPI);
    


  84. 

  85.     GPIO_SetOutBits(HT_GPIOA, GPIO_PIN_8);
    

  86.     GPIO_DirectionConfig(HT_GPIOA, GPIO_PIN_8, GPIO_DIR_OUT);
    

  87. }
    


  88. 

  89. static void spi_device_initialize(void) {
    

  90.     SPI_InitTypeDef  SPI_InitStructure;
    


  91. 

  92.     SPI_InitStructure.SPI_Mode        = SPI_MASTER;
    

  93.     SPI_InitStructure.SPI_FIFO        = SPI_FIFO_DISABLE;
    

  94.     SPI_InitStructure.SPI_DataLength  = SPI_DATALENGTH_8;
    

  95.     SPI_InitStructure.SPI_SELMode     = SPI_SEL_SOFTWARE;
    

  96.     SPI_InitStructure.SPI_SELPolarity = SPI_SELPOLARITY_LOW;
    

  97.     SPI_InitStructure.SPI_FirstBit    = SPI_FIRSTBIT_MSB;
    

  98.     SPI_InitStructure.SPI_CPOL        = SPI_CPOL_HIGH;
    

  99.     SPI_InitStructure.SPI_CPHA        = SPI_CPHA_SECOND;
    

  100.     SPI_InitStructure.SPI_RxFIFOTriggerLevel = 0;
    

  101.     SPI_InitStructure.SPI_TxFIFOTriggerLevel = 0;
    

  102. #if (LIBCFG_MAX_SPEED > 48000000)
    

  103.     SPI_InitStructure.SPI_ClockPrescaler = 4;
    

  104. #else
    

  105.     SPI_InitStructure.SPI_ClockPrescaler = 2;
    

  106. #endif
    

  107.     SPI_Init(HT_SPI1, &SPI_InitStructure);
    


  108. 

  109.     SPI_SELOutputCmd(HT_SPI1, ENABLE);
    


  110. 

  111.     SPI_Cmd(HT_SPI1, ENABLE);
    

  112. }
    


  113. 

  114. static void spi_lock(const sfud_spi *spi) {
    

  115.     __disable_irq();
    

  116. }
    


  117. 

  118. static void spi_unlock(const sfud_spi *spi) {
    

  119.     __enable_irq();
    

  120. }
    


  121. 

  122. static void retry_delay_100us(void) {
    

  123.     uint32_t delay = 120;
    

  124.     while (delay--);
    

  125. }
    


  126. 

  127. sfud_err sfud_spi_port_init(sfud_flash *flash) {
    

  128.     sfud_err result = SFUD_SUCCESS;
    


  129. 

  130.     /**
    

  131.      * add your port spi bus and device object initialize code like this:
    

  132.      * 1. rcc initialize
    

  133.      * 2. gpio initialize
    

  134.      * 3. spi device initialize
    

  135.      * 4. flash->spi and flash->retry item initialize
    

  136.      *    flash->spi.wr = spi_write_read; //Required
    

  137.      *    flash->spi.qspi_read = qspi_read; //Required when QSPI mode enable
    

  138.      *    flash->spi.lock = spi_lock;
    

  139.      *    flash->spi.unlock = spi_unlock;
    

  140.      *    flash->spi.user_data = &spix;
    

  141.      *    flash->retry.delay = null;
    

  142.      *    flash->retry.times = 10000; //Required
    

  143.      */
    

  144.     switch (flash->index) {
    

  145.         case SFUD_FLASH_DEVICE_INDEX:
    

  146.             rcc_initialize();
    


  147. 

  148.             gpio_initialize();
    


  149. 

  150.             spi_device_initialize();
    


  151. 

  152.             flash->spi.wr        = spi_write_read;
    

  153.             flash->spi.qspi_read = qspi_read;
    

  154.             flash->spi.lock      = spi_lock;
    

  155.             flash->spi.unlock    = spi_unlock;
    

  156.             flash->spi.user_data = NULL;
    

  157.             flash->retry.delay   = retry_delay_100us;
    

  158.             flash->retry.times   = 60 * 10000;
    

  159.             break;
    


  160. 

  161.         default: break;
    

  162.     }
    


  163. 

  164.     return result;
    

  165. }
    


  166. 

  167. /**
    

  168.  * This function is print debug info.
    

  169.  *
    

  170.  * @param file the file which has call this function
    

  171.  * @param line the line number which has call this function
    

  172.  * @param format output format
    

  173.  * @param ... args
    

  174.  */
    

  175. void sfud_log_debug(const char *file, const long line, const char *format, ...) {
    

  176.     va_list args;
    


  177. 

  178.     /* args point to the first variable parameter */
    

  179.     va_start(args, format);
    

  180.     printf("[SFUD](%s:%ld) ", file, line);
    

  181.     /* must use vprintf to print */
    

  182.     vsnprintf(log_buf, sizeof(log_buf), format, args);
    

  183.     printf("%s\r\n", log_buf);
    

  184.     va_end(args);
    

  185. }
    


  186. 

  187. /**
    

  188.  * This function is print routine info.
    

  189.  *
    

  190.  * @param format output format
    

  191.  * @param ... args
    

  192.  */
    

  193. void sfud_log_info(const char *format, ...) {
    

  194.     va_list args;
    


  195. 

  196.     /* args point to the first variable parameter */
    

  197.     va_start(args, format);
    

  198.     printf("[SFUD]");
    

  199.     /* must use vprintf to print */
    

  200.     vsnprintf(log_buf, sizeof(log_buf), format, args);
    

  201.     printf("%s\r\n", log_buf);
    

  202.     va_end(args);
    

  203. }


运行结果
  • EEPROM
1.png 2.png 3.png
  • SPI FLASH
4.png


软件工程源代码
Project.zip (896.97 KB, 下载次数: 10)

回复 赏

举报

相关帖子
51xlf 发表于 2022-11-1 14:29 | 显示全部楼层
SPI FLASH 主要用于哪些产品呢?
回复 赏

举报

houjiakai 发表于 2022-11-1 15:24 | 显示全部楼层
是硬件spi驱动的吗？              
回复 赏

举报

fengm 发表于 2022-11-1 15:45 | 显示全部楼层
eeprom可以实现文件的存储吗
回复 赏

举报

olivem55arlowe 发表于 2022-11-1 17:12 | 显示全部楼层
移植了fatfs文件操作系统了吗
回复 赏

举报

hudi008 发表于 2023-1-5 14:14 | 显示全部楼层
最大的读写速度是多少？              
回复 赏

举报

sheflynn 发表于 2023-1-5 14:24 | 显示全部楼层
可以跑fatfs系统的吗？              
回复 赏

举报

beacherblack 发表于 2023-1-5 16:17 | 显示全部楼层
硬件iic和spi搞起来。              
回复 赏

举报

kmzuaz 发表于 2023-1-5 18:04 | 显示全部楼层
这个写的非常的详细了。              
回复 赏

举报

bartonalfred 发表于 2023-1-6 16:40 | 显示全部楼层
这个flash可以做字库使用的。
回复 赏

举报

mollylawrence 发表于 2023-1-6 19:26 | 显示全部楼层
单片机的性能看着非常的给力。              
回复 赏

举报

benjaminka 发表于 2023-1-9 13:49 | 显示全部楼层
可以移植fatfs？              
回复 赏

举报

albertaabbot 发表于 2023-1-9 17:45 | 显示全部楼层
这个设计的性能怎么              
回复 赏

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

xld0932 Image
个人签名：King.Xu

77

主题

3023

帖子

38

粉丝
快速回复 在线客服 返回列表 返回顶部
xld0932 Image
个人签名：King.Xu

77

主题

3023

帖子

38

粉丝
快速回复 在线客服 返回列表 返回顶部