21ic电子技术开发论坛 › 单片机与嵌入式系统 › 灵动MM32 MCU › 【灵动微电子MM32F0121测评】6.硬件SPI读写FLASH ...
返回列表 发新帖我要提问

[MM32硬件] 【灵动微电子MM32F0121测评】6.硬件SPI读写FLASH

[复制链接]
4454|1
 楼主| 阿源玩电子 发表于 2025-6-30 20:00 | 显示全部楼层 |阅读模式
flash, pi, spi, 微电子, 电子
硬件SPI读写FLASH

  • 原理图部分

原理图

原理图

SPI Flash 芯片（U6）
型号: W25Q80DVSNIG，这是一种串行外设接口（SPI）闪存芯片，常用于存储数据。
引脚功能:
  • VCC (引脚 8): 电源输入，连接到 3.3V 电源。
  • GND (引脚 4): 地线，连接到地（GND）。
  • CS (引脚 1): 片选信号，用于选择该 SPI 设备。
  • CLK (引脚 6): 时钟信号，由主设备（微控制器）提供，用于同步数据传输。
  • DI/IQ0 (引脚 5): 数据输入（Master Out Slave In, MOSI），主设备向从设备发送数据。
  • DO/IQ1 (引脚 2): 数据输出（Master In Slave Out, MISO），从设备向主设备发送数据。
  • WP/IQ2 (引脚 3): 写保护信号，用于防止意外写入或擦除操作。
  • HOLD/IQ3 (引脚 7): 持续信号，用于暂停当前操作。
