【正点原子FPGA连载】第三十七章SD卡读写测试实验

正点原子 · 发表于 2020-12-3 16:06:41

本帖最后由正点原子于 2021-1-23 15:45 编辑

1）实验平台：正点原子达芬奇FPGA开发板
2）购买链接:https://detail.tmall.com/item.htm?id=624335496505
3）全套实验源码+手册+视频下载地址：http://www.openedv.com/docs/boards/fpga/zdyz_dafenqi.html
4）正点原子官方B站：https://space.bilibili.com/394620890
5）对正点原子FPGA感兴趣的同学可以加群讨论：905624739 点击加入:

第三十七章SD卡读写测试实验

SD存储卡是一种基于半导体快闪记忆器的新一代记忆设备。它具有体积小、传输速度快、支持热插拔等优点，在便携式装置领域得到了广泛的应用，如数码相机、多媒体播放器、笔记本电脑等。本章我们将使用FPGA开发板学习如何对SD卡（本章是用的是TF卡也就是MicroSD卡，以下简称SD卡）进行读写操作并进行SD卡的读写测试实验。
本章包括以下几个部分：
3737.1简介
37.2实验任务
37.3硬件设计
37.4程序设计
37.5下载验证

37.1简介
SD卡的英文全称是Secure Digital Card，即安全数字卡（又叫安全数码卡），是在MMC卡（Multimedia Card，多媒体卡）的基础上发展而来，具有两个突出的优点：更高的安全性和更快的读写速度。SD卡和MMC卡的长度和宽度都是32mm x 24mm，不同的是，SD卡的厚度为2.1mm，而MMC卡的厚度为1.4mm，SD卡比MMC卡略厚，以容纳更大容量的存贮单元，同时SD卡比MMC卡触点引脚要多，且在侧面多了一个写保护开关。SD卡与MMC卡保持着向上兼容，也就是说，MMC卡可以被新的SD设备存取，兼容性则取决于应用软件，但SD卡却不可以被MMC设备存取。SD卡和MMC卡可通过卡片上面的标注进行区分，如下图左侧图片上面标注为“MultiMediaCard”字母样式的为MMC卡，右侧图片上面标注为“SD”字母样式的为SD卡。

图 37.1.1  MMC外观图（左）和SD卡外观图（右）
上图中右侧图片的SD卡实际上为SDHC卡，SD卡从存储容量上分为3个级别，分别为：SD卡、SDHC卡（Secure Digital High Capacity，高容量安全数字卡）和SDXC卡（SD eXtended Capacity，容量扩大化的安全存储卡）。SD卡在MMC卡的基础上发展而来，使用FAT12/FAT16文件系统，SD卡采用SD1.0协议规范，该协议规定了SD卡的最大存储容量为2GB；SDHC卡是大容量存储SD卡，使用FAT32文件系统，SDHC卡采用SD2.0协议规范，该协议规定了SDHC卡的存储容量范围为2GB至32GB；SDXC卡是新提出的标准，不同于SD卡和SDHC卡使用的FAT文件系统，SDXC卡使用exFAT文件系统，即扩展FAT文件系统。SDXC卡采用SD3.0协议规范，该协议规定了SDXC卡的存储容量范围为32GB至2TB（2048GB），一般用于中高端单反相机和高清摄像机。
下表为不同类型的SD卡采用的协议规范、容量等级及读写速度。
表 37.1.1 SD卡的类型、协议规范、容量等级及支持的文件系统
SD卡类型       协议规范       容量等级       支持文件系统
SD       SD1.0       0GB-2GB       FAT12，FAT16
SDHC       SD2.0       2GB-32GB       FAT32
SDXC       SD3.0       32GB-2TB       exFAT
不同协议规范的SD卡有着不同速度等级的表示方法。在SD1.0协议规范中（现在用的较少），使用“X”表示不同的速度等级；在SD2.0协议规范中，使用SpeedClass表示不同的速度等级；SD3.0协议规范使用UHS（Ultra High Speed）表示不同的速度等级。SD2.0规范中对SD卡的速度等级划分为普通卡（Class2、Class4、Class6）和高速卡（Class10）；SD3.0规范对SD卡的速度等级划分为UHS速度等级1和3而在SD4.0中则是UHS-II,它不仅速度等级大大加快，接口也有所变化。不同等级的读写速度和应用如下图所示。

图 37.1.2 SD卡不同速度等级表示法

SD卡共有9个引脚线，可工作在SDIO模式或者SPI模式。在SDIO模式下，共用到CLK、CMD、DAT[3:0]六根信号线；在SPI模式下，共用到CS（SDIO_DAT[3]）、CLK（SDIO_CLK）、MISO（SDIO_DAT[0]）、MOSI（SDIO_CMD）四根信号线。SD卡接口定义以及各引脚功能说明如下图所示。

图 37.1.3 SD卡接口定义以及各引脚功能说明

市面上除标准SD卡外，还有MicroSD卡（原名TF卡，就是本次实验所使用的SD卡），是一种极细小的快闪存储器卡，是由SanDisk(闪迪)公司发明，主要用于移动手机。MicroSD卡插入适配器（Adapter）可以转换成SD卡，其操作时序和SD卡是一样的。MicroSD卡接口定义以及各引脚功能说明如下图所示。

图 37.1.4 MicroSD卡接口定义以及各引脚功能说明

标准SD卡2.0版本中，工作时钟频率可以达到50Mhz，在SDIO模式下采用4位数据位宽，理论上可以达到200Mbps（50Mx4bit）的传输速率；在SPI模式下采用1位数据位宽，理论上可以达到50Mbps的传输速率。因此SD卡在SDIO模式下的传输速率更快，同时其操作时序也更复杂。对于使用SD卡读取音乐文件和图片来说，SPI模式下的传输速度已经能够满足我们的需求，因此我们本章采用SD卡的SPI模式来对SD卡进行读写测试。
SD卡在正常读写操作之前，必须先对SD卡进行初始化，SD卡的初始化过程就是向SD中写入命令，使其工作在预期的工作模式。在对SD卡进行读写操作时同样需要先发送写命令和读命令，因此SD卡的命令格式是学习SD卡的重要内容。SD卡的命令格式由6个字节组成，发送数据时高位在前，SD卡的写入命令格式如下图所示：

图 37.1.5 SD卡命令格式

Byte1：命令字的第一个字节为命令号（如CMD0、CMD1等），格式为“0 1 x x x x x x”。命令号的最高位始终为0，是命令号的起始位；次高位始终为1，是命令号的发送位；低6位为具体的命令号（如CMD55，8’d55 = 8’b0011_0111，命令号为 0 1 1 1 0 1 1 1 = 0x77）。
Byte2~Byte5：命令参数，有些命令参数是保留位，没有定义参数的内容，保留位应设置为0。
Byte6：前7位为CRC（循环冗余校验）校验位，最后一位为停止位0。SD卡在SPI模式下默认不开启CRC校验，在SDIO模式下开启CRC校验。也就是说在SPI模式下，CRC校验位必须要发，但是SD卡会在读到CRC校验位时自动忽略它，所以校验位全部设置为1即可。需要注意的是，SD卡上电默认是SDIO模式，在接收SD卡返回CMD0的响应命令时，拉低片选CS，进入SPI模式。所以在发送CMD0命令的时候，SD卡处于SDIO模式，需要开启CRC校验。另外CMD8的CRC校验是始终启用的，也需要启用CRC校验。除了这两个命令，其它命令的CRC可以不用做校验。
SD卡的命令分为标准命令（如CMD0）和应用相关命令（如ACMD41）。ACMD命令是特殊命令，发送方法同标准命令一样，但是在发送应用相关命令之前，必须先发送CMD55命令，告诉SD卡接下来的命令是应用相关命令，而非标准命令。发送完命令后，SD卡会返回响应命令的信息，不同的CMD命令会有不同类型的返回值，常用的返回值有R1类型、R3类型和R7类型（R7类型是CMD8命令专用）。SD卡的常用命令说明如下表所示。
表 37.1.2 SD卡常用命令说明
命令索引       命令号（HEX）       参数       返回类型       描述
CMD0       0x40       保留位       R1       重置SD卡进入默认状态，如果返回值为0x01，则表示SD卡复位成功
CMD8       0x48       Bit[31:12]：保留位
Bit[11:8]：主机电压范围（VHS）
      0：未定义
      1：2.7V~3.6V
      2：低电压
      4：保留位
      8：保留位
      其它：未定义
