huo_hu 发表于 2016-9-5 14:50
怀疑你没有修改文件长度

1. void Test_f_write(void)//写数据到文件，如果没有此文件则创建文件
   
2. {
   
3.     FATFS fs;            // Work area (file system object) for logical drive
   
4.     FRESULT res;         // FatFs function common result code
   
5.         FIL Make_file;
   
6.     char file_name[20]="jj.txt";
   
7.     char Storage_buffer[] ="1234567890";       
   
8.         UINT bw;
   
9.         //检测磁盘是否插好
   
10.         if( disk_detect_OK()==FALSE ) return;
    
11.          logout(" inaert_ok:>");
    
12.     // Register a work area for logical drive 0
    
13.     f_mount(0, &fs);
    
14. 
    
15.         logout(" Make file Name:>");
    
16. //        USART_Scanf_Name(file_name);//通过串口输入源文件路径名/dir/file.txt或者0:dir/file.txt或者0:/dir/file.txt
    
17. 
    
18.    res = f_open(&Make_file, file_name,  FA_OPEN_ALWAYS | FA_WRITE); //可写方式打开 没有文件则创建
    
19.          logout(" open_ok:>");
    
20.          die(res);
    
21.    res = f_lseek(&Make_file, bsize); //指针移到文件最后  
    
22.    logout(" seek_ok:>");
    
23.          die(res);
    
24.          res = f_write(&Make_file, Storage_buffer, (sizeof (Storage_buffer))-1 , &bw); //每次需要写入的数据字节数，去掉最后的所以-1  
    
25.    logout(" write_ok:>");
    
26.          die(res);
    
27.          //logout("文件大小=%d字节 ",Make_file.fsize);
    
28.         res = f_lseek(&Make_file, Make_file.fsize); //指针移到文件最后  
    
29.         //logout("文件大小=%d字节 ",Make_file.fsize);
    
30.         f_close(&Make_file);//关闭文件
    
31.         logout(" close_ok:>");
    
32.   //logout("文件大小=%d字节 ",Make_file.fsize);
    
33.         logout(" 写文件测试OK! ");
    
34. 
    
35.         // Unregister a work area before discard it
    
36.    f_mount(0, NULL);
    
37. }
    
38. 
    
39. 
    
40. 
    
41. 
    
42. 
    
43. 
    
44. //其中调用的f_wriite函数如下
    
45. FRESULT f_write (
    
46.     FIL *fp,            /* Pointer to the file object */
    
47.     const void *buff,    /* Pointer to the data to be written */
    
48.     UINT btw,            /* Number of bytes to write */
    
49.     UINT *bw            /* Pointer to number of bytes written */
    
50. )
    
