前些天淘宝购得30只w25q64fviq芯片,1.9元/只.直接替换掉原来红牛板上的SST25VF016B,花了些功夫终于成功了.
例子是将BMP图片写入SPI_Flash中,再读取SPI_Flash中的图片显示在LCD屏上,由于之前是2M_Byte,现在是8M_Byte,想测试一下8M空间,于是改写了测试程序.
方案是:
        首先将Flash写入地址定义到0页的0x000000,擦除写入230454 Byte的图片,读出显示.
然后首地址按4KB增加,循环擦除写入230454 Byte的图片,读出显示.

擦除程序会根据写入数据的大小计算,采用最佳方式来擦除(64K,32K,4K).
        由于BMP图片大小是:        230454 Byte,按最小4K擦除块方式,需要擦除228K的空间.
按最佳方案应该是:228K = 3次*64K擦除 + 1次*32K擦除 +1次*4K擦除.
结果现在问题来了:
        图片第一次擦除写入读出显示没有问题,接着第二次以后的会出现图片花屏现象,而且多出现在后半屏花屏,
已经确定是没有正常擦除造成的,于是在擦除子程序中取消了64K,32K的擦除操作,只采用4K擦除方式.结果正常.
经反复验证,无论是64K+4K擦除方案或是32K+4K擦除方案,都不正常.

不知道有没有人遇到过这样的问题,特来请教一下是那里出了问题???


3.png (340.79 KB, 下载次数: 0) 下载附件 2016-4-22 04:23 上传

1. /*******************************************************************************
   
2. * Function Name  : SSTF016B_WR
   
3. * Description    : SST25VF016B的写函数，可写1个和多个数据到指定地址
   
4. * Input          : - Dst: 目标地址,范围 0x0 - MAX_ADDR（MAX_ADDR = 0x1FFFFF）
   
5. *                  - SndbufPt: 发送缓存区指针
   
6. *                  - NByte: 要写的数据字节数
   
7. * Output         : None
   
8. * Return         : 操作成功则返回OK,失败则返回ERROR
   
9. * Attention                 : 若某功能下,某一入口参数无效,可在该入口参数处填Invalid，该参数将被忽略
   
10. *******************************************************************************/
    
11. uint8_t SSTF016B_WR(uint32_t Dst, uint8_t* SndbufPt,uint32_t NByte)
    
12. {
    
13. //        uint8_t temp = 0,temp1 = 0,StatRgVal = 0;//
    
14.         uint32_t i = 0;
    
15.         //------------------------------------------------------------------------------------------
    
16.         if (( (Dst+NByte-1 > MAX_ADDR)||(NByte == 0) ))
    
17.         {
    
18.                 return (ERROR);         /*        检查入口参数 */
    
19.         }
    
20.         //------------------------------------------------------------------------------------------
    
21. 
    
22.         #if 0        //--取消下面的读取状态寄存器操作
    
23.         SPI_FLASH_CS_LOW();                                 
    
24.         Flash_ReadWriteByte(0x05);                                                            /* 发送读状态寄存器1命令        */
    
25.         temp = Flash_ReadWriteByte(0xFF);                                            /* 保存读得的状态寄存器值 */
    
26.         SPI_FLASH_CS_HIGH();
    
27. 
    
28.         SPI_FLASH_CS_LOW();                                 
    
29.         Flash_ReadWriteByte(0x35);                                                            /* 发送读状态寄存器2命令        */
    
30.         temp1 = Flash_ReadWriteByte(0xFF);                                            /* 保存读得的状态寄存器值 */
    
31.         SPI_FLASH_CS_HIGH();       
    
32. 
    
33.         SPI_FLASH_CS_LOW();                               
    
34.         Flash_ReadWriteByte(0x50);                                                            /* 使状态寄存器可写        */
    
35.         SPI_FLASH_CS_HIGH();       
    
36.                
    
37.         SPI_FLASH_CS_LOW();                               
    
38.         Flash_ReadWriteByte(0x01);                                                            /* 发送写状态寄存器指令 */
    
39.         Flash_ReadWriteByte(0);                                                                    /* 清0BPx位，使Flash芯片全区可写 */
    
40.         Flash_ReadWriteByte(temp1);                                                                /* 清0BPx位，使Flash芯片全区可写 */
    
41.         SPI_FLASH_CS_HIGH();
    
42.        
    
43.         SPI_FLASH_WaitForWriteEnd();                                              /* 一直等待，直到芯片空闲        */                       
    
44.         #endif
    
45.        
    
46.         //------------------------------------------------------------------------------------------
    
47.         for(i = 0; i < NByte; i++)
    
48.         {
    
49.                 SPI_FLASH_CS_LOW();                               
    
50.                 Flash_ReadWriteByte(0x06);                                                    /* 发送写使能命令 */
    
51.                 SPI_FLASH_CS_HIGH();                       
    
52. 
    
53.                 SPI_FLASH_CS_LOW();                                       
    
54.                 Flash_ReadWriteByte(0x02);                                                     /* 发送字节数据烧写命令        */
    
55.                 Flash_ReadWriteByte((((Dst+i) & 0xFFFFFF) >> 16));  /* 发送3个字节的地址信息 */
    
56.                 Flash_ReadWriteByte((((Dst+i) & 0xFFFF) >> 8));
    
57.                 Flash_ReadWriteByte((Dst+i) & 0xFF);
    
58.                 Flash_ReadWriteByte(SndbufPt[i]);                                        /* 发送被烧写的数据        */
    
59.                 SPI_FLASH_CS_HIGH();                       
    
60.                 SPI_FLASH_WaitForWriteEnd();                                              /* 一直等待，直到芯片空闲        */       
    
61.         }
    
62.         //------------------------------------------------------------------------------------------
    
63.         #if 0        //--取消下面的恢复状态寄存器操作
    
64.         SPI_FLASH_CS_LOW();                                       
    
65.         Flash_ReadWriteByte(0x06);                                                            /* 发送写使能命令 */
    
66.         SPI_FLASH_CS_HIGH();                       
    
67. 
    
68.         SPI_FLASH_CS_LOW();                                       
    
69.         Flash_ReadWriteByte(0x50);                                                            /* 使状态寄存器可写        */
    
70.         SPI_FLASH_CS_HIGH();
    
71.                        
    
72.         SPI_FLASH_CS_LOW();                               
    
73.         Flash_ReadWriteByte(0x01);                                                            /* 发送写状态寄存器指令 */
    
74.         Flash_ReadWriteByte(temp);                                                             /* 恢复状态寄存器设置信息 */
    
75.         Flash_ReadWriteByte(temp1);                                                             /* 恢复状态寄存器设置信息 */
    
76.         SPI_FLASH_CS_HIGH();
    
77.         SPI_FLASH_WaitForWriteEnd();                                              /* 一直等待，直到芯片空闲        */       
    
78.         #endif
    
79.         //------------------------------------------------------------------------------------------
    
80. 
    
81.         return (ENABLE);               
    
82. }

