你的浏览器版本过低，可能导致网站不能正常访问！
为了你能正常使用网站功能，请使用这些浏览器。

st-img
chrome st-img
firefox st-img
safari st-img
ie8及以上

【经验分享】stm32-SPI读取串行FLASH

[复制链接]
STMCU小助手 发布时间：2022-2-3 19:00
SPI协议：是由摩托罗拉公司提出的通讯协议(Serial Peripheral Interface)，即串行外围设备接口，是一种高速全双工的通信总线。它被广泛地使用在ADC、LCD 等设备与MCU 间，要求通讯速率较高的场合。

物理层：
S S  ( Slave Select)：从设备选择信号线，常称为片选信号线，也称为NSS、CS，以下用NSS 表示。当有多个SPI 从设备与SPI 主机相连时，设备的其它信号线SCK、MOSI及MISO 同时并联到相同的SPI 总线上，即无论有多少个从设备，都共同只使用这3 条总线；而每个从设备都有独立的这一条NSS 信号线，本信号线独占主机的一个引脚，即有多少个从设备，就有多少条片选信号线。I2C  协议中通过设备地址来寻址、选中总线上的某个设备并与其进行通讯；而SPI 协议中没有设备地址，它使用NSS 信号线来寻址，当主机要选择从设备时，把该从设备的NSS 信号线设置为低电平，该从设备即被选中，即片选有效，接着主机开始与被选中的从设备进行SPI通讯。所以SPI通讯以NSS 线置低电平为开始信号，以NSS 线被拉高作为结束信号。

SCK (Serial Clock)：时钟信号线，用于通讯数据同步。它由通讯主机产生，决定了通讯的速率，不同的设备支持的最高时钟频率不一样，如STM32 的SPI 时钟频率最大为fpclk/2，两个设备之间通讯时，通讯速率受限于低速设备。

MOSI (Master Output，Slave Input)：主设备输出/从设备输入引脚。主机的数据从这条信号线输出，从机由这条信号线读入主机发送的数据，即这条线上数据的方向为主机到从机。

MISO(Master Input,，Slave Output)：主设备输入/从设备输出引脚。主机从这条信号线读入数据，从机的数据由这条信号线输出到主机，即在这条线上数据的方向为从机到主机，只有这条线的信号由从机产生。
SPI设备之间的常用连线方式如下：

1424785-20180627201708179-223816288.png

协议层：
SPI 一共有四种通讯模式，它们的主要区别是总线空闲时SCK 的时钟状态以及数据采样时刻。为方便说明，在此引入“时钟极性CPOL”和“时钟相位CPHA”的概念。时钟极性CPOL 是指SPI 通讯设备处于空闲状态时，SCK 信号线的电平信号(即SPI 通讯开始前、NSS 线为高电平时SCK 的状态)。CPOL=0 时，SCK 在空闲状态时为低电平，CPOL=1 时，则相反。时钟相位CPHA 是指数据的采样的时刻，当CPHA=0 时，MOSI 或MISO 数据线上的信号将会在SCK 时钟线的“奇数边沿”被采样。当CPHA=1 时，数据线在SCK 的“偶数边沿”采样。

1424785-20180627201728482-474134694.png