Bit[7:0]：校验字节，注意校验字节不是CRC校验位，而是此字节和返回的校验字节相同。如果这个字节写出“0Xaa”，那么当接收CMD8命令回复的数据时接收到的校验字节也是“0XAA”。       R7       发送主机的电压范围以及查询SD卡支持的电压范围，需要注意的是，V1.0版本的卡不支持此命令，只有V2.0版本的卡才支持此命令。如果SD卡返回的值为0x01，则表示此卡为V2.0卡，否则为MMC卡或者V1.0卡
CMD17       0x51       Bit[31:0]：SD卡读扇区地址       R1       SD卡的读命令
CMD24       0x58       Bit[31:0]：SD卡写扇区地址       R1       SD卡的写命令
CMD55       0x77       Bit[31:16]：RCA（SD卡相对地址），在SPI模式下没有用到
Bit[15:0]：保留位       R1       告诉SD卡接下来的命令是应用相关命令，而非标准命令
ACMD41       0x69       Bit[31]：保留位
Bit[30]：HCS（OCR[30]），如果主机支持SDHC或SDXC的卡，此位应设置为1
Bit[29:0]：保留位       R3       要求访问的SD卡发送它的操作条件寄存器（OCR）内容
SD卡返回类型R1数据格式如下图所示：

图 37.1.6 SD卡返回类型R1数据格式

由上图可知，SD卡返回类型R1格式共返回1个字节，最高位固定为0，其它位分别表示对应状态的标志，高电平有效。
SD卡返回类型R3数据格式如下图所示：

图 37.1.7 SD卡返回类型R3数据格式

由上图可知，SD卡返回类型R3格式共返回5个字节，首先返回的第一个字节为前面介绍的R1的内容，其余字节为OCR（Operation Conditions Register，操作条件寄存器）寄存器的内容。
SD卡返回类型R7数据格式如下图所示：

图 37.1.8 SD卡返回类型R7数据格式

由上图可知，SD卡返回类型R7格式共返回5个字节，首先返回的第一个字节为前面介绍的R1的内容，其余字节包含SD卡操作电压信息和校验字节等内容。其中电压范围是一个比较重要的参数，其具体内容如下所示：
Bit[11:8]：操作电压反馈
      0：未定义
      1：2.7V~3.6V
      2：低电压
      4：保留位
      8：保留位
      其它：未定义
SD卡在正常读写操作之前，必须先对SD卡进行初始化，使其工作在预期的工作模式。SD卡1.0版本协议和2.0版本协议在初始化过程中有区别，只有SD2.0版本协议的SD卡才支持CMD8命令，所以响应此命令的SD卡可以判断为SD2.0版本协议的卡，否则为SD1.0版本协议的SD卡或者MMC卡；对于CMD8无响应的情况，可以发送CMD55 + ACMD41命令，如果返回0，则表示SD1.0协议版本卡初始化成功，如果返回错误，则确定为MMC卡；在确定为MMC卡后，继续向卡发送CMD1命令，如果返回0，则MMC卡初始化成功，否则判断为错误卡。
由于市面上大多采用SD2.0版本协议的SD卡，接下来我们仅介绍SD2.0版本协议的初始化流程，以下提到的SD卡均代表基于SD2.0版本协议的SDHC卡，其详细初始化步骤如下：
1，SD卡完成上电后，主机FPGA先对从机SD卡发送至少74个以上的同步时钟，在上电同步期间，片选CS引脚和MOSI引脚必须为高电平（MOSI引脚除发送命令或数据外，其余时刻都为高电平）；
2，拉低片选CS引脚，发送命令CMD0（0x40）复位SD卡，命令发送完成后等待SD卡返回响应数据；
3，SD卡返回响应数据后，先等待8个时钟周期再拉高片选CS信号，此时判断返回的响应数据。如果返回的数据为复位完成信号0x01，在接收返回信息期间片选CS为低电平，此时SD卡进入SPI模式，并开始进行下一步，如果返回的值为其它值，则重新执行第2步；
4，拉低片选CS引脚，发送命令CMD8（0x48）查询SD卡的版本号，只有SD2.0版本的卡才支持此命令，命令发送完成后等待SD卡返回响应数据；
5，SD卡返回响应数据后，先等待8个时钟周期再拉高片选CS信号，此时判断返回的响应数据。如果返回的电压范围为4’b0001即2.7V~3.6V，说明此SD卡为2.0版本，进行下一步，否则重新执行第4步；
拉低片选CS引脚，发送命令CMD55（0x77）告诉SD卡下一次发送的命令是应用相关命令，命令发送完成后等待SD卡返回响应数据；
SD卡返回响应数据后，先等待8个时钟周期再拉高片选CS信号，此时判断返回的响应数据。如果返回的数据为空闲信号0x01，开始进行下一步，否则重新执行第6步。
拉低片选CS引脚，发送命令ACMD41（0x69）查询SD卡是否初始化完成，命令发送完成后等待SD卡返回响应数据；
SD卡返回响应数据后，先等待8个时钟周期再拉高片选CS信号，此时判断返回的响应数据。如果返回的数据为0x00，此时初始化完成，否则重新执行第6步。
SD卡上电复位及初始化命令时序如下图所示：

图 37.1.9 SD卡复位时序图

图 37.1.10 SD卡初始化时序图

至此，SD卡完成了复位以及初始化操作，进入到SPI模式的读写操作。需要注意的是：SD卡在初始化的时候，SPI_CLK的时钟频率不能超过400KHz，在初始化完成之后，再将SPI_CLK的时钟频率切换至SD卡的最大时钟频率。尽管目前市面上的很多SD卡支持以较快的时钟频率进行初始化，为了能够兼容更多的SD卡，在SD卡初始化的时候时钟频率不能超过400KHz。
SD卡读写一次的数据量必须为512字节的整数倍，即对SD卡读写操作的最少数据量为512个字节。我们可以通过命令CMD16来配置单次读写操作的数据长度，以使每次读写的数据量为（n*512）个字节（n≥1），本次SD卡的读写操作使用SD卡默认配置，即单次读写操作的数据量为512个字节。
SD卡初始化完成后，即可对SD卡进行读写测试，SD卡的读写测试是先向SD卡中写入数据，再从SD卡中读出数据，并验证数据的正确性。SD卡的写操作时序图如下图所示：

图 37.1.11 SD卡写操作时序图

SD卡的写操作流程如下：
1、拉低片选CS引脚，发送命令CMD24（0x58）读取单个数据块，命令发送完成后等待SD卡返回响应数据；
2、SD卡返回正确响应数据0x00后，等待至少8个时钟周期，开始发送数据头0xfe；
3、发送完数据头0xfe后，接下来开始发送512个字节的数据；
4、数据发送完成后，发送2个字节的CRC校验数据。由于SPI模式下不对数据进行CRC校验，直接发送两个字节的0xff即可；
5、校验数据发送完成后，等待SD卡响应；
6、SD卡返回响应数据后会进入写忙状态（MISO引脚为低电平），即此时不允许其它操作。当检测到MISO引脚为高电平时，SD卡此时退出写忙状态；
7、拉高CS引脚，等待8个时钟周期后允许进行其它操作。
SD卡的读操作时序图如下图所示：

图 37.1.12 SD卡读操作时序图

SD卡的读操作流程如下：
1、拉低片选CS引脚，发送命令CMD17（0x51）读取单个数据块，命令发送完成后等待SD卡返回响应数据；
2、SD卡返回正确响应数据0x00后，准备开始解析SD卡返回的数据头0xfe；
3、解析到数据头0xfe后，接下来接收SD卡返回的512个字节的数据；
4、数据解析完成后，接下来接收两个字节的CRC校验值。由于SPI模式下不对数据进行CRC校验，可直接忽略这两个字节；
5、校验数据接收完成后，等待8个时钟周期；
6、拉高片选CS引脚，等待8个时钟周期后允许进行其它操作。
在前面介绍的SD卡读写操作中，使用的是SD卡的SPI模式，即采用SPI协议进行读写操作。SPI和IIC都是芯片上常用的通信协议，SPI相比于IIC具有更高的通信速率，但同时占用更多的引脚线，接下来我们了解一下SPI的协议及传输时序。
SPI（Serial Peripheral interface）是由摩托罗拉公司定义的一种串行外围设备接口，是一种高速、全双工、同步的通信总线，只需要四根信号线即可，节约引脚，同时有利于PCB的布局。正是出于这种简单易用的特性，现在越来越多的芯片集成了SPI通信协议，如FLASH、AD转换器等。
SPI的通信原理比较简单，它以主从方式工作，通常有一个主设备（此处指FPGA）和一个或多个从设备（此处指SD卡）。SPI通信需要四根线，分别为SPI_CS、SPI_CLK、SPI_MOSI和SPI_MISO。其中SPI_CS、SPI_CLK和SPI_MOSI由主机输出给从机，而SPI_MISO由从机输出给主机。SPI_CS用于控制芯片是否被选中，也就是说只有片选信号有效时（对于SD卡来说是低电平有效），对芯片的操作才有效；SPI_CLK是由主机产生的同步时钟，用于同步数据；SPI_MOSI和SPI_MISO是主机发送和接收的数据脚。
一般而言，SPI通信有4种不同的模式，不同的从设备在出厂时被厂家配置为其中一种模式，模式是不允许用户修改的。主设备和从设备必须在同一模式下进行通信，否则数据会接收错误。SPI的通信模式是由CPOL（时钟极性）和CPHA（时钟相位）来决定的，四种通信模式如下：
模式0：CPOL = 0，CPHA = 0；
模式1：CPOL = 0，CPHA = 1；
模式2：CPOL = 1，CPHA = 0；
模式3：CPOL = 1，CPHA = 1。
CPOL控制着SPI_CLK的时钟极性，时钟极性变化如下图所示：