51. {
    
52.     FRESULT res;
    
53.     DWORD clst, sect;
    
54.     UINT wcnt, cc;
    
55.     const BYTE *wbuff = buff;
    
56.    
    
57.     BYTE csect;
    
58. 
    
59.   bsize+=btw;
    
60.     *bw = 0;    /* Initialize byte counter */
    
61.     logout("1111111111111111111 ");
    
62.     res = validate(fp->fs, fp->id);            /* Check validity */
    
63.     fp->fsize =fp->fsize +btw;
    
64.     logout("wenjian=%d ",fp->fsize);
    
65.     //f_sync (fp);
    
66.     if (res != FR_OK) LEAVE_FF(fp->fs, res);
    
67.     if (fp->flag & FA__ERROR)                /* Aborted file? */
    
68.         LEAVE_FF(fp->fs, FR_INT_ERR);
    
69.     logout("22222222222222222222222222 ");
    
70.     if (!(fp->flag & FA_WRITE))                /* Check access mode */
    
71.         LEAVE_FF(fp->fs, FR_DENIED);
    
72.     if ((DWORD)(fp->fsize + btw) < fp->fsize) btw = 0;    /* File size cannot reach 4GB */
    
73.    logout("333333333333333333333333 ");
    
74.     for ( ;  btw;                            /* Repeat until all data written */
    
75.         wbuff += wcnt, fp->fptr += wcnt, *bw += wcnt, btw -= wcnt) {
    
76.             logout("44444444444444444 ");
    
77.         if ((fp->fptr % SS(fp->fs)) == 0)
    
78.         {    /* On the sector boundary? */
    
79.             
    
80.             csect = (BYTE)(fp->fptr / SS(fp->fs) & (fp->fs->csize - 1));    /* Sector offset in the cluster */
    
81.             if (!csect)
    
82.                 {
    
83.                     /* On the cluster boundary? */
    
84.                 if (fp->fptr == 0) {        /* On the top of the file? */
    
85.                     clst = fp->sclust;        /* Follow from the origin */
    
86.                     if (clst == 0)            /* When no cluster is allocated, */
    
87.                         fp->sclust = clst = create_chain(fp->fs, 0);    /* Create a new cluster chain */
    
88.                 } else {                    /* Middle or end of the file */
    
89. #if _USE_FASTSEEK
    
90.                     if (fp->cltbl)
    
91.                         clst = clmt_clust(fp, fp->fptr);    /* Get cluster# from the CLMT */
    
92.                     else
    
93. #endif
    
94.                     
    
95.                         clst = create_chain(fp->fs, fp->clust);    /* Follow or stretch cluster chain on the FAT */
    
96.                 }
    
97.                 if (clst == 0) break;        /* Could not allocate a new cluster (disk full) */
    
98.                 if (clst == 1) ABORT(fp->fs, FR_INT_ERR);   
    
99.                         
    
100.                 if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
     
101.                 fp->clust = clst;            /* Update current cluster */
     
102.                 //fp->pad1 = 0;
     
103.             }
     
104.             
     
105. #if _FS_TINY
     
106.             if (fp->fs->winsect == fp->dsect && move_window(fp->fs, 0))    /* Write-back sector cache */
     
107.                 ABORT(fp->fs, FR_DISK_ERR);
     
108. #else
     
109.             if (fp->flag & FA__DIRTY) {        /* Write-back sector cache */
     
110.                 if (disk_write(fp->fs->drv, fp->buf, fp->dsect, 1) != RES_OK)
     
111.                     ABORT(fp->fs, FR_DISK_ERR);
     
112.                 fp->flag &= ~FA__DIRTY;
     
113.             }
     
114. #endif
     
115.             sect = clust2sect(fp->fs, fp->clust);    /* Get current sector */
     
116.             if (!sect) ABORT(fp->fs, FR_INT_ERR);
     
117.             sect += csect;
     
118.             cc = btw / SS(fp->fs);            /* When remaining bytes >= sector size, */
     
119.             if (cc) {                        /* Write maximum contiguous sectors directly */
     
120.                 if (csect + cc > fp->fs->csize)    /* Clip at cluster boundary */
     
121.                     cc = fp->fs->csize - csect;
     
122.                 if (disk_write(fp->fs->drv, wbuff, sect, (BYTE)cc) != RES_OK)
     
123.                     ABORT(fp->fs, FR_DISK_ERR);
     
124. #if _FS_TINY
     
125.                 if (fp->fs->winsect - sect < cc) {    /* Refill sector cache if it gets invalidated by the direct write */
     
126.                     mem_cpy(fp->fs->win, wbuff + ((fp->fs->winsect - sect) * SS(fp->fs)), SS(fp->fs));
     
127.                     //logout("tiny");
     
128.                     fp->fs->wflag = 0;
     
129.                 }
     
130. #else
     
131.                 if (fp->dsect - sect < cc) { /* Refill sector cache if it gets invalidated by the direct write */
     
132.                     mem_cpy(fp->buf, wbuff + ((fp->dsect - sect) * SS(fp->fs)), SS(fp->fs));
     
133.                     //logout("no tiny");
     
134.                     fp->flag &= ~FA__DIRTY;
     
135.                 }
     
136. #endif
     
137.                 wcnt = SS(fp->fs) * cc;        /* Number of bytes transferred */
     
138.                 continue;
     
139.             }
     
140. #if _FS_TINY
     
141.             if (fp->fptr >= fp->fsize) {    /* Avoid silly cache filling at growing edge */
     
142.                 if (move_window(fp->fs, 0)) ABORT(fp->fs, FR_DISK_ERR);
     
143.                 fp->fs->winsect = sect;
     
144.             }
     
145. #else
     
146.             if (fp->dsect != sect) {        /* Fill sector cache with file data */
     
147.                 if (fp->fptr < fp->fsize &&
     
148.                     disk_read(fp->fs->drv, fp->buf, sect, 1) != RES_OK)
     
149.                         ABORT(fp->fs, FR_DISK_ERR);
     
150.             }
     
151. #endif
     
152.             fp->dsect = sect;
     
153.         }
     
154.         logout("555555555555555555 ");
     
155.         wcnt = SS(fp->fs) - (fp->fptr % SS(fp->fs));/* Put partial sector into file I/O buffer */
     
156.         if (wcnt > btw) wcnt = btw;
     
157. #if _FS_TINY
     
158.         if (move_window(fp->fs, fp->dsect))    /* Move sector window */
     
159.             ABORT(fp->fs, FR_DISK_ERR);
     
160.         mem_cpy(&fp->fs->win[fp->fptr % SS(fp->fs)], wbuff, wcnt);    /* Fit partial sector */
     
161.         fp->fs->wflag = 1;
     
162. #else
     
163.         mem_cpy(&fp->buf[fp->fptr % SS(fp->fs)], wbuff, wcnt);    /* Fit partial sector */
     
164.         fp->flag |= FA__DIRTY;
     
165. #endif
     
166.     }
     
167. 
     
168.     if (fp->fptr > fp->fsize)
     
169.     fp->fsize = fp->fptr;    /* Update file size if needed */
     
170.     fp->flag |= FA__WRITTEN;                        /* Set file change flag */
     
171. 
     
172.     LEAVE_FF(fp->fs, FR_OK);
     
173. }
     