bsp_spi_flash.h文件：
  1. #ifndef __SPI_FLASH_H
  2. #define __SPI_FLASH_H

  4. #include "stm32f10x.h"
  5. #include <stdio.h>
  6. #define  sFLASH_ID    0XEF4017
  7. #define  SPI_FLASH_PageSize   256
  8. #define  SPI_FLASH_PerWritePageSize 256
  9. //Flash命令定义
  10. #define W25X_WriteEnable              0x06
  11. #define W25X_WriteDisable              0x04
  12. #define W25X_ReadStatusReg            0x05
  13. #define W25X_WriteStatusReg            0x01
  14. #define W25X_ReadData                    0x03
  15. #define W25X_FastReadData              0x0B
  16. #define W25X_FastReadDual              0x3B
  17. #define W25X_PageProgram              0x02
  18. #define W25X_BlockErase                  0xD8
  19. #define W25X_SectorErase              0x20
  20. #define W25X_ChipErase                  0xC7
  21. #define W25X_PowerDown                  0xB9
  22. #define W25X_ReleasePowerDown        0xAB
  23. #define W25X_DeviceID                    0xAB
  24. #define W25X_ManufactDeviceID       0x90
  25. #define W25X_JedecDeviceID            0x9F
  26. //WIP（busy) 标志，Flash内部正在写入
  27. #define WIP_flag   0x01
  28. #define Dummy_Byte 0xFF
  29. //SPI接口定义
  30. #define FLASH_SPIx   SPI1
  31. #define FLASH_SPI_CLK   RCC_APB2Periph_SPI1
  32. //片选引脚
  33. #define FLASH_SPI_CS_CLK   RCC_APB2Periph_GPIOC
  34. #define FLASH_SPI_CS_PORT  GPIOC
  35. #define FLASH_SPI_CS_PIN   GPIO_Pin_0
  36. //SCK引脚
  37. #define FLASH_SPI_SCK_CLK  RCC_APB2Periph_GPIOA
  38. #define FLASH_SPI_SCK_PORT GPIOA
  39. #define FLASH_SPI_SCK_PIN  GPIO_Pin_5
  40. //MISO引脚
  41. #define FLASH_SPI_MISO_CLK  RCC_APB2Periph_GPIOA
  42. #define FLASH_SPI_MISO_PORT GPIOA
  43. #define FLASH_SPI_MISO_PIN  GPIO_Pin_6
  44. //MOSI引脚
  45. #define FLASH_SPI_MOSI_CLK  RCC_APB2Periph_GPIOA
  46. #define FLASH_SPI_MOSI_PORT GPIOA
  47. #define FLASH_SPI_MOSI_PIN  GPIO_Pin_7

  49. #define SPI_FLASH_CS_LOW()   GPIO_ResetBits(FLASH_SPI_CS_PORT, FLASH_SPI_CS_PIN)
  50. #define SPI_FLASH_CS_HIGH()  GPIO_SetBits( FLASH_SPI_CS_PORT, FLASH_SPI_CS_PIN )

  52. #define SPIT_FLAG_TIMEOUT         ((uint32_t)0x1000)
  53. #define SPIT_LONG_TIMEOUT         ((uint32_t)(10 * SPIT_FLAG_TIMEOUT))

  55. #define FLASH_DEBUG_ON         1

  57. #define FLASH_INFO(fmt,arg...)           printf("<<-FLASH-INFO->> "fmt"\n",##arg)
  58. #define FLASH_ERROR(fmt,arg...)          printf("<<-FLASH-ERROR->> "fmt"\n",##arg)
  59. #define FLASH_DEBUG(fmt,arg...)          do{\
  60.                                           if(FLASH_DEBUG_ON)\
  61.                                           printf("<<-FLASH-DEBUG->> [%d]"fmt"\n",__LINE__, ##arg);\
  62.                                           }while(0)

  64. void SPI_FLASH_Init(void);
  65. void SPI_FLASH_SectorErase(u32 SectorAddr);
  66. void SPI_FLASH_BulkErase(void);
  67. void SPI_FLASH_PageWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite);
  68. void SPI_FLASH_BufferWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite);
  69. void SPI_FLASH_BufferRead(u8* pBuffer, u32 ReadAddr, u16 NumByteToRead);
  70. u32 SPI_FLASH_ReadID(void);
  71. u32 SPI_FLASH_ReadDeviceID(void);
  72. void SPI_FLASH_StartReadSequence(up32 ReadAddr);
  73. void SPI_Flash_PowerDown(void);
  74. void SPI_Flash_WAKEUP(void);


  77. u8 SPI_FLASH_ReadByte(void);
  78. u8 SPI_FLASH_SendByte(u8 byte);
  79. u16 SPI_FLASH_SendHalfWord(u16 HalfWord);
  80. void SPI_FLASH_WriteEnable(void);
  81. void SPI_FLASH_WaitForWriteEnd(void);
  82. #endif
复制代码