图 37.1.13 SPI_CLK时钟极性

由上图可知，当CPOL = 1时，SPI_CLK在空闲时为高电平，发起通信后的第一个时钟沿为下降沿；CPOL = 0时，SPI时钟信号SPI_CLK空闲时为低电平，发起通信后的第一个时钟沿为上升沿。
CPHA用于控制数据与时钟的对齐模式，其不同模式下的时序图如下图所示：

图 37.1.14 不同CPHA模式下的时序图

由上图可知，当CPHA=1时，时钟的第一个变化沿（上升沿或者下降沿）数据开始改变，那么也就意味着时钟的第2个变化沿（与第一个变化沿相反）锁存数据；当CPHA=0时，数据在时钟的第一个变化沿之前就已经改变，并且保持稳定，也就意味着在时钟的第一个变化沿锁存数据。
对于SD卡的SPI模式而言，采用的SPI的通信模式为模式3，即CPOL=1，CPHA=1，在SD卡2.0版本协议中，SPI_CLK时钟频率可达50Mhz。
以上是SD卡简介部分的全部内容，在这里还需要补充下FAT文件系统的知识。如果对SD卡的读写测试像EEPROM一样仅仅是写数据，读数据并验证数据的正确性的话，是不需要FAT文件系统的。而SD卡经常被用来在Windows操作系统上存取数据，必须使用Windows操作系统支持的FAT文件系统才能在电脑上正常使用。
FAT（File Allocation Table，文件分配表）是Windows操作系统所使用的一种文件系统，它的发展过程经历了FAT12、FAT16、FAT32三个阶段。FAT文件系统用“簇”作为数据单元，一个“簇”由一组连续的扇区组成，而一个扇区由512个字节组成。簇所包含的扇区数必须是2的整数次幂，其扇区个数最大为64，即32KB（512Byte * 64 = 32KB）。所有的簇从2开始进行编号，每个簇都有一个自己的地址编号，用户文件和目录都存储在簇中。
FAT文件系统的基本结构依次为：分区引导记录、文件分配表（FAT表1和FAT表2）、根目录和数据区。
分区引导记录：分区引导记录区通常占用分区的第一个扇区，共512个字节。包含四部分内容：BIOS参数记录块BPB（BIOS Parameter Block）、磁盘标志记录表、分区引导记录代码区和结束标志0x55AA。
文件分配表（FAT表1和FAT表2）：文件在磁盘上以簇为单位存储，但是同一个文件的数据并不一定完整地存放在磁盘的一个连续的区域内，往往会分成若干簇，FAT表就是记录文件存储中簇与簇之间连接的信息，这就是文件的链式存储。对于FAT16文件系统来说，每个簇用16Bit来表示文件分配表，而对于FAT32文件系统，使用32Bit来表示文件分配表，这是两者之间的最重要区别。
根目录：根目录是文件或者目录的首簇号。在FAT32文件系统中，不再对根目录的位置做硬性规定，可以存储在分区内可寻址的任意簇内。不过通常根目录是最早建立的(格式化就生成了)目录表，所以我们看到的情况基本上都是根目录首簇紧邻FAT2，占簇区顺序上的第1个簇（即2号簇）。
数据区：数据区紧跟在根目录后面，是文件等数据存放的地方，占用大部分的磁盘空间。
37.2实验任务
本节实验任务是使用FPGA开发板向SD卡指定的扇区地址中写入512个字节的数据，写完后将数据读出，并验证数据是否正确。
37.3硬件设计
我们的达芬奇FPGA开发板上有一个SD卡插槽，用于插入SD卡，其原理图如图 37.3.1所示：

图 37.3.1 SD卡接口原理图

本次实验，我们使用SD卡的SPI模式，只用到了SDIO_D3（SPI_CS）、SDIO_CMD（SPI_MOSI），SDIO_SC（SPI_SCK）和SDIO_D0（SPI_MISO）引脚，而其它两个引脚是在SD卡的SDIO模式下用到的。
本实验中各端口信号的管脚分配如下表所示。
表 37.3.1 SD卡读写测试实验管脚分配
信号名       方向       管脚       端口说明       电平标准
sys_clk       input       R4       系统时钟，50Mhz       LVCMOS33
sys_rst_n       input       U2       系统复位，低有效       LVCMOS33
sd_miso       input       W6       SD卡SPI串行输入数据信号       LVCMOS33
sd_clk       output       V5       SD卡SPI时钟信号       LVCMOS33
sd_cs       output       W4       SD卡SPI片选信号       LVCMOS33
sd_mosi       output       W5       SD卡SPI串行输出数据信号       LVCMOS33
led[3]       output       Y2       LED灯       LVCMOS33
led[2]       output       V2       LED灯       LVCMOS33
led[1]       output       R3       LED灯       LVCMOS33
led[0]       output       R2       LED灯       LVCMOS33
对应的约束语句如下所示：
set_property PACKAGE_PIN R4 [get_ports sys_clk]
set_property PACKAGE_PIN U2 [get_ports sys_rst_n]
set_property IOSTANDARD LVCMOS33 [get_ports sys_clk]
set_property IOSTANDARD LVCMOS33 [get_ports sys_rst_n]
set_property -dict {PACKAGE_PIN W6 IOSTANDARD LVCMOS33} [get_ports sd_miso]
set_property -dict {PACKAGE_PIN W5 IOSTANDARD LVCMOS33} [get_ports sd_mosi]
set_property -dict {PACKAGE_PIN V5 IOSTANDARD LVCMOS33} [get_ports sd_clk]
set_property -dict {PACKAGE_PIN W4 IOSTANDARD LVCMOS33} [get_ports sd_cs]
set_property -dict {PACKAGE_PIN R2 IOSTANDARD LVCMOS15} [get_ports {led[0]}]
set_property -dict {PACKAGE_PIN R3 IOSTANDARD LVCMOS15} [get_ports {led[1]}]
set_property -dict {PACKAGE_PIN V2 IOSTANDARD LVCMOS15} [get_ports {led[2]}]
set_property -dict {PACKAGE_PIN Y2 IOSTANDARD LVCMOS15} [get_ports {led[3]}]
37.4程序设计
通过前面介绍的SD卡初始化、写操作以及读操作可知，SD卡的这个三个操作是相互独立且不能同时进行的，因此我们可以将SD卡的初始化、写操作以及读操作分别划分为三个独立的模块，最后将这三个模块例化在SD卡的控制器模块中，便于在其它工程项目中使用。下图是实验的系统框图，clk_wiz_0是时钟模块用作为各个模块提供驱动时钟，SD卡测试数据产生模块产生测试数据写入SD卡，写完后从SD卡中读出数据，最终读写测试结果由LED显示模块通过控制LED灯的显示状态来指示。

图 37.4.1 SD卡读写测试系统框图

顶层模块的原理图如下图所示：

图 37.4.2 顶层模块原理图