174. //感觉涉及的函数有点多，不知道该贴些啥。。。
     

flyword 发表于 2016-9-7 08:29
贴出代码看看行不行，我原来出现过只能创建文件，不能读写文件，是因为读写函数有问题。

flyword 发表于 2016-9-7 14:49
使用的SPI吗？贴出来那部分代码看看！

1. void SD_LowLevel_DeInit(void)
   
2. {
   
3.   GPIO_InitTypeDef  GPIO_InitStructure;
   
4.   
   
5.   SPI_Cmd(SD_SPI, DISABLE); /*!< SD_SPI disable */
   
6.   SPI_DeInit(SD_SPI);   /*!< DeInitializes the SD_SPI */
   
7.   
   
8.   /*!< SD_SPI Periph clock disable */
   
9.   RCC_APB1PeriphClockCmd(SD_SPI_CLK, DISABLE);
   
10. 
    
11.   /*!< Configure SD_SPI pins: SCK */
    
12.   GPIO_InitStructure.GPIO_Pin = SD_SPI_SCK_PIN;
    
13.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
    
14.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
    
15.   GPIO_Init(SD_SPI_SCK_GPIO_PORT, &GPIO_InitStructure);
    
16. 
    
17.   /*!< Configure SD_SPI pins: MISO */
    
18.   GPIO_InitStructure.GPIO_Pin = SD_SPI_MISO_PIN;
    
19.   GPIO_Init(SD_SPI_MISO_GPIO_PORT, &GPIO_InitStructure);
    
20. 
    
21.   /*!< Configure SD_SPI pins: MOSI */
    
22.   GPIO_InitStructure.GPIO_Pin = SD_SPI_MOSI_PIN;
    
23.   GPIO_Init(SD_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure);
    
24. 
    
25.   /*!< Configure SD_SPI_CS_PIN pin: SD Card CS pin */
    
26.   GPIO_InitStructure.GPIO_Pin = SD_CS_PIN;
    
27.   GPIO_Init(SD_CS_GPIO_PORT, &GPIO_InitStructure);
    
28. 
    
29.   /*!< Configure SD_SPI_DETECT_PIN pin: SD Card detect pin */
    
30. //  GPIO_InitStructure.GPIO_Pin = SD_DETECT_PIN;
    
31. //  GPIO_Init(SD_DETECT_GPIO_PORT, &GPIO_InitStructure);
    
32. }

1. SD_Error SD_Init(void)
   