2.dsp_spi.c
复制
  1. #include "dsp_spi.h"
    


  2. 


  3. 

  4. #define SPI_FLASH_CS_H() SPI_CSInternalSelected(SPI1, DISABLE)
    

  5. #define SPI_FLASH_CS_L() SPI_CSInternalSelected(SPI1, ENABLE)
    


  6. 


  7. 

  8.  volatile SPI_RxTx_TypeDef SPI_RxStruct;
    

  9.  volatile SPI_RxTx_TypeDef SPI_TxStruct;
    


  10. 

  11. void SPI_Configure(void)
    

  12. {
    

  13.     GPIO_InitTypeDef GPIO_InitStruct;
    

  14.     NVIC_InitTypeDef NVIC_InitStruct;
    

  15.     SPI_InitTypeDef  SPI_InitStruct;
    

  16.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
    

  17.     SPI_StructInit(&SPI_InitStruct);
    

  18.     SPI_InitStruct.SPI_Mode      = SPI_Mode_Master;
    

  19.     SPI_InitStruct.SPI_DataSize  = SPI_DataSize_8b;
    

  20.     SPI_InitStruct.SPI_DataWidth = 8;
    

  21.     SPI_InitStruct.SPI_CPOL      = SPI_CPOL_Low;
    

  22.     SPI_InitStruct.SPI_CPHA      = SPI_CPHA_1Edge;
    

  23.     SPI_InitStruct.SPI_NSS       = SPI_NSS_Soft;
    

  24.     SPI_InitStruct.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;
    

  25.     SPI_InitStruct.SPI_FirstBit  = SPI_FirstBit_MSB;
    

  26.     SPI_Init(SPI1, &SPI_InitStruct);
    

  27.     SPI_BiDirectionalLineConfig(SPI1, SPI_Enable_RX);
    

  28.     SPI_BiDirectionalLineConfig(SPI1, SPI_Enable_TX);
    

  29.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
    

  30.     GPIO_PinAFConfig(GPIOA, GPIO_PinSource4,  GPIO_AF_0);
    

  31.     GPIO_PinAFConfig(GPIOA, GPIO_PinSource5,  GPIO_AF_0);
    

  32.     GPIO_PinAFConfig(GPIOA, GPIO_PinSource6,  GPIO_AF_0);
    

  33.     GPIO_PinAFConfig(GPIOA, GPIO_PinSource7,  GPIO_AF_0);
    

  34.     GPIO_StructInit(&GPIO_InitStruct);
    

  35.     GPIO_InitStruct.GPIO_Pin   = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_7;
    

  36.     GPIO_InitStruct.GPIO_Speed = GPIO_Speed_High;
    

  37.     GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_AF_PP;
    

  38.     GPIO_Init(GPIOA, &GPIO_InitStruct);
    

  39.     GPIO_StructInit(&GPIO_InitStruct);
    

  40.     GPIO_InitStruct.GPIO_Pin   = GPIO_Pin_6;
    

  41.     GPIO_InitStruct.GPIO_Speed = GPIO_Speed_High;
    

  42.     GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_IPU;
    

  43.     GPIO_Init(GPIOA, &GPIO_InitStruct);
    

  44.     NVIC_InitStruct.NVIC_IRQChannel = SPI1_IRQn;
    

  45.     NVIC_InitStruct.NVIC_IRQChannelPriority = 0;
    

  46.     NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    

  47.     NVIC_Init(&NVIC_InitStruct);
    

  48.     SPI_ITCmd(SPI1, ENABLE);
    

  49.     SPI_Cmd(SPI1, ENABLE);
    

  50. }
    

  51. void SPI_RxData_Interrupt(uint8_t *Buffer, uint8_t Length)
    

  52. {
    

  53.     uint8_t i = 0;
    

  54.     for (i = 0; i < Length; i++)
    

  55.     {
    

  56.         SPI_RxStruct.Buffer[i] = 0;
    

  57.         SPI_TxStruct.Buffer[i] = 0;
    

  58.     }
    

  59.     SPI_RxStruct.Length = Length;
    

  60.     SPI_RxStruct.CurrentCount = 0;
    

  61.     SPI_RxStruct.CompleteFlag = 0;
    

  62.     SPI_TxStruct.Length = Length;
    

  63.     SPI_TxStruct.CurrentCount = 0;
    

  64.     SPI_TxStruct.CompleteFlag = 0;
    

  65.     SPI_ITConfig(SPI1, SPI_IT_RX, ENABLE);
    

  66.     SPI_ITConfig(SPI1, SPI_IT_TX, ENABLE);
    

  67.     while (0 == SPI_TxStruct.CompleteFlag)
    

  68.     {
    

  69.     }
    

  70.     while (0 == SPI_RxStruct.CompleteFlag)
    

  71.     {
    

  72.     }
    

  73.     for (i = 0; i < Length; i++)
    

  74.     {
    

  75.         Buffer[i] = SPI_RxStruct.Buffer[i];
    

  76.     }
    

  77. }
    

  78. void SPI_TxData_Interrupt(uint8_t *Buffer, uint8_t Length)
    

  79. {
    

  80.     uint8_t i = 0;
    

  81.     for (i = 0; i < Length; i++)
    

  82.     {
    

  83.         SPI_RxStruct.Buffer[i] = 0;
    

  84.         SPI_TxStruct.Buffer[i] = Buffer[i];
    

  85.     }
    

  86.     SPI_RxStruct.Length = Length;
    

  87.     SPI_RxStruct.CurrentCount = 0;
    

  88.     SPI_RxStruct.CompleteFlag = 0;
    

  89.     SPI_TxStruct.Length = Length;
    

  90.     SPI_TxStruct.CurrentCount = 0;
    

  91.     SPI_TxStruct.CompleteFlag = 0;
    

  92.     SPI_ITConfig(SPI1, SPI_IT_RX, ENABLE);
    

  93.     SPI_ITConfig(SPI1, SPI_IT_TX, ENABLE);
    

  94.     while (0 == SPI_TxStruct.CompleteFlag)
    

  95.     {
    

  96.     }
    

  97.     while (0 == SPI_RxStruct.CompleteFlag)
    

  98.     {
    

  99.     }
    

  100. }
    

  101. void SPI_FLASH_RxBuffer(uint8_t *Buffer, uint8_t Length)
    

  102. {
    

  103.     if (Length)
    

  104.     {
    

  105.         SPI_RxData_Interrupt(Buffer, Length);
    

  106.     }
    

  107. }
    

  108. void SPI_FLASH_TxBuffer(uint8_t *Buffer, uint8_t Length)
    

  109. {
    

  110.     if (Length)
    

  111.     {
    

  112.         SPI_TxData_Interrupt(Buffer, Length);
    

  113.     }
    

  114. }
    

  115. void SPI_FLASH_ReadDeviceID(void)
    

  116. {
    

  117.     uint8_t  Command[4] =
    

  118.     {
    

  119.         0x90, 0xFF, 0xFF, 0x00
    

  120.     };
    

  121.     uint8_t  Buffer[2];
    

  122.     uint16_t DeviceID = 0;
    

  123.     SPI_FLASH_CS_L();
    

  124.     SPI_FLASH_TxBuffer(Command, 0x04);
    

  125.     SPI_FLASH_RxBuffer(Buffer, 0x02);
    

  126.     SPI_FLASH_CS_H();
    

  127.     DeviceID   = Buffer[0];
    

  128.     DeviceID <<= 8;
    

  129.     DeviceID  |= Buffer[1];
    

  130.     printf("\r\nSPI Flash DeviceID : 0x%04x", DeviceID);
    

  131. }
    

  132. void SPI_FLASH_ReadJEDEC_ID(void)
    

  133. {
    

  134.     uint8_t  Command = 0x9F;
    

  135.     uint8_t  Buffer[3];
    

  136.     uint32_t JEDEC_ID = 0;
    

  137.     SPI_FLASH_CS_L();
    

  138.     SPI_FLASH_TxBuffer(&Command, 0x01);
    

  139.     SPI_FLASH_RxBuffer(Buffer, 0x03);
    

  140.     SPI_FLASH_CS_H();
    

  141.     JEDEC_ID   = Buffer[0];
    

  142.     JEDEC_ID <<= 8;
    

  143.     JEDEC_ID  |= Buffer[1];
    

  144.     JEDEC_ID <<= 8;
    

  145.     JEDEC_ID  |= Buffer[2];
    

  146.     printf("\r\nSPI Flash JEDEC ID : 0x%06x", JEDEC_ID);
    

  147. }
    

  148. void SPI_FLASH_WaitBusy(void)
    

  149. {
    

  150.     uint8_t  Status     = 0;
    

  151.     uint8_t  Command[2] =
    

  152.     {
    

  153.         0x05, 0xFF
    

  154.     };
    

  155.     uint32_t Timeout = 0;
    

  156.     do
    

  157.     {
    

  158.         SPI_FLASH_CS_L();
    

  159.         SPI_FLASH_TxBuffer(Command, 0x02);
    

  160.         SPI_FLASH_RxBuffer(&Status, 0x01);
    

  161.         SPI_FLASH_CS_H();
    

  162.         if (Timeout++ > 0xFFFF)
    

  163.         {
    

  164.             break;
    

  165.         }
    

  166.     }
    

  167.     while (Status & 0x01);
    

  168. }
    

  169. void SPI_FLASH_WriteEnable(void)
    

  170. {
    

  171.     uint8_t Command = 0x06;
    

  172.     SPI_FLASH_CS_L();
    

  173.     SPI_FLASH_TxBuffer(&Command, 0x01);
    

  174.     SPI_FLASH_CS_H();
    

  175. }
    

  176. void SPI_FLASH_SectorErase(uint16_t Index)
    

  177. {
    

  178.     uint8_t  Command[4] =
    

  179.     {
    

  180.         0x20, 0x00, 0x00, 0x00
    

  181.     };
    

  182.     uint32_t Address = Index * 4 * 1024;
    

  183.     Command[1] = (uint8_t)((Address >> 16) & 0x000000FF);
    

  184.     Command[2] = (uint8_t)((Address >> 8) & 0x000000FF);
    

  185.     Command[3] = (uint8_t)((Address >> 0) & 0x000000FF);
    

  186.     SPI_FLASH_WriteEnable();
    

  187.     SPI_FLASH_CS_L();
    

  188.     SPI_FLASH_TxBuffer(Command, 4);
    

  189.     SPI_FLASH_CS_H();
    

  190.     SPI_FLASH_WaitBusy();
    

  191. }
    

  192. void SPI_FLASH_FastRead(uint32_t Address, uint8_t *Buffer, uint32_t Length)
    

  193. {
    

  194.     uint8_t Command[5] =
    

  195.     {
    

  196.         0x0B, 0x00, 0x00, 0x00, 0xFF
    

  197.     };
    

  198.     Command[1] = (uint8_t)((Address >> 16) & 0x000000FF);
    

  199.     Command[2] = (uint8_t)((Address >> 8) & 0x000000FF);
    

  200.     Command[3] = (uint8_t)((Address >> 0) & 0x000000FF);
    

  201.     SPI_FLASH_CS_L();
    

  202.     SPI_FLASH_TxBuffer(Command, 0x05);
    

  203.     SPI_FLASH_RxBuffer(Buffer, Length);
    

  204.     SPI_FLASH_CS_H();
    

  205. }
    

  206. void SPI_FLASH_PageProgram(uint32_t Address, uint8_t *Buffer, uint32_t Length)
    

  207. {
    

  208.     uint8_t Command[4] =
    

  209.     {
    

  210.         0x02, 0x00, 0x00, 0x00
    

  211.     };
    

  212.     Command[1] = (uint8_t)((Address >> 16) & 0x000000FF);
    

  213.     Command[2] = (uint8_t)((Address >> 8) & 0x000000FF);
    

  214.     Command[3] = (uint8_t)((Address >> 0) & 0x000000FF);
    

  215.     SPI_FLASH_WriteEnable();
    

  216.     SPI_FLASH_CS_L();
    

  217.     SPI_FLASH_TxBuffer(Command, 0x04);
    

  218.     SPI_FLASH_TxBuffer(Buffer, Length);
    

  219.     SPI_FLASH_CS_H();
    

  220.     SPI_FLASH_WaitBusy();
    

  221. }
    

  222. void SPI_Master_FLASH_Interrupt_Sample(void)
    

  223. {
    

  224.     uint8_t i = 0;
    

  225.     uint8_t WriteBuffer[100], ReadBuffer[100];
    

  226.     const char* helloStr = "Hello 21ic, Hello MM32F0121";
    

  227.     uint8_t strLen = strlen(helloStr);
    

  228.     
    

  229.     printf("\r\nTest %s", __FUNCTION__);
    

  230.     SPI_Configure();
    

  231.     SPI_FLASH_ReadDeviceID();
    

  232.     SPI_FLASH_ReadJEDEC_ID();
    

  233.     
    

  234.     printf("\r\nSPI FLASH Sector Erase...");
    

  235.     SPI_FLASH_SectorErase(0);
    

  236.     
    

  237.     printf("\r\nWriting string: "%s"", helloStr);
    

  238.     
    

  239.     for (i = 0; i < strLen; i++) {
    

  240.         WriteBuffer[i] = helloStr[i];
    

  241.     }
    

  242.     
    

  243.     printf("\r\nSPI FLASH Page Program...");
    

  244.     SPI_FLASH_PageProgram(0, WriteBuffer, strLen);
    

  245.     
    

  246.     printf("\r\nSPI FLASH Read...");
    

  247.     SPI_FLASH_FastRead(0, ReadBuffer, strLen);
    

  248.     
    

  249.     printf("\r\nRead Data: "");
    

  250.     for (i = 0; i < strLen; i++) {
    

  251.         printf("%c", ReadBuffer[i]);
    

  252.     }
    

  253.     printf(""");
    

  254.     
    

  255.     printf("\r\nHex Data:");
    

  256.     for (i = 0; i < strLen; i++) {
    

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

  258.         printf("0x%02x ", ReadBuffer[i]);
    

  259.     }
    

  260.     
    

  261. }
    


  262. 


  263. 


  264. 

  265. void SPI1_IRQHandler(void)
    

  266. {
    

  267.     uint8_t Data = 0;
    


  268. 

  269.     if (SPI_RxStruct.CurrentCount != SPI_TxStruct.CurrentCount)
    

  270.     {
    

  271.         if (SET == SPI_GetITStatus(SPI1, SPI_IT_RX))
    

  272.         {
    

  273.             Data = SPI_ReceiveData(SPI1);
    


  274. 

  275.             SPI_ClearITPendingBit(SPI1, SPI_IT_RX);
    


  276. 

  277.             if (0 == SPI_RxStruct.CompleteFlag)
    

  278.             {
    

  279.                 SPI_RxStruct.Buffer[SPI_RxStruct.CurrentCount++] = Data;
    


  280. 

  281.                 if (SPI_RxStruct.CurrentCount == SPI_RxStruct.Length)
    

  282.                 {
    

  283.                     SPI_RxStruct.CompleteFlag = 1;
    


  284. 

  285.                     SPI_ITConfig(SPI1, SPI_IT_TX, DISABLE);
    

  286.                     SPI_ITConfig(SPI1, SPI_IT_RX, DISABLE);
    

  287.                 }
    

  288.             }
    

  289.         }
    

  290.     }
    

  291.     else
    

  292.     {
    

  293.         if (SET == SPI_GetITStatus(SPI1, SPI_IT_TX))
    

  294.         {
    

  295.             SPI_ClearITPendingBit(SPI1, SPI_IT_TX);
    


  296. 

  297.             if (0 == SPI_TxStruct.CompleteFlag)
    

  298.             {
    

  299.                 SPI_SendData(SPI1, SPI_TxStruct.Buffer[SPI_TxStruct.CurrentCount++]);
    


  300. 

  301.                 if (SPI_TxStruct.CurrentCount == SPI_TxStruct.Length)
    

  302.                 {
    

  303.                     SPI_TxStruct.CompleteFlag = 1;
    

  304.                 }
    

  305.             }
    

  306.         }
    

  307.     }
    

  308. }
3.dsp_spi.h
复制
  1. #include <stdio.h>
    

  2. #include "hal_conf.h"
    


  3. 

  4. typedef struct
    

  5. {
    

  6.     uint8_t Buffer[255];
    

  7.     uint8_t Length;
    

  8.     uint8_t CurrentCount;
    

  9.     uint8_t CompleteFlag;
    

  10. } SPI_RxTx_TypeDef;
    


  11. 


  12. 

  13. extern volatile SPI_RxTx_TypeDef SPI_RxStruct;
    

  14. extern volatile SPI_RxTx_TypeDef SPI_TxStruct;
    


  15. 

  16. void SPI_Master_FLASH_Interrupt_Sample(void);
4.实验现象
实验现象.jpg






MM32F0121C6PV_06SPI.zip

6.14 MB, 下载次数: 0
回复

收藏 举报

相关帖子
AdaMaYun 发表于 2025-7-31 17:45 | 显示全部楼层
非常不错的硬件SPI读写FLASH
回复

收藏 举报

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

本版积分规则

阿源玩电子

13

主题

35

帖子

0

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