bsp_spi_flash.c文件：
  1. #include "bsp_spi_flash.h"

  3. static __IO uint32_t  SPITimeout = SPIT_LONG_TIMEOUT;   
  4. static uint16_t SPI_TIMEOUT_UserCallback(uint8_t errorCode);

  6. void SPI_FLASH_Init(void)
  7. {
  8.   SPI_InitTypeDef  SPI_InitStructure;
  9.   GPIO_InitTypeDef GPIO_InitStructure;
  10.     RCC_APB2PeriphClockCmd(FLASH_SPI_CLK, ENABLE );
  11.      RCC_APB2PeriphClockCmd(FLASH_SPI_CS_CLK|FLASH_SPI_SCK_CLK|
  12.         FLASH_SPI_MISO_PIN|FLASH_SPI_MOSI_PIN, ENABLE );
  13.   GPIO_InitStructure.GPIO_Pin = FLASH_SPI_CS_PIN;
  14.   //配置片选
  15.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  16.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  17.   GPIO_Init(FLASH_SPI_CS_PORT, &GPIO_InitStructure);
  18.   GPIO_InitStructure.GPIO_Pin = FLASH_SPI_SCK_PIN;
  19.   //配置SCK
  20.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  21.   GPIO_Init(FLASH_SPI_SCK_PORT, &GPIO_InitStructure);
  22.   //配置MISO
  23.   GPIO_InitStructure.GPIO_Pin = FLASH_SPI_MISO_PIN;
  24.   GPIO_Init(FLASH_SPI_MISO_PORT, &GPIO_InitStructure);
  25.   //配置MOSI
  26.   GPIO_InitStructure.GPIO_Pin = FLASH_SPI_MOSI_PIN;
  27.   GPIO_Init(FLASH_SPI_MOSI_PORT, &GPIO_InitStructure);
  28.   //cs高电平，通讯停止
  29.   SPI_FLASH_CS_HIGH();
  30.   //SPI模式配置
  31.   SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  32.   SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
  33.   SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
  34.   SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
  35.   SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
  36.   SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
  37.   SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
  38.   SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
  39.   SPI_InitStructure.SPI_CRCPolynomial = 7;
  40.   SPI_Init(FLASH_SPIx , &SPI_InitStructure);
  41.   SPI_Cmd(FLASH_SPIx , ENABLE);
  42.    
  43. }
  44. //擦除FLASH
  45. void SPI_FLASH_SectorErase(u32 SectorAddr)
  46. {
  47.   SPI_FLASH_WriteEnable();
  48.   SPI_FLASH_WaitForWriteEnd();
  49.   SPI_FLASH_CS_LOW();
  50.   SPI_FLASH_SendByte(W25X_SectorErase);
  51.   SPI_FLASH_SendByte((SectorAddr & 0xFF0000) >> 16);
  52.   SPI_FLASH_SendByte((SectorAddr & 0xFF00) >> 8);
  53.   SPI_FLASH_SendByte(SectorAddr & 0xFF);
  54.   SPI_FLASH_CS_HIGH();
  55.   SPI_FLASH_WaitForWriteEnd();
  56. }
  57. //擦除FLASH扇区
  58. void SPI_FLASH_BulkErase(void)
  59. {
  60.   SPI_FLASH_WriteEnable();
  61.   SPI_FLASH_CS_LOW();
  62.   SPI_FLASH_SendByte(W25X_ChipErase);
  63.   SPI_FLASH_CS_HIGH();
  64.   SPI_FLASH_WaitForWriteEnd();
  65. }

  67. //按页写入数据
  68. void SPI_FLASH_PageWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)
  69. {
  70.   SPI_FLASH_WriteEnable();
  71.   SPI_FLASH_CS_LOW();
  72.   SPI_FLASH_SendByte(W25X_PageProgram);
  73.   SPI_FLASH_SendByte((WriteAddr & 0xFF0000) >> 16);
  74.   SPI_FLASH_SendByte((WriteAddr & 0xFF00) >> 8);
  75.   SPI_FLASH_SendByte(WriteAddr & 0xFF);
  76.   if(NumByteToWrite > SPI_FLASH_PerWritePageSize)
  77.   {
  78.      NumByteToWrite = SPI_FLASH_PerWritePageSize;
  79.      FLASH_ERROR("SPI_FLASH_PageWrite too large!");
  80.   }
  81.   while (NumByteToWrite--)
  82.   {
  83.     SPI_FLASH_SendByte(*pBuffer);
  84.     pBuffer++;
  85.   }
  86.   SPI_FLASH_CS_HIGH();
  87.   SPI_FLASH_WaitForWriteEnd();
  88. }
  89. //写数据
  90. void SPI_FLASH_BufferWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)
  91. {
  92.   u8 NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
  93.   Addr = WriteAddr % SPI_FLASH_PageSize;
  94.   count = SPI_FLASH_PageSize - Addr;
  95.   NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
  96.   NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
  97.   if (Addr == 0)
  98.   {
  99.     if (NumOfPage == 0)
  100.     {
  101.       SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
  102.     }
  103.     else
  104.     {
  105.       while (NumOfPage--)
  106.       {
  107.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
  108.         WriteAddr +=  SPI_FLASH_PageSize;
  109.         pBuffer += SPI_FLASH_PageSize;
  110.       }
  111.       SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
  112.     }
  113.   }
  114.   else
  115.   {
  116.     if (NumOfPage == 0)
  117.     {
  118.       if (NumOfSingle > count)
  119.       {
  120.         temp = NumOfSingle - count;
  121.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
  122.                
  123.         WriteAddr +=  count;
  124.         pBuffer += count;
  125.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, temp);
  126.       }
  127.       else
  128.       {
  129.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
  130.       }
  131.     }
  132.     else
  133.     {
  134.       NumByteToWrite -= count;
  135.       NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
  136.       NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
  137.       SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
  138.       WriteAddr +=  count;
  139.       pBuffer += count;
  140.       while (NumOfPage--)
  141.       {
  142.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
  143.         WriteAddr +=  SPI_FLASH_PageSize;
  144.         pBuffer += SPI_FLASH_PageSize;
  145.       }
  146.       if (NumOfSingle != 0)
  147.       {
  148.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
  149.       }
  150.     }
  151.   }
  152. }

  154. //读数据
  155. void SPI_FLASH_BufferRead(u8* pBuffer, u32 ReadAddr, u16 NumByteToRead)
  156. {
  157.   SPI_FLASH_CS_LOW();
  158.   SPI_FLASH_SendByte(W25X_ReadData);
  159.   SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
  160.   SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
  161.   SPI_FLASH_SendByte(ReadAddr & 0xFF);
  162.   while (NumByteToRead--)
  163.   {
  164.     *pBuffer = SPI_FLASH_SendByte(Dummy_Byte);
  165.     pBuffer++;
  166.   }
  167.   SPI_FLASH_CS_HIGH();
  168. }
  169. //读取ID
  170. u32 SPI_FLASH_ReadID(void)
  171. {
  172.   u32 Temp = 0, Temp0 = 0, Temp1 = 0, Temp2 = 0;
  173.   SPI_FLASH_CS_LOW();
  174.   SPI_FLASH_SendByte(W25X_JedecDeviceID);
  175.   Temp0 = SPI_FLASH_SendByte(Dummy_Byte);
  176.   Temp1 = SPI_FLASH_SendByte(Dummy_Byte);
  177.   Temp2 = SPI_FLASH_SendByte(Dummy_Byte);
  178.   SPI_FLASH_CS_HIGH();
  179.     Temp = (Temp0 << 16) | (Temp1 << 8) | Temp2;

  181.   return Temp;
  182. }
  183. //读取DeviceID
  184. u32 SPI_FLASH_ReadDeviceID(void)
  185. {
  186.   u32 Temp = 0;
  187.   SPI_FLASH_CS_LOW();
  188.   SPI_FLASH_SendByte(W25X_DeviceID);
  189.   SPI_FLASH_SendByte(Dummy_Byte);
  190.   SPI_FLASH_SendByte(Dummy_Byte);
  191.   SPI_FLASH_SendByte(Dummy_Byte);
  192.   Temp = SPI_FLASH_SendByte(Dummy_Byte);
  193.   SPI_FLASH_CS_HIGH();

  195.   return Temp;
  196. }

  198. void SPI_FLASH_StartReadSequence(u32 ReadAddr)
  199. {
  200.   SPI_FLASH_CS_LOW();
  201.   SPI_FLASH_SendByte(W25X_ReadData);
  202.   SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
  203.   SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
  204.   SPI_FLASH_SendByte(ReadAddr & 0xFF);
  205. }

  207. u8 SPI_FLASH_ReadByte(void)
  208. {
  209.   return (SPI_FLASH_SendByte(Dummy_Byte));
  210. }

  212. u8 SPI_FLASH_SendByte(u8 byte)
  213. {
  214.      SPITimeout = SPIT_FLAG_TIMEOUT;
  215.   while (SPI_I2S_GetFlagStatus(FLASH_SPIx , SPI_I2S_FLAG_TXE) == RESET)
  216.     {
  217.     if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(0);
  218.    }
  219.   SPI_I2S_SendData(FLASH_SPIx , byte);

  221.     SPITimeout = SPIT_FLAG_TIMEOUT;
  222.   while (SPI_I2S_GetFlagStatus(FLASH_SPIx , SPI_I2S_FLAG_RXNE) == RESET)
  223.   {
  224.     if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(1);
  225.    }
  226.   return SPI_I2S_ReceiveData(FLASH_SPIx );
  227. }

  229. u16 SPI_FLASH_SendHalfWord(u16 HalfWord)
  230. {
  231.       SPITimeout = SPIT_FLAG_TIMEOUT;
  232.   while (SPI_I2S_GetFlagStatus(FLASH_SPIx , SPI_I2S_FLAG_TXE) == RESET)
  233.     {
  234.     if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(2);
  235.    }
  236.   SPI_I2S_SendData(FLASH_SPIx , HalfWord);

  238.      SPITimeout = SPIT_FLAG_TIMEOUT;
  239.   while (SPI_I2S_GetFlagStatus(FLASH_SPIx , SPI_I2S_FLAG_RXNE) == RESET)
  240.      {
  241.     if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(3);
  242.    }
  243.   return SPI_I2S_ReceiveData(FLASH_SPIx );
  244. }

  246. void SPI_FLASH_WriteEnable(void)
  247. {
  248.   SPI_FLASH_CS_LOW();
  249.   SPI_FLASH_SendByte(W25X_WriteEnable);
  250.   SPI_FLASH_CS_HIGH();
  251. }

  253. void SPI_FLASH_WaitForWriteEnd(void)
  254. {
  255.   u8 FLASH_Status = 0;
  256.   SPI_FLASH_CS_LOW();
  257.   SPI_FLASH_SendByte(W25X_ReadStatusReg);
  258.   do
  259.   {
  260.     FLASH_Status = SPI_FLASH_SendByte(Dummy_Byte);     
  261.   }
  262.   while ((FLASH_Status & WIP_flag ) == SET);  
  263.   SPI_FLASH_CS_HIGH();
  264. }

  266. void SPI_Flash_PowerDown(void)   
  267. {
  268.   SPI_FLASH_CS_LOW();
  269.   SPI_FLASH_SendByte(W25X_PowerDown);
  270.   SPI_FLASH_CS_HIGH();
  271. }   

  273. void SPI_Flash_WAKEUP(void)   
  274. {
  275.   SPI_FLASH_CS_LOW();
  276.   SPI_FLASH_SendByte(W25X_ReleasePowerDown);
  277.   SPI_FLASH_CS_HIGH();
  278. }   
  279.    
  280. static  uint16_t SPI_TIMEOUT_UserCallback(uint8_t errorCode)
  281. {
  282.   FLASH_ERROR("SPI等待超时!errorCode = %d",errorCode);
  283.   return 0;
  284. }