2. {
   
3.         uint32_t i = 0;
   
4.         uint8_t r1 = 0;
   
5.         uint16_t retry = 0;
   
6.         uint8_t buf[4];
   
7.   //SPI_InitTypeDef   SPI_InitStructure;  
   
8.         //logout("sd init ");
   
9.   /*!< Initialize SD_SPI */
   
10.    for(i=0;i<0xf00;i++);
    
11.         //logout("SD_LowLevel_Init done ");
    
12.   /*!< SD chip select high */
    
13. 
    
14.    SPI2_SetSpeed(SPI_BaudRatePrescaler_256);
    
15.   /*!< Send dummy byte 0xFF, 10 times with CS high */
    
16.   /*!< Rise CS and MOSI for 80 clocks cycles */
    
17.   for(i=0;i<10;i++)SD_ReadWriteByte(0XFF);//发送最少74个脉冲
    
18.         retry=20;
    
19.         do
    
20.         {
    
21.                 r1 = SD_SendCmd1(SD_CMD_GO_IDLE_STATE,0,0x95);//进入IDLE状态
    
22.         }while((r1!=0X01) && retry--);
    
23.         //logout("SD_idle_pass ");
    
24.         //logout("R1 = %d ",r1);
    
25. 
    
26.         SD_Type=0;//默认无卡
    
27.        
    
28.         if(r1==0X01)
    
29.         {
    
30.                 //logout("1111");
    
31.                 if(SD_SendCmd1(SD_CMD_SEND_IF_COND,0x1AA,0x87)==1)//SD V2.0
    
32.                 {
    
33.                         for(i=0;i<4;i++)buf[i]=SD_ReadWriteByte(0XFF);        //Get trailing return value of R7 resp
    
34.                         if(buf[2]==0X01&&buf[3]==0XAA)//卡是否支持2.7~3.6V
    
35.                         {
    
36.                                 retry=0XFFFE;
    
37.                                 do
    
38.                                 {
    
39.                                         SD_SendCmd1(55,0,0X01);        //发送CMD55
    
40.                                         r1=SD_SendCmd1(41,0x40000000,0X01);//发送CMD41
    
41.                                 }while(r1&&retry--);
    
42.                                 if(retry&&SD_SendCmd1(58,0,0X01)==0)//鉴别SD2.0卡版本开始
    
43.                                 {
    
44.                                         for(i=0;i<4;i++)buf[i]=SD_ReadWriteByte(0XFF);//得到OCR值
    
45.                                         if(buf[0]&0x40)SD_Type=SD_TYPE_V2HC;    //检查CCS
    
46.                                         else SD_Type=SD_TYPE_V2;   
    
47.                                 }
    
48.                         }
    
49.                 }
    
50.                 else//SD V1.x/ MMC        V3
    
51.                 {
    
52.                         //logout("222");
    
53.                         SD_SendCmd1(55,0,0X01);                //发送CMD55
    
54.                         r1=SD_SendCmd1(41,0,0X01);        //发送CMD41
    
55.                         if(r1<=1)
    
56.                         {               
    
57.                                 SD_Type=SD_TYPE_V1;
    
58.                                 retry=0XFFFE;
    
59.                                 do //等待退出IDLE模式
    
60.                                 {
    
61.                                         SD_SendCmd1(55,0,0X01);        //发送CMD55
    
62.                                         r1=SD_SendCmd1(41,0,0X01);//发送CMD41
    
63.                                 }while(r1&&retry--);
    
64.                         }else//MMC卡不支持CMD55+CMD41识别
    
65.                         {
    
66.                                 SD_Type=SD_TYPE_MMC;//MMC V3
    
67.                                 logout("MMC");
    
68.                                 retry=0XFFFE;
    
69.                                 do //等待退出IDLE模式
    
70.                                 {                                                                                            
    
71.                                         r1=SD_SendCmd1(1,0,0X01);//发送CMD1
    
72.                                 }while(r1&&retry--);  
    
73.                         }
    
74.                         if(retry==0||SD_SendCmd1(16,512,0X01)!=0)SD_Type=SD_TYPE_ERR,logout("fau");//错误的卡
    
75.                 }
    
76.         }
    
77.         SD_DisSelect();//取消片选
    
78.         SPI2_SetSpeed(SPI_BaudRatePrescaler_2);
    
79.         if(SD_Type)
    
80.         {
    
81.                 //logout("0");       
    
82.                 return 0;
    
83.         }
    
84.         else if(r1)
    
85.         {
    
86.                 logout("R1 = %d ",r1);  
    
87.                 return r1;
    
88.         }       
    
89.        
    
90. }

1. uint8_t SD_SendCmd1(uint8_t  cmd, uint32_t  arg, uint8_t  crc)
   
2. {
   
3.   uint8_t r1;       
   
4.         uint8_t Retry=0;
   
5.         SD_DisSelect();//取消上次片选
   
6.         if(SD_Select())return 0XFF;//片选失效
   
7.         //发送
   
8.     SD_ReadWriteByte(cmd | 0x40);//分别写入命令
   
9.     SD_ReadWriteByte(arg >> 24);
   
10.     SD_ReadWriteByte(arg >> 16);
    
11.     SD_ReadWriteByte(arg >> 8);
    
12.     SD_ReadWriteByte(arg);          
    
13.     SD_ReadWriteByte(crc);
    
14.         if(cmd==SD_CMD_STOP_TRANSMISSION)SD_ReadWriteByte(0xff);//Skip a stuff byte when stop reading
    
15.     //等待响应，或超时退出
    
16.         Retry=0X1F;
    
17.         do
    
18.         {
    
19.                 r1=SD_ReadWriteByte(0xff);
    
20.         }while((r1&0X80) && Retry--);         
    
21.         //返回状态值
    
22.     return r1;
    
23. }
    
