前言与废话
        做项目时网找资料，不会的东西上网查阅一下多半可以解决，一些尚未解决的问题也会有所启发。最近由于项目的需要，仔细阅读了SD卡相关内容，顺藤摸瓜学习FatFS。网上关于SD卡和FatFS的内容非常的多，重复的部分我就不介绍了，我把移植和使用部分的经验和大家分享一下。
刚开始的时候，我找来一些现成的代码研究一下，不用说看的是一头雾水。看FatFS示例代码，也不知如何移植。最后还是下定决心，慢慢的阅读FatFS的相关文档和范例代码，对于移植部分一点一点的研究，相信一定会有所收获。

一、硬件准备
# _3 J! U: }# e2 B+ ?2 j        开始移植之前，你必须要有一块SD卡。从形状上来说，有普通的SD卡，有很小的microSD卡，microSD卡就是手机中长见的TF卡。购买microSD卡的时候，往往会附带一个SD卡套，那么小个头的microSD卡就变成了普通的SD卡，接口都是一样的。
( }. Q5 ?3 I1 F7 j6 y) |" I( Y        但是还是您注意了，建议大家购买2G以下的SD卡（如果可以的话，买个128M的SD卡就可以达到实验的效果，价格也非常便宜）。刚开始移植的时候，我使用了4G的SD卡，但是发现程序无法完成SD卡的初始化。查阅网上相关的资料，发现SD卡技术已2G作为分界线，大于或者等于4G的卡属于高速SD卡，和小于或者等于4G的SD卡略有区别。
8 k6 R3 j- j1 U  e# h0 V/ V, V二、软件准备
2 ^7 Q7 `, k- L        在进行移植之前，先编写一些最简单的STM32程序。在调试之前，我都会完成USART的初始化和发送函数，通过串口把STM32的运行状态打印出来，这样配合Jlink硬件调试，可以很快的找到错误。由于SD卡可以使用SPI进行读写操作，所以还需要完成SPI的初始化工作。
6 s) a3 ^8 F5 S# d& Q5 m        先来说一下USART的操作，我个人比较喜欢使用系统的printf函数，所以还需要引入stdio头文件。在IAR中必须设定option的某个选项。如下图所示。

        除了完成USART的初始化工作以外，还需要重写fputc函数，具体的代码如下。

1. int fputc(int ch, FILE * f)
   
2. {
   
3.   USART_SendData(USART1, (uint8_t)ch);
   
4.   while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET );
   4 E  Y" p  ]% V3 t' J
5.   return ch;
   
6. }

复制代码

/ c4 K& a1 `0 L8 M, s& c

然后说一下SPI的初始化工作。阅读网上的代码，发现STM32 V2的库函数和V3函数中，关于SPI端口初始化的部分还是有些出入的。
        V2库中，把SCK，MOSI，MISO全部设置为复用输出。而V3库中，SCK，MOSI设置为复用输出，而MISO设置为浮动输入。在SD的SPI接口中，SCK，MOSI和MOSI，甚至包括CS都使用了上拉电阻。