由上图可知，SD卡测试数据产生模块产生的开始写入信号（wr_start_en）及数据（wr_data）连接至SD卡控制器模块，数据写完后输出开始读出信号（rd_start_en）即可从SD卡控制器中读出数据（rd_data），数据测试的结果error_flag连接至LED显示模块，完成各模块之间的数据交互。
FPGA顶层模块（top_sd_rw）例化了以下四个模块：时钟模块（clk_wiz_0）、SD卡测试数据产生模块（data_gen）、SD卡控制器模块（sd_ctrl_top）和LED显示模块（led_alarm）。
顶层模块（top_sd_rw）：顶层模块完成了对其它四个模块的例化，SD卡测试数据产生模块产生的开始写入信号及数据连接至SD卡控制器模块，数据写完后从SD卡控制器中读出数据，并验证数据的正确性，将验证的结果连接至LED显示模块。
时钟模块（clk_wiz_0）：MMCM时钟模块通过调用时钟IP核来实现，总共输出两个时钟，频率都是50Mhz，但两个时钟相位相差180度。我们知道，SD卡的SPI通信模式为CPOL=1，CPHA=1；即SPI_CLK在空闲时为高电平，数据发送是在时钟的第一个边沿，也就是SPI_CLK由高电平到低电平的跳变，所以数据采集是在上升沿，数据发送是在下降沿。为了在程序代码中统一使用上升沿，我们使用两个相位相差180度的时钟来对SD卡进行操作。
SD卡测试数据产生模块（data_gen）：SD卡测试数据产生模块产生的开始写入信号和数据写入SD卡控制器模块中，数据写完后从SD卡控制器中读出数据，并验证数据的正确性，将验证的结果发送给LED显示模块。
SD卡控制器模块（sd_ctrl_top）：SD卡控制器模块例化了SD卡初始化模块（sd_init）、SD卡写数据模块（sd_write）和SD卡读数据模块（sd_read）。SD卡初始化模块完成对SD卡的上电初始化操作；SD卡写数据模块完成对SD卡的写操作；SD卡读数据模块完成对SD卡的读操作。由于这三个模块都操作了SD卡的引脚信号，且这三个模块在同一时间内不会同时操作，所以此模块实现了对其它三个模块的例化以及选择SD卡的引脚连接至其中某一个模块。
LED显示模块（led_alarm）：LED显示模块将SD卡测试数据产生模块输出的验证结果值，通过控制LED灯的显示状态来指示。
顶层模块的代码如下：