复制代码

main.c文件：
  1. #include "stm32f10x.h"
  2. #include "bsp_usart.h"
  3. #include "bsp_led.h"
  4. #include "bsp_spi_flash.h"


  7. typedef enum { FAILED = 0, PASSED = !FAILED} TestStatus;

  9. #define TxBufferSize1   (countof(TxBuffer1) - 1)
  10. #define RxBufferSize1   (countof(TxBuffer1) - 1)
  11. #define countof(a)      (sizeof(a) / sizeof(*(a)))
  12. #define  BufferSize (countof(Tx_Buffer)-1)

  14. #define  FLASH_WriteAddress     0x00000
  15. #define  FLASH_ReadAddress      FLASH_WriteAddress
  16. #define  FLASH_SectorToErase    FLASH_WriteAddress

  18. uint8_t Tx_Buffer[] = "hello stm32!!!\r\n";
  19. uint8_t Rx_Buffer[BufferSize];

  21. __IO uint32_t DeviceID = 0;
  22. __IO uint32_t FlashID = 0;
  23. __IO TestStatus TransferStatus1 = FAILED;

  25. void Delay(__IO uint32_t nCount);
  26. TestStatus Buffercmp(uint8_t* pBuffer1,uint8_t* pBuffer2, uint16_t BufferLength);

  28. int main(void)
  29. {     
  30.     LED_GPIO_Config();
  31.     USART_Config();
  32.     printf("\r\n 这是一个8M的串行flash W25Q64实验!\r\n");
  33.     SPI_FLASH_Init();
  34.     DeviceID = SPI_FLASH_ReadDeviceID();   
  35.     Delay( 200 );
  36.     FlashID = SPI_FLASH_ReadID();   
  37.     printf("\r\n FlashID is 0x%X,\
  38.     Manufacturer Device ID is 0x%X\r\n", FlashID, DeviceID);
  39.     if (FlashID == sFLASH_ID)
  40.     {   
  41.         printf("\r\n检测到串行flash W25Q64\r\n");
  42.         SPI_FLASH_SectorErase(FLASH_SectorToErase);         
  43.         SPI_FLASH_BufferWrite(Tx_Buffer, FLASH_WriteAddress, BufferSize);        
  44.         printf("\r\n 写入的数据为：%s \r\t", Tx_Buffer);
  45.         SPI_FLASH_BufferRead(Rx_Buffer, FLASH_ReadAddress, BufferSize);
  46.         printf("\r\n 读出的数据为\r\n", Rx_Buffer);
  47.         TransferStatus1 = Buffercmp(Tx_Buffer, Rx_Buffer, BufferSize);
  48.         if( PASSED == TransferStatus1 )
  49.         {
  50.             green(ON);
  51.             printf("\r\n 测试成功!\n\r");
  52.         }
  53.         else
  54.         {        
  55.             red(ON);
  56.             printf("\r\n 测试失败\n\r");
  57.         }
  58.     }// if (FlashID == sFLASH_ID)
  59.     else// if (FlashID == sFLASH_ID)
  60.     {
  61.         red(ON);
  62.         printf("\r\n 获取不到W25Q64 ID!\n\r");
  63.     }
  64.    
  65.     while(1);  
  66. }
  67. //比较两个缓冲区的内容是否一样
  68. TestStatus Buffercmp(uint8_t* pBuffer1, uint8_t* pBuffer2, uint16_t BufferLength)
  69. {
  70.   while(BufferLength--)
  71.   {
  72.     if(*pBuffer1 != *pBuffer2)
  73.     {
  74.       return FAILED;
  75.     }
  76.     pBuffer1++;
  77.     pBuffer2++;
  78.   }
  79.   return PASSED;
  80. }

  82. void Delay(__IO uint32_t nCount)
  83. {
  84.   for(; nCount != 0; nCount--);
  85. }
复制代码

赞 收藏 评论0 发布时间：2022-2-3 19:00

举报

0个回答

所属标签

STM32团队

STM32团队

意法半导体微控制器和微处理器拥有广泛的产品线，包含低成本的8位单片机和基于ARM® Cortex®-M0、M0+、M3、M4、M33、M7及A7内核并具备丰富外设选择的32位微控制器及微处理器。关注该话题即可发布文章！

最新内容

相似技术帖

官网相关资源

关于
意法半导体
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
STM32N6 AI生态系统
STM32MCU,MPU高性能GUI
ST ACEPACK电源模块
意法半导体生物传感器
STM32Cube扩展软件包
关注我们
st-img 微信公众号
st-img 手机版