2 [& [2 z! O' X/ [+ x" R+ f7 V0 n您需要注意一下几点
1.         没有上拉电阻时 MISO应该如何设置
3 p, M% l$ K4 }" r2 h/ d, J% o由于我的开发板中没有使用上拉电阻，若设定MISO为浮动输入的话，或许会有某些问题，由于SD卡的输出端口驱动能力很弱，很有可能就接收不到返回数据，事实也正是如此。所以MISO最后被我甚至成了上拉输入模式，具体的代码如下。（所以还是要相信过来人的电路图，老实的加一个上拉电阻。）
2.        SPI的模式应该如何选择
: ?+ E6 V% J* t( m           SPI的速度不能太快，在初始化时时钟设为400k以下为宜。
3.        SPI的速度应该如何选择
           SD卡使用SPI的模式0和模式3，这两个模式是等价的。

1. void SPI1_Config(void)
   
2. {
   . O7 |1 C: [; M$ }9 F3 Y% [6 e( s! A
3.   //使能APB2上相关时钟
   
4.   //使能SPI时钟，使能GPIOA时钟
   
5.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1 |\
   
6.                          RCC_APB2Periph_GPIOA ,ENABLE );
   
7.   //定义一个GPIO结构体
   
8.   GPIO_InitTypeDef  GPIO_InitStructure;
   
9.   //SPI SCK MOSI
   ( o4 o6 u+ f4 t; l0 Y
10.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5  |  GPIO_Pin_7;
    
11.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
12.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;//复用推挽输出
    
13.   GPIO_Init(GPIOA, &GPIO_InitStructure);
    
14.   //SPI MISO
    " z: y( _9 l2 W$ h/ `( J5 [
15.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
    
16.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    7 E. i, r. l4 b* B
17.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;//上拉输入
    
18.   GPIO_Init(GPIOA, &GPIO_InitStructure);
    
19.   //自定义SPI结构体
    
20.   SPI_InitTypeDef SPI_InitStructure;
    9 p4 W4 Y, b  o; B2 ?$ X
21.   //双线双向全双工
    
22.   SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    
23. //主机模式
    
24.   SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
    
25.   //8位帧结构
    
26.   SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
    
27.   //时钟空闲时为低
    
28.   SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
    
29.   //第一个上升沿捕获数据。模式,0
    
30.   SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
    
31.   //MSS 端口软件控制，实际没有使用
    + v) c1 ]3 Z; L* t. A8 ]
32.   SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
    ' @6 Q) X4 d( _( p
33.   //SPI时钟72Mhz / 256 = 281.25K  < 400K
    
34.   SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;
    . \8 B. c6 e2 t: l
35.   //数据传输高位在前
    : h/ v% \7 ^' x  w( c
36.   SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
    
37.   SPI_InitStructure.SPI_CRCPolynomial = 7;//
    + o  ?: x  n' o  p" r& ?
38.   //初始化SPI1
    
39.   SPI_Init(SPI1, &SPI_InitStructure);
    
40.   //使能SPI1
    
41.   SPI_Cmd(SPI1, ENABLE);
    
42. }

复制代码

除了初始化操作以外，还需要一个SPI发送函数和一个SPI接收函数。由于SPI是同步通信方式，所以SPI接收函数，实际上只需要发送0xFF就可以，具体的代码如下。

1. uint8_t SPI1_SendByte(uint8_t byte)
   7 Y+ U0 {' O8 `* n% s% F
2. {
   
3.   //等待发送缓冲寄存器为空
   1 Y4 ~5 ?! E4 X9 F1 I0 [" q3 C+ _
4.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
   ( M$ U, e' s/ S' r0 a0 @
5.   //发送数据
   
6.   SPI_I2S_SendData(SPI1, byte);
   
7.   //等待接收缓冲寄存器为非空
   $ q: S( J, q1 E! N
8.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
   
9.   //返回从SPI通信中接收到的数据
   5 r- [+ ~; }2 Y: u' ~* i
10.   return SPI_I2S_ReceiveData(SPI1);
    
11. }
    ! r7 P6 Z' }6 y( {0 {) Y4 k: Q
12. uint8_t SPI1_ReceiveByte()
    
13. {
    
14.   //等待发送缓冲寄存器为空
    * g* Q$ y  p; U* Y- A
15.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
    ; F: v5 {& R' l  t. [7 M
16.   //发送数据,通过发送xff,获得返回数据
    3 n! P2 s& G5 E2 z6 q% O9 g7 G( i
17.   SPI_I2S_SendData(SPI1, 0xff);
    
18.   //等待接收缓冲寄存器为非空
    
19.   while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
    
20.   //返回从SPI通信中接收到的数据
    
21.   return SPI_I2S_ReceiveData(SPI1);
    
22. }

复制代码

三、移植前的“心灵”准备
        “移植”实际上就是研究他人的代码，你必须敏锐的看清代码的核心内容，了解你必须要做什么，哪一些可以以后再实现。在移植的初步阶段，我建议您使用最简单的方法完成某些内容，而不是去重视代码效率。例如，在移植过程中需要使用到延时函数，可以使用软件延时，可以配合Systick延时，甚至可以使用uCOS的延时函数。但是我建议您在面对选择的时候选择最简单的函数——软件延时，虽然它不准确效率也不高，但是您可以把更多的精力投入到其他重要的内容中去，你会觉得移植是那么简单，而延时函数的效率提高是锦上添花的事情。
/ M8 K! l4 ?0 }, r# l        例如您在移植之前会查看FatFS中关于STM32的移植范例。在该范例中，有关于SD卡插入，SD卡上电控制，SD卡写保护检测的函数。除了这些函数之外，代码中通过宏定义的方法，可以选择使用DMA来传送SPI数据，初始化SD卡时使用低速SPI，读写块的时候使用高速SPI，虽然这些改动让您觉得代码强大而高效，但是对您的移植一定用处都没有。您需要从最简单的generic开始，如果从这个文件开始，您会觉得移植是那么的简单，仅需要十几分钟。我相信您看完文章就会了，其实非常的简单。
0 d& ?1 F* K3 c* H7 \3 }& V9 h7 B
四、移植开始——从generic开始
2 R8 n* r' D6 ~% @! r7 s        您所需要操作的只是mmcbb文件，里面主要包括SD卡的初始化、读块和写块函数。其实修改仅需要三步。
4 n6 `0 y, \! X* p/ y        第一步，修改宏定义，添加合适的头文件，添加延时函数
* P9 c8 M& V. v1 a        第二步，修改多字节发送函数
; |- X6 F2 _! U' Y5 @        第三步，修改多字节接收函数
        下面我通过原代码和移植代码的比较，来说明这个移植问题。
4.1  修改头文件和宏定义
7 Y$ V# t/ G" c原代码如下

1. /* Include device specific declareation file here */
   - `6 j$ ?, M* }; R6 x+ O  [
2. #include <device.h>
   
3. /* Initialize MMC control port (CS/CLK/DI:output, DO/WP/INS:input) */
   
4. #define        INIT_PORT()        { init_port(); }
   - S- ~0 i* ~% D' N: G3 n
5. /* Delay n microseconds */
   
6. #define DLY_US(n)        { dly_us(n); }
   2 d$ H8 ~2 Q$ Q! |2 g+ ?+ h
7. #define CS_H()                bset(P0)           /* Set MMC CS "high" */
   ; M* H( z+ F% s5 J
8. #define CS_L()                 bclr(P0)            /* Set MMC CS "low" */
   
9. #define CK_H()                bset(P1)           /* Set MMC SCLK "high" */
   / g% A$ L: B8 |$ `9 h
10. #define  CK_L()                bclr(P1)            /* Set MMC SCLK "low" */
    
11. #define DI_H()                 bset(P2)           /* Set MMC DI "high" */
    * B' k* \$ u: X6 t# \
12. #define DI_L()                 bclr(P2)            /* Set MMC DI "low" */
    
13. #define DO                     btest(P3)          /* Get MMC DO value (high:true, low:false) */
    - u- F* q) x2 I" Q4 b
14. /* Socket: Card is inserted (yes:true, no:false, default:true) */
    
15. #define        INS                        (1)
    
16. /* Socket: Card is write protected (yes:true, no:false, default:false) */.
    
17. #define        WP                        (0)

复制代码

/ k* A& `) O0 R/ [( R

==========修改后的代码如下==========

1. /* Include device specific declareation file here */
   ; p# l9 G! K4 v1 N3 x" A4 W! G
2. #include "stm32f10x.h"
   
3. #include "spi1.h"
   
4. #include <stdio.h>
   3 a8 H# I9 U6 W% L
5. /* Initialize MMC control port (CS/CLK/DI:output, DO/WP/INS:input) */
   5 x6 f" Q) g/ U. _
6. #define        INIT_PORT()        { init_port(); }
   . |9 \; _; b) P  ~- E
7. /* Set MMC CS "high" */
   0 B5 X3 t+ G* O% V3 D. a
8. #define        CS_H()                  GPIO_SetBits(GPIOE,GPIO_Pin_7)
   
9. /* Set MMC CS "low" */
   1 P9 P. O* v' @7 a+ M
10. #define CS_L()                  GPIO_ResetBits(GPIOE,GPIO_Pin_7)
    
11. /* Delay n microseconds */
    3 e; c4 j8 u0 M! t& I  q. t
12. #define DLY_US(n)        { dly_us(n); }
    8 H3 _2 q0 t6 N* [: S$ m- o& M
13. /* Socket: Card is inserted (yes:true, no:false, default:true) */
    9 c7 g& v8 g* \5 Y! \& M3 W6 k
14. #define        INS                          (1)
    
15. /* Socket: Card is write protected (yes:true, no:false, default:false) */
    
16. #define        WP                          (0)

复制代码

4 \; Z% a6 ?$ C3 `/ @

使用STM32时需要包含STM3210x头文件；spi1.h包括了spi相关操作函数。修改了CS操作的宏定义。
6 Z6 ?0 Q" [1 K* u        除了一个宏定义外，还需要些一个延时函数和一个初始化函数。延时函数使用软件延时，很不精确，但是可以说明问题。初始化函数，只是配置CS端口，而SPI初始化工作在调用fatfs API函数时已完成初始化。（若是SPI初始化也完成了CS的操作，init_port()可以省略）

1. //初始化端口
   ) ^* \$ B+ I% p0 a7 o
2. void init_port()
   
3. {
   9 Z5 ~. c/ i  l6 N
4.   //初始化时钟GPIOE
   ) \, U& I5 Y/ @5 }8 O
5.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE ,ENABLE );
   & Z! y3 I, H; ]2 p) r7 [$ I) O9 |
6.   //配置GPIOE.7
   ' s: Y, L' T$ e$ _; Y
7.   //定义一个GPIO结构体
   & b; X* E* W. w; x' N7 [! k7 B) \
8.   GPIO_InitTypeDef  GPIO_InitStructure;
   : Q. v5 [' c! T& Y+ c
9.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
   
10.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    # J& K1 ]- z5 m- L- e- T2 I
11.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    
12.   GPIO_Init(GPIOE, &GPIO_InitStructure);
    ( a" ?+ {" y1 p0 }8 Y( ~
13. }
    
14. //软件演示函数
    0 L$ d: J7 h5 t/ U, j+ u
15. void dly_us(uint16_t n)
    
16. {
    
17.   for( ; n > 0 ; n--)
    
18.     for(uint8_t i = 100 ; i > 0 ; i--);
    . X) m2 H* A, v( s- \$ h
19. }

复制代码

4.2 多字节发送函数
原代码和修改后的代码如下。

1. static
   1 _8 G- v% g5 Z  u
2. void xmit_mmc (
   
3.         const BYTE* buff,        /* Data to be sent */
   
4.         UINT bc                                /* Number of bytes to send */
   
5. )
   ' a- h; I% w+ C) y
6. {
   
7.         BYTE d;
   ) R: J* u; B$ M( O( D: `
8.         do {
   2 L5 P1 C# O2 q9 D, N
9.                 d = *buff++;        /* Get a byte to be sent */
   + h5 e& w) D# t' K8 ~2 F: d7 e, ]/ c
10.                 if (d & 0x80) DI_H(); else DI_L();        /* bit7 */
    . B( E- @/ B8 r6 }, k
11.                 CK_H(); CK_L();
    
12.                 if (d & 0x40) DI_H(); else DI_L();        /* bit6 */
    4 J" c2 C* X, o7 }5 ^3 V5 T8 l0 {7 |
13.                 CK_H(); CK_L();
    
14.                 if (d & 0x20) DI_H(); else DI_L();        /* bit5 */
    
15.                 CK_H(); CK_L();
    
16.                 if (d & 0x10) DI_H(); else DI_L();        /* bit4 */
    " z& E( p8 Q6 h3 R
17.                 CK_H(); CK_L();
    0 l6 }1 ]! q) E5 [
18.                 if (d & 0x08) DI_H(); else DI_L();        /* bit3 */
    
19.                 CK_H(); CK_L();
    
20.                 if (d & 0x04) DI_H(); else DI_L();        /* bit2 */
    
21.                 CK_H(); CK_L();
    
22.                 if (d & 0x02) DI_H(); else DI_L();        /* bit1 */
    
23.                 CK_H(); CK_L();
    
24.                 if (d & 0x01) DI_H(); else DI_L();        /* bit0 */
    5 Q' n; G$ e* ?- n: d% L' q
25.                 CK_H(); CK_L();
    0 c$ C( F6 U6 B1 q1 ]( C' n
26.         } while (--bc);
    
27. }
    

复制代码

==========修改后的代码===========

1. static void xmit_mmc (const BYTE* buff,        UINT bc)
   : {  J0 ^  C. \, W
2. {
   
3.         BYTE d;
   
4.         do {
   
5.     /* Get a byte to be sent */
   
6.         d = *buff++;
   
7.     //通过SPI发送
   ( T! C+ `/ C& e! e
8.     SPI1_SendByte(d);
   
9.         } while (--bc);
   
10. }

复制代码

) C. e! ^! S; E2 V6 H* B# L+ ]7 M8 M

4.3 多字节接收函数
原代码和修改后的代码如下。

1. static
   
2. void rcvr_mmc (
     }' Q  N0 v4 N6 j2 Q. l
3.         BYTE *buff,        /* Pointer to read buffer */
   
4.         UINT bc                /* Number of bytes to receive */
   , _# L& W& ^" z9 @8 U/ a/ ^' \' k1 j
5. )
     g; Y; k, o0 C% Y; C) v
6. {
   ) A' t. a: K: f- ?( ]! [( z" r
7.         BYTE r;
   
8.         DI_H();         /* Send 0xFF */
   
9.         do {
   # k7 g$ T/ e' Y. b
10.                 r = 0;   if (DO) r++;        /* bit7 */
    5 T8 c/ p4 v, D; X, y
11.                 CK_H(); CK_L();
    
12.                 r <<= 1; if (DO) r++;        /* bit6 */
    * ~! s% l+ z7 c) O
13.                 CK_H(); CK_L();
    
14.                 r <<= 1; if (DO) r++;        /* bit5 */
    9 R8 t+ B% J9 E; z7 {9 ?
15.                 CK_H(); CK_L();
      v5 @- y; A( x+ V
16.                 r <<= 1; if (DO) r++;        /* bit4 */
    # t5 @4 _$ S+ x. l6 D$ i
17.                 CK_H(); CK_L();
    
18.                 r <<= 1; if (DO) r++;        /* bit3 */
    
19.                 CK_H(); CK_L();
    1 H, G* T  d0 @, k# q
20.                 r <<= 1; if (DO) r++;        /* bit2 */
    
21.                 CK_H(); CK_L();
    " h" \7 b: b% G: k: K! ~
22.                 r <<= 1; if (DO) r++;        /* bit1 */
    5 n! V6 P- T2 y4 a- c3 L  u
23.                 CK_H(); CK_L();
    
24.                 r <<= 1; if (DO) r++;        /* bit0 */
    ! D+ p0 J" o, _. T& f$ |3 Q; n
25.                 CK_H(); CK_L();
    . E9 I/ R3 y* w7 u# D) n% C. i
26.                 *buff++ = r;                        /* Store a received byte */
    3 Q% i( s/ `, c2 |8 a
27.         } while (--bc);
    0 ~' U# v9 J& m
28. }
    % s3 ~, l* R0 \. Z' o: m; t& Z  O/ U

复制代码

& C. w& W. \) e" e* T% O$ ]0 e

===========修改后的函数===========

1. static void rcvr_mmc ( BYTE *buff,        UINT bc        )
   & M6 {7 Z! p$ ^9 |' v$ d+ Q
2. {
   - G+ j( U" f. d* a5 }' ]2 {
3.         BYTE r;
   
4.         do {
   6 |6 {, C' t9 ~! H
5.     //重新赋值
   + {% R+ j3 o6 R9 [+ c
6.                 r = 0;
   , ]+ e- S  r) b
7.     //通过SPI获得数据
   % V  v" E+ }3 V. J& v3 z7 M6 G
8.     r = SPI1_ReceiveByte();
   ( i5 Y6 n7 H# |8 M% T
9.     /* Store a received byte */
   + Y6 ^4 a" x! z' B4 Z# R
10.                 *buff++ = r;
    
11.         } while (--bc);
    
12. }

复制代码

在这里多说一句，源代码中
DI_H();         /* Send 0xFF */
        作者的本意应该是把IO设为输入状态，51系列单片机就是这么操作的，但是写代码注释写成了发送0xFF，其实并不需要发送0xFF。
+ R: j5 w1 c$ `4 [! x: r; T: W! C" O到这里就完成了fatfs的STM32移植工作，虽然只有简单的三步，但是却花了我整整三天的时间。我想您看了这样的描述，不知道能否在10分钟之内完成修改。

五 FatFS初步使用
        接下来就是使用FatFS了，看了这个函数我找回了当初初学C语言的感觉，打开一个文件，然后读一些数据，然后创建另一个文件，在文件中写一些数据，最后关闭文件。

1. int main(void)
   
2. {
   
3.   //初始化Systick
   
4.   RCC_Config();
   
5.   //初始化串口
   
6.   USART1_Config();
   
7.   //初始化SPI1
   ; O. G/ m" u% |  ?6 `
8.   SPI1_Config();
   
9.   printf("start to read file\n");
   
10.   /* Register volume work area (never fails) */
    
11.   f_mount(0, &fatfs);
    
12.   printf("\nOpen a test file (test.txt).\n");
    + H  |9 x5 a( a, s
13. rc = f_open(&fil, "test.txt", FA_READ);
    ; d( y1 v7 A. x; H1 h" I
14. if (rc) die(rc);
    0 R0 s" H; \2 U/ R
15.         printf("\nType the file content.\n");
    
16.         for (;;) {
    6 r- \- u' |! ~! M, A9 @' V
17.                 rc = f_read(&fil, buff, sizeof(buff), &br);        /* Read a chunk of file */
    
18.                 if (rc || !br) break;                                    /* Error or end of file */
    
19.                 for (i = 0; i < br; i++)                                /* Type the data */
    
20.                         putchar(buff);
    
21.         }
    ' n. o& N0 d0 ], r1 r0 d2 `& W
22.         if (rc) die(rc);
    
23.         printf("\nClose the file.\n");
    
24.         rc = f_close(&fil);
    $ Z1 w% t, D! T. T$ }2 C
25.         if (rc) die(rc);
    
26.         printf("\nCreate a new file (hello.txt).\n");
    
27.         rc = f_open(&fil, "HELLO.TXT", FA_WRITE | FA_CREATE_ALWAYS);
    
28.         if (rc) die(rc);
    4 _1 X3 ]! ]. S0 S9 N9 L% C( I- Y
29.         printf("\nWrite a text data. (Hello world!)\n");
    $ o3 G' `( k2 f) z3 w
30.         rc = f_write(&fil, "Hello world!\r\n", 14, &bw);
    . [% [2 a% m9 i: z* S! }
31.         if (rc) die(rc);
    
32.         printf("%u bytes written.\n", bw);
    
33.         printf("\nClose the file.\n");
    
34.         rc = f_close(&fil);
    
35.         if (rc) die(rc);
    
36.   while (1)
    ! B) {6 i+ Q) s  v
37.   {
      m% w; ^( G; n1 S" g/ c
38.   }
    0 m/ _1 m) L5 ]
39. }
    

复制代码

如果出现失败的话，程序会进入die函数，该函数会输出错误代码，并进入一个无限循环。
通过串口的输出结果如下所示。

, E9 O4 x0 @* h6 s我再把SD卡从目标板上拿下，查看文件中的内容。的确hello.txt文件中写了hello world字符（应该还有回车和换行符）。

六         我的错误经历
/ d. r* N' D# ^        再快要移植成功的时候，我一运行程序，程序就进入die函数，并显示错误1，提示应该是SD卡操作错误。我通过断点调试和printf输出，把问题定位到发送cmd0处，返回的结果为一个非法的命令。我从CMD17命令入手，查阅了网上各位大神的经验，有说是发送命令的延时时候不够。但是照着这个修改之后问题存在，无奈之下在电脑面前苦苦思考。直到我的女朋友，在愚人节那天“玩”我，当时我正在仔细的检查代码，她和我说某某老师要找我并提醒我一定要拿手机，我收拾起我凌乱的思绪，立刻跑过去时，她却打电话给我说愚人节快乐。我很无奈但也有点开心的回到电脑面前，一动鼠标就看到了某些异样。
#define CMD17        (7)                        /* READ_SINGLE_BLOCK */
! E. ], V3 Y9 C9 |  Q: w. o7 j我把CMD17命令的宏定义写成了7，而实际上是17。就这么一个简答的错误，花费了我一天的时间。也非常感谢女朋友的这个愚人节玩笑，没有她或许就无法发现这个问题。
        一个尚未解决的问题！
2 H- x, c, l" s0 B) M0 O; {: R5 S        还有一个比较特殊的地方请聪明的你注意一下，在generic中man函数中，把这些定义在了main函数里面。这些定义如下

1.           FRESULT rc;                                /* Result code */
   8 S" c4 p6 h8 I% T. m
2.         FATFS fatfs;                                /* File system object */
   
3.         FIL fil;                                                /* File object */
   
4.         DIR dir;                                        /* Directory object */
   
5.         FILINFO fno;                                /* File information object */
   % X3 g/ G- P. F6 ?  ^
6.         UINT bw, br, i;
   : Y7 U9 {- e) J% m
7.         BYTE buff[128];

复制代码

如果把这些变量的声明都放在main函数中的话，系统将会运行到一个异常中，如下图所示。这个错误会让人非常的沮丧。虽然我没有找到原因，但是我找到了解决的方法。把这些变量的声明放在函数之外。

3 O. a) v6 S$ t+ h

  t1 I& p( @" |* I1 B% @6 H% N