24. ///////////////////////////////////////////////////////////////////////////////////
    
25. //取消选择,释放SPI总线
    
26. void SD_DisSelect(void)
    
27. {
    
28.         SD_CS_HIGH();
    
29.         SD_ReadWriteByte(0xff);//提供额外的8个时钟
    
30. }
    
31. //选择sd卡,并且等待卡准备OK
    
32. //返回值:0,成功;1,失败;
    
33. uint8_t SD_Select(void)
    
34. {
    
35.         SD_CS_LOW();
    
36.         if(SD_WaitReady()==0)return 0;//等待成功
    
37.         SD_DisSelect();
    
38.         return 1;//等待失败
    
39. }
    
40. //等待卡准备好
    
41. //返回值:0,准备好了;其他,错误代码
    
42. uint8_t SD_WaitReady(void)
    
43. {
    
44.         uint32_t t=0;
    
45.         do
    
46.         {
    
47.                 if(SD_ReadWriteByte(0XFF)==0XFF)return 0;//OK
    
48.                 t++;                         
    
49.         }while(t<0XFFFFFF);//等待
    
50.         return 1;
    
51. }
    
52. 
    
53. uint32_t  SD_GetSectorCount(void)
    
54. {
    
55.     uint8_t csd[16];
    
56.     uint32_t  Capacity;  
    
57.     uint8_t  n;
    
58.           uint16_t  csize;                                              
    
59.         //取CSD信息，如果期间出错，返回0
    
60.     if(SD_GetCSD(csd)!=0)
    
61.                 {
    
62.                         logout("csd fail ");
    
63.                         return 0;
    
64.                 }            
    
65.     //如果为SDHC卡，按照下面方式计算
    
66.     if((csd[0]&0xC0)==0x40)         //V2.00的卡
    
67.     {       
    
68.                 csize = csd[9] + ((uint16_t)csd[8] << 8) + 1;
    
69.                 Capacity = (uint32_t)csize << 10;//得到扇区数                           
    
70.     }else//V1.XX的卡
    
71.     {       
    
72.                 n = (csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2;
    
73.                 csize = (csd[8] >> 6) + ((uint16_t)csd[7] << 2) + ((uint16_t)(csd[6] & 3) << 10) + 1;
    
74.                 Capacity= (uint32_t)csize << (n - 9);//得到扇区数   
    
75.     }
    
76.     return Capacity;
    
77. }
    
78. //获取SD卡的CSD信息，包括容量和速度信息
    
79. //输入:uint8_t *cid_data(存放CID的内存，至少16Byte）            
    
80. //返回值:0：NO_ERR
    
81. //                 1：错误                                                                                                                  
    
82. uint8_t SD_GetCSD(uint8_t *csd_data)
    
83. {
    
84.     uint8_t r1;         
    
85.           logout("gCSD1 ");
    
86.     r1 = SD_SendCmd1(SD_CMD_SEND_CSD,0,0x01);//发CMD9命令，读CSD
    
87.           logout("gCSD2 ");
    
88.     if(r1==0)
    
89.         {
    
90.             r1= SD_RecvData(csd_data, 16);//接收16个字节的数据
    
91.     }
    
92.         SD_DisSelect();//取消片选
    
93.         if(r1)return 1;
    
94.         else return 0;
    
95. }
    
96. //从sd卡读取一个数据包的内容
    
97. //buf:数据缓存区
    
98. //len:要读取的数据长度.
    
99. //返回值:0,成功;其他,失败;       
    
100. uint8_t SD_RecvData(uint8_t *buf,uint16_t len)
     
101. {                                    
     
102.         if(SD_GetResponse(0xFE))return 1;//等待SD卡发回数据起始令牌0xFE
     
103.     while(len--)//开始接收数据
     
104.     {
     
105.         *buf=SD_ReadWriteByte(0xFF);
     
106.         buf++;
     
107.     }
     
108.     //下面是2个伪CRC（dummy CRC）
     
109.     SD_ReadWriteByte(0xFF);
     
110.     SD_ReadWriteByte(0xFF);                                                                                                                      
     
111.     return 0;//读取成功
     
112. }
     
113. void SPI2_SetSpeed(uint8_t SpeedSet)
     
114. {
     
115.         SPI_InitStructure.SPI_BaudRatePrescaler = SpeedSet ;
     
116.   SPI_Init(SPI2, &SPI_InitStructure);
     
117.         SPI_Cmd(SPI2,ENABLE);
     
118. }
     
119. //读SD卡
     
120. //buf:数据缓存区
     
121. //sector:扇区
     
122. //cnt:扇区数
     
123. //返回值:0,ok;其他,失败.
     
124. uint8_t SD_ReadDisk(uint8_t*buf,uint32_t sector,uint8_t cnt)
     
125. {
     
126.         uint8_t r1;
     
127.         if(SD_Type!=SD_TYPE_V2HC)sector <<= 9;//转换为字节地址
     
128.         if(cnt==1)
     
129.         {
     
130.                 r1=SD_SendCmd1(SD_CMD_READ_SINGLE_BLOCK,sector,0X01);//读命令
     
131.                 if(r1==0)//指令发送成功
     
132.                 {
     
133.                         r1=SD_RecvData(buf,512);//接收512个字节          
     
134.                 }
     
135.         }else
     
136.         {
     
137.                 r1=SD_SendCmd1(SD_CMD_READ_MULT_BLOCK,sector,0X01);//连续读命令
     
138.                 do
     
139.                 {
     
140.                         r1=SD_RecvData(buf,512);//接收512个字节         
     
141.                         buf+=512;  
     
142.                 }while(--cnt && r1==0);        
     
143.                 SD_SendCmd(SD_CMD_STOP_TRANSMISSION,0,0X01);        //发送停止命令
     
144.         }   
     
145.         SD_DisSelect();//取消片选
     
146.         return r1;//
     
147. }
     
148. //写SD卡
     
149. //buf:数据缓存区
     
150. //sector:起始扇区
     
151. //cnt:扇区数
     
152. //返回值:0,ok;其他,失败.
     
153. uint8_t SD_WriteDisk(const uint8_t*buf,uint32_t sector,uint8_t cnt)
     
154. {
     
155.         uint8_t r1;
     
156.         if(SD_Type!=SD_TYPE_V2HC)sector *= 512;//转换为字节地址
     
157.         if(cnt==1)
     
158.         {
     
159.                 r1=SD_SendCmd1(SD_CMD_WRITE_SINGLE_BLOCK,sector,0X01);//读命令
     
160.                 if(r1==0)//指令发送成功
     
161.                 {
     
162.                         r1=SD_SendBlock(buf,0xFE);//写512个字节          
     
163.                 }
     
164.         }else
     
165.         {
     
166.                 if(SD_Type!=SD_TYPE_MMC)
     
167.                 {
     
168.                         SD_SendCmd1(55,0,0X01);       
     
169.                         SD_SendCmd1(SD_CMD_SET_BLOCK_COUNT,cnt,0X01);//发送指令       
     
170.                 }
     
171.                 r1=SD_SendCmd1(SD_CMD_WRITE_MULT_BLOCK,sector,0X01);//连续读命令
     
172.                 if(r1==0)
     
173.                 {
     
174.                         do
     
175.                         {
     
176.                                 r1=SD_SendBlock(buf,0xFC);//接收512个字节         
     
177.                                 buf+=512;  
     
178.                         }while(--cnt && r1==0);
     
179.                         r1=SD_SendBlock(0,0xFD);//接收512个字节
     
180.                 }
     
181.         }   
     
182.         SD_DisSelect();//取消片选
     
183.         return r1;//
     
184. }       
     
185. 
     
186. uint8_t SD_SendBlock(const uint8_t *buf,uint8_t cmd)
     
187. {       
     
188.         uint16_t  t;                            
     
189.         if(SD_WaitReady())return 1;//等待准备失效
     
190.         SD_ReadWriteByte(cmd);
     
191.         if(cmd!=0XFD)//不是结束指令
     
192.         {
     
193.                 for(t=0;t<512;t++)SD_ReadWriteByte(buf[t]);//提高速度,减少函数传参时间
     
194.             SD_ReadWriteByte(0xFF);//忽略crc
     
195.             SD_ReadWriteByte(0xFF);
     
196.                 t=SD_ReadWriteByte(0xFF);//接收响应
     
197.                 if((t&0x1F)!=0x05)return 2;//响应错误                                                                                                                      
     
198.         }                                                                                                                                                                       
     
199.     return 0;//写入成功
     
200. }