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

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

【经验分享】STM32 SPI程序示例

[复制链接]
STMCU小助手 发布时间：2022-6-16 18:00
01. SPI简介
SPI 是英语 Serial Peripheral interface 的缩写，顾名思义就是串行外围设备接口。是 Motorola首先在其 MC68HCXX 系列处理器上定义的。SPI 接口主要应用在 EEPROM，FLASH，实时时钟，AD 转换器，还有数字信号处理器和数字信号解码器之间。SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为 PCB 的布局上节省空间，提供方便，正是出于这种简单易用的特性，现在越来越多的芯片集成了这种通信协议，STM32F4 也有 SPI 接口。

02. 功能描述
使用 STM32F4 自带的 SPI来实现对外部 FLASH（W25Q128）的读写，并将结果显示在 TFTLCD 模块上。

03. 硬件模块
开机的时候先检测 W25Q128 是否存在，然后在主循环里面检测两个按键，其中 1 个按键（KEY1）用来执行写入 W25Q128 的操作，另外一个按键（KEY0）用来执行读出操作，在 TFTLCD 模块上显示相关信息。同时用 DS0 提示程序正在运行。
所要用到的硬件资源如下：
1） 指示灯 DS0
2） KEY_UP 和 KEY1 按键
3） TFTLCD 模块
4） SPI
5） W25Q128