1 module top_sd_rw(
2 input sys_clk , //系统时钟
3 input sys_rst_n , //系统复位，低电平有效
4
5 //SD卡接口
6 input sd_miso , //SD卡SPI串行输入数据信号
7 output sd_clk , //SD卡SPI时钟信号
8 output sd_cs , //SD卡SPI片选信号
9 output sd_mosi , //SD卡SPI串行输出数据信号
10
11 //LED
12 output [3:0] led //LED灯
13 );
14
15 //wire define
16 wire clk_ref ;
17 wire clk_ref_180deg ;
18 wire rst_n ;
19 wire locked ;
20 wire clk_100m ;
21 wire wr_start_en ; //开始写SD卡数据信号
22 wire [31:0] wr_sec_addr ; //写数据扇区地址
23 wire [15:0] wr_data ; //写数据
24 wire rd_start_en ; //开始写SD卡数据信号
25 wire [31:0] rd_sec_addr ; //读数据扇区地址
26 wire error_flag ; //SD卡读写错误的标志
27 wire wr_busy ; //写数据忙信号
28 wire wr_req ; //写数据请求信号
29 wire rd_busy ; //读忙信号
30 wire rd_val_en ; //数据读取有效使能信号
31 wire [15:0] rd_val_data ; //读数据
32 wire sd_init_done ; //SD卡初始化完成信号
33
34 //*****************************************************
35 //** main code
36 //*****************************************************
37
38 assign rst_n = sys_rst_n & locked;
39
40 clk_wiz_0 u_clk_wiz_0
41 (
42 // Clock out ports
43 .clk_out1(clk_ref), // output clk_out1
44 .clk_out2(clk_ref_180deg), // output clk_out2
45 .clk_out3(clk_100m),
46 // Status and control signals
47 .reset(1'b0), // input reset
48 .locked(locked), // output locked
49 // Clock in ports
50 .clk_in1(sys_clk)); // input clk_in1
51
52 //产生SD卡测试数据
53 data_gen u_data_gen(
54 .clk (clk_ref),
55 .rst_n (rst_n),
56 .sd_init_done (sd_init_done),
57 .wr_busy (wr_busy),
58 .wr_req (wr_req),
59 .wr_start_en (wr_start_en),
60 .wr_sec_addr (wr_sec_addr),
61 .wr_data (wr_data),
62 .rd_val_en (rd_val_en),
63 .rd_val_data (rd_val_data),
64 .rd_start_en (rd_start_en),
65 .rd_sec_addr (rd_sec_addr),
66 .error_flag (error_flag)
67 );
68
69 //SD卡顶层控制模块
70 sd_ctrl_top u_sd_ctrl_top(
71 .clk_ref (clk_ref),
72 .clk_ref_180deg (clk_ref_180deg),
73 .rst_n (rst_n),
74 //SD卡接口
75 .sd_miso (sd_miso),
76 .sd_clk (sd_clk),
77 .sd_cs (sd_cs),
78 .sd_mosi (sd_mosi),
79 //用户写SD卡接口
80 .wr_start_en (wr_start_en),
81 .wr_sec_addr (wr_sec_addr),
82 .wr_data (wr_data),
83 .wr_busy (wr_busy),
84 .wr_req (wr_req),
85 //用户读SD卡接口
86 .rd_start_en (rd_start_en),
87 .rd_sec_addr (rd_sec_addr),
88 .rd_busy (rd_busy),
89 .rd_val_en (rd_val_en),
90 .rd_val_data (rd_val_data),
91
92 .sd_init_done (sd_init_done)
93 );
94
95 //led警示
96 led_alarm #(
97 .L_TIME (25'd25_000_000)
98 )
99 u_led_alarm(
100 .clk (clk_ref),
101 .rst_n (rst_n),
102 .led (led),
103 .error_flag (error_flag)
104 );
105
106 endmodule

复制代码

SD卡控制器模块输出的sd_init_done（SD卡初始化完成信号）连接至SD卡测试数据产生模块，只有在SD卡初始化完成之后（sd_init_done为高电平），才能对SD卡进行读写测试。SD卡控制器模块将SD卡的初始化以及读写操作封装成方便用户调用的接口，SD卡测试数据产生模块只需对SD卡控制器模块的用户接口进行操作即可完成对SD卡的读写操作。
在代码的第97行定义了一个参数（L_TIME），用于在读写测试错误时控制LED闪烁的时间，其单位是1个时钟周期。因为输入的时钟频率为50Mhz，周期为20ns，所以20 * 25'd25_000_000 = 500ms，因此LED灯在读写错误时每500ms闪烁一次。
SD卡控制器模块的代码如下：

1 module sd_ctrl_top(
2 input clk_ref , //时钟信号
3 input clk_ref_180deg, //时钟信号,与clk_ref相位相差180度
4 input rst_n , //复位信号,低电平有效
5 //SD卡接口
6 input sd_miso , //SD卡SPI串行输入数据信号
7 output sd_clk , //SD卡SPI时钟信号
8 output reg sd_cs , //SD卡SPI片选信号
9 output reg sd_mosi , //SD卡SPI串行输出数据信号
10 //用户写SD卡接口
11 input wr_start_en , //开始写SD卡数据信号
12 input [31:0] wr_sec_addr , //写数据扇区地址
13 input [15:0] wr_data , //写数据
14 output wr_busy , //写数据忙信号
15 output wr_req , //写数据请求信号
16 //用户读SD卡接口
17 input rd_start_en , //开始读SD卡数据信号
18 input [31:0] rd_sec_addr , //读数据扇区地址
19 output rd_busy , //读数据忙信号
20 output rd_val_en , //读数据有效信号
21 output [15:0] rd_val_data , //读数据
22
23 output sd_init_done //SD卡初始化完成信号
24 );
25
26 //wire define
27 wire init_sd_clk ; //初始化SD卡时的低速时钟
28 wire init_sd_cs ; //初始化模块SD片选信号
29 wire init_sd_mosi ; //初始化模块SD数据输出信号
30 wire wr_sd_cs ; //写数据模块SD片选信号
31 wire wr_sd_mosi ; //写数据模块SD数据输出信号
32 wire rd_sd_cs ; //读数据模块SD片选信号
33 wire rd_sd_mosi ; //读数据模块SD数据输出信号
34
35 //*****************************************************
36 //** main code
37 //*****************************************************
38
39 //SD卡的SPI_CLK
40 assign sd_clk = (sd_init_done==1'b0) ? init_sd_clk : clk_ref_180deg;
41
42 //SD卡接口信号选择
43 always @(*) begin
44 //SD卡初始化完成之前,端口信号和初始化模块信号相连
45 if(sd_init_done == 1'b0) begin
46 sd_cs = init_sd_cs;
47 sd_mosi = init_sd_mosi;
48 end
49 else if(wr_busy) begin
50 sd_cs = wr_sd_cs;
51 sd_mosi = wr_sd_mosi;
52 end
53 else if(rd_busy) begin
54 sd_cs = rd_sd_cs;
55 sd_mosi = rd_sd_mosi;
56 end
57 else begin
58 sd_cs = 1'b1;
59 sd_mosi = 1'b1;
60 end
61 end
62
63 //SD卡初始化
64 sd_init u_sd_init(
65 .clk_ref (clk_ref),
66 .rst_n (rst_n),
67
68 .sd_miso (sd_miso),
69 .sd_clk (init_sd_clk),
70 .sd_cs (init_sd_cs),
71 .sd_mosi (init_sd_mosi),
72
73 .sd_init_done (sd_init_done)
74 );
75
76 //SD卡写数据
77 sd_write u_sd_write(
78 .clk_ref (clk_ref),
79 .clk_ref_180deg (clk_ref_180deg),
80 .rst_n (rst_n),
81
82 .sd_miso (sd_miso),
83 .sd_cs (wr_sd_cs),
84 .sd_mosi (wr_sd_mosi),
85 //SD卡初始化完成之后响应写操作
86 .wr_start_en (wr_start_en & sd_init_done),
87 .wr_sec_addr (wr_sec_addr),
88 .wr_data (wr_data),
89 .wr_busy (wr_busy),
90 .wr_req (wr_req)
91 );
92
93 //SD卡读数据
94 sd_read u_sd_read(
95 .clk_ref (clk_ref),
96 .clk_ref_180deg (clk_ref_180deg),
97 .rst_n (rst_n),
98
99 .sd_miso (sd_miso),
100 .sd_cs (rd_sd_cs),
101 .sd_mosi (rd_sd_mosi),
102 //SD卡初始化完成之后响应读操作
103 .rd_start_en (rd_start_en & sd_init_done),
104 .rd_sec_addr (rd_sec_addr),
105 .rd_busy (rd_busy),
106 .rd_val_en (rd_val_en),
107 .rd_val_data (rd_val_data)
108 );
109
110 endmodule

复制代码

SD卡控制器模块例化了SD卡初始化模块（sd_init）、SD卡写数据模块（sd_write）和SD卡读数据模块（sd_read）。由于这三个模块都驱动着SD卡的引脚，因此在代码的第43行开始的always块中，用于选择哪一个模块连接至SD卡的引脚。在代码的第40行，init_sd_clk用于初始化SD卡时提供较慢的时钟，在SD卡初始化完成之后，再将较快的时钟clk_ref_180deg赋值给sd_clk。sd_clk从上电之后，是一直都有时钟的，而我们在前面说过SPI_CLK的时钟在空闲时为高电平或者低电平。事实上，为了简化设计，sd_clk在空闲时提供时钟也是可以的，其是否有效主要由片选信号来控制。
在这里主要介绍下SD卡控制器模块的使用方法。当外部需要对SD卡进行读写操作时，首先要判断sd_init_done（SD卡初始化完成）信号，该信号拉高之后才能对SD卡进行读写操作；在对SD卡进行写操作时，只需给出wr_start_en（开始写SD卡数据信号）和wr_sec_addr（写数据扇区地址），此时SD卡控制器模块会拉高wr_busy信号，开始对SD卡发起写入命令；在命令发起成功后SD卡控制器模块会输出wr_req（写数据请求）信号，此时我们给出wr_data（写数据）即可将数据写入SD卡中；待所有数据写入完成后，wr_busy信号拉低，即可再次发起读写操作。SD卡的读操作是给出rd_start_en（rd_start_en）和rd_sec_addr（读数据扇区地址），此时SD卡控制器会拉高rd_busy（读数据忙）信号，开始对SD卡发起读出命令；在命令发起成功后SD卡控制器模块会输出rd_val_en（读数据有效）信号和rd_val_data（读数据），待所有数据读完之后，拉低rd_busy信号。需要注意的是，SD卡单次写入和读出的数据量为512个字节，因为接口封装为16位数据，所以单次读写操作会有256个16位数据。
SD卡初始化模块完成对SD卡的上电初始化操作，我们在SD卡的简介部分已经详细的介绍了SD卡的初始化流程，我们只需要按照SD卡的初始化步骤即可完成SD卡的初始化。由SD卡的初始化流程可知，其步骤非常适合状态机编写，其状态跳转图如图 37.4.3所示。

图 37.4.3 SD卡初始化状态跳转图

由上图可知，我们把SD卡初始化过程定义为7个状态，分别为st_idle（初始状态）、st_send_cmd0（发送软件复位命令）、st_wait_cmd0（等待SD卡响应）、st_send_cmd8（发送CMD8命令）、st_send_cmd55（发送CMD55命令）、st_send_acmd41（发送ACMD41命令）以及st_init_done（SD卡初始化完成）。因为SD卡的初始化只需要上电后执行一次，所以在初始化完成之后，状态机一直处于st_init_done状态。
SD卡初始化模块的部分代码如下所示：

91 //接收sd卡返回的响应数据
92 //在div_clk_180deg(sd_clk)的上升沿锁存数据
93 always @(posedge div_clk_180deg or negedge rst_n) begin
94 if(!rst_n) begin
95 res_en <= 1'b0;
96 res_data <= 48'd0;
97 res_flag <= 1'b0;
98 res_bit_cnt <= 6'd0;
99 end
100 else begin
101 //sd_miso = 0 开始接收响应数据
102 if(sd_miso == 1'b0 && res_flag == 1'b0) begin
103 res_flag <= 1'b1;
104 res_data <= {res_data[46:0],sd_miso};
105 res_bit_cnt <= res_bit_cnt + 6'd1;
106 res_en <= 1'b0;
107 end
108 else if(res_flag) begin
109 //R1返回1个字节,R3 R7返回5个字节
110 //在这里统一按照6个字节来接收,多出的1个字节为NOP(8个时钟周期的延时)
111 res_data <= {res_data[46:0],sd_miso};
112 res_bit_cnt <= res_bit_cnt + 6'd1;
113 if(res_bit_cnt == 6'd47) begin
114 res_flag <= 1'b0;
115 res_bit_cnt <= 6'd0;
116 res_en <= 1'b1;
117 end
118 end
119 else
120 res_en <= 1'b0;
121 end
122 end

复制代码

在上述代码的always语句块中，我们使用div_clk_180deg（同sd_clk）的上升沿采集SD卡返回的信号，而其它语句块使用div_clk时钟（sd_clk相位偏差180度的时钟）来操作，这是因为SD卡的SPI模式下SD卡的上升沿锁存（采集）数据，在下降沿的时候更新（发送）数据，所以在SD卡的上升沿采集数据是数据保持稳定的时刻，以确保采集的数据不会发送错误。我们知道，SD卡在初始化过程中共返回三种响应类型，分别为R1、R3和R7，其中返回的R3类型和R7类型中包含R1类型，R1类型最高位固定为0，而SD_MISO在空闲时是为高电平状态，因此我们可以通过判断SD_MISO引脚拉低作为开始接收响应信号的条件。
图 37.4.4 和图 37.4.5为SD卡初始化过程中ILA抓取的波形图，从图中我们可以清晰的看到在SD卡正在初始化过程中，其中cur_state是初始化过程的状态机跳变，其中1，2，4，8，16，32分别对应代码中的st_idle，st_send_cmd0，st_wait_cmd0，st_send_cmd8，st_send_cmd55，st_send_acmd41这6个状态，是根据SD卡的数据手册进行的初始化操作（其中16和32两个状态可能会重复多次，直到SD卡给出正确应答），在没有初始化完成时sd_init_done信号是处于低电平的，当SD卡的状态机进入64也就是st_init_done时SD卡就算初始化成功了，此时sd_init_done（初始化完成标志）拉高说明SD卡初始化完成，sd_cs信号拉高，SD卡进入空闲状态，等待下一步操作。

图 37.4.4 SD卡初始化前ILA波形图

图 37.4.5 SD卡初始化完成ILA波形图

SD卡写操作模块的代码如下：

1 module sd_write(
2 input clk_ref , //时钟信号
3 input clk_ref_180deg, //时钟信号,与clk_ref相位相差180度
4 input rst_n , //复位信号,低电平有效
5 //SD卡接口
6 input sd_miso , //SD卡SPI串行输入数据信号
7 output reg sd_cs , //SD卡SPI片选信号
8 output reg sd_mosi , //SD卡SPI串行输出数据信号
9 //用户写接口
10 input wr_start_en , //开始写SD卡数据信号
11 input [31:0] wr_sec_addr , //写数据扇区地址
12 input [15:0] wr_data , //写数据
13 output reg wr_busy , //写数据忙信号
14 output reg wr_req //写数据请求信号
15 );
16
17 //parameter define
18 parameter HEAD_BYTE = 8'hfe ; //数据头
19
20 //reg define
21 reg wr_en_d0 ; //wr_start_en信号延时打拍
22 reg wr_en_d1 ;
23 reg res_en ; //接收SD卡返回数据有效信号
24 reg [7:0] res_data ; //接收SD卡返回数据
25 reg res_flag ; //开始接收返回数据的标志
26 reg [5:0] res_bit_cnt ; //接收位数据计数器
27
28 reg [3:0] wr_ctrl_cnt ; //写控制计数器
29 reg [47:0] cmd_wr ; //写命令
30 reg [5:0] cmd_bit_cnt ; //写命令位计数器
31 reg [3:0] bit_cnt ; //写数据位计数器
32 reg [8:0] data_cnt ; //写入数据数量
33 reg [15:0] wr_data_t ; //寄存写入的数据，防止发生改变
34 reg detect_done_flag ; //检测写空闲信号的标志
35 reg [7:0] detect_data ; //检测到的数据
36
37 //wire define
38 wire pos_wr_en ; //开始写SD卡数据信号的上升沿
39
40 //*****************************************************
41 //** main code
42 //*****************************************************
43
44 assign pos_wr_en = (~wr_en_d1) & wr_en_d0;
45
46 //wr_start_en信号延时打拍
47 always @(posedge clk_ref or negedge rst_n) begin
48 if(!rst_n) begin
49 wr_en_d0 <= 1'b0;
50 wr_en_d1 <= 1'b0;
51 end
52 else begin
53 wr_en_d0 <= wr_start_en;
54 wr_en_d1 <= wr_en_d0;
55 end
56 end
57
58 //接收sd卡返回的响应数据
59 //在clk_ref_180deg(sd_clk)的上升沿锁存数据
60 always @(posedge clk_ref_180deg or negedge rst_n) begin
61 if(!rst_n) begin
62 res_en <= 1'b0;
63 res_data <= 8'd0;
64 res_flag <= 1'b0;
65 res_bit_cnt <= 6'd0;
66 end
67 else begin
68 //sd_miso = 0 开始接收响应数据
69 if(sd_miso == 1'b0 && res_flag == 1'b0) begin
70 res_flag <= 1'b1;
71 res_data <= {res_data[6:0],sd_miso};
72 res_bit_cnt <= res_bit_cnt + 6'd1;
73 res_en <= 1'b0;
74 end
75 else if(res_flag) begin
76 res_data <= {res_data[6:0],sd_miso};
77 res_bit_cnt <= res_bit_cnt + 6'd1;
78 if(res_bit_cnt == 6'd7) begin
79 res_flag <= 1'b0;
80 res_bit_cnt <= 6'd0;
81 res_en <= 1'b1;
82 end
83 end
84 else
85 res_en <= 1'b0;
86 end
87 end
88
89 //写完数据后检测SD卡是否空闲
90 always @(posedge clk_ref or negedge rst_n) begin
91 if(!rst_n)
92 detect_data <= 8'd0;
93 else if(detect_done_flag)
94 detect_data <= {detect_data[6:0],sd_miso};
95 else
96 detect_data <= 8'd0;
97 end
98
99 //SD卡写入数据
100 always @(posedge clk_ref or negedge rst_n) begin
101 if(!rst_n) begin
102 sd_cs <= 1'b1;
103 sd_mosi <= 1'b1;
104 wr_ctrl_cnt <= 4'd0;
105 wr_busy <= 1'b0;
106 cmd_wr <= 48'd0;
107 cmd_bit_cnt <= 6'd0;
108 bit_cnt <= 4'd0;
109 wr_data_t <= 16'd0;
110 data_cnt <= 9'd0;
111 wr_req <= 1'b0;
112 detect_done_flag <= 1'b0;
113 end
114 else begin
115 wr_req <= 1'b0;
116 case(wr_ctrl_cnt)
117 4'd0 : begin
118 wr_busy <= 1'b0; //写空闲
119 sd_cs <= 1'b1;
120 sd_mosi <= 1'b1;
121 if(pos_wr_en) begin
122 cmd_wr <= {8'h58,wr_sec_addr,8'hff}; //写入单个命令块CMD24
123 wr_ctrl_cnt <= wr_ctrl_cnt + 4'd1; //控制计数器加1
124 //开始执行写入数据,拉高写忙信号
125 wr_busy <= 1'b1;
126 end
127 end
128 4'd1 : begin
129 if(cmd_bit_cnt <= 6'd47) begin //开始按位发送写命令
130 cmd_bit_cnt <= cmd_bit_cnt + 6'd1;
131 sd_cs <= 1'b0;
132 sd_mosi <= cmd_wr[6'd47 - cmd_bit_cnt]; //先发送高字节
133 end
134 else begin
135 sd_mosi <= 1'b1;
136 if(res_en) begin //SD卡响应
137 wr_ctrl_cnt <= wr_ctrl_cnt + 4'd1; //控制计数器加1
138 cmd_bit_cnt <= 6'd0;
139 bit_cnt <= 4'd1;
140 end
141 end
142 end
143 4'd2 : begin
144 bit_cnt <= bit_cnt + 4'd1;
145 //bit_cnt = 0~7 等待8个时钟周期
146 //bit_cnt = 8~15,写入命令头8'hfe
147 if(bit_cnt>=4'd8 && bit_cnt <= 4'd15) begin
148 sd_mosi <= HEAD_BYTE[4'd15-bit_cnt]; //先发送高字节
149 if(bit_cnt == 4'd14)
150 wr_req <= 1'b1; //提前拉高写数据请求信号
151 else if(bit_cnt == 4'd15)
152 wr_ctrl_cnt <= wr_ctrl_cnt + 4'd1; //控制计数器加1
153 end
154 end
155 4'd3 : begin //写入数据
156 bit_cnt <= bit_cnt + 4'd1;
157 if(bit_cnt == 4'd0) begin
158 sd_mosi <= wr_data[4'd15-bit_cnt]; //先发送数据高位
159 wr_data_t <= wr_data; //寄存数据
160 end
161 else
162 sd_mosi <= wr_data_t[4'd15-bit_cnt]; //先发送数据高位
163 if((bit_cnt == 4'd14) && (data_cnt <= 9'd255))
164 wr_req <= 1'b1;
165 if(bit_cnt == 4'd15) begin
166 data_cnt <= data_cnt + 9'd1;
167 //写入单个BLOCK共512个字节 = 256 * 16bit
168 if(data_cnt == 9'd255) begin
169 data_cnt <= 9'd0;
170 //写入数据完成,控制计数器加1
171 wr_ctrl_cnt <= wr_ctrl_cnt + 4'd1;
172 end
173 end
174 end
175 //写入2个字节CRC校验,由于SPI模式下不检测校验值,此处写入两个字节的8'hff
176 4'd4 : begin
177 bit_cnt <= bit_cnt + 4'd1;
178 sd_mosi <= 1'b1;
179 //crc写入完成,控制计数器加1
180 if(bit_cnt == 4'd15)
181 wr_ctrl_cnt <= wr_ctrl_cnt + 4'd1;
182 end
183 4'd5 : begin
184 if(res_en) //SD卡响应
185 wr_ctrl_cnt <= wr_ctrl_cnt + 4'd1;
186 end
187 4'd6 : begin //等待写完成
188 detect_done_flag <= 1'b1;
189 //detect_data = 8'hff时,SD卡写入完成,进入空闲状态
190 if(detect_data == 8'hff) begin
191 wr_ctrl_cnt <= wr_ctrl_cnt + 4'd1;
192 detect_done_flag <= 1'b0;
193 end
194 end
195 default : begin
196 //进入空闲状态后,拉高片选信号,等待8个时钟周期
197 sd_cs <= 1'b1;
198 wr_ctrl_cnt <= wr_ctrl_cnt + 4'd1;
199 end
200 endcase
201 end
202 end
203
204 endmodule

复制代码

SD卡写数据模块主要完成对SD卡的写操作，在程序的第18定义了一个参数HEAD_BYTE（SD卡写数据头），在开始写入有效数据之前，必须先发送数据头8’hfe。在代码的第60行开始的always语句块中，同样使用clk_ref_180deg（sd_clk）的上升沿采集数据，其原因同SD初始化模块一样，clk_ref_180deg的上升沿是数据保持稳定的时刻，采集的数据不会发生错误。
在代码第100行开始的always语句块中，使用写计数控制器（wr_ctrl_cnt）控制写入的流程。其流程为首先检测开始写入数据信号（wr_start_en）的上升沿，检测到上升沿之后开始发送写命令（CMD24）；写命令发送完成等待SD卡返回响应信号；SD卡返回响应命令后，等待8个时钟周期，随后写入数据头和数据，注意写数据之前写请求信号要提前拉高，以保证写入数据时刻数据是有效的；发送完数据之后，再次发送两个字节的CRC校验值，由于SPI模式下不对数据做校验，这里发送两个字节的8’hff，然后等待SD卡返回响应数据。在接收完SD卡的响应之后给出标志detect_done_flag，以检测SD卡是否进入空闲状态。当SD卡进入空闲状态后等待8个时钟周期即可重新检测开始写入数据信号（wr_start_en）的上升沿。
图 37.4.6为SD卡写数据过程中ILA抓取的波形图。从图中可以看出，在检测到wr_start_en信号为高电平时开始写数据状态（wr_start_en只拉高一次作为写开始标志），此时wr_busy（写忙信号）开始拉高，sd_cs片选信号拉低，开始对SD卡写命令和数据，当SD卡准备好写入数据时wr_req拉高，每拉高一次写入一个数据，共写入数据256次。在数据及CRC校验写完后detect_done_flag信号拉高，开始等待SD卡空闲。

图 37.4.6 SD卡写数据ILA波形图

图 37.4.7为数据写完后抓取到的ILA波形图。从图中可以看出，SD卡写数据完成wr_data(写数据线）锁定在256，片选信号sd_cs拉高，wr_busy（写忙信号）拉低，detect_done_flag信号由高拉低，说明SD卡再次处于空闲状态此时可以进行下一次写操作。

图 37.4.7 SD卡数据写完成ILA波形图

SD卡读操作模块的代码如下：

1 module sd_read(
2 input clk_ref , //时钟信号
3 input clk_ref_180deg, //时钟信号,与clk_ref相位相差180度
4 input rst_n , //复位信号,低电平有效
5 //SD卡接口
6 input sd_miso , //SD卡SPI串行输入数据信号
7 output reg sd_cs , //SD卡SPI片选信号
8 output reg sd_mosi , //SD卡SPI串行输出数据信号
9 //用户读接口
10 input rd_start_en , //开始读SD卡数据信号
11 input [31:0] rd_sec_addr , //读数据扇区地址
12 output reg rd_busy , //读数据忙信号
13 output reg rd_val_en , //读数据有效信号
14 output reg [15:0] rd_val_data //读数据
15 );
16
17 //reg define
18 reg rd_en_d0 ; //rd_start_en信号延时打拍
19 reg rd_en_d1 ;
20 reg res_en ; //接收SD卡返回数据有效信号
21 reg [7:0] res_data ; //接收SD卡返回数据
22 reg res_flag ; //开始接收返回数据的标志
23 reg [5:0] res_bit_cnt ; //接收位数据计数器
24
25 reg rx_en_t ; //接收SD卡数据使能信号
26 reg [15:0] rx_data_t ; //接收SD卡数据
27 reg rx_flag ; //开始接收的标志
28 reg [3:0] rx_bit_cnt ; //接收数据位计数器
29 reg [8:0] rx_data_cnt ; //接收的数据个数计数器
30 reg rx_finish_en ; //接收完成使能信号
31
32 reg [3:0] rd_ctrl_cnt ; //读控制计数器
33 reg [47:0] cmd_rd ; //读命令
34 reg [5:0] cmd_bit_cnt ; //读命令位计数器
35 reg rd_data_flag ; //准备读取数据的标志
36
37 //wire define
38 wire pos_rd_en ; //开始读SD卡数据信号的上升沿
39
40 //*****************************************************
41 //** main code
42 //*****************************************************
43
44 assign pos_rd_en = (~rd_en_d1) & rd_en_d0;
45
46 //rd_start_en信号延时打拍
47 always @(posedge clk_ref or negedge rst_n) begin
48 if(!rst_n) begin
49 rd_en_d0 <= 1'b0;
50 rd_en_d1 <= 1'b0;
51 end
52 else begin
53 rd_en_d0 <= rd_start_en;
54 rd_en_d1 <= rd_en_d0;
55 end
56 end
57
58 //接收sd卡返回的响应数据
59 //在clk_ref_180deg(sd_clk)的上升沿锁存数据
60 always @(posedge clk_ref_180deg or negedge rst_n) begin
61 if(!rst_n) begin
62 res_en <= 1'b0;
63 res_data <= 8'd0;
64 res_flag <= 1'b0;
65 res_bit_cnt <= 6'd0;
66 end
67 else begin
68 //sd_miso = 0 开始接收响应数据
69 if(sd_miso == 1'b0 && res_flag == 1'b0) begin
70 res_flag <= 1'b1;
71 res_data <= {res_data[6:0],sd_miso};
72 res_bit_cnt <= res_bit_cnt + 6'd1;
73 res_en <= 1'b0;
74 end
75 else if(res_flag) begin
76 res_data <= {res_data[6:0],sd_miso};
77 res_bit_cnt <= res_bit_cnt + 6'd1;
78 if(res_bit_cnt == 6'd7) begin
79 res_flag <= 1'b0;
80 res_bit_cnt <= 6'd0;
81 res_en <= 1'b1;
82 end
83 end
84 else
85 res_en <= 1'b0;
86 end
87 end
88
89 //接收SD卡有效数据
90 //在clk_ref_180deg(sd_clk)的上升沿锁存数据
91 always @(posedge clk_ref_180deg or negedge rst_n) begin
92 if(!rst_n) begin
93 rx_en_t <= 1'b0;
94 rx_data_t <= 16'd0;
95 rx_flag <= 1'b0;
96 rx_bit_cnt <= 4'd0;
97 rx_data_cnt <= 9'd0;
98 rx_finish_en <= 1'b0;
99 end
100 else begin
101 rx_en_t <= 1'b0;
102 rx_finish_en <= 1'b0;
103 //数据头0xfe 8'b1111_1110，所以检测0为起始位
104 if(rd_data_flag && sd_miso == 1'b0 && rx_flag == 1'b0)
105 rx_flag <= 1'b1;
106 else if(rx_flag) begin
107 rx_bit_cnt <= rx_bit_cnt + 4'd1;
108 rx_data_t <= {rx_data_t[14:0],sd_miso};
109 if(rx_bit_cnt == 4'd15) begin
110 rx_data_cnt <= rx_data_cnt + 9'd1;
111 //接收单个BLOCK共512个字节 = 256 * 16bit
112 if(rx_data_cnt <= 9'd255)
113 rx_en_t <= 1'b1;
114 else if(rx_data_cnt == 9'd257) begin //接收两个字节的CRC校验值
115 rx_flag <= 1'b0;
116 rx_finish_en <= 1'b1; //数据接收完成
117 rx_data_cnt <= 9'd0;
118 rx_bit_cnt <= 4'd0;
119 end
120 end
121 end
122 else
123 rx_data_t <= 16'd0;
124 end
125 end
126
127 //寄存输出数据有效信号和数据
128 always @(posedge clk_ref or negedge rst_n) begin
129 if(!rst_n) begin
130 rd_val_en <= 1'b0;
131 rd_val_data <= 16'd0;
132 end
133 else begin
134 if(rx_en_t) begin
135 rd_val_en <= 1'b1;
136 rd_val_data <= rx_data_t;
137 end
138 else
139 rd_val_en <= 1'b0;
140 end
141 end
142
143 //读命令
144 always @(posedge clk_ref or negedge rst_n) begin
145 if(!rst_n) begin
146 sd_cs <= 1'b1;
147 sd_mosi <= 1'b1;
148 rd_ctrl_cnt <= 4'd0;
149 cmd_rd <= 48'd0;
150 cmd_bit_cnt <= 6'd0;
151 rd_busy <= 1'b0;
152 rd_data_flag <= 1'b0;
153 end
154 else begin
155 case(rd_ctrl_cnt)
156 4'd0 : begin
157 rd_busy <= 1'b0;
158 sd_cs <= 1'b1;
159 sd_mosi <= 1'b1;
160 if(pos_rd_en) begin
161 cmd_rd <= {8'h51,rd_sec_addr,8'hff}; //写入单个命令块CMD17
162 rd_ctrl_cnt <= rd_ctrl_cnt + 4'd1; //控制计数器加1
163 //开始执行读取数据,拉高读忙信号
164 rd_busy <= 1'b1;
165 end
166 end
167 4'd1 : begin
168 if(cmd_bit_cnt <= 6'd47) begin //开始按位发送读命令
169 cmd_bit_cnt <= cmd_bit_cnt + 6'd1;
170 sd_cs <= 1'b0;
171 sd_mosi <= cmd_rd[6'd47 - cmd_bit_cnt]; //先发送高字节
172 end
173 else begin
174 sd_mosi <= 1'b1;
175 if(res_en) begin //SD卡响应
176 rd_ctrl_cnt <= rd_ctrl_cnt + 4'd1; //控制计数器加1
177 cmd_bit_cnt <= 6'd0;
178 end
179 end
180 end
181 4'd2 : begin
182 //拉高rd_data_flag信号,准备接收数据
183 rd_data_flag <= 1'b1;
184 if(rx_finish_en) begin //数据接收完成
185 rd_ctrl_cnt <= rd_ctrl_cnt + 4'd1;
186 rd_data_flag <= 1'b0;
187 sd_cs <= 1'b1;
188 end
189 end
190 default : begin
191 //进入空闲状态后,拉高片选信号,等待8个时钟周期
192 sd_cs <= 1'b1;
193 rd_ctrl_cnt <= rd_ctrl_cnt + 4'd1;
194 end
195 endcase
196 end
197 end
198
199 endmodule

复制代码

SD卡读数据模块主要完成对SD卡的读操作。在代码的第60行开始的always语句块和第91行开始的always语句块中，同样采用clk_ref_180deg的上升沿采集数据，其原因同SD初始化模块一样，clk_ref_180deg的上升沿是数据保持稳定的时刻，采集的数据不会发生错误。
在代码第144行开始的always语句块中，使用读计数控制器（rd_ctrl_cnt）控制读取数据的流程。其流程为检测开始读取数据信号（rd_start_en）的上升沿，检测到上升沿之后开始发送读命令（CMD17）；读命令发送完成之后等待SD卡返回响应信号；SD卡返回响应命令后，准备接收SD卡的数据头，因为SD卡的数据头为8’hfe = 8’b1111_1110，所以我们只需要检测SD_MISO输入引脚的第一个低电平即可检测到数据头；检测到数据头之后，紧跟后面的就是256个16位数据和两个字节的CRC校验值，我们只需接收有效数据，CRC的校验值可不用关心；CRC校验接收完成后等待8个时钟周期即可检测开始读取数据信号（rd_start_en）的上升沿，再次对SD卡进行读操作。
图 37.4.8为SD卡读数据过程中ILA逻辑分析仪抓取的波形图。从图中可以看出，在检测到rd_start_en后读数据开始，rd_busy（读忙信号）开始拉高，sd_cs片选信号拉低，开始对SD卡发送读命令但是此时rd_val_data读数据没有值，是因为我们一次接收256个16bit数据，此时数据未完全接收，读数据有效信号没有被拉高；当数据接收完成后，读数据有效信号rd_val_en拉高，此时我们可以看到rd_val_data读数据与wr_data写入的数据完全一致（如图 37.4.9所示），所以确定我们的读写工程功能是正常可以工作的。

图 37.4.8 SD卡开始读数据过程ILA波形图

图 37.4.9 SD卡读数据有效波形图
SD卡测试数据产生模块的代码如下：

1 module data_gen(
2 input clk , //时钟信号
3 input rst_n , //复位信号,低电平有效
4 input sd_init_done , //SD卡初始化完成信号
5 //写SD卡接口
6 input wr_busy , //写数据忙信号
7 input wr_req , //写数据请求信号
8 output reg wr_start_en , //开始写SD卡数据信号
9 output reg [31:0] wr_sec_addr , //写数据扇区地址
10 output [15:0] wr_data , //写数据
11 //读SD卡接口
12 input rd_val_en , //读数据有效信号
13 input [15:0] rd_val_data , //读数据
14 output reg rd_start_en , //开始写SD卡数据信号
15 output reg [31:0] rd_sec_addr , //读数据扇区地址
16
17 output error_flag //SD卡读写错误的标志
18 );
19
20 //reg define
21 reg sd_init_done_d0 ; //sd_init_done信号延时打拍
22 reg sd_init_done_d1 ;
23 reg wr_busy_d0 ; //wr_busy信号延时打拍
24 reg wr_busy_d1 ;
25 reg [15:0] wr_data_t ;
26 reg [15:0] rd_comp_data ; //用于对读出数据作比较的正确数据
27 reg [8:0] rd_right_cnt ; //读出正确数据的个数
28
29 //wire define
30 wire pos_init_done ; //sd_init_done信号的上升沿,用于启动写入信号
31 wire neg_wr_busy ; //wr_busy信号的下降沿,用于判断数据写入完成
32
33 //*****************************************************
34 //** main code
35 //*****************************************************
36
37 assign pos_init_done = (~sd_init_done_d1) & sd_init_done_d0;
38 assign neg_wr_busy = wr_busy_d1 & (~wr_busy_d0);
39 //wr_data_t变化范围0~256;wr_data范围:0~255
40 assign wr_data = (wr_data_t > 16'd0) ? (wr_data_t - 1'b1) : 16'd0;
41 //读256次正确的数据,说明读写测试成功,error_flag = 0
42 assign error_flag = (rd_right_cnt == (9'd256)) ? 1'b0 : 1'b1;
43
44 //sd_init_done信号延时打拍
45 always @(posedge clk or negedge rst_n) begin
46 if(!rst_n) begin
47 sd_init_done_d0 <= 1'b0;
48 sd_init_done_d1 <= 1'b0;
49 end
50 else begin
51 sd_init_done_d0 <= sd_init_done;
52 sd_init_done_d1 <= sd_init_done_d0;
53 end
54 end
55
56 //SD卡写入信号控制
57 always @(posedge clk or negedge rst_n) begin
58 if(!rst_n) begin
59 wr_start_en <= 1'b0;
60 wr_sec_addr <= 32'd0;
61 end
62 else begin
63 if(pos_init_done) begin
64 wr_start_en <= 1'b1;
65 wr_sec_addr <= 32'd2000; //任意指定一块扇区地址
66 end
67 else
68 wr_start_en <= 1'b0;
69 end
70 end
71
72 //SD卡写数据
73 always @(posedge clk or negedge rst_n) begin
74 if(!rst_n)
75 wr_data_t <= 16'b0;
76 else if(wr_req)
77 wr_data_t <= wr_data_t + 16'b1;
78
79 end
80
81 //wr_busy信号延时打拍
82 always @(posedge clk or negedge rst_n) begin
83 if(!rst_n) begin
84 wr_busy_d0 <= 1'b0;
85 wr_busy_d1 <= 1'b0;
86 end
87 else begin
88 wr_busy_d0 <= wr_busy;
89 wr_busy_d1 <= wr_busy_d0;
90 end
91 end
92
93 //SD卡读出信号控制
94 always @(posedge clk or negedge rst_n) begin
95 if(!rst_n) begin
96 rd_start_en <= 1'b0;
97 rd_sec_addr <= 32'd0;
98 end
99 else begin
100 if(neg_wr_busy) begin
101 rd_start_en <= 1'b1;
102 rd_sec_addr <= 32'd2000;
103 end
104 else
105 rd_start_en <= 1'b0;
106 end
107 end
108
109 //读数据错误时给出标志
110 always @(posedge clk or negedge rst_n) begin
111 if(!rst_n) begin
112 rd_comp_data <= 16'd0;
113 rd_right_cnt <= 9'd0;
114 end
115 else begin
116 if(rd_val_en) begin
117 rd_comp_data <= rd_comp_data + 16'b1;
118 if(rd_val_data == rd_comp_data)
119 rd_right_cnt <= rd_right_cnt + 9'd1;
120 end
121 end
122 end
123
124 endmodule

复制代码

在代码的第45行开始的always语句块中，对SD卡控制器的初始化完成信号（sd_init_done）打两拍，以检测SD卡的上升沿，用于发起SD卡的写入操作。在代码的第57行开始的always块中，当检测到SD卡的上升沿之后，开始发起写入操作，即wr_start_en（开始写SD卡数据信号）和wr_sec_addr（wr_sec_addr）。这里需要注意的是，写扇区地址并没有从0开始写，0扇区地址为SD卡的分区引导记录区，如果从0扇区地址开始写入测试数据会破坏SD卡的FAT文件系统，因此我们随意指定SD卡的中间数据区域开始测试，这里是从扇区地址2000开始写入，读出扇区地址和写扇区地址保持一致。
测试数据写完后（wr_busy写忙信号的下降沿代表写完数据），就开始从SD卡中读出数据。需要注意的是代码中的error_flag默认是高电平，即错误状态，正确读取到256次（单个扇区为512个字节，因为接口封装成16位，因此需要读取256次）时才会变成低电平，目的是在未插入SD卡时，SD卡无法完成初始化，也就无法对SD卡进行读写测试，如果此时默认低电平的话，会误以为读写测试正确。
37.5下载验证
首先我们将SD卡（TF卡）插入开发板的SD卡插槽，注意带有金属引脚的一面朝上。接下来将下载器一端连接电脑，另一端与开发板上对应端口连接，最后连接电源线并打开电源开关。
注意：本次实验是基于市面上常用的SD2.0版本协议的MicroSD卡，存储容量为2GB至32GB。
打开工程，下载完成后开发板上的LED灯常亮，说明从SD卡读出的512个字节（256个16位数据）与写入的数据相同，SD卡读写测试程序下载验证成功。

图 37.5.1 实物图

【正点原子FPGA连载】第三十七章SD卡读写测试实验

阿莫论坛20周年了！感谢大家的支持与爱护！！