标题: 单片机读写SD卡数据为什么发生变异(左移一位)附源码+图 [打印本页]

---

作者: zxwdown    时间: 2018-12-13 07:13
标题: 单片机读写SD卡数据为什么发生变异(左移一位)附源码+图
    本人想对SD卡进行简单读写操作，就对一个扇区写入数据，然后读出来。可是却碰到一个奇怪的问题，本人以SPI方式读写SD卡，在复位，初始化等过程都正常，但在对一个扇区写入数据时，在写入扇区写命令并得到SD卡正确的0回应后，随后写入的数据都发生变化，所有数据都左移一位，相当于所有数据都乘2。读数据倒正常。为了验正本人的SPI读写函数正确，特地在SD卡读写前先进行对SPI存储芯片25AA010A的读写测试，证明可以对25AA010A芯片正常写入16字节数据，也能正常读出数据。但对SD卡却出现奇怪现象，请高手指点问题出在哪。


这是本人的原理图：

这是终端显示情况：


SPI存储芯片写入内存图：



SPI终端监视图：


















以下是程序：

1. #include<reg52.h>
   
2. sbit SD_SCL=P3^5;
   
3. sbit SD_SI=P3^6;
   
4. sbit SD_SO=P3^7;
   
5. sbit SD_CS=P3^4;
   
6. 
   
7. 
   
8. #define DELAY_TIME 100
   
9. #define TryNum 127
   
10. 
    
11. 
    
12. #define INIT_CMD0_ERROR 0x01
    
13. #define INIT_CMD1_ERROR 0x02
    
14. #define WRITE_BLOCK_ERROR 0x03
    
15. #define READ_BLOCK_ERROR 0x04
    
16. 
    
17. 
    
18. unsigned char waitnum;
    
19. 
    
20. 
    
21. #define uint unsigned int
    
22. #define uchar unsigned char
    
23. 
    
24. 
    
25. void delay(int i)
    
26. {int x;
    
27. for(x=0;x<i;x++);
    
28. }
    
29. //==============================================================
    
30. unsigned char bdata _dat;
    
31. sbit _dat7=_dat^7;
    
32. sbit _dat6=_dat^6;
    
33. sbit _dat5=_dat^5;
    
34. sbit _dat4=_dat^4;
    
35. sbit _dat3=_dat^3;
    
36. sbit _dat2=_dat^2;
    
37. sbit _dat1=_dat^1;
    
38. sbit _dat0=_dat^0;
    
39. 
    
40. 
    
41. void SD_spi_write(unsigned char x)
    
42. {_dat=x;
    
43. SD_SI=_dat7;
    
44. SD_SCL=0;
    
45. delay(waitnum);
    
46. SD_SCL=1;
    
47. delay(waitnum);
    
48. 
    
49. SD_SI=_dat6;
    
50. SD_SCL=0;
    
51. delay(waitnum);
    
52. SD_SCL=1;
    
53. delay(waitnum);
    
54. 
    
55. 
    
56. SD_SI=_dat5;
    
57. SD_SCL=0;
    
58. delay(waitnum);
    
59. SD_SCL=1;
    
60. delay(waitnum);
    
61. 
    
62. SD_SI=_dat4;
    
63. SD_SCL=0;
    
64. delay(waitnum);
    
65. SD_SCL=1;
    
66. delay(waitnum);
    
67. 
    
68. SD_SI=_dat3;
    
69. SD_SCL=0;
    
70. delay(waitnum);
    
71. SD_SCL=1;
    
72. delay(waitnum);
    
73. 
    
74. SD_SI=_dat2;
    
75. SD_SCL=0;
    
76. delay(waitnum);
    
77. SD_SCL=1;
    
78. delay(waitnum);
    
79. 
    
80. SD_SI=_dat1;
    
81. SD_SCL=0;
    
82. delay(waitnum);
    
83. SD_SCL=1;
    
84. delay(waitnum);
    
85. 
    
86. SD_SI=_dat0;
    
87. SD_SCL=0;
    
88. delay(waitnum);
    
89. SD_SCL=1;
    
90. delay(waitnum);
    
91. }
    
92. unsigned char SD_spi_read()
    