VS96Y8D~PWW}I%)M`SF}LAQ.png

04. 软件设计
spi.h

  1. #ifndef __SPI_H
  2. #define __SPI_H
  3. #include "sys.h"
  4.                                                                                                                      
  5. void SPI1_Init(void);                         //初始化SPI1口
  6. void SPI1_SetSpeed(u8 SpeedSet); //设置SPI1速度   
  7. u8 SPI1_ReadWriteByte(u8 TxData);//SPI1总线读写一个字节
  8.                  
  9. #endif
复制代码

spi.c

  1. #include "spi.h"


  4. //以下是SPI模块的初始化代码，配置成主机模式                                                   
  5. //SPI口初始化
  6. //这里针是对SPI1的初始化
  7. void SPI1_Init(void)
  8. {         
  9.   GPIO_InitTypeDef  GPIO_InitStructure;
  10.   SPI_InitTypeDef  SPI_InitStructure;
  11.         
  12.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);//使能GPIOB时钟
  13.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);//使能SPI1时钟

  15.   //GPIOFB3,4,5初始化设置
  16.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5;//PB3~5复用功能输出        
  17.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
  18.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
  19.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
  20.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
  21.   GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化
  22.         
  23.         GPIO_PinAFConfig(GPIOB,GPIO_PinSource3,GPIO_AF_SPI1); //PB3复用为 SPI1
  24.         GPIO_PinAFConfig(GPIOB,GPIO_PinSource4,GPIO_AF_SPI1); //PB4复用为 SPI1
  25.         GPIO_PinAFConfig(GPIOB,GPIO_PinSource5,GPIO_AF_SPI1); //PB5复用为 SPI1

  27.         //这里只针对SPI口初始化
  28.         RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1,ENABLE);//复位SPI1
  29.         RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1,DISABLE);//停止复位SPI1

  31.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
  32.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                //设置SPI工作模式:设置为主SPI
  33.         SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                //设置SPI的数据大小:SPI发送接收8位帧结构
  34.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                //串行同步时钟的空闲状态为高电平
  35.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;        //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
  36.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
  37.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;                //定义波特率预分频的值:波特率预分频值为256
  38.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;        //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
  39.         SPI_InitStructure.SPI_CRCPolynomial = 7;        //CRC值计算的多项式
  40.         SPI_Init(SPI1, &SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器

  42.         SPI_Cmd(SPI1, ENABLE); //使能SPI外设

  44.         SPI1_ReadWriteByte(0xff);//启动传输                 
  45. }   
  46. //SPI1速度设置函数
  47. //SPI速度=fAPB2/分频系数
  48. //@ref SPI_BaudRate_Prescaler:SPI_BaudRatePrescaler_2~SPI_BaudRatePrescaler_256  
  49. //fAPB2时钟一般为84Mhz：
  50. void SPI1_SetSpeed(u8 SPI_BaudRatePrescaler)
  51. {
  52.   assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));//判断有效性
  53.         SPI1->CR1&=0XFFC7;//位3-5清零，用来设置波特率
  54.         SPI1->CR1|=SPI_BaudRatePrescaler;        //设置SPI1速度
  55.         SPI_Cmd(SPI1,ENABLE); //使能SPI1
  56. }
  57. //SPI1 读写一个字节
  58. //TxData:要写入的字节
  59. //返回值:读取到的字节
  60. u8 SPI1_ReadWriteByte(u8 TxData)
  61. {                                          

  63.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET){}//等待发送区空  
  64.         
  65.         SPI_I2S_SendData(SPI1, TxData); //通过外设SPIx发送一个byte  数据
  66.                
  67.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET){} //等待接收完一个byte  

  69.         return SPI_I2S_ReceiveData(SPI1); //返回通过SPIx最近接收的数据        
  70.                      
  71. }
复制代码

w25qxx.h

  1. #ifndef __W25QXX_H
  2. #define __W25QXX_H                           
  3. #include "sys.h"  

  5. //W25X系列/Q系列芯片列表           
  6. //W25Q80  ID  0XEF13
  7. //W25Q16  ID  0XEF14
  8. //W25Q32  ID  0XEF15
  9. //W25Q64  ID  0XEF16        
  10. //W25Q128 ID  0XEF17        
  11. #define W25Q80         0XEF13         
  12. #define W25Q16         0XEF14
  13. #define W25Q32         0XEF15
  14. #define W25Q64         0XEF16
  15. #define W25Q128        0XEF17

  17. extern u16 W25QXX_TYPE;                                        //定义W25QXX芯片型号                  

  19. #define        W25QXX_CS                 PBout(14)                  //W25QXX的片选信号

  21. //
  22. //指令表
  23. #define W25X_WriteEnable                0x06
  24. #define W25X_WriteDisable                0x04
  25. #define W25X_ReadStatusReg                0x05
  26. #define W25X_WriteStatusReg                0x01
  27. #define W25X_ReadData                        0x03
  28. #define W25X_FastReadData                0x0B
  29. #define W25X_FastReadDual                0x3B
  30. #define W25X_PageProgram                0x02
  31. #define W25X_BlockErase                        0xD8
  32. #define W25X_SectorErase                0x20
  33. #define W25X_ChipErase                        0xC7
  34. #define W25X_PowerDown                        0xB9
  35. #define W25X_ReleasePowerDown        0xAB
  36. #define W25X_DeviceID                        0xAB
  37. #define W25X_ManufactDeviceID        0x90
  38. #define W25X_JedecDeviceID                0x9F

  40. void W25QXX_Init(void);
  41. u16  W25QXX_ReadID(void);                              //读取FLASH ID
  42. u8         W25QXX_ReadSR(void);                        //读取状态寄存器
  43. void W25QXX_Write_SR(u8 sr);                          //写状态寄存器
  44. void W25QXX_Write_Enable(void);                  //写使能
  45. void W25QXX_Write_Disable(void);                //写保护
  46. void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);
  47. void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead);   //读取flash
  48. void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);//写入flash
  49. void W25QXX_Erase_Chip(void);                      //整片擦除
  50. void W25QXX_Erase_Sector(u32 Dst_Addr);        //扇区擦除
  51. void W25QXX_Wait_Busy(void);                   //等待空闲
  52. void W25QXX_PowerDown(void);                //进入掉电模式
  53. void W25QXX_WAKEUP(void);                                //唤醒
  54. #endif
复制代码

w25qxx.c

  1. #include "w25qxx.h"
  2. #include "spi.h"
  3. #include "delay.h"           
  4. #include "usart.h"        


  7. u16 W25QXX_TYPE=W25Q128;        //默认是W25Q128

  9. //4Kbytes为一个Sector
  10. //16个扇区为1个Block
  11. //W25Q128
  12. //容量为16M字节,共有128个Block,4096个Sector
  13.                                                                                                          
  14. //初始化SPI FLASH的IO口
  15. void W25QXX_Init(void)
  16. {
  17.   GPIO_InitTypeDef  GPIO_InitStructure;

  19.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);//使能GPIOB时钟
  20.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOG, ENABLE);//使能GPIOG时钟

  22.           //GPIOB14
  23.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;//PB14
  24.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//输出
  25.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
  26.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
  27.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
  28.   GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化

  30.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;//PG7
  31.   GPIO_Init(GPIOG, &GPIO_InitStructure);//初始化

  33.         GPIO_SetBits(GPIOG,GPIO_Pin_7);//PG7输出1,防止NRF干扰SPI FLASH的通信
  34.         W25QXX_CS=1;                        //SPI FLASH不选中
  35.         SPI1_Init();                                           //初始化SPI
  36.         SPI1_SetSpeed(SPI_BaudRatePrescaler_4);                //设置为21M时钟,高速模式
  37.         W25QXX_TYPE=W25QXX_ReadID();        //读取FLASH ID.
  38. }  

  40. //读取W25QXX的状态寄存器
  41. //BIT7  6   5   4   3   2   1   0
  42. //SPR   RV  TB BP2 BP1 BP0 WEL BUSY
  43. //SPR:默认0,状态寄存器保护位,配合WP使用
  44. //TB,BP2,BP1,BP0:FLASH区域写保护设置
  45. //WEL:写使能锁定
  46. //BUSY:忙标记位(1,忙;0,空闲)
  47. //默认:0x00
  48. u8 W25QXX_ReadSR(void)   
  49. {  
  50.         u8 byte=0;   
  51.         W25QXX_CS=0;                            //使能器件   
  52.         SPI1_ReadWriteByte(W25X_ReadStatusReg);    //发送读取状态寄存器命令   
  53.         byte=SPI1_ReadWriteByte(0Xff);             //读取一个字节  
  54.         W25QXX_CS=1;                            //取消片选     
  55.         return byte;   
  56. }
  57. //写W25QXX状态寄存器
  58. //只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
  59. void W25QXX_Write_SR(u8 sr)   
  60. {   
  61.         W25QXX_CS=0;                            //使能器件   
  62.         SPI1_ReadWriteByte(W25X_WriteStatusReg);   //发送写取状态寄存器命令   
  63.         SPI1_ReadWriteByte(sr);               //写入一个字节  
  64.         W25QXX_CS=1;                            //取消片选                  
  65. }   
  66. //W25QXX写使能        
  67. //将WEL置位   
  68. void W25QXX_Write_Enable(void)   
  69. {
  70.         W25QXX_CS=0;                            //使能器件   
  71.     SPI1_ReadWriteByte(W25X_WriteEnable);      //发送写使能  
  72.         W25QXX_CS=1;                            //取消片选                  
  73. }
  74. //W25QXX写禁止        
  75. //将WEL清零  
  76. void W25QXX_Write_Disable(void)   
  77. {  
  78.         W25QXX_CS=0;                            //使能器件   
  79.     SPI1_ReadWriteByte(W25X_WriteDisable);     //发送写禁止指令   
  80.         W25QXX_CS=1;                            //取消片选                  
  81. }                 
  82. //读取芯片ID
  83. //返回值如下:                                   
  84. //0XEF13,表示芯片型号为W25Q80  
  85. //0XEF14,表示芯片型号为W25Q16   
  86. //0XEF15,表示芯片型号为W25Q32  
  87. //0XEF16,表示芯片型号为W25Q64
  88. //0XEF17,表示芯片型号为W25Q128           
  89. u16 W25QXX_ReadID(void)
  90. {
  91.         u16 Temp = 0;         
  92.         W25QXX_CS=0;                                    
  93.         SPI1_ReadWriteByte(0x90);//发送读取ID命令            
  94.         SPI1_ReadWriteByte(0x00);            
  95.         SPI1_ReadWriteByte(0x00);            
  96.         SPI1_ReadWriteByte(0x00);                                    
  97.         Temp|=SPI1_ReadWriteByte(0xFF)<<8;  
  98.         Temp|=SPI1_ReadWriteByte(0xFF);         
  99.         W25QXX_CS=1;                                    
  100.         return Temp;
  101. }                       
  102. //读取SPI FLASH  
  103. //在指定地址开始读取指定长度的数据
  104. //pBuffer:数据存储区
  105. //ReadAddr:开始读取的地址(24bit)
  106. //NumByteToRead:要读取的字节数(最大65535)
  107. void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)   
  108. {
  109.          u16 i;                                                                                       
  110.         W25QXX_CS=0;                            //使能器件   
  111.     SPI1_ReadWriteByte(W25X_ReadData);         //发送读取命令   
  112.     SPI1_ReadWriteByte((u8)((ReadAddr)>>16));  //发送24bit地址   
  113.     SPI1_ReadWriteByte((u8)((ReadAddr)>>8));   
  114.     SPI1_ReadWriteByte((u8)ReadAddr);   
  115.     for(i=0;i<NumByteToRead;i++)
  116.         {
  117.         pBuffer<i>=SPI1_ReadWriteByte(0XFF);   //循环读数  
  118.     }
  119.         W25QXX_CS=1;                                                   
  120. }  
  121. //SPI在一页(0~65535)内写入少于256个字节的数据
  122. //在指定地址开始写入最大256字节的数据
  123. //pBuffer:数据存储区
  124. //WriteAddr:开始写入的地址(24bit)
  125. //NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!         
  126. void W25QXX_Write_Page(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
  127. {
  128.          u16 i;  
  129.     W25QXX_Write_Enable();                  //SET WEL
  130.         W25QXX_CS=0;                            //使能器件   
  131.     SPI1_ReadWriteByte(W25X_PageProgram);      //发送写页命令   
  132.     SPI1_ReadWriteByte((u8)((WriteAddr)>>16)); //发送24bit地址   
  133.     SPI1_ReadWriteByte((u8)((WriteAddr)>>8));   
  134.     SPI1_ReadWriteByte((u8)WriteAddr);   
  135.     for(i=0;i<NumByteToWrite;i++)SPI1_ReadWriteByte(pBuffer<i>);//循环写数  
  136.         W25QXX_CS=1;                            //取消片选
  137.         W25QXX_Wait_Busy();                                           //等待写入结束
  138. }
  139. //无检验写SPI FLASH
  140. //必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
  141. //具有自动换页功能
  142. //在指定地址开始写入指定长度的数据,但是要确保地址不越界!
  143. //pBuffer:数据存储区
  144. //WriteAddr:开始写入的地址(24bit)
  145. //NumByteToWrite:要写入的字节数(最大65535)
  146. //CHECK OK
  147. void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
  148. {                                          
  149.         u16 pageremain;           
  150.         pageremain=256-WriteAddr%256; //单页剩余的字节数                             
  151.         if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
  152.         while(1)
  153.         {           
  154.                 W25QXX_Write_Page(pBuffer,WriteAddr,pageremain);
  155.                 if(NumByteToWrite==pageremain)break;//写入结束了
  156.                  else //NumByteToWrite>pageremain
  157.                 {
  158.                         pBuffer+=pageremain;
  159.                         WriteAddr+=pageremain;        

  161.                         NumByteToWrite-=pageremain;                          //减去已经写入了的字节数
  162.                         if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
  163.                         else pageremain=NumByteToWrite;           //不够256个字节了
  164.                 }
  165.         };            
  166. }
  167. //写SPI FLASH  
  168. //在指定地址开始写入指定长度的数据
  169. //该函数带擦除操作!
  170. //pBuffer:数据存储区
  171. //WriteAddr:开始写入的地址(24bit)                                                
  172. //NumByteToWrite:要写入的字节数(最大65535)   
  173. u8 W25QXX_BUFFER[4096];                 
  174. void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
  175. {
  176.         u32 secpos;
  177.         u16 secoff;
  178.         u16 secremain;           
  179.          u16 i;   
  180.         u8 * W25QXX_BUF;         
  181.            W25QXX_BUF=W25QXX_BUFFER;            
  182.          secpos=WriteAddr/4096;//扇区地址  
  183.         secoff=WriteAddr%4096;//在扇区内的偏移
  184.         secremain=4096-secoff;//扇区剩余空间大小   
  185.          //printf("ad:%X,nb:%X\r\n",WriteAddr,NumByteToWrite);//测试用
  186.          if(NumByteToWrite<=secremain)secremain=NumByteToWrite;//不大于4096个字节
  187.         while(1)
  188.         {        
  189.                 W25QXX_Read(W25QXX_BUF,secpos*4096,4096);//读出整个扇区的内容
  190.                 for(i=0;i<secremain;i++)//校验数据
  191.                 {
  192.                         if(W25QXX_BUF[secoff+i]!=0XFF)break;//需要擦除            
  193.                 }
  194.                 if(i<secremain)//需要擦除
  195.                 {
  196.                         W25QXX_Erase_Sector(secpos);//擦除这个扇区
  197.                         for(i=0;i<secremain;i++)           //复制
  198.                         {
  199.                                 W25QXX_BUF[i+secoff]=pBuffer<i>;         
  200.                         }
  201.                         W25QXX_Write_NoCheck(W25QXX_BUF,secpos*4096,4096);//写入整个扇区  

  203.                 }else W25QXX_Write_NoCheck(pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                    
  204.                 if(NumByteToWrite==secremain)break;//写入结束了
  205.                 else//写入未结束
  206.                 {
  207.                         secpos++;//扇区地址增1
  208.                         secoff=0;//偏移位置为0         

  210.                            pBuffer+=secremain;  //指针偏移
  211.                         WriteAddr+=secremain;//写地址偏移           
  212.                            NumByteToWrite-=secremain;                                //字节数递减
  213.                         if(NumByteToWrite>4096)secremain=4096;        //下一个扇区还是写不完
  214.                         else secremain=NumByteToWrite;                        //下一个扇区可以写完了
  215.                 }         
  216.         };         
  217. }
  218. //擦除整个芯片                  
  219. //等待时间超长...
  220. void W25QXX_Erase_Chip(void)   
  221. {                                   
  222.     W25QXX_Write_Enable();                  //SET WEL
  223.     W25QXX_Wait_Busy();   
  224.           W25QXX_CS=0;                            //使能器件   
  225.     SPI1_ReadWriteByte(W25X_ChipErase);        //发送片擦除命令  
  226.         W25QXX_CS=1;                            //取消片选                  
  227.         W25QXX_Wait_Busy();                                      //等待芯片擦除结束
  228. }   
  229. //擦除一个扇区
  230. //Dst_Addr:扇区地址 根据实际容量设置
  231. //擦除一个山区的最少时间:150ms
  232. void W25QXX_Erase_Sector(u32 Dst_Addr)   
  233. {  
  234.         //监视falsh擦除情况,测试用   
  235.          printf("fe:%x\r\n",Dst_Addr);         
  236.          Dst_Addr*=4096;
  237.     W25QXX_Write_Enable();                  //SET WEL         
  238.     W25QXX_Wait_Busy();   
  239.           W25QXX_CS=0;                            //使能器件   
  240.     SPI1_ReadWriteByte(W25X_SectorErase);      //发送扇区擦除指令
  241.     SPI1_ReadWriteByte((u8)((Dst_Addr)>>16));  //发送24bit地址   
  242.     SPI1_ReadWriteByte((u8)((Dst_Addr)>>8));   
  243.     SPI1_ReadWriteByte((u8)Dst_Addr);  
  244.         W25QXX_CS=1;                            //取消片选                  
  245.     W25QXX_Wait_Busy();                                      //等待擦除完成
  246. }  
  247. //等待空闲
  248. void W25QXX_Wait_Busy(void)   
  249. {   
  250.         while((W25QXX_ReadSR()&0x01)==0x01);   // 等待BUSY位清空
  251. }  
  252. //进入掉电模式
  253. void W25QXX_PowerDown(void)   
  254. {
  255.           W25QXX_CS=0;                            //使能器件   
  256.     SPI1_ReadWriteByte(W25X_PowerDown);        //发送掉电命令  
  257.         W25QXX_CS=1;                            //取消片选                  
  258.     delay_us(3);                               //等待TPD  
  259. }   
  260. //唤醒
  261. void W25QXX_WAKEUP(void)   
  262. {  
  263.           W25QXX_CS=0;                            //使能器件   
  264.     SPI1_ReadWriteByte(W25X_ReleasePowerDown);   //  send W25X_PowerDown command 0xAB   
  265.         W25QXX_CS=1;                            //取消片选                  
  266.     delay_us(3);                               //等待TRES1
  267. }   </i></i></i>
复制代码

main.c

  1. #include "sys.h"
  2. #include "delay.h"
  3. #include "usart.h"
  4. #include "led.h"
  5. #include "lcd.h"
  6. #include "spi.h"
  7. #include "w25qxx.h"
  8. #include "key.h"  


  11. //要写入到W25Q16的字符串数组
  12. const u8 TEXT_Buffer[]={"Explorer STM32F4 SPI TEST"};
  13. #define SIZE sizeof(TEXT_Buffer)         
  14.         
  15. int main(void)
  16. {
  17.         u8 key;
  18.         u16 i=0;
  19.         u8 datatemp[SIZE];
  20.         u32 FLASH_SIZE;
  21.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
  22.         delay_init(168);     //初始化延时函数
  23.         uart_init(115200);        //初始化串口波特率为115200
  24.         LED_Init();                                        //初始化LED
  25.          LCD_Init();                                        //LCD初始化
  26.         KEY_Init();                                 //按键初始化  
  27.         W25QXX_Init();                        //W25QXX初始化
  28.          POINT_COLOR=RED;
  29.         LCD_ShowString(30,50,200,16,16,"Explorer STM32F4");        
  30.         LCD_ShowString(30,70,200,16,16,"SPI TEST");        
  31.         LCD_ShowString(30,90,200,16,16,"ATOM@ALIENTEK");
  32.         LCD_ShowString(30,110,200,16,16,"2014/5/6");         
  33.         LCD_ShowString(30,130,200,16,16,"KEY1:Write  KEY0:Read");        //显示提示信息               
  34.         while(W25QXX_ReadID()!=W25Q128)                                                                //检测不到W25Q128
  35.         {
  36.                 LCD_ShowString(30,150,200,16,16,"W25Q128 Check Failed!");
  37.                 delay_ms(500);
  38.                 LCD_ShowString(30,150,200,16,16,"Please Check!      ");
  39.                 delay_ms(500);
  40.                 LED1=!LED1;                //DS0闪烁
  41.         }
  42.         LCD_ShowString(30,150,200,16,16,"W25Q128 Ready!");
  43.         FLASH_SIZE=16*1024*1024;        //FLASH 大小为16字节
  44.           POINT_COLOR=BLUE;                        //设置字体为蓝色         
  45.         while(1)
  46.         {
  47.                 key=Key_Scan();
  48.                 if(key==KEY1_PRESS)//KEY1按下,写入W25Q128
  49.                 {
  50.                         LCD_Fill(0,170,239,319,WHITE);//清除半屏   
  51.                          LCD_ShowString(30,170,200,16,16,"Start Write W25Q128....");
  52.                         W25QXX_Write((u8*)TEXT_Buffer,FLASH_SIZE-100,SIZE);                //从倒数第100个地址处开始,写入SIZE长度的数据
  53.                         LCD_ShowString(30,170,200,16,16,"W25Q128 Write Finished!");        //提示传送完成
  54.                 }
  55.                 if(key==KEY0_PRESS)//KEY0按下,读取字符串并显示
  56.                 {
  57.                          LCD_ShowString(30,170,200,16,16,"Start Read W25Q128.... ");
  58.                         W25QXX_Read(datatemp,FLASH_SIZE-100,SIZE);                                        //从倒数第100个地址处开始,读出SIZE个字节
  59.                         LCD_ShowString(30,170,200,16,16,"The Data Readed Is:   ");        //提示传送完成
  60.                         LCD_ShowString(30,190,200,16,16,datatemp);                                        //显示读到的字符串
  61.                 }
  62.                 i++;
  63.                 delay_ms(10);
  64.                 if(i==20)
  65.                 {
  66.                         LED1=!LED1;//提示系统正在运行        
  67.                         i=0;
  68.                 }                  
  69.         }      
  70. }
复制代码

05. 结果验证
按 KEY1 按键写入数据，然后按 KEY0 读取数据。DS0 的不停闪烁，提示程序在运行。


赞 收藏 评论0 发布时间：2022-6-16 18:00

举报

0个回答

所属标签

相似分享

官网相关资源

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