复制代码

1. <p>/*******************************************************************************
   
2. * Function Name  : SSTF016B_Erase
   
3. * Description    : 根据指定的扇区号选取最高效的算法擦除
   
4. * Input          : - sec1: 起始扇区号,范围(0~511)
   
5. *                  - sec2: 终止扇区号,范围(0~511)
   
6. * Output         : None
   
7. * Return         : 操作成功则返回OK,失败则返回ERROR
   
8. * Attention                 : None
   
9. *******************************************************************************/
   
10. uint8_t SSTF016B_Erase(uint32_t sec1, uint32_t sec2)
    
11. {
    
12.         uint8_t  ErCount,temp2 = 0;
    
13. //        uint8_t  temp0 = 0,temp1 = 0;//
    
14.     uint32_t sectorStartAddr = 0;                                 
    
15.         uint32_t sectorNumber = 0;                                                               /* 要擦除的扇区数目 */
    
16.         uint32_t CurSecNumber = 0;                                                              /* 当前要擦除的扇区号 */
    
17.        
    
18.         /*  检查入口参数 */
    
19.         if ((sec1 > SEC_MAX)||(sec2 > SEC_MAX))       
    
20.         {
    
21.                 return (ERROR);       
    
22.         }
    
23.         //------------------------------------------------------------------------------------------
    
24.            #if 0        //--取消下面的读取状态寄存器操作
    
25.            SPI_FLASH_CS_LOW();                         
    
26.         Flash_ReadWriteByte(0x05);                                                                /* 发送读状态寄存器1命令        */
    
27.         temp0 = Flash_ReadWriteByte(0xFF);                                                /* 保存读得的状态寄存器值 */
    
28.         SPI_FLASH_CS_HIGH();
    
29. 
    
30.            SPI_FLASH_CS_LOW();                         
    
31.         Flash_ReadWriteByte(0x35);                                                                /* 发送读状态寄存器2命令        */
    
32.         temp1 = Flash_ReadWriteByte(0xFF);                                                /* 保存读得的状态寄存器值 */
    
33.         SPI_FLASH_CS_HIGH();       
    
34. 
    
35.         SPI_FLASH_CS_LOW();                       
    
36.         Flash_ReadWriteByte(0x50);                                                                /* 使状态寄存器可写        */
    
37.         SPI_FLASH_CS_HIGH();                       
    
38. 
    
39.         SPI_FLASH_CS_LOW();                                                                         
    
40.         Flash_ReadWriteByte(0x01);                                                                /* 发送写状态寄存器指令        */
    
41.         Flash_ReadWriteByte(0);                                                                        /* 清0BPx位，使Flash芯片全区可写 */
    
42.         Flash_ReadWriteByte(temp1);                                                                /* 清0BPx位，使Flash芯片全区可写 */
    
43.         SPI_FLASH_CS_HIGH();
    
44.        
    
45.         SPI_FLASH_CS_LOW();                       
    
46.         Flash_ReadWriteByte(0x06);                                                                /* 发送写使能命令 */
    
47.         SPI_FLASH_CS_HIGH();
    
48.         SPI_FLASH_WaitForWriteEnd();                                              /* 一直等待，直到芯片空闲        */                               
    
49.         #endif
    
50.         //------------------------------------------------------------------------------------------
    
51.         /* 如果用户输入的起始扇区号大于终止扇区号，则在内部作出调整 */
    
52.         if (sec1 > sec2)
    
53.         {
    
54.            temp2 = sec1;
    
55.            sec1  = sec2;
    
56.            sec2  = temp2;
    
57.         }
    
58.         /* 若起止扇区号相等则擦除单个扇区 */
    
59.         if (sec1 == sec2)       
    
60.         {
    
61.                 SPI_FLASH_CS_LOW();                               
    
62.                 Flash_ReadWriteByte(0x06);                                                    /* 发送写使能命令 */
    
63.                 SPI_FLASH_CS_HIGH();                       
    
64. 
    
65.             sectorStartAddr = SEC_SIZE * sec1;                                          /* 计算扇区的起始地址        */
    
66.             SPI_FLASH_CS_LOW();       
    
67.             Flash_ReadWriteByte(0x20);                                                                          /* 发送扇区擦除指令 */
    
68.             Flash_ReadWriteByte(((sectorStartAddr & 0xFFFFFF) >> 16)); /* 发送3个字节的地址信息 */
    
69.                    Flash_ReadWriteByte(((sectorStartAddr & 0xFFFF) >> 8));
    
70.                    Flash_ReadWriteByte(sectorStartAddr & 0xFF);
    
71.                   SPI_FLASH_CS_HIGH();
    
72.                 SPI_FLASH_WaitForWriteEnd();                                              /* 一直等待，直到芯片空闲        */       
    
73.                 return (ENABLE);                       
    
74.         }
    
75.         //------------------------------------------------------------------------------------------
    
76.        
    
77.     /* 根据起始扇区和终止扇区间距调用最快速的擦除功能 */       
    
78.        
    
79.         if (sec2 - sec1 == SEC_MAX)       
    
80.         {
    
81.                 SPI_FLASH_CS_LOW();                               
    
82.                 Flash_ReadWriteByte(0x06);                                                    /* 发送写使能命令 */
    
83.                 SPI_FLASH_CS_HIGH();
    
84.                
    
85.                 SPI_FLASH_CS_LOW();                       
    
86.                 Flash_ReadWriteByte(0xC7);                                                          /* 发送芯片擦除指令(60h or C7h) */
    
87.                 SPI_FLASH_CS_HIGH();               
    
88.                 SPI_FLASH_WaitForWriteEnd();                                              /* 一直等待，直到芯片空闲        */       
    
89.                    return (ENABLE);
    
90.         }
    
91.        
    
92.         sectorNumber = sec2 - sec1 +1;                                                  /* 获取要擦除的扇区数目 */
    
93.         CurSecNumber  = sec1;                                                                      /* 从起始扇区开始擦除        */
    
94.         GUI_IntegerText(10,55,CurSecNumber);
    
95.         //------------------------------------------------------------------------------------------
    
96.         #if 1
    
97.         /* 若两个扇区之间的间隔够大，则采取8扇区擦除算法 */
    
98.         ErCount = 0;
    
99.         while (sectorNumber >= 16)
    
100.         {
     
101.                 SPI_FLASH_CS_LOW();                               
     
102.                 Flash_ReadWriteByte(0x06);                                                    /* 发送写使能命令 */
     
103.                 SPI_FLASH_CS_HIGH();                       
     
104. 
     
105.             sectorStartAddr = SEC_SIZE * CurSecNumber;                          /* 计算扇区的起始地址 */
     
106.             SPI_FLASH_CS_LOW();       
     
107.             Flash_ReadWriteByte(0xd8);                                                          /* 发送64KB擦除指令 */
     
108.             Flash_ReadWriteByte(((sectorStartAddr & 0xFFFFFF) >> 16)); /* 发送3个字节的地址信息 */
     
109.                    Flash_ReadWriteByte(((sectorStartAddr & 0xFFFF) >> 8));
     
110.                    Flash_ReadWriteByte(sectorStartAddr & 0xFF);
     
111.                   SPI_FLASH_CS_HIGH();       
     
112.                 SPI_FLASH_WaitForWriteEnd();                                              /* 一直等待，直到芯片空闲        */       
     
113.                 CurSecNumber  += 16;
     
114.                 sectorNumber -=  16;
     
115.                 GUI_IntegerText(59,55,++ErCount);
     
116.         }
     
117.         #endif
     
118.         //------------------------------------------------------------------------------------------
     
119.         #if 1
     
120.         /* 若两个扇区之间的间隔够大，则采取8扇区擦除算法 */
     
121.         ErCount = 0;
     
122.         while (sectorNumber >= 8)
     
123.         {
     
124.                 SPI_FLASH_CS_LOW();                               
     
125.                 Flash_ReadWriteByte(0x06);                                                    /* 发送写使能命令 */
     
126.                 SPI_FLASH_CS_HIGH();                       
     
127. 
     
128.             sectorStartAddr = SEC_SIZE * CurSecNumber;                                  /* 计算扇区的起始地址 */
     
129.             SPI_FLASH_CS_LOW();       
     
130.             Flash_ReadWriteByte(0x52);                                                          /* 发送32KB擦除指令 */
     
131.             Flash_ReadWriteByte(((sectorStartAddr & 0xFFFFFF) >> 16)); /* 发送3个字节的地址信息 */
     
132.                    Flash_ReadWriteByte(((sectorStartAddr & 0xFFFF) >> 8));
     
133.                    Flash_ReadWriteByte(sectorStartAddr & 0xFF);
     
134.                   SPI_FLASH_CS_HIGH();       
     
135.                 SPI_FLASH_WaitForWriteEnd();                                              /* 一直等待，直到芯片空闲        */       
     
136.                 CurSecNumber  += 8;
     
137.                 sectorNumber -=  8;
     
138.                 GUI_IntegerText(114,55,++ErCount);
     
139.         }
     
140.         #endif
     
141.         //------------------------------------------------------------------------------------------
     
142.         /* 采用扇区擦除算法擦除剩余的扇区 */
     
143.         ErCount = 0;
     
144.         while (sectorNumber >= 1)
     
145.         {
     
146.                 SPI_FLASH_CS_LOW();                               
     
147.                 Flash_ReadWriteByte(0x06);                                                    /* 发送写使能命令 */
     
148.                 SPI_FLASH_CS_HIGH();                       
     
149. 
     
150.             sectorStartAddr = SEC_SIZE * CurSecNumber;                                  /* 计算扇区的起始地址 */
     
151.             SPI_FLASH_CS_LOW();       
     
152.             Flash_ReadWriteByte(0x20);                                                          /* 发送4K扇区擦除指令 */
     
153.             Flash_ReadWriteByte(((sectorStartAddr & 0xFFFFFF) >> 16)); /* 发送3个字节的地址信息 */
     
154.                    Flash_ReadWriteByte(((sectorStartAddr & 0xFFFF) >> 8));
     
155.                    Flash_ReadWriteByte(sectorStartAddr & 0xFF);
     
156.                   SPI_FLASH_CS_HIGH();
     
157.                 SPI_FLASH_WaitForWriteEnd();                                              /* 一直等待，直到芯片空闲        */       
     
158.                 CurSecNumber  += 1;
     
159.                 sectorNumber -=  1;
     
160.                 GUI_IntegerText(170,55,++ErCount);
     
161.         }
     
162.         //------------------------------------------------------------------------------------------
     
163.         #if 0        //--取消下面的恢复状态寄存器操作
     
164.        
     
165.     /* 擦除结束,恢复状态寄存器信息 */
     
166.         SPI_FLASH_CS_LOW();                       
     
167.         Flash_ReadWriteByte(0x06);                                                                  /* 发送写使能命令 */
     
168.         SPI_FLASH_CS_HIGH();                       
     
169. 
     
170.         SPI_FLASH_CS_LOW();                       
     
171.         Flash_ReadWriteByte(0x50);                                                                  /* 使状态寄存器可写 */
     
172.         SPI_FLASH_CS_HIGH();
     
173.        
     
174.         SPI_FLASH_CS_LOW();                       
     
175.         Flash_ReadWriteByte(0x01);                                                                  /* 发送写状态寄存器指令 */
     
176.         Flash_ReadWriteByte(temp0);                                                                  /* 恢复状态寄存器设置信息 */
     
177.         Flash_ReadWriteByte(temp1);                                                                  /* 恢复状态寄存器设置信息 */
     
178.         SPI_FLASH_CS_HIGH();
     
179.         SPI_FLASH_WaitForWriteEnd();                                              /* 一直等待，直到芯片空闲        */         
     
180.         #endif  
     
181.         //------------------------------------------------------------------------------------------
     
182.         return (ENABLE);
     
183. }</p><p>
     
184. </p><p>
     
185. </p><p>
     
186. </p>

复制代码