93. {SD_SO=1;
    
94. SD_SCL=1;
    
95. delay(waitnum);
    
96. SD_SCL=0;
    
97. delay(waitnum);
    
98. _dat7=SD_SO;
    
99. 
    
100. SD_SCL=1;
     
101. delay(waitnum);
     
102. SD_SCL=0;
     
103. delay(waitnum);
     
104. _dat6=SD_SO;
     
105. 
     
106. SD_SCL=1;
     
107. delay(waitnum);
     
108. SD_SCL=0;
     
109. delay(waitnum);
     
110. _dat5=SD_SO;
     
111. SD_SCL=1;
     
112. delay(waitnum);
     
113. SD_SCL=0;
     
114. delay(waitnum);
     
115. _dat4=SD_SO;
     
116. 
     
117. SD_SCL=1;
     
118. delay(waitnum);
     
119. SD_SCL=0;
     
120. delay(waitnum);
     
121. _dat3=SD_SO;
     
122. SD_SCL=1;
     
123. delay(waitnum);
     
124. SD_SCL=0;
     
125. delay(waitnum);
     
126. _dat2=SD_SO;
     
127. 
     
128. SD_SCL=1;
     
129. delay(waitnum);
     
130. SD_SCL=0;
     
131. delay(waitnum);
     
132. _dat1=SD_SO;
     
133. 
     
134. SD_SCL=1;
     
135. delay(waitnum);
     
136. SD_SCL=0;
     
137. delay(waitnum);
     
138. _dat0=SD_SO;
     
139. 
     
140. 
     
141. return _dat;
     
142. }
     
143. 
     
144. 
     
145. //##########################################################
     
146. char Rec_C;
     
147. void SerInit()
     
148. {SCON=0x50;
     
149.   TMOD=0x22;
     
150.   TH1=0xfd;
     
151.   TL1=0xfd;
     
152.   EA=1;
     
153.   ES=1;
     
154.   ET1=0;
     
155.   TR1=1;
     
156. }
     
157. void Serp()interrupt 4
     
158. {if(RI==1)
     
159.    {Rec_C=SBUF;
     
160.     RI=0;
     
161.     }
     
162. }
     
163. void SendC(uchar ci)
     
164. {SBUF=ci;
     
165. while(TI==0);
     
166. TI==0;
     
167. }
     
168. void Sendstr(uchar *cp)
     
169. {int i=0;
     
170. while(cp[ i]!=0)[ i]
     
171.   {delay(50);
     
172.    SendC(cp[ i]);[ i]
     
173.    delay(50);
     
174.    i++;
     
175.    }
     
176. }
     
177. //##########################################################
     
178. void SPI_Write_Addstr(int add,int num,char *cp)
     
179. {int i;
     
180. SD_CS=0;
     
181. SD_spi_write(6);
     
182. SD_CS=1;delay(8);
     
183. SD_CS=0;
     
184. SD_spi_write(2);
     
185. SD_spi_write(add);
     
186. for(i=0;i<num;i++)
     
187.    {SD_spi_write(cp[ i]);[ i]
     
188.     SendC(cp[ i]);[ i]
     
189.         }
     
190. SD_CS=1;
     
191. }
     
192. //-----------------------------------------------------------
     
193. void SPI_Read_Addstr(int add,int len)
     
194. {int i;
     
195. SD_CS=0;
     
196. SD_spi_write(3);
     
197. SD_spi_write(add);
     
198. for(i=0;i<len;i++)
     
199.     SendC(SD_spi_read());
     
200. SD_CS=1;
     
201. }
     
202. //###########################################################
     
203. unsigned char SD_Write_Cmd(unsigned char *pcmd)
     
204. {unsigned char temp,time=0;
     
205. SD_CS=1;
     
206. SD_spi_write(0xff);
     
207. SD_CS=0;
     
208. SD_spi_write(pcmd[0]);
     
209. SD_spi_write(pcmd[1]);
     
210. SD_spi_write(pcmd[2]);
     
211. SD_spi_write(pcmd[3]);
     
212. SD_spi_write(pcmd[4]);
     
213. SD_spi_write(pcmd[5]);
     
214. do{temp=SD_spi_read();
     
215.     time++;
     
216.         }while((temp==0xff)&&(time<TryNum));
     
217. return temp;
     
218. }
     
219. //================================================================
     
220. unsigned char SD_Reset()
     
221. {unsigned char i,time,temp;
     
222. unsigned char pcmd[]={0x40,0,0,0,0,0x95};
     
223. SD_CS=1;
     
224. for(i=0;i<0x0f;i++)
     
225.   {SD_spi_write(0xff);
     
226.    }
     
227. SD_CS=0;
     
228. time=0;
     
229. do{temp=SD_Write_Cmd(pcmd);
     
230.     time++;
     
231.         if(time==TryNum){SD_CS=1;return(INIT_CMD0_ERROR);}
     
232.     }while(temp!=0x01);
     
233.   SD_CS=1;
     
234.   SD_spi_write(0xff);
     
235.   return 0;
     
236. }
     
237. //==================================================================
     
238. unsigned char SD_Init()
     
239. {unsigned char time,temp;
     
240. unsigned char pcmd[]={0x41,0,0,0x02,0,0xff};
     
241. SD_CS=0;
     
242. time=0;
     
243. do{temp=SD_Write_Cmd(pcmd);
     
244.     time++;
     
245.         if(time==TryNum){SD_CS=1;return(INIT_CMD1_ERROR);}
     
246.         }while(temp!=0);
     
247. SD_CS=1;
     
248. SD_spi_write(0xff);
     
249. return 0;
     
250. }
     
251. //==================================================================
     
252. unsigned char SD_Write_Sector(unsigned long addr)
     
253. {unsigned char temp,time;
     
254. unsigned int i;
     
255. unsigned char pcmd[]={0x58,0,0,0,0,0xff};
     
256. waitnum=1;
     
257. addr<<=9;
     
258. pcmd[1]=((addr&0xff000000)>>24);
     
259. pcmd[2]=((addr&0x00ff0000)>>16);
     
260. pcmd[3]=((addr&0x0000ff00)>>8);
     
261. SD_CS=0;
     
262. time=0;
     
263. do{temp=SD_Write_Cmd(pcmd);
     
264.     time++;
     
265.         if(time==TryNum){SD_CS=1;return temp;}
     
266.         }while(temp!=0);//偿试写入命令并获取反应不超过127次
     
267. for(i=0;i<100;i++)SD_spi_read();
     
268. SD_spi_write(0xff);//此句本来应写入标志字0xfe；因写入数据会左移一位，所以写入0xff，左移1位后正好是0xfe；勉强完成写入扇区操作。
     
269. for(i=0;i<512;i++)//写入512个#
     
270.    {SD_spi_write(0x23);
     
271.     if(i%32==0)Sendstr("\r");
     
272.         SendC(0x23);
     
273.         }
     
274. SD_spi_write(0xff);
     
275. SD_spi_write(0xff);
     
276. temp=SD_spi_read();
     
277. if((temp&0x1f)!=0x05){SD_CS=1;return WRITE_BLOCK_ERROR;}
     
278. while(SD_spi_read()!=0xff);
     
279. SD_CS=1;
     
280. SD_spi_write(0xff);
     
281. return 0;
     
282. }
     
283. //===================================================================
     
284. unsigned char SD_Read_Sector(unsigned long addr)
     
285. {unsigned char temp,time;
     
286. unsigned int j;
     
287. unsigned char pcmd[]={0x51,0,0,0,0,0xff};
     
288. addr<<=9;
     
289. pcmd[1]=((addr&0xff000000)>>24);
     
290. pcmd[2]=((addr&0x00ff0000)>>16);
     
291. pcmd[3]=((addr&0x0000ff00)>>8);
     
292. SD_CS=0;
     
293. time=0;
     
294. do{temp=SD_Write_Cmd(pcmd);
     
295.     time++;
     
296.         if(time==TryNum){return READ_BLOCK_ERROR;}
     
297.         }while(temp!=0);//偿试写入命令并获取反应不超过127次
     
298. while(SD_spi_read()!=0xfe);//读到标志字0xfe为止
     
299. for(j=0;j<512;j++)//读出512个字节
     
300.    {temp=SD_spi_read();
     
301.     if(j%32==0)Sendstr("\r");
     
302.         SendC(temp);
     
303.         }
     
304. SD_spi_read();
     
305. SD_spi_read();
     
306. SD_CS=1;
     
307. SD_spi_write(0xff);
     
308. return 0;
     
309. }
     
310. //################################################################
     
311. main()
     
312. {uchar i,j;
     
313. SerInit();
     
314. Sendstr("SPI RW Test\r");
     
315. SPI_Write_Addstr(0x40,16,"123456789abcdef");
     
316. delay(1000);
     
317. SendC('\r');
     
318. SPI_Read_Addstr(0x40,16);
     
319. Sendstr("\rSD RW Test...\r");
     
320. waitnum=100;
     
321. i=SD_Reset();
     
322. Sendstr("\rreset=");
     
323. SendC(i+0x30);
     
324. i=SD_Init();
     
325. Sendstr("\rinit=");
     
326. SendC(i+0x30);
     
327. waitnum=2;
     
328. i=SD_Write_Sector(0x5);
     
329. Sendstr("\rwrite sec=");
     
330. SendC(i+0x30);
     
331. i=SD_Read_Sector(0x6);
     
332. Sendstr("\rread sec=");
     
333. SendC(i+0x30);
     
334. while(1);
     
335. 
     
336. }

复制代码

---

作者: 51hei团团    时间: 2018-12-14 04:06
所有数据都左移一位这个的确很怪，有没有换过sd卡？看样子应该还是程序的问题

---

作者: zxwdown    时间: 2018-12-14 06:55
是在proteus仿真的时候出现的，用真实SD卡只有一次复位成功，初始化没成功，其他就连复位都不成功，因实物SD卡读写没办法监测，所以有没有左移一位不知道。

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1