help:SST25VF016 SPI FLASH 读数据都是0xff不正常

2019-12-23 18:35发布

本帖最后由 磊磊映画 于 2015-5-17 20:08 编辑

硬件SPI 方式,能够读出ID来 0xbf41 但是从0x000000读取的数据都是0xff
写数据也试过,写什么读都是0xff
上代码

  1. void main(void)
  2. {
  3.   while(1)  
  4.     {
  5.          
  6.            u8 key_value=bsp_adminKeyScan( 0 );
  7.              if(key_value!=0xff)
  8.              {
  9.                   bsp_clear_lcd();
  10.                 bsp_show_numberWithXY(0,0,key_value);
  11.                    bsp_show_numberWithXY(0,16,bsp_spi2_flash_readID());
  12.                    bsp_show_numberWithXY(3, 0, bsp_spi2_flash_readSR());
  13.                  bsp_spi2_flash_read(datatemp, addToread, 2 );
  14.                    bsp_show_numberWithXY(1, 0, datatemp[0]);
  15.                    bsp_show_number(datatemp[1]);
  16.              }   
  17.              bsp_watchDog_reload();
  18.     }
  19. }
复制代码
  1. #include "flash.h"
  2. #include "spi.h"


  3. /*FLASH 型号  25VF016B-75-4I-S2AF
  4. **共2M Byte  支持最大速度 75MHZ
  5. **4K  1个扇区Sector   16个扇区64K一个Block  
  6. **总共有 32个块 512个扇区
  7. */
  8. //////////////////////////////////////////////////////////////////////////////////

  9. u16 g_spi_flash_ID=NULL;//默认就是 25VF016B

  10. //4
  11. //初始化SPI FLASH的IO口
  12. void bsp_flash_init(void)
  13. {
  14.    
  15.         RCC->APB2ENR|=1<<3;     //使能PORTB时钟             
  16.       RCC->APB2ENR|=1<<2;    //使能A端口时钟
  17.       
  18.         GPIOB->CRH&=0XFFF0FFFF;
  19.         GPIOB->CRH|=0X00030000;        //PB12 推挽CS           
  20.       GPIOB->ODR|=1<<12;
  21.           
  22.         GPIOA->CRH&=0XFFF0FFFF;
  23.         GPIOA->CRH|=0X00030000;        //PA12 推挽 WP
  24.       GPIOA->ODR|=1<<12;
  25.        
  26.       bsp_spi2_flash_writeSR(0x02);//使能状态寄存器写存储器
  27.       bsp_spi2_flash_cmdDbsy();
  28.        
  29.         g_spi_flash_ID=bsp_spi2_flash_readID();//读取FLASH ID.
  30.       
  31. }  
  32. void bsp_spi2_flash_cmdDbsy(void)
  33. {
  34.      SPI_FLASH_CS=0;
  35.      bsp_spi2_readWritebyte( SST25_DBSY);
  36.      SPI_FLASH_CS=1;   
  37. }
  38. //读取SPI_FLASH的状态寄存器
  39. //BIT7  6   5   4   3   2   1   0
  40. //SPR   RV  TB BP2 BP1 BP0 WEL BUSY
  41. //SPR:默认0,状态寄存器保护位,配合WP使用
  42. //TB,BP2,BP1,BP0:FLASH区域写保护设置
  43. //WEL:写使能锁定
  44. //BUSY:忙标记位(1,忙;0,空闲)
  45. //默认:0x00
  46. u8 bsp_spi2_flash_readSR(void)   
  47. {  
  48.         u8 byte=0;   
  49.         SPI_FLASH_CS=0;                            //使能器件   
  50.         bsp_spi2_readWritebyte(SST25_ReadStatusReg);    //发送读取状态寄存器命令   
  51.         byte=bsp_spi2_readWritebyte(0Xff);             //读取一个字节  
  52.         SPI_FLASH_CS=1;                            //取消片选     
  53.         return byte;   
  54. }

  55. //写SPI_FLASH状态寄存器
  56. //只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
  57. void bsp_spi2_flash_writeSR(u8 sr)   
  58. {   
  59.       SPI_FLASH_CS=0;
  60.         bsp_spi2_readWritebyte(SST25_WriteEnable);//使能写状态寄存器
  61.         SPI_FLASH_CS=1;                           //取消片选
  62.         SPI_FLASH_CS=0;                            //使能器件   
  63.         bsp_spi2_readWritebyte(SST25_WriteStatusReg);   //发送写取状态寄存器命令   
  64.         bsp_spi2_readWritebyte(sr);               //写入一个字节  
  65.         SPI_FLASH_CS=1;                            //取消片选                  
  66. }   

  67. //SPI_FLASH写使能       
  68. //将WEL置位   
  69. void bsp_spi2_flash_write_enable(void)   
  70. {
  71.         SPI_FLASH_CS=0;                            //使能器件   
  72.       bsp_spi2_readWritebyte(SST25_WriteEnable);      //发送写使能  
  73.         SPI_FLASH_CS=1;                            //取消片选                  
  74. }

  75. //SPI_FLASH写禁止       
  76. //将WEL清零  
  77. void bsp_spi2_flash_write_disable(void)   
  78. {  
  79.         SPI_FLASH_CS=0;                            //使能器件   
  80.       bsp_spi2_readWritebyte(SST25_WriteDisable);     //发送写禁止指令   
  81.         SPI_FLASH_CS=1;                            //取消片选                  
  82. }

  83. //读取芯片ID
  84. //返回值如下:                                  
  85. //0XEF13,表示芯片型号为W25Q80  
  86. //0XEF14,表示芯片型号为W25Q16   
  87. //0XEF15,表示芯片型号为W25Q32  
  88. //0XEF16,表示芯片型号为W25Q64  
  89. //0XBF41,表示芯片型号为25VF016B
  90. u16 bsp_spi2_flash_readID(void)
  91. {
  92.         u16 Temp = 0;          
  93.         SPI_FLASH_CS=0;                                          
  94.         bsp_spi2_readWritebyte(0x90);//发送读取ID命令            
  95.         bsp_spi2_readWritebyte(0x00);             
  96.         bsp_spi2_readWritebyte(0x00);             
  97.         bsp_spi2_readWritebyte(0x00);                                    
  98.         Temp|=bsp_spi2_readWritebyte(0xFF)<<8;  
  99.         Temp|=bsp_spi2_readWritebyte(0xFF);         
  100.         SPI_FLASH_CS=1;                                    
  101.         return Temp;
  102. }                  

  103. //读取SPI FLASH  
  104. //在指定地址开始读取指定长度的数据
  105. //pBuffer:数据存储区
  106. //ReadAddr:开始读取的地址(24bit)
  107. //NumByteToRead:要读取的字节数(最大65535)
  108. void bsp_spi2_flash_read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)   
  109. {
  110.     u16 i;                                                                                       
  111.     SPI_FLASH_CS=0;                            //使能器件   
  112.     bsp_spi2_readWritebyte(SST25_ReadData);         //发送读取命令   
  113.     bsp_spi2_readWritebyte((u8)((ReadAddr)>>16));  //发送24bit地址   
  114.     bsp_spi2_readWritebyte((u8)((ReadAddr)>>8));   
  115.     bsp_spi2_readWritebyte((u8)ReadAddr);   
  116.     for(i=0;i<NumByteToRead;i++)
  117.    {
  118.         pBuffer[i]=bsp_spi2_readWritebyte(0XFF);   //循环读数  
  119.     }
  120.     SPI_FLASH_CS=1;                                                   
  121. }  

  122. //SPI在一页(0~65535)内写入少于256个字节的数据
  123. //在指定地址开始写入最大256字节的数据
  124. //pBuffer:数据存储区
  125. //WriteAddr:开始写入的地址(24bit)
  126. //NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!         
  127. void bsp_spi2_flash_write_page(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
  128. {
  129.         u16 i;  
  130.     bsp_spi2_flash_write_enable();                  //SET WEL
  131.     SPI_FLASH_CS=0;                            //使能器件   
  132.     bsp_spi2_readWritebyte(SST25_ByteProgram);      //发送写页命令   
  133.     bsp_spi2_readWritebyte((u8)((WriteAddr)>>16)); //发送24bit地址   
  134.     bsp_spi2_readWritebyte((u8)((WriteAddr)>>8));   
  135.     bsp_spi2_readWritebyte((u8)WriteAddr);   
  136.     for(i=0;i<NumByteToWrite;i++)bsp_spi2_readWritebyte(pBuffer[i]);//循环写数  
  137.     SPI_FLASH_CS=1;                            //取消片选
  138.     bsp_spi2_flash_waitIdle();                                           //等待写入结束
  139. }
  140. #if 0
  141. //无检验写SPI FLASH
  142. //必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
  143. //具有自动换页功能
  144. //在指定地址开始写入指定长度的数据,但是要确保地址不越界!
  145. //pBuffer:数据存储区
  146. //WriteAddr:开始写入的地址(24bit)
  147. //NumByteToWrite:要写入的字节数(最大65535)
  148. //CHECK OK
  149. void SPI_Flash_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
  150. {                                           
  151.         u16 pageremain;          
  152.         pageremain=256-WriteAddr%256; //单页剩余的字节数                             
  153.         if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
  154.         while(1)
  155.         {          
  156.                 SPI_Flash_Write_Page(pBuffer,WriteAddr,pageremain);
  157.                 if(NumByteToWrite==pageremain)break;//写入结束了
  158.                  else //NumByteToWrite>pageremain
  159.                 {
  160.                         pBuffer+=pageremain;
  161.                         WriteAddr+=pageremain;       

  162.                         NumByteToWrite-=pageremain;                          //减去已经写入了的字节数
  163.                         if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
  164.                         else pageremain=NumByteToWrite;           //不够256个字节了
  165.                 }
  166.         };            
  167. }

  168. #endif
  169. /*
  170. **测试后不可用
  171. */
  172. void AutoAddressIncrement_WordProgramA(u8 Byte1, u8 Byte2, u32 Addr)  
  173. {  
  174.         bsp_spi2_flash_write_enable();  
  175.         SPI_FLASH_CS=0;  
  176.         bsp_spi2_readWritebyte(SST25_AAI_WordProgram);  
  177.   
  178. //输入所要写数据的起始地址  
  179.         bsp_spi2_readWritebyte((Addr & 0xFF0000) >> 16);  
  180.         bsp_spi2_readWritebyte((Addr & 0xFF00) >> 8);  
  181.         bsp_spi2_readWritebyte(Addr & 0xFF);                                  //发送最初的两个数据  
  182.         bsp_spi2_readWritebyte(Byte1);  
  183.         bsp_spi2_readWritebyte(Byte2);  
  184.         SPI_FLASH_CS=1;  
  185.         bsp_spi2_flash_waitIdle();  
  186. }  
  187. //地址自动增加的写数据B  
  188. void AutoAddressIncrement_WordProgramB(u8 state,u8 Byte1, u8 Byte2)  
  189. {  
  190.       bsp_spi2_flash_write_enable();
  191.       SPI_FLASH_CS=0;  
  192.       bsp_spi2_readWritebyte(SST25_AAI_WordProgram);  
  193.       bsp_spi2_readWritebyte(Byte1);  
  194.       bsp_spi2_readWritebyte(Byte2);  
  195.       SPI_FLASH_CS=1;  
  196.       bsp_spi2_flash_waitIdle();  
  197.       if(state==1)  
  198.      {  
  199.           bsp_spi2_flash_write_disable();  
  200.      }  
  201.       bsp_spi2_flash_waitIdle();  
  202. }  
  203. #if 0
  204. //写SPI FLASH  
  205. //在指定地址开始写入指定长度的数据
  206. //该函数带擦除操作!
  207. //pBuffer:数据存储区
  208. //WriteAddr:开始写入的地址(24bit)                                               
  209. //NumByteToWrite:要写入的字节数(最大65535)   
  210. u8 SPI_FLASH_BUFFER[4096];                 
  211. void bsp_spi2_flash_write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
  212. {
  213.         u32 secpos;
  214.         u16 secoff;
  215.         u16 secremain;          
  216.         u16 i;   
  217.         u8 * SPI_FLASH_BUF;          
  218.            SPI_FLASH_BUF=SPI_FLASH_BUFFER;             
  219.         secpos=WriteAddr/4096;//扇区地址  
  220.         secoff=WriteAddr%4096;//在扇区内的偏移
  221.         secremain=4096-secoff;//扇区剩余空间大小   
  222.         //printf("ad:%X,nb:%X ",WriteAddr,NumByteToWrite);//测试用
  223.         if(NumByteToWrite<=secremain)secremain=NumByteToWrite;//不大于4096个字节
  224.         while(1)
  225.         {       
  226.                 SPI_Flash_Read(SPI_FLASH_BUF,secpos*4096,4096);//读出整个扇区的内容
  227.                 for(i=0;i<secremain;i++)//校验数据
  228.                 {
  229.                         if(SPI_FLASH_BUF[secoff+i]!=0XFF)break;//需要擦除            
  230.                 }
  231.                 if(i<secremain)//需要擦除
  232.                 {
  233.                         SPI_Flash_Erase_Sector(secpos);//擦除这个扇区
  234.                         for(i=0;i<secremain;i++)           //复制
  235.                         {
  236.                                 SPI_FLASH_BUF[i+secoff]=pBuffer[i];          
  237.                         }
  238.                         SPI_Flash_Write_NoCheck(SPI_FLASH_BUF,secpos*4096,4096);//写入整个扇区  

  239.                 }else SPI_Flash_Write_NoCheck(pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间.                                   
  240.                 if(NumByteToWrite==secremain)break;//写入结束了
  241.                 else//写入未结束
  242.                 {
  243.                         secpos++;//扇区地址增1
  244.                         secoff=0;//偏移位置为0          

  245.                            pBuffer+=secremain;  //指针偏移
  246.                         WriteAddr+=secremain;//写地址偏移          
  247.                            NumByteToWrite-=secremain;                                //字节数递减
  248.                         if(NumByteToWrite>4096)secremain=4096;        //下一个扇区还是写不完
  249.                         else secremain=NumByteToWrite;                        //下一个扇区可以写完了
  250.                 }         
  251.         };         
  252. }

  253. //擦除整个芯片                  
  254. //等待时间超长...
  255. void SPI_Flash_Erase_Chip(void)   
  256. {                                   
  257.     SPI_FLASH_Write_Enable();                  //SET WEL
  258.     SPI_Flash_Wait_Busy();   
  259.     SPI_FLASH_CS=0;                            //使能器件   
  260.     bsp_spi2_readWritebyte(W25X_ChipErase);        //发送片擦除命令  
  261.     SPI_FLASH_CS=1;                            //取消片选                  
  262.     SPI_Flash_Wait_Busy();                                      //等待芯片擦除结束
  263. }   
  264. //擦除一个扇区
  265. //Dst_Addr:扇区地址 根据实际容量设置
  266. //擦除一个山区的最少时间:150ms
  267. void SPI_Flash_Erase_Sector(u32 Dst_Addr)   
  268. {  
  269.         //监视falsh擦除情况,测试用   
  270.     printf("fe:%x ",Dst_Addr);          
  271.     Dst_Addr*=4096;
  272.     SPI_FLASH_Write_Enable();                  //SET WEL          
  273.     SPI_Flash_Wait_Busy();   
  274.     SPI_FLASH_CS=0;                            //使能器件   
  275.     bsp_spi2_readWritebyte(W25X_SectorErase);      //发送扇区擦除指令
  276.     bsp_spi2_readWritebyte((u8)((Dst_Addr)>>16));  //发送24bit地址   
  277.     bsp_spi2_readWritebyte((u8)((Dst_Addr)>>8));   
  278.     bsp_spi2_readWritebyte((u8)Dst_Addr);  
  279.     SPI_FLASH_CS=1;                            //取消片选                  
  280.     SPI_Flash_Wait_Busy();                                      //等待擦除完成
  281. }  
  282. #endif
  283. //等待空闲
  284. void bsp_spi2_flash_waitIdle(void)   
  285. {   
  286.         while((bsp_spi2_flash_readSR()&0x01)==0x01)
  287.         {
  288.               bsp_watchDog_reload();
  289.         };   // 等待BUSY位清空
  290. }  
  291. #if 0
  292. //进入掉电模式
  293. void SPI_Flash_PowerDown(void)   
  294. { [code]#include "spi.h"


  295. //以下是SPI模块的初始化代码,配置成主机模式,访问SD Card/W25Q64/NRF24L01                                                  
  296. //SPI口初始化
  297. //这里针是对SPI2的初始化
  298. void bsp_spi2_init(void)
  299. {         
  300.         RCC->APB2ENR|=1<<3;          //PORTB时钟使能          
  301.         RCC->APB1ENR|=1<<14;           //SPI2时钟使能
  302.         //这里只针对SPI口初始化
  303.         GPIOB->CRH&=0X000FFFFF;
  304.         GPIOB->CRH|=0XBBB00000;        //PB13/14/15复用             
  305.         GPIOB->ODR|=0X7<<13;           //PB13/14/15上拉
  306.         SPI2->CR1|=0<<10;                //全双工模式       
  307.         SPI2->CR1|=1<<9;                 //软件nss管理
  308.         SPI2->CR1|=1<<8;  

  309.         bsp_watchDog_reload();
  310.         SPI2->CR1|=1<<2;                 //SPI主机
  311.         SPI2->CR1|=0<<11;                //8bit数据格式       
  312.         SPI2->CR1|=1<<1;                 //空闲模式下SCK为1 CPOL=1
  313.         SPI2->CR1|=1<<0;                 //数据采样从第二个时间边沿开始,CPHA=1  
  314.         //对SPI2属于APB1的外设.时钟频率最大为36M.
  315.         SPI2->CR1|=3<<3;                 //Fsck=Fpclk1/256
  316.         SPI2->CR1|=0<<7;                 //MSBfirst   
  317.         SPI2->CR1|=1<<6;                 //SPI设备使能
  318.         bsp_spi2_readWritebyte(0xff);//启动传输                 

  319.         bsp_spi2_setSpeed(SPI_SPEED_2);//设置为18M时钟,高速模式
  320. }   
  321. //SPI2速度设置函数
  322. //SpeedSet:0~7
  323. //SPI速度=fAPB1/2^(SpeedSet+1)
  324. //APB1时钟一般为36Mhz
  325. void bsp_spi2_setSpeed(u8 SpeedSet)
  326. {
  327.         SpeedSet&=0X07;                        //限制范围
  328.         SPI2->CR1&=0XFFC7;
  329.         SPI2->CR1|=SpeedSet<<3;        //设置SPI2速度  
  330.         SPI2->CR1|=1<<6;                 //SPI设备使能          
  331. }
  332. //SPI2 读写一个字节
  333. //TxData:要写入的字节
  334. //返回值:读取到的字节
  335. u8 bsp_spi2_readWritebyte(u8 TxData)
  336. {               
  337.         u16 retry=0;               
  338.        
  339.         while((SPI2->SR&1<<1)==0)                //等待发送区空       
  340.         {
  341.                 retry++;
  342.                 if(retry>=0XFFFE)return 0;         //超时退出
  343.                 bsp_watchDog_reload();
  344.         }                          
  345.         SPI2->DR=TxData;                                   //发送一个byte
  346.         retry=0;
  347.         while((SPI2->SR&1<<0)==0)                 //等待接收完一个byte  
  348.         {
  349.                 retry++;
  350.                 if(retry>=0XFFFE)return 0;        //超时退出
  351.                 bsp_watchDog_reload();
  352.         }                                                              
  353.         return SPI2->DR;                          //返回收到的数据                                    
  354. }




复制代码
          SPI_FLASH_CS=0;                            //使能器件   
      bsp_spi2_readWritebyte(W25X_PowerDown);        //发送掉电命令  
        SPI_FLASH_CS=1;                            //取消片选                  
      delay_us(3);                               //等待TPD  
}   
//唤醒
void SPI_Flash_WAKEUP(void)   
{  
          SPI_FLASH_CS=0;                            //使能器件   
      bsp_spi2_readWritebyte(W25X_ReleasePowerDown);   //  send W25X_PowerDown command 0xAB   
        SPI_FLASH_CS=1;                            //取消片选                  
       delay_us(3);                               //等待TRES1
}   


#endif[/code]
  1. #ifndef __FLASH_H
  2. #define __FLASH_H                            
  3. #include "bsp.h"
  4. //////////////////////////////////////////////////////////////////////////////////         
  5. //本程序只供学习使用,未经作者许可,不得用于其它任何用途
  6. //ALIENTEK战舰STM32开发板
  7. //W25Q64 代码          
  8. //正点原子@ALIENTEK
  9. //技术论坛:www.openedv.com
  10. //修改日期:2012/9/9
  11. //版本:V1.0
  12. //版权所有,盗版必究。
  13. //Copyright(C) 广州市星翼电子科技有限公司 2009-2019
  14. //All rights reserved                                                                          
  15. //////////////////////////////////////////////////////////////////////////////////

  16. //W25X系列/Q系列芯片列表          
  17. //W25Q80 ID  0XEF13
  18. //W25Q16 ID  0XEF14
  19. //W25Q32 ID  0XEF15
  20. //W25Q32 ID  0XEF16       
  21. #define W25Q80         0XEF13        
  22. #define W25Q16         0XEF14
  23. #define W25Q32         0XEF15
  24. #define W25Q64         0XEF16

  25. extern u16 g_spi_flash_ID;                //定义我们使用的flash芯片型号                  
  26. #define        SPI_FLASH_CS PBout(12)  //选中FLASH       
  27. #define   SPI_FLASH_WP PAout(12) //FLASH读保护
  28.                                  
  29. ////////////////////////////////////////////////////////////////////////////

  30. //指令表

  31. #define SST25_ReadData                        0x03
  32. #define SST25_FastReadData                 0x0B
  33. #define SST25_4KByte_BlockERASE        0x20
  34. #define SST25_32KByte_BlockErase       0x52
  35. #define SST25_64KByte_BlockErase       0xD8
  36. #define SST25_ChipErase                      0xC7
  37. #define SST25_ByteProgram                  0x02
  38. #define SST25_AAI_WordProgram          0xAD
  39. #define SST25_ReadStatusReg               0x05
  40. #define SST25_EnableWriteStatusReg     0x50
  41. #define SST25_WriteStatusReg              0x01
  42. #define SST25_WriteEnable                   0x06
  43. #define SST25_WriteDisable                  0x04
  44. #define SST25_ManufactDeviceID          0x90
  45. #define SST25_JedecDeviceID               0x9F
  46. #define SST25_EBSY                             0x70
  47. #define SST25_DBSY                             0x80


  48. void bsp_flash_init(void);
  49. void bsp_spi2_flash_cmdDbsy(void);
  50. u16 bsp_spi2_flash_readID(void);             //读取FLASH ID
  51. u8 bsp_spi2_flash_readSR(void) ;        //读取状态寄存器
  52. void bsp_spi2_flash_writeSR(u8 sr);            //写状态寄存器
  53. void bsp_spi2_flash_write_enable(void);  //写使能
  54. void bsp_spi2_flash_write_disable(void);        //写失能
  55. void AutoAddressIncrement_WordProgramA(u8 Byte1, u8 Byte2, u32 Addr) ;//地址自动增加写A
  56. void AutoAddressIncrement_WordProgramB(u8 state,u8 Byte1, u8 Byte2) ;//地址自动增加写B
  57. void SPI_Flash_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);
  58. void bsp_spi2_flash_read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead);      //读取flash
  59. void bsp_spi2_flash_write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);   //写入flash
  60. void bsp_spi2_flash_write_page(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);//页内写<256
  61. void SPI_Flash_Erase_Chip(void);              //整片擦除
  62. void SPI_Flash_Erase_Sector(u32 Dst_Addr);//扇区擦除
  63. void bsp_spi2_flash_waitIdle(void);      //等待空闲
  64. void SPI_Flash_PowerDown(void);           //进入掉电模式
  65. void SPI_Flash_WAKEUP(void);                          //唤醒

  66. #endif







复制代码
友情提示: 此问题已得到解决,问题已经关闭,关闭后问题禁止继续编辑,回答。
该问题目前已经被作者或者管理员关闭, 无法添加新回复
9条回答
霸气侧漏
1楼-- · 2019-12-24 08:28
现在也是读出来全是0xFF  有没有驱动
磊磊映画
2楼-- · 2019-12-24 10:33
霸气侧漏 发表于 2017-9-13 17:12
现在也是读出来全是0xFF  有没有驱动

贴的代码就是驱动啊
smilepppp
3楼-- · 2019-12-24 15:39
flash初始状态不就是全是ff吗,你可以试着先擦除 在写入,擦除写入之前需要关闭写保护

一周热门 更多>