devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Verilog：【8】基于FPGA实现SD NAND FLASH的SPI协议读写_verilog实现sd卡的读写

作者：不正经 | 2024-05-04 09:34:40

赞

踩

verilog实现sd卡的读写

碎碎念：

终于熬过了期末周，可以开始快乐的开发之旅了。

这一期作为一千粉后的首篇博客，由于之后项目会涉及到相关的部分，因此介绍的是使用FPGA实现SD NAND FLASH的读写操作，以雷龙发展提供的CS创世SD NAND FLASH样品为例，分别讲解电路连接、读写时序与仿真和实验结果。

目录

1 视频讲解

2 SD NAND FLASH背景介绍

3 样品申请

4 电路结构与接口协议

4.1 SD NAND

4.2 SD NAND测试板

4.3 FPGA开发板

5 SD卡协议与时序流程

5.1 SD卡协议

5.2 SD卡2.0版本初始化步骤

5.3 SD卡的读步骤

5.4 SD卡的写步骤

6 模块代码

6.1 sd_card_top

6.2 sd_card_cmd

6.3 sd_card_sec_read_write

6.4 spi_master

6.5 其余代码

6.5.1 sd_card_test

6.5.2 ax_debounce

6.5.3 seg_decoder

6.5.4 seg_scan

7 实验结果

8 参考资料

使用FPGA讲解SD NAND FLASH的文章网上也有很多比较详实的内容，本文的部分思路也是参考了其他博主的博客思路。

1 视频讲解

为了便于更加清晰地讲解内容，本文也将文章的对应部分以视频的形式进行了录制：

（后期正在紧锣密鼓制作ing）

2 SD NAND FLASH背景介绍

目前市面上主流的存储芯片，分为了EEPROM、NOR FLASH、NAND FLASH三种，其中后两种是市面上主要的非易失闪存技术，他们分别具有不同的特点：

1.EEPROM

EEPROM (Electrically Erasable Programmable read only memory)是指带电可擦可编程只读存储器。是一种掉电后数据不丢失的存储芯片。 EEPROM 可以在电脑上或专用设备上擦除已有信息，重新编程。一般用在即插即用设备中。

相较于EEPROM计数，下文提到的FLASH技术，具有更快的速度，工艺上可以分为NOR FLASH和NAND FLASH两种

2.NOR FLASH

NOR FLASH是一种非易失闪存技术。其特点是芯片内执行 (XIP)，应用程序可以直接在存储芯片内运行，不必再把代码读到系统 RAM 中。其传输效率较高高，在 1~4MB 的小容量时具有很高的成本效益。

3.NAND FLASH

NAND FLASH内部采用非线性宏单元模式，这种结构能提供极高的单元密度，并且写入和擦除的速度很快。作为当前最热门的存储芯片，目前生活中常见的电子产品都会使用到这种存储芯片，例如数码相机、U盘等等。

由于NAND FLASH在大容量应用中的便利性，因此作为今天介绍的主角~

什么是SD NAND呢（以下省略FLASH）？下面的内容是从雷龙发展官网的介绍中得到：

SD NAND俗称贴片式TF卡，尽管与TF卡名称类似，但是有较大的区别：

相比常见的TF卡，SD NAND是专门为内置存储进行设计，焊接在PCB板上以供工业级产品的应用。因此对品质稳定性、一致性、以及尺寸都有较高的要求。

下图中左侧即为SD NAND、右侧是常见的TF卡。

3 样品申请

本文所使用的CS创世SD NAND是从深圳雷龙发展申请获得，可以在官网中最上面找到申请样品的入口：

深圳市雷龙发展有限公司创立于2008年，专注NAND Flash设计研发13年。创始人均为步步高/华为技术背景出身。是一家专注于存储元器件代理分销商。 如果有一些技术问题也可以和其公司人员进行沟通，相关的工作人员非常专业和热心。

下图是我收到的测试样品：

4 电路结构与接口协议

4.1 SD NAND

本文所使用的产品是CSNP4GCR01-AMW，是雷龙的第二代产品，产品如下图所示：

数据手册可以在立创商城进行下载，其封装与连接的电路原理参考图如下图所示： 

芯片共包含8个引脚，包括4根数据线（6、7、1、2）；2根电源线（4、8）；1根时钟线（3）；1根命令控制线（5）

手册中提供了SD NAND的两种使用模式，分别为SD MODE 以及 SPI MODE。他们所对应的引脚定义，如下图所示：

对于两种模式的切换，官方给出了初始化的方式。下文在代码的时序部分也会涉及到相关内容。

在对SD卡数据读写速度要求不高的情况下，选用SPI通信模式可以说是一种最佳方案。因为在该模式下，同只需要通过四根线就是可以完成所有的数据交换，可以为我们节省出宝贵的FPGA I/O资源。下图给出了SPI一对一通信时，主设备与从设备之间的连接关系。 

（注：SPI协议详解传送门）

因此本文主要介绍SPI MODE下各个引脚的功能：

引脚功能
CLK同步时钟线，与SPI总线时钟SCK相连
CMD命令控制线，与SPI总线的MOSI相连，主机用于发送命令
SDD0-3只有SDD0使用，与SPI总线MISO相连，用于主机选择从设备
VCC、VSS电源线

确定了通讯模式后，也就便于我们后文中，利用这种通讯模式按照SD卡的读写时序进行读写操作。

4.2 SD NAND测试板

单独的SD NAND不便于我们使用FPGA进行读写测试，好在官方提供了测试板，如下图所示：

有了它就可以轻松实现SD NAND与我们常见的FPGA开发板上的Micro SD插槽进行连接与测试了。

适用产品:LGA8，6x8mm 封装的SD NAND产品。

测试板尺寸:长度6.22厘米，宽度2.49厘米，接口长度2.53厘米。

使用方法:将芯片焊接至测试板上，可在原有的Micro SD卡座上直接调试和测试。

准备工具:热风枪，锡膏，镊子。温度要求:将热风枪温度调至300摄氏度℃即可焊接。

4.3 FPGA开发板

本文所使用的是黑金的AX301开发板，上面装有一个 Micro SD 卡座， FPGA 通过 SPI 数据总线访问 Micro SD 卡,SD 卡座和 FPGA 的硬件电路连接如下：

借由硬件电路的连接，FPGA可以直接与我们的SD NAND进行通信了。

至此，我们已经实现了SD NANDSPI通信方式方案的确定以及基于此的硬件电路连接，下一步就是根据SD卡的读写时序讲通信方式初始化为SPI模式，并按照SD卡协议进行读写操作。

5 SD卡协议与时序流程

5.1 SD卡协议

以下内容来自黑金的实验手册：

SD 卡的协议是一种简单的命令/响应的协议。全部命令由主机发起， SD 卡接收到命令后并返
回响应数据。根据命令的不同，返回的数据内容和长度也不同。 SD 卡命令是一个 6 字节组成的命
令包，其中第一个字节为命令号， 命令号高位 bit7 和 bit6 为固定的“01“，其它 6 个 bit 为具体
的命令号。第 2 个字节到第 5 个字节为命令参数。第 6 个字节为 7 个 bit 的 CRC 校验加 1 个 bit 的结束位。 如果在 SPI 模式的时候， CRC 校验位为可选。 如下图所示， Command 表示命令，通常使用十进制表示名称，例如 CMD17，这个时候 Command 就是十进制的 17。

对于详细的SD卡协议内容，可以参考传送门中的相关内容，给出了比较具体的解释。

SD 卡对每个命令会返回一个响应，每个命令有一定的响应格式。响应的格式跟给它的命令号
有关。在 SPI 模式中，有三种响应格式： R1， R2， R3。

在进行SD NAND的SPI模式读写操作时，主要使用到了以下几种SD卡命令，下面的表格进行简单介绍，这里可以找到完整版：

5.2 SD卡2.0版本初始化步骤

  1. 上电后延时至少 74clock，等待 SD 卡内部操作完成
  2. 片选 CS 低电平选中 SD 卡
  3. 发送 CMD0，需要返回 0x01，进入 Idle 状态
  4. 为了区别 SD 卡是 2.0 还是 1.0，或是 MMC 卡，这里根据协议向上兼容的，首先发送只有SD2.0 才有的命令 CMD8，如果 CMD8 返回无错误，则初步判断为 2.0 卡，进一步循环发送命令 CMD55+ACMD41，直到返回 0x00，确定 SD2.0 卡
  5. 如果 CMD8 返回错误则判断为 1.0 卡还是 MMC 卡，循环发送 CMD55+ACMD41，返回无错误，则为 SD1.0 卡，到此 SD1.0 卡初始成功，如果在一定的循环次数下，返回为错误，则进一步发送 CMD1 进行初始化，如果返回无错误，则确定为 MMC 卡，如果在一定的次数下，返回为错误，则不能识别该卡，初始化结束。 （通过 CMD16 可以改变 SD 卡一次性读写的长度）
  6. CS 拉高

5.3 SD卡的读步骤

  1. 发送 CMD17（单块）或 CMD18（多块）读命令，返回 0X00
  2. 接收数据开始令牌 fe（或 fc） +正式数据 512Bytes + CRC 校验 2Bytes（默认正式传输的数据长度是 512Bytes）

5.4 SD卡的写步骤

  1. 发送 CMD24（单块）或 CMD25（多块）写命令，返回 0X00
  2. 发送数据开始令牌 fe（或 fc） +正式数据 512Bytes + CRC 校验 2Bytes

6 模块代码

本代码所实现的功能，是基于黑金AX301B，实现对SD NAND FLASH的数据写入与读取，并显示在开发板的数码管上。当按下开发板上的按键时，会自动将数据加一操作，并进行同步显示。

前文介绍的是SD NAND的协议以及初始化、读写操作的流程，下面介绍代码的组成部分，整个工程主要由以下部分模块构成：

sd_card_test（top模块）

        ax_debounce:ax_debounce_m0（按键消抖模块）

        sd_card_top:sd_card_top_m0（SD卡top模块）

                sd_card_cmd:sd_card_cmd_m0（SD卡指令）

                sd_card_sec_read_write:sd_card_sec_read_write_m0（SD卡读写）

                spi_master:spi_master_m0（SPI一个字节读写）

        seg_decoder:seg_decoder_m0（数码管控制）

        seg_decoder:seg_decoder_m1（数码管控制）

        seg_scan:seg_scan_m0（数码管控制）

下面主要介绍上述四个加粗的模块以及其功能

6.1 sd_card_top

本模块是SD card的top模块，用来实现不同子模块之间的连接。

  1. //
  2. //                                                                              //
  3. //                                                                              //
  4. //  Author: meisq                                                               //
  5. //          msq@qq.com                                                          //
  6. //          ALINX(shanghai) Technology Co.,Ltd                                  //
  7. //          heijin                                                              //
  8. //     WEB: http://www.alinx.cn/                                                //
  9. //     BBS: http://www.heijin.org/                                              //
  10. //                                                                              //
  11. //
  12. //                                                                              //
  13. // Copyright (c) 2017,ALINX(shanghai) Technology Co.,Ltd                        //
  14. //                    All rights reserved                                       //
  15. //                                                                              //
  16. // This source file may be used and distributed without restriction provided    //
  17. // that this copyright statement is not removed from the file and that any      //
  18. // derivative work contains the original copyright notice and the associated    //
  19. // disclaimer.                                                                  //
  20. //                                                                              //
  21. //
  22.  
  23. //==========================================================================
  24. //  Revision History:
  25. //  Date          By            Revision    Change Description
  26. //--------------------------------------------------------------------------
  27. //  2017/6/21    meisq         1.0         Original
  28. //*************************************************************************/
  29. module sd_card_top
  30. #(
  31. 	parameter  SPI_LOW_SPEED_DIV = 248,         // SD card low speed mode frequency division parameter,spi clk speed = clk speed /((SPI_LOW_SPEED_DIV + 2) * 2 )
  32. 	parameter  SPI_HIGH_SPEED_DIV = 0           // SD card high speed mode frequency division parameter,spi clk speed = clk speed /((SPI_HIGH_SPEED_DIV + 2) * 2 )
  33. )
  34. (
  35. 	input            clk,
  36. 	input            rst,
  37. 	output           SD_nCS,                    //SD card chip select (SPI mode)
  38. 	output           SD_DCLK,                   //SD card clock
  39. 	output           SD_MOSI,                   //SD card controller data output
  40. 	input            SD_MISO,                   //SD card controller data input
  41. 	output           sd_init_done,              //SD card initialization is complete
  42. 	input            sd_sec_read,               //SD card sector read
  43. 	input[31:0]      sd_sec_read_addr,          //SD card sector read address
  44. 	output[7:0]      sd_sec_read_data,          //SD card sector read data
  45. 	output           sd_sec_read_data_valid,    //SD card sector read data valid
  46. 	output           sd_sec_read_end,           //SD card sector read end
  47. 	input            sd_sec_write,              //SD card sector write
  48. 	input[31:0]      sd_sec_write_addr,         //SD card sector write address
  49. 	input[7:0]       sd_sec_write_data,         //SD card sector write data
  50. 	output           sd_sec_write_data_req,     //SD card sector write data next clock is valid
  51. 	output           sd_sec_write_end           //SD card sector write end
  52. );
  53. wire[15:0]           spi_clk_div;               //SPI module clock division parameter
  54. wire                 cmd_req;                   //SD card command request
  55. wire                 cmd_req_ack;               //SD card command request response
  56. wire                 cmd_req_error;             //SD card command request error
  57. wire[47:0]           cmd;                       //SD card command
  58. wire[7:0]            cmd_r1;                    //SD card expect response
  59. wire[15:0]           cmd_data_len;              //SD card command read data length
  60. wire                 block_read_req;            //SD card sector data read request
  61. wire                 block_read_valid;          //SD card sector data read data valid
  62. wire[7:0]            block_read_data;           //SD card sector data read data
  63. wire                 block_read_req_ack;        //SD card sector data read response
  64. wire                 block_write_req;           //SD card sector data write request
  65. wire[7:0]            block_write_data;          //SD card sector data write data next clock is valid
  66. wire                 block_write_data_rd;       //SD card sector data write data
  67. wire                 block_write_req_ack;       //SD card sector data write response
  68.  
  69. wire                 nCS_ctrl;                  //SPI module chip select control
  70. wire                 spi_wr_req;                //SPI module data sending request
  71. wire                 spi_wr_ack;                //SPI module data request response
  72. wire[7:0]            spi_data_in;               //SPI module send data
  73. wire[7:0]            spi_data_out;              //SPI module data returned
  74. wire[15:0]           clk_div;
  75. sd_card_sec_read_write
  76. #(
  77. 	.SPI_LOW_SPEED_DIV(SPI_LOW_SPEED_DIV),
  78. 	.SPI_HIGH_SPEED_DIV(SPI_HIGH_SPEED_DIV)
  79. )
  80. sd_card_sec_read_write_m0(
  81. 	.clk                            (clk                    ),
  82. 	.rst                            (rst                    ),
  83. 	.sd_init_done                   (sd_init_done           ),
  84. 	.sd_sec_read                    (sd_sec_read            ),
  85. 	.sd_sec_read_addr               (sd_sec_read_addr       ),
  86. 	.sd_sec_read_data               (sd_sec_read_data       ),
  87. 	.sd_sec_read_data_valid         (sd_sec_read_data_valid ),
  88. 	.sd_sec_read_end                (sd_sec_read_end        ),
  89. 	.sd_sec_write                   (sd_sec_write           ),
  90. 	.sd_sec_write_addr              (sd_sec_write_addr      ),
  91. 	.sd_sec_write_data              (sd_sec_write_data      ),
  92. 	.sd_sec_write_data_req          (sd_sec_write_data_req  ),
  93. 	.sd_sec_write_end               (sd_sec_write_end       ),
  94. 	.spi_clk_div                    (spi_clk_div            ),
  95. 	.cmd_req                        (cmd_req                ),
  96. 	.cmd_req_ack                    (cmd_req_ack            ),
  97. 	.cmd_req_error                  (cmd_req_error          ),
  98. 	.cmd                            (cmd                    ),
  99. 	.cmd_r1                         (cmd_r1                 ),
  100. 	.cmd_data_len                   (cmd_data_len           ),
  101. 	.block_read_req                 (block_read_req         ),
  102. 	.block_read_valid               (block_read_valid       ),
  103. 	.block_read_data                (block_read_data        ),
  104. 	.block_read_req_ack             (block_read_req_ack     ),
  105. 	.block_write_req                (block_write_req        ),
  106. 	.block_write_data               (block_write_data       ),
  107. 	.block_write_data_rd            (block_write_data_rd    ),
  108. 	.block_write_req_ack            (block_write_req_ack    )
  109. );
  110.  
  111. sd_card_cmd sd_card_cmd_m0(
  112. 	.sys_clk                        (clk                    ),
  113. 	.rst                            (rst                    ),
  114. 	.spi_clk_div                    (spi_clk_div            ),
  115. 	.cmd_req                        (cmd_req                ),
  116. 	.cmd_req_ack                    (cmd_req_ack            ),
  117. 	.cmd_req_error                  (cmd_req_error          ),
  118. 	.cmd                            (cmd                    ),
  119. 	.cmd_r1                         (cmd_r1                 ),
  120. 	.cmd_data_len                   (cmd_data_len           ),
  121. 	.block_read_req                 (block_read_req         ),
  122. 	.block_read_req_ack             (block_read_req_ack     ),
  123. 	.block_read_data                (block_read_data        ),
  124. 	.block_read_valid               (block_read_valid       ),
  125. 	.block_write_req                (block_write_req        ),
  126. 	.block_write_data               (block_write_data       ),
  127. 	.block_write_data_rd            (block_write_data_rd    ),
  128. 	.block_write_req_ack            (block_write_req_ack    ),
  129. 	.nCS_ctrl                       (nCS_ctrl               ),
  130. 	.clk_div                        (clk_div                ),
  131. 	.spi_wr_req                     (spi_wr_req             ),
  132. 	.spi_wr_ack                     (spi_wr_ack             ),
  133. 	.spi_data_in                    (spi_data_in            ),
  134. 	.spi_data_out                   (spi_data_out           )
  135.  
  136. );
  137.  
  138. spi_master spi_master_m0(
  139. 	.sys_clk                        (clk                    ),
  140. 	.rst                            (rst                    ),
  141. 	.nCS                            (SD_nCS                 ),
  142. 	.DCLK                           (SD_DCLK                ),
  143. 	.MOSI                           (SD_MOSI                ),
  144. 	.MISO                           (SD_MISO                ),
  145. 	.clk_div                        (clk_div                ),
  146. 	.CPOL                           (1'b1                   ),
  147. 	.CPHA                           (1'b1                   ),
  148. 	.nCS_ctrl                       (nCS_ctrl               ),
  149. 	.wr_req                         (spi_wr_req             ),
  150. 	.wr_ack                         (spi_wr_ack             ),
  151. 	.data_in                        (spi_data_in            ),
  152. 	.data_out                       (spi_data_out           )
  153. );
  154. endmodule

6.2 sd_card_cmd

sd_card_cmd 模块主要实验 sd 卡基本命令操作，还有上电初始化的 88 个周期的时钟，数据
块的读写，状态机如下：

代码如下：

  1. //
  2. //                                                                              //
  3. //                                                                              //
  4. //  Author: meisq                                                               //
  5. //          msq@qq.com                                                          //
  6. //          ALINX(shanghai) Technology Co.,Ltd                                  //
  7. //          heijin                                                              //
  8. //     WEB: http://www.alinx.cn/                                                //
  9. //     BBS: http://www.heijin.org/                                              //
  10. //                                                                              //
  11. //
  12. //                                                                              //
  13. // Copyright (c) 2017,ALINX(shanghai) Technology Co.,Ltd                        //
  14. //                    All rights reserved                                       //
  15. //                                                                              //
  16. // This source file may be used and distributed without restriction provided    //
  17. // that this copyright statement is not removed from the file and that any      //
  18. // derivative work contains the original copyright notice and the associated    //
  19. // disclaimer.                                                                  //
  20. //                                                                              //
  21. //
  22.  
  23. //==========================================================================
  24. //  Revision History:
  25. //  Date          By            Revision    Change Description
  26. //--------------------------------------------------------------------------
  27. //  2017/6/21     meisq         1.0         Original
  28. //*************************************************************************/
  29. module sd_card_cmd(
  30. 	input                       sys_clk,
  31. 	input                       rst,
  32. 	input[15:0]                 spi_clk_div,                  //SPI module clock division parameter
  33. 	input                       cmd_req,                      //SD card command request
  34. 	output                      cmd_req_ack,                  //SD card command request response
  35. 	output reg                  cmd_req_error,                //SD card command request error
  36. 	input[47:0]                 cmd,                          //SD card command
  37. 	input[7:0]                  cmd_r1,                       //SD card expect response
  38. 	input[15:0]                 cmd_data_len,                 //SD card command read data length
  39. 	input                       block_read_req,               //SD card sector data read request
  40. 	output reg                  block_read_valid,             //SD card sector data read data valid
  41. 	output reg[7:0]             block_read_data,              //SD card sector data read data
  42. 	output                      block_read_req_ack,           //SD card sector data read response
  43. 	input                       block_write_req,              //SD card sector data write request
  44. 	input[7:0]                  block_write_data,             //SD card sector data write data next clock is valid
  45. 	output                      block_write_data_rd,          //SD card sector data write data
  46. 	output                      block_write_req_ack,          //SD card sector data write response
  47. 	output                      nCS_ctrl,                     //SPI module chip select control
  48. 	output reg[15:0]            clk_div,
  49. 	output reg                  spi_wr_req,                   //SPI module data sending request
  50. 	input                       spi_wr_ack,                   //SPI module data request response
  51. 	output[7:0]                 spi_data_in,                  //SPI module send data
  52. 	input[7:0]                  spi_data_out                  //SPI module data returned
  53. );
  54. parameter S_IDLE         = 0;
  55. parameter S_WAIT         = 1;
  56. parameter S_INIT         = 2;
  57. parameter S_CMD_PRE      = 3;
  58. parameter S_CMD          = 4;
  59. parameter S_CMD_DATA     = 5;
  60. parameter S_READ_WAIT    = 6;
  61. parameter S_READ         = 7;
  62. parameter S_READ_ACK     = 8;
  63. parameter S_WRITE_TOKEN  = 9;
  64. parameter S_WRITE_DATA_0 = 10;
  65. parameter S_WRITE_DATA_1 = 11;
  66. parameter S_WRITE_CRC    = 12;
  67. parameter S_WRITE_ACK    = 13;
  68. parameter S_ERR          = 14;
  69. parameter S_END          = 15;
  70.  
  71. reg[3:0]                      state;
  72. reg                           CS_reg;
  73. reg[15:0]                     byte_cnt;
  74. reg[7:0]                      send_data;
  75. wire[7:0]                     data_recv;
  76. reg[9:0]                      wr_data_cnt;
  77.  
  78. assign cmd_req_ack = (state == S_END);
  79. assign block_read_req_ack = (state == S_READ_ACK);
  80. assign block_write_req_ack= (state == S_WRITE_ACK);
  81. assign block_write_data_rd = (state == S_WRITE_DATA_0);
  82. assign spi_data_in = send_data;
  83. assign data_recv = spi_data_out;
  84. assign nCS_ctrl = CS_reg;
  85. always@(posedge sys_clk or posedge rst)
  86. begin
  87. 	if(rst == 1'b1)
  88. 	begin
  89. 		CS_reg <= 1'b1;
  90. 		spi_wr_req <= 1'b0;
  91. 		byte_cnt <= 16'd0;
  92. 		clk_div <= 16'd0;
  93. 		send_data <= 8'hff;
  94. 		state <= S_IDLE;
  95. 		cmd_req_error <= 1'b0;
  96. 		wr_data_cnt <= 10'd0;
  97. 	end
  98. 	else
  99. 		case(state)
  100. 			S_IDLE:
  101. 			begin
  102. 				state <= S_INIT;
  103. 				clk_div <= spi_clk_div;
  104. 				CS_reg <= 1'b1;
  105. 			end
  106. 			S_INIT:
  107. 			begin
  108. 				//send 11 bytes on power(at least 74 SPI clocks)
  109. 				if(spi_wr_ack == 1'b1)
  110. 				begin
  111. 					if(byte_cnt >= 16'd10)
  112. 					begin
  113. 						byte_cnt <= 16'd0;
  114. 						spi_wr_req <= 1'b0;
  115. 						state <= S_WAIT;
  116. 					end
  117. 					begin
  118. 						byte_cnt <= byte_cnt + 16'd1;
  119. 					end
  120. 				end
  121. 				else
  122. 				begin
  123. 					spi_wr_req <= 1'b1;
  124. 					send_data <= 8'hff;
  125. 				end
  126. 			end
  127. 			S_WAIT:
  128. 			begin
  129. 				cmd_req_error <= 1'b0;
  130. 				wr_data_cnt <= 10'd0;
  131. 				//wait for  instruction
  132. 				if(cmd_req == 1'b1)
  133. 					state <= S_CMD_PRE;
  134. 				else if(block_read_req == 1'b1)
  135. 					state <= S_READ_WAIT;
  136. 				else if(block_write_req == 1'b1)
  137. 					state <= S_WRITE_TOKEN;
  138. 				clk_div <= spi_clk_div;
  139. 			end
  140. 			S_CMD_PRE:
  141. 			begin
  142. 				//before sending a command, send an byte 'ff',provide some clocks
  143. 				if(spi_wr_ack == 1'b1)
  144. 				begin
  145. 					state <= S_CMD;
  146. 					spi_wr_req <= 1'b0;
  147. 					byte_cnt <= 16'd0;
  148. 				end
  149. 				else
  150. 				begin
  151. 					spi_wr_req <= 1'b1;
  152. 					CS_reg <= 1'b1;
  153. 					send_data <= 8'hff;
  154. 				end
  155. 			end
  156. 			S_CMD:
  157. 			begin
  158. 				if(spi_wr_ack == 1'b1)
  159. 				begin
  160. 					if((byte_cnt == 16'hffff) || (data_recv != cmd_r1 && data_recv[7] == 1'b0))
  161. 					begin
  162. 						state <= S_ERR;
  163. 						spi_wr_req <= 1'b0;
  164. 					end
  165. 					else if(data_recv == cmd_r1)
  166. 					begin
  167. 						spi_wr_req <= 1'b0;
  168. 						if(cmd_data_len != 16'd0)
  169. 						begin
  170. 							state <= S_CMD_DATA;
  171. 							byte_cnt <= 16'd0;
  172. 						end
  173. 						else
  174. 							state <= S_END;
  175. 					end
  176. 					else
  177. 						byte_cnt <=  byte_cnt + 16'd1;
  178. 				end
  179. 				else
  180. 				begin
  181. 					spi_wr_req <= 1'b1;
  182. 					CS_reg <= 1'b0;
  183. 					if(byte_cnt == 16'd0)
  184. 						send_data <= (cmd[47:40] | 8'h40);
  185. 					else if(byte_cnt == 16'd1)
  186. 						send_data <= cmd[39:32];
  187. 					else if(byte_cnt == 16'd2)
  188. 						send_data <= cmd[31:24];
  189. 					else if(byte_cnt == 16'd3)
  190. 						send_data <= cmd[23:16];
  191. 					else if(byte_cnt == 16'd4)
  192. 						send_data <= cmd[15:8];
  193. 					else if(byte_cnt == 16'd5)
  194. 						send_data <= cmd[7:0];
  195. 					else
  196. 						send_data <= 8'hff;
  197. 				end
  198. 			end
  199. 			S_CMD_DATA:
  200. 			begin
  201. 				if(spi_wr_ack == 1'b1)
  202. 				begin
  203. 					if(byte_cnt == cmd_data_len - 16'd1)
  204. 					begin
  205. 						state <= S_END;
  206. 						spi_wr_req <= 1'b0;
  207. 						byte_cnt <= 16'd0;
  208. 					end
  209. 					else
  210. 					begin
  211. 						byte_cnt <= byte_cnt + 16'd1;
  212. 					end
  213. 				end
  214. 				else
  215. 				begin
  216. 					spi_wr_req <= 1'b1;
  217. 					send_data <= 8'hff;
  218. 				end
  219. 			end
  220. 			S_READ_WAIT:
  221. 			begin
  222. 				if(spi_wr_ack == 1'b1 && data_recv == 8'hfe)
  223. 				begin
  224. 					spi_wr_req <= 1'b0;
  225. 					state <= S_READ;
  226. 					byte_cnt <= 16'd0;
  227. 				end
  228. 				else
  229. 				begin
  230. 					spi_wr_req <= 1'b1;
  231. 					send_data <= 8'hff;
  232. 				end
  233. 			end
  234. 			S_READ:
  235. 			begin
  236. 				if(spi_wr_ack == 1'b1)
  237. 				begin
  238. 					if(byte_cnt == 16'd513)
  239. 					begin
  240. 						state <= S_READ_ACK;
  241. 						spi_wr_req <= 1'b0;
  242. 						byte_cnt <= 16'd0;
  243. 					end
  244. 					else
  245. 					begin
  246. 						byte_cnt <= byte_cnt + 16'd1;
  247. 					end
  248. 				end
  249. 				else
  250. 				begin
  251. 					spi_wr_req <= 1'b1;
  252. 					send_data <= 8'hff;
  253. 				end
  254. 			end
  255. 			S_WRITE_TOKEN:
  256. 				if(spi_wr_ack == 1'b1)
  257. 				begin
  258. 					state <= S_WRITE_DATA_0;
  259. 					spi_wr_req <= 1'b0;
  260. 				end
  261. 				else
  262. 				begin
  263. 					spi_wr_req <= 1'b1;
  264. 					send_data <= 8'hfe;
  265. 				end
  266. 			S_WRITE_DATA_0:
  267. 			begin
  268. 				state <= S_WRITE_DATA_1;
  269. 				wr_data_cnt <= wr_data_cnt + 10'd1;
  270. 			end
  271. 			S_WRITE_DATA_1:
  272. 			begin
  273. 				if(spi_wr_ack == 1'b1 && wr_data_cnt == 10'd512)
  274. 				begin
  275. 					state <= S_WRITE_CRC;
  276. 					spi_wr_req <= 1'b0;
  277. 				end
  278. 				else if(spi_wr_ack == 1'b1)
  279. 				begin
  280. 					state <= S_WRITE_DATA_0;
  281. 					spi_wr_req <= 1'b0;
  282. 				end
  283. 				else
  284. 				begin
  285. 					spi_wr_req <= 1'b1;
  286. 					send_data <= block_write_data;
  287. 				end
  288. 			end
  289. 			S_WRITE_CRC:
  290. 			begin
  291. 				if(spi_wr_ack == 1'b1)
  292. 				begin
  293. 					if(byte_cnt == 16'd2)
  294. 					begin
  295. 						state <= S_WRITE_ACK;
  296. 						spi_wr_req <= 1'b0;
  297. 						byte_cnt <= 16'd0;
  298. 					end
  299. 					else
  300. 					begin
  301. 						byte_cnt <= byte_cnt + 16'd1;
  302. 					end
  303. 				end
  304. 				else
  305. 				begin
  306. 					spi_wr_req <= 1'b1;
  307. 					send_data <= 8'hff;
  308. 				end
  309. 			end
  310. 			S_ERR:
  311. 			begin
  312. 				state <= S_END;
  313. 				cmd_req_error <= 1'b1;
  314. 			end
  315. 			S_READ_ACK,S_WRITE_ACK,S_END:
  316. 			begin
  317. 				state <= S_WAIT;
  318. 			end
  319. 			default:
  320. 				state <= S_IDLE;
  321. 		endcase
  322. end
  323. always@(posedge sys_clk or posedge rst)
  324. begin
  325. 	if(rst == 1'b1)
  326. 		block_read_valid <= 1'b0;
  327. 	else if(state == S_READ && byte_cnt < 16'd512)
  328. 		block_read_valid <= spi_wr_ack;
  329. 	else
  330. 		block_read_valid <= 1'b0;
  331. end
  332.  
  333. always@(posedge sys_clk or posedge rst)
  334. begin
  335. 	if(rst == 1'b1)
  336. 		block_read_data <= 8'd0;
  337. 	else if(state == S_READ && spi_wr_ack == 1'b1)
  338. 		block_read_data <= data_recv;
  339. end
  341. endmodule

6.3 sd_card_sec_read_write

sd_card_sec_read_write 模块继续完成 SD 卡初始化，然后等待扇区读写指令，并完成扇区的
读写操作。 下图为模块的状态机转换图，首先发送 CMD0 命令，然后发送 CMD8 命令，再发送
CMD55，接着发送 ACMD41，如果应答正常， sd 卡初始化完成，等待扇区的读写。
 

代码如下： 

  1. //
  2. //                                                                              //
  3. //                                                                              //
  4. //  Author: meisq                                                               //
  5. //          msq@qq.com                                                          //
  6. //          ALINX(shanghai) Technology Co.,Ltd                                  //
  7. //          heijin                                                              //
  8. //     WEB: http://www.alinx.cn/                                                //
  9. //     BBS: http://www.heijin.org/                                              //
  10. //                                                                              //
  11. //
  12. //                                                                              //
  13. // Copyright (c) 2017,ALINX(shanghai) Technology Co.,Ltd                        //
  14. //                    All rights reserved                                       //
  15. //                                                                              //
  16. // This source file may be used and distributed without restriction provided    //
  17. // that this copyright statement is not removed from the file and that any      //
  18. // derivative work contains the original copyright notice and the associated    //
  19. // disclaimer.                                                                  //
  20. //                                                                              //
  21. //
  22.  
  23. //===============================================================================
  24. //  Revision History:
  25. //  Date          By            Revision    Change Description
  26. //-------------------------------------------------------------------------------
  27. //  2017/6/21     meisq         1.0         Original
  28. //*******************************************************************************/
  29. module sd_card_sec_read_write
  30. #(
  31. 	parameter  SPI_LOW_SPEED_DIV = 248,         // spi clk speed = clk speed /((SPI_LOW_SPEED_DIV + 2) * 2 )
  32. 	parameter  SPI_HIGH_SPEED_DIV = 0           // spi clk speed = clk speed /((SPI_HIGH_SPEED_DIV + 2) * 2 )
  33. )
  34. (
  35. 	input            clk,
  36. 	input            rst,
  37. 	output reg       sd_init_done,
  38. 	input            sd_sec_read,
  39. 	input[31:0]      sd_sec_read_addr,
  40. 	output[7:0]      sd_sec_read_data,
  41. 	output           sd_sec_read_data_valid,
  42. 	output           sd_sec_read_end,
  43. 	input            sd_sec_write,
  44. 	input[31:0]      sd_sec_write_addr,
  45. 	input[7:0]       sd_sec_write_data,
  46. 	output           sd_sec_write_data_req,
  47. 	output           sd_sec_write_end,
  48.  
  49. 	output reg[15:0] spi_clk_div,
  50. 	output reg       cmd_req,
  51. 	input            cmd_req_ack,
  52. 	input            cmd_req_error,
  53. 	output reg[47:0] cmd,
  54. 	output reg[7:0]  cmd_r1,
  55. 	output reg[15:0] cmd_data_len,
  56. 	output reg       block_read_req,
  57. 	input            block_read_valid,
  58. 	input[7:0]       block_read_data,
  59. 	input            block_read_req_ack,
  60. 	output reg       block_write_req,
  61. 	output[7:0]      block_write_data,
  62. 	input            block_write_data_rd,
  63. 	input            block_write_req_ack
  64. );
  65. reg[7:0] read_data;
  66. reg[31:0] timer;
  67.  
  68. localparam S_IDLE               = 0;
  69. localparam S_CMD0               = 1;
  70. localparam S_CMD8               = 2;
  71. localparam S_CMD55              = 3;
  72. localparam S_CMD41              = 4;
  73. localparam S_CMD17              = 5;
  74. localparam S_READ               = 6;
  75. localparam S_CMD24              = 7;
  76. localparam S_WRITE              = 8;
  77. localparam S_ERR                = 14;
  78. localparam S_WRITE_END          = 15;
  79. localparam S_READ_END           = 16;
  80. localparam S_WAIT_READ_WRITE    = 17;
  81. localparam S_CMD16              = 18;
  82.  
  83. reg[4:0]                       state;
  84. reg[31:0]                      sec_addr;
  85. assign sd_sec_read_data_valid = (state == S_READ) && block_read_valid;
  86. assign sd_sec_read_data = block_read_data;
  87. assign sd_sec_read_end = (state == S_READ_END);
  88. assign sd_sec_write_data_req = (state == S_WRITE) && block_write_data_rd;
  89. assign block_write_data = sd_sec_write_data;
  90. assign sd_sec_write_end = (state == S_WRITE_END);
  91.  
  92. always@(posedge clk or posedge rst)
  93. begin
  94. 	if(rst == 1'b1)
  95. 	begin
  96. 		state <= S_IDLE;
  97. 		cmd_req <= 1'b0;
  98. 		cmd_data_len <= 16'd0;
  99. 		cmd_r1 <= 8'd0;
  100. 		cmd <= 48'd0;
  101. 		spi_clk_div <= SPI_LOW_SPEED_DIV[15:0];
  102. 		block_write_req <= 1'b0;
  103. 		block_read_req <= 1'b0;
  104. 		sec_addr <= 32'd0;
  105. 		sd_init_done <= 1'b0;
  106. 	end
  107. 	else
  108. 		case(state)
  109. 			S_IDLE:
  110. 			begin
  111. 				state <= S_CMD0;
  112. 				sd_init_done <= 1'b0;
  113. 				spi_clk_div <= SPI_LOW_SPEED_DIV[15:0];
  114. 			end
  115. 			S_CMD0:
  116. 			begin
  117. 				if(cmd_req_ack & ~cmd_req_error)
  118. 				begin
  119. 					state <= S_CMD8;
  120. 					cmd_req <= 1'b0;
  121. 				end
  122. 				else
  123. 				begin
  124. 					cmd_req <= 1'b1;
  125. 					cmd_data_len <= 16'd0;
  126. 					cmd_r1 <= 8'h01;
  127. 					cmd <= {8'd0,8'h00,8'h00,8'h00,8'h00,8'h95};
  128. 				end
  129. 			end
  130. 			S_CMD8:
  131. 			begin
  132. 				if(cmd_req_ack & ~cmd_req_error)
  133. 				begin
  134. 					state <= S_CMD55;
  135. 					cmd_req <= 1'b0;
  136. 				end
  137. 				else
  138. 				begin
  139. 					cmd_req <= 1'b1;
  140. 					cmd_data_len <= 16'd4;
  141. 					cmd_r1 <= 8'h01;
  142. 					cmd <= {8'd8,8'h00,8'h00,8'h01,8'haa,8'h87};
  143. 				end
  144. 			end
  145. 			S_CMD55:
  146. 			begin
  147. 				if(cmd_req_ack & ~cmd_req_error)
  148. 				begin
  149. 					state <= S_CMD41;
  150. 					cmd_req <= 1'b0;
  151. 				end
  152. 				else
  153. 				begin
  154. 					cmd_req <= 1'b1;
  155. 					cmd_data_len <= 16'd0;
  156. 					cmd_r1 <= 8'h01;
  157. 					cmd <= {8'd55,8'h00,8'h00,8'h00,8'h00,8'hff};
  158. 				end
  159. 			end
  160. 			S_CMD41:
  161. 			begin
  162. 				if(cmd_req_ack & ~cmd_req_error)
  163. 				begin
  164. 					state <= S_CMD16;
  165. 					cmd_req <= 1'b0;
  166. 					sd_init_done <= 1'b1;
  167. 					spi_clk_div <= SPI_HIGH_SPEED_DIV[15:0];
  168. 				end
  169. 				else if(cmd_req_ack)
  170. 				begin
  171. 					state <= S_CMD55;
  172. 				end
  173. 				else
  174. 				begin
  175. 					cmd_req <= 1'b1;
  176. 					cmd_data_len <= 16'd0;
  177. 					cmd_r1 <= 8'h00;
  178. 					cmd <= {8'd41,8'h40,8'h00,8'h00,8'h00,8'hff};
  179. 				end
  180. 			end
  181. 			S_CMD16:
  182. 			begin
  183. 				if(cmd_req_ack & ~cmd_req_error)
  184. 				begin
  185. 					state <= S_WAIT_READ_WRITE;
  186. 					cmd_req <= 1'b0;
  187. 					sd_init_done <= 1'b1;
  188. 					spi_clk_div <= SPI_HIGH_SPEED_DIV[15:0];
  189. 				end
  190. 				else if(cmd_req_ack)
  191. 				begin
  192. 					state <= S_CMD55;
  193. 				end
  194. 				else
  195. 				begin
  196. 					cmd_req <= 1'b1;
  197. 					cmd_data_len <= 16'd0;
  198. 					cmd_r1 <= 8'h00;
  199. 					cmd <= {8'd16,32'd512,8'hff};
  200. 				end
  201. 			end			
  202. 			S_WAIT_READ_WRITE:
  203. 			begin
  204. 				if(sd_sec_write ==  1'b1)
  205. 				begin
  206. 					state <= S_CMD24;
  207. 					sec_addr <= sd_sec_write_addr;
  208. 				end
  209. 				else if(sd_sec_read == 1'b1)
  210. 				begin
  211. 					state <= S_CMD17;
  212. 					sec_addr <= sd_sec_read_addr;
  213. 				end
  215. 				spi_clk_div <= 16'd0;
  216. 			end
  217. 			S_CMD24:
  218. 			begin
  219. 				if(cmd_req_ack & ~cmd_req_error)
  220. 				begin
  221. 					state <= S_WRITE;
  222. 					cmd_req <= 1'b0;
  223. 				end
  224. 				else
  225. 				begin
  226. 					cmd_req <= 1'b1;
  227. 					cmd_data_len <= 16'd0;
  228. 					cmd_r1 <= 8'h00;
  229. 					cmd <= {8'd24,sec_addr,8'hff};
  230.  
  231. 				end
  232. 			end
  233. 			S_WRITE:
  234. 			begin
  235. 				if(block_write_req_ack == 1'b1)
  236. 				begin
  237. 					block_write_req <= 1'b0;
  238. 					state <= S_WRITE_END;
  239. 				end
  240. 				else
  241. 					block_write_req <= 1'b1;
  242. 			end
  243. 			S_CMD17:
  244. 			begin
  245. 				if(cmd_req_ack & ~cmd_req_error)
  246. 				begin
  247. 					state <= S_READ;
  248. 					cmd_req <= 1'b0;
  249. 				end
  250. 				else
  251. 				begin
  252. 					cmd_req <= 1'b1;
  253. 					cmd_data_len <= 16'd0;
  254. 					cmd_r1 <= 8'h00;
  255. 					cmd <= {8'd17,sec_addr,8'hff};
  256. 				end
  257. 			end
  258. 			S_READ:
  259. 			begin
  260. 				if(block_read_req_ack)
  261. 				begin
  262. 					state <= S_READ_END;
  263. 					block_read_req <= 1'b0;
  264. 				end
  265. 				else
  266. 				begin
  267. 					block_read_req <= 1'b1;
  268. 				end
  269. 			end
  270. 			S_WRITE_END:
  271. 			begin
  272. 				state <= S_WAIT_READ_WRITE;
  273. 			end
  274. 			S_READ_END:
  275. 			begin
  276. 				state <= S_WAIT_READ_WRITE;
  277. 			end
  278. 			default:
  279. 				state <= S_IDLE;
  280. 		endcase
  281. end
  282. endmodule

6.4 spi_master

这一模块用来完成SPI一个字节的读写。

spi master 状态机设计， 主要完成一个字节 spi 数据的读写，由于是全双工的，写一个字节的
同时也读一个字节。 首先空闲状态“IDLE”接收到写请求后进入“DCLK_IDLE”状态，这个状态为
spi 时钟沿变化保持一定的时间，用来控制 spi 时钟的周期，然后进入 spi 时钟沿的变化状态，一
个字节上升沿和下降沿一共 16 个数据沿。 在最后一个数据沿进入“LAST_HALF_CYCLE”状态，为
让最后一个沿也保持一定的时间，再进入应答状态，完成一次写请求。spi_master 模块中模拟了一个 spi 时钟，在状态机进入到‘DCLK_EDGE’时进行翻转。状态机图示如下：

 代码如下：

  1. //
  2. //                                                                              //
  3. //                                                                              //
  4. //  Author: meisq                                                               //
  5. //          msq@qq.com                                                          //
  6. //          ALINX(shanghai) Technology Co.,Ltd                                  //
  7. //          heijin                                                              //
  8. //     WEB: http://www.alinx.cn/                                                //
  9. //     BBS: http://www.heijin.org/                                              //
  10. //                                                                              //
  11. //
  12. //                                                                              //
  13. // Copyright (c) 2017,ALINX(shanghai) Technology Co.,Ltd                        //
  14. //                    All rights reserved                                       //
  15. //                                                                              //
  16. // This source file may be used and distributed without restriction provided    //
  17. // that this copyright statement is not removed from the file and that any      //
  18. // derivative work contains the original copyright notice and the associated    //
  19. // disclaimer.                                                                  //
  20. //                                                                              //
  21. //
  22.  
  23. //==========================================================================
  24. //  Revision History:
  25. //  Date          By            Revision    Change Description
  26. //--------------------------------------------------------------------------
  27. //  2017/6/19     meisq         1.0         Original
  28. //*************************************************************************/
  29. module spi_master
  30. (
  31. 	input                       sys_clk,
  32. 	input                       rst,
  33. 	output                      nCS,       //chip select (SPI mode)
  34. 	output                      DCLK,      //spi clock
  35. 	output                      MOSI,      //spi data output
  36. 	input                       MISO,      //spi input
  37. 	input                       CPOL,
  38. 	input                       CPHA,
  39. 	input                       nCS_ctrl,
  40. 	input[15:0]                 clk_div,
  41. 	input                       wr_req,
  42. 	output                      wr_ack,
  43. 	input[7:0]                  data_in,
  44. 	output[7:0]                 data_out
  45. );
  46. localparam                   IDLE            = 0;
  47. localparam                   DCLK_EDGE       = 1;
  48. localparam                   DCLK_IDLE       = 2;
  49. localparam                   ACK             = 3;
  50. localparam                   LAST_HALF_CYCLE = 4;
  51. localparam                   ACK_WAIT        = 5;
  52. reg                          DCLK_reg;
  53. reg[7:0]                     MOSI_shift;
  54. reg[7:0]                     MISO_shift;
  55. reg[2:0]                     state;
  56. reg[2:0]                     next_state;
  57. reg [15:0]                   clk_cnt;
  58. reg[4:0]                     clk_edge_cnt;
  59. assign MOSI = MOSI_shift[7];
  60. assign DCLK = DCLK_reg;
  61. assign data_out = MISO_shift;
  62. assign wr_ack = (state == ACK);
  63. assign nCS = nCS_ctrl;
  64. always@(posedge sys_clk or posedge rst)
  65. begin
  66. 	if(rst)
  67. 		state <= IDLE;
  68. 	else
  69. 		state <= next_state;
  70. end
  71.  
  72. always@(*)
  73. begin
  74. 	case(state)
  75. 		IDLE:
  76. 			if(wr_req == 1'b1)
  77. 				next_state <= DCLK_IDLE;
  78. 			else
  79. 				next_state <= IDLE;
  80. 		DCLK_IDLE:
  81. 			//half a SPI clock cycle produces a clock edge
  82. 			if(clk_cnt == clk_div)
  83. 				next_state <= DCLK_EDGE;
  84. 			else
  85. 				next_state <= DCLK_IDLE;
  86. 		DCLK_EDGE:
  87. 			//a SPI byte with a total of 16 clock edges
  88. 			if(clk_edge_cnt == 5'd15)
  89. 				next_state <= LAST_HALF_CYCLE;
  90. 			else
  91. 				next_state <= DCLK_IDLE;
  92. 		//this is the last data edge
  93. 		LAST_HALF_CYCLE:
  94. 			if(clk_cnt == clk_div)
  95. 				next_state <= ACK;
  96. 			else
  97. 				next_state <= LAST_HALF_CYCLE;
  98. 		//send one byte complete
  99. 		ACK:
  100. 			next_state <= ACK_WAIT;
  101. 		//wait for one clock cycle, to ensure that the cancel request signal
  102. 		ACK_WAIT:
  103. 			next_state <= IDLE;
  104. 		default:
  105. 			next_state <= IDLE;
  106. 	endcase
  107. end
  108.  
  109. always@(posedge sys_clk or posedge rst)
  110. begin
  111. 	if(rst)
  112. 		DCLK_reg <= 1'b0;
  113. 	else if(state == IDLE)
  114. 		DCLK_reg <= CPOL;
  115. 	else if(state == DCLK_EDGE)
  116. 		DCLK_reg <= ~DCLK_reg;//SPI clock edge
  117. end
  118. //SPI clock wait counter
  119. always@(posedge sys_clk or posedge rst)
  120. begin
  121. 	if(rst)
  122. 		clk_cnt <= 16'd0;
  123. 	else if(state == DCLK_IDLE || state == LAST_HALF_CYCLE)
  124. 		clk_cnt <= clk_cnt + 16'd1;
  125. 	else
  126. 		clk_cnt <= 16'd0;
  127. end
  128. //SPI clock edge counter
  129. always@(posedge sys_clk or posedge rst)
  130. begin
  131. 	if(rst)
  132. 		clk_edge_cnt <= 5'd0;
  133. 	else if(state == DCLK_EDGE)
  134. 		clk_edge_cnt <= clk_edge_cnt + 5'd1;
  135. 	else if(state == IDLE)
  136. 		clk_edge_cnt <= 5'd0;
  137. end
  138. //SPI data output
  139. always@(posedge sys_clk or posedge rst)
  140. begin
  141. 	if(rst)
  142. 		MOSI_shift <= 8'd0;
  143. 	else if(state == IDLE && wr_req)
  144. 		MOSI_shift <= data_in;
  145. 	else if(state == DCLK_EDGE)
  146. 		if(CPHA == 1'b0 && clk_edge_cnt[0] == 1'b1)
  147. 			MOSI_shift <= {MOSI_shift[6:0],MOSI_shift[7]};
  148. 		else if(CPHA == 1'b1 && (clk_edge_cnt != 5'd0 && clk_edge_cnt[0] == 1'b0))
  149. 			MOSI_shift <= {MOSI_shift[6:0],MOSI_shift[7]};
  150. end
  151. //SPI data input
  152. always@(posedge sys_clk or posedge rst)
  153. begin
  154. 	if(rst)
  155. 		MISO_shift <= 8'd0;
  156. 	else if(state == IDLE && wr_req)
  157. 		MISO_shift <= 8'h00;
  158. 	else if(state == DCLK_EDGE)
  159. 		if(CPHA == 1'b0 && clk_edge_cnt[0] == 1'b0)
  160. 			MISO_shift <= {MISO_shift[6:0],MISO};
  161. 		else if(CPHA == 1'b1 && (clk_edge_cnt[0] == 1'b1))
  162. 			MISO_shift <= {MISO_shift[6:0],MISO};
  163. end
  164. endmodule

6.5 其余代码

6.5.1 sd_card_test

  1. //
  2. //                                                                              //
  3. //                                                                              //
  4. //  Author: meisq                                                               //
  5. //          msq@qq.com                                                          //
  6. //          ALINX(shanghai) Technology Co.,Ltd                                  //
  7. //          heijin                                                              //
  8. //     WEB: http://www.alinx.cn/                                                //
  9. //     BBS: http://www.heijin.org/                                              //
  10. //                                                                              //
  11. //
  12. //                                                                              //
  13. // Copyright (c) 2017,ALINX(shanghai) Technology Co.,Ltd                        //
  14. //                    All rights reserved                                       //
  15. //                                                                              //
  16. // This source file may be used and distributed without restriction provided    //
  17. // that this copyright statement is not removed from the file and that any      //
  18. // derivative work contains the original copyright notice and the associated    //
  19. // disclaimer.                                                                  //
  20. //                                                                              //
  21. //
  22.  
  23. //================================================================================
  24. //  Revision History:
  25. //  Date          By            Revision    Change Description
  26. //--------------------------------------------------------------------------------
  27. //  2017/6/19     meisq         1.0         Original
  28. //*******************************************************************************/
  29. module sd_card_test(
  30. 	input            clk,
  31. 	input            rst_n,
  32. 	input            key1,
  33. 	output           SD_nCS,
  34. 	output           SD_DCLK,
  35. 	output           SD_MOSI,
  36. 	input            SD_MISO,
  37. 	output [5:0]     seg_sel,
  38. 	output [7:0]     seg_data
  39. );
  40. parameter S_IDLE         = 0;
  41. parameter S_READ         = 1;
  42. parameter S_WRITE        = 2;
  43. parameter S_END          = 3;
  44.  
  45. reg[3:0] state;
  46. wire             sd_init_done;
  47. reg              sd_sec_read;
  48. wire[31:0]       sd_sec_read_addr;
  49. wire[7:0]        sd_sec_read_data;
  50. wire             sd_sec_read_data_valid;
  51. wire             sd_sec_read_end;
  52. reg              sd_sec_write;
  53. wire[31:0]       sd_sec_write_addr;
  54. reg [7:0]        sd_sec_write_data;
  55. wire             sd_sec_write_data_req;
  56. wire             sd_sec_write_end;
  57. reg[9:0]         wr_cnt;
  58. reg[9:0]         rd_cnt;
  59. wire             button_negedge;
  60. reg[7:0]         read_data;
  61. ax_debounce ax_debounce_m0
  62. (
  63. 	.clk             (clk),
  64. 	.rst             (~rst_n),
  65. 	.button_in       (key1),
  66. 	.button_posedge  (),
  67. 	.button_negedge  (button_negedge),
  68. 	.button_out      ()
  69. );
  70.  
  71. wire[6:0] seg_data_0;
  72. seg_decoder seg_decoder_m0(
  73.     .bin_data  (read_data[3:0]),
  74.     .seg_data  (seg_data_0)
  75. );
  76. wire[6:0] seg_data_1;
  77. seg_decoder seg_decoder_m1(
  78.     .bin_data  (read_data[7:4]),
  79.     .seg_data  (seg_data_1)
  80. );
  81. seg_scan seg_scan_m0(
  82.     .clk        (clk),
  83.     .rst_n      (rst_n),
  84.     .seg_sel    (seg_sel),
  85.     .seg_data   (seg_data),
  86.     .seg_data_0 ({1'b1,7'b1111_111}),
  87.     .seg_data_1 ({1'b1,7'b1111_111}),
  88.     .seg_data_2 ({1'b1,7'b1111_111}),
  89.     .seg_data_3 ({1'b1,7'b1111_111}),
  90.     .seg_data_4 ({1'b1,seg_data_1}),
  91.     .seg_data_5 ({sd_init_done,seg_data_0})
  92. );
  95. always@(posedge clk or negedge rst_n)
  96. begin
  97. 	if(rst_n == 1'b0)
  98. 		wr_cnt <= 10'd0;
  99. 	else if(state == S_WRITE)
  100. 	begin
  101. 		if(sd_sec_write_data_req == 1'b1)
  102. 			wr_cnt <= wr_cnt + 10'd1;
  103. 	end
  104. 	else
  105. 		wr_cnt <= 10'd0;
  106. end
  107.  
  108. always@(posedge clk or negedge rst_n)
  109. begin
  110. 	if(rst_n == 1'b0)
  111. 		rd_cnt <= 10'd0;
  112. 	else if(state == S_READ)
  113. 	begin
  114. 		if(sd_sec_read_data_valid == 1'b1)
  115. 			rd_cnt <= rd_cnt + 10'd1;
  116. 	end
  117. 	else
  118. 		rd_cnt <= 10'd0;
  119. end
  121. always@(posedge clk or negedge rst_n)
  122. begin
  123. 	if(rst_n == 1'b0)
  124. 		read_data <= 8'd0;
  125. 	else if(state == S_READ)
  126. 	begin
  127. 		if(sd_sec_read_data_valid == 1'b1 && rd_cnt == 10'd0)
  128. 			read_data <= sd_sec_read_data;
  129. 	end
  130. 	else if(state == S_END && button_negedge == 1'b1)
  131. 		read_data <= read_data + 8'd1;
  132. end
  134. always@(posedge clk or negedge rst_n)
  135. begin
  136. 	if(rst_n == 1'b0)
  137. 		sd_sec_write_data <= 8'd0;
  138. 	else if(sd_sec_write_data_req)
  139. 		sd_sec_write_data <= read_data + wr_cnt[7:0];
  140. end
  142. always@(posedge clk or negedge rst_n)
  143. begin
  144. 	if(rst_n == 1'b0)
  145. 	begin
  146. 		state <= S_IDLE;
  147. 		sd_sec_read <= 1'b0;
  148. 		sd_sec_write <= 1'b0;
  149. 	end
  150. 	else if(sd_init_done == 1'b0)
  151. 	begin
  152. 		state <= S_IDLE;
  153. 	end
  154. 	else
  155. 		case(state)
  156. 			S_IDLE:
  157. 			begin
  158. 				state <= S_READ;
  159. 			end
  160. 			S_WRITE:
  161. 			begin
  162. 				if(sd_sec_write_end == 1'b1)
  163. 				begin
  164. 					sd_sec_write <= 1'b0;
  165. 					state <= S_READ;
  166. 				end
  167. 				else
  168. 					sd_sec_write <= 1'b1;
  169. 			end
  170. 			
  171. 			S_READ:
  172. 			begin
  173. 				if(sd_sec_read_end == 1'b1)
  174. 				begin
  175. 					state <= S_END;
  176. 					sd_sec_read <= 1'b0;
  177. 				end
  178. 				else
  179. 				begin
  180. 					sd_sec_read <= 1'b1;
  181. 				end                 
  182. 			end         
  183. 			S_END:
  184. 			begin
  185. 				if(button_negedge == 1'b1)
  186. 					state <= S_WRITE;
  187. 			end
  188. 			default:
  189. 				state <= S_IDLE;
  190. 		endcase
  191. end
  192.  
  193. sd_card_top  sd_card_top_m0(
  194. 	.clk                       (clk                    ),
  195. 	.rst                       (~rst_n                 ),
  196. 	.SD_nCS                    (SD_nCS                 ),
  197. 	.SD_DCLK                   (SD_DCLK                ),
  198. 	.SD_MOSI                   (SD_MOSI                ),
  199. 	.SD_MISO                   (SD_MISO                ),
  200. 	.sd_init_done              (sd_init_done           ),
  201. 	.sd_sec_read               (sd_sec_read            ),
  202. 	.sd_sec_read_addr          (sd_sec_read_addr       ),
  203. 	.sd_sec_read_data          (sd_sec_read_data       ),
  204. 	.sd_sec_read_data_valid    (sd_sec_read_data_valid ),
  205. 	.sd_sec_read_end           (sd_sec_read_end        ),
  206. 	.sd_sec_write              (sd_sec_write           ),
  207. 	.sd_sec_write_addr         (sd_sec_write_addr      ),
  208. 	.sd_sec_write_data         (sd_sec_write_data      ),
  209. 	.sd_sec_write_data_req     (sd_sec_write_data_req  ),
  210. 	.sd_sec_write_end          (sd_sec_write_end       )
  211. );
  212. endmodule

6.5.2 ax_debounce

  1. //
  2. //                                                                              //
  3. //                                                                              //
  4. //  Author: meisq                                                               //
  5. //          msq@qq.com                                                          //
  6. //          ALINX(shanghai) Technology Co.,Ltd                                  //
  7. //          heijin                                                              //
  8. //     WEB: http://www.alinx.cn/                                                //
  9. //     BBS: http://www.heijin.org/                                              //
  10. //                                                                              //
  11. //
  12. //                                                                              //
  13. // Copyright (c) 2017,ALINX(shanghai) Technology Co.,Ltd                        //
  14. //                    All rights reserved                                       //
  15. //                                                                              //
  16. // This source file may be used and distributed without restriction provided    //
  17. // that this copyright statement is not removed from the file and that any      //
  18. // derivative work contains the original copyright notice and the associated    //
  19. // disclaimer.                                                                  //
  20. //                                                                              //
  21. //
  22.  
  23. //================================================================================
  24. //  Revision History:
  25. //  Date          By            Revision    Change Description
  26. //--------------------------------------------------------------------------------
  27. //  2017/5/3     meisq          1.0         Original
  28. //*******************************************************************************/
  29.  
  30. `timescale 1 ns / 100 ps
  31. module  ax_debounce 
  32. (
  33.     input       clk, 
  34.     input       rst, 
  35.     input       button_in,
  36.     output reg  button_posedge,
  37.     output reg  button_negedge,
  38.     output reg  button_out
  39. );
  40.  ---------------- internal constants --------------
  41. parameter N = 32 ;           // debounce timer bitwidth
  42. parameter FREQ = 50;         //model clock :Mhz
  43. parameter MAX_TIME = 20;     //ms
  44. localparam TIMER_MAX_VAL =   MAX_TIME * 1000 * FREQ;
  45. ---------------- internal variables ---------------
  46. reg  [N-1 : 0]  q_reg;      // timing regs
  47. reg  [N-1 : 0]  q_next;
  48. reg DFF1, DFF2;             // input flip-flops
  49. wire q_add;                 // control flags
  50. wire q_reset;
  51. reg button_out_d0;
  52.  ------------------------------------------------------
  53.  
  54. contenious assignment for counter control
  55. assign q_reset = (DFF1  ^ DFF2);          // xor input flip flops to look for level chage to reset counter
  56. assign q_add = ~(q_reg == TIMER_MAX_VAL); // add to counter when q_reg msb is equal to 0
  57.     
  58.  combo counter to manage q_next 
  59. always @ ( q_reset, q_add, q_reg)
  60. begin
  61.     case( {q_reset , q_add})
  62.         2'b00 :
  63.                 q_next <= q_reg;
  64.         2'b01 :
  65.                 q_next <= q_reg + 1;
  66.         default :
  67.                 q_next <= { N {1'b0} };
  68.     endcase     
  69. end
  71.  Flip flop inputs and q_reg update
  72. always @ ( posedge clk or posedge rst)
  73. begin
  74.     if(rst == 1'b1)
  75.     begin
  76.         DFF1 <= 1'b0;
  77.         DFF2 <= 1'b0;
  78.         q_reg <= { N {1'b0} };
  79.     end
  80.     else
  81.     begin
  82.         DFF1 <= button_in;
  83.         DFF2 <= DFF1;
  84.         q_reg <= q_next;
  85.     end
  86. end
  88.  counter control
  89. always @ ( posedge clk or posedge rst)
  90. begin
  91. 	if(rst == 1'b1)
  92. 		button_out <= 1'b1;
  93.     else if(q_reg == TIMER_MAX_VAL)
  94.         button_out <= DFF2;
  95.     else
  96.         button_out <= button_out;
  97. end
  99. always @ ( posedge clk or posedge rst)
  100. begin
  101. 	if(rst == 1'b1)
  102. 	begin
  103. 		button_out_d0 <= 1'b1;
  104. 		button_posedge <= 1'b0;
  105. 		button_negedge <= 1'b0;
  106. 	end
  107. 	else
  108. 	begin
  109. 		button_out_d0 <= button_out;
  110. 		button_posedge <= ~button_out_d0 & button_out;
  111. 		button_negedge <= button_out_d0 & ~button_out;
  112. 	end	
  113. end
  114. endmodule

6.5.3 seg_decoder

  1. //
  2. //                                                                              //
  3. //                                                                              //
  4. //  Author: meisq                                                               //
  5. //          msq@qq.com                                                          //
  6. //          ALINX(shanghai) Technology Co.,Ltd                                  //
  7. //          heijin                                                              //
  8. //     WEB: http://www.alinx.cn/                                                //
  9. //     BBS: http://www.heijin.org/                                              //
  10. //                                                                              //
  11. //
  12. //                                                                              //
  13. // Copyright (c) 2017,ALINX(shanghai) Technology Co.,Ltd                        //
  14. //                    All rights reserved                                       //
  15. //                                                                              //
  16. // This source file may be used and distributed without restriction provided    //
  17. // that this copyright statement is not removed from the file and that any      //
  18. // derivative work contains the original copyright notice and the associated    //
  19. // disclaimer.                                                                  //
  20. //                                                                              //
  21. //
  22.  
  23. //==========================================================================
  24. //  Revision History:
  25. //  Date          By            Revision    Change Description
  26. //--------------------------------------------------------------------------
  27. //  2017/6/19     meisq         1.0         Original
  28. //*************************************************************************/
  29. module seg_decoder
  30. (
  31. 	input[3:0]      bin_data,     // bin data input
  32. 	output reg[6:0] seg_data      // seven segments LED output
  33. );
  34.  
  35. always@(*)
  36. begin
  37. 	case(bin_data)
  38. 		4'd0:seg_data <= 7'b100_0000;
  39. 		4'd1:seg_data <= 7'b111_1001;
  40. 		4'd2:seg_data <= 7'b010_0100;
  41. 		4'd3:seg_data <= 7'b011_0000;
  42. 		4'd4:seg_data <= 7'b001_1001;
  43. 		4'd5:seg_data <= 7'b001_0010;
  44. 		4'd6:seg_data <= 7'b000_0010;
  45. 		4'd7:seg_data <= 7'b111_1000;
  46. 		4'd8:seg_data <= 7'b000_0000;
  47. 		4'd9:seg_data <= 7'b001_0000;
  48. 		4'ha:seg_data <= 7'b000_1000;
  49. 		4'hb:seg_data <= 7'b000_0011;
  50. 		4'hc:seg_data <= 7'b100_0110;
  51. 		4'hd:seg_data <= 7'b010_0001;
  52. 		4'he:seg_data <= 7'b000_0110;
  53. 		4'hf:seg_data <= 7'b000_1110;
  54. 		default:seg_data <= 7'b111_1111;
  55. 	endcase
  56. end
  57. endmodule

6.5.4 seg_scan

  1. //
  2. //                                                                              //
  3. //                                                                              //
  4. //  Author: meisq                                                               //
  5. //          msq@qq.com                                                          //
  6. //          ALINX(shanghai) Technology Co.,Ltd                                  //
  7. //          heijin                                                              //
  8. //     WEB: http://www.alinx.cn/                                                //
  9. //     BBS: http://www.heijin.org/                                              //
  10. //                                                                              //
  11. //
  12. //                                                                              //
  13. // Copyright (c) 2017,ALINX(shanghai) Technology Co.,Ltd                        //
  14. //                    All rights reserved                                       //
  15. //                                                                              //
  16. // This source file may be used and distributed without restriction provided    //
  17. // that this copyright statement is not removed from the file and that any      //
  18. // derivative work contains the original copyright notice and the associated    //
  19. // disclaimer.                                                                  //
  20. //                                                                              //
  21. //
  22.  
  23. //==========================================================================
  24. //  Revision History:
  25. //  Date          By            Revision    Change Description
  26. //--------------------------------------------------------------------------
  27. //  2017/6/19     meisq         1.0         Original
  28. //*************************************************************************/
  29. module seg_scan(
  30. 	input           clk,
  31. 	input           rst_n,
  32. 	output reg[5:0] seg_sel,      //digital led chip select
  33. 	output reg[7:0] seg_data,     //eight segment digital tube output,MSB is the decimal point
  34. 	input[7:0]      seg_data_0,
  35. 	input[7:0]      seg_data_1,
  36. 	input[7:0]      seg_data_2,
  37. 	input[7:0]      seg_data_3,
  38. 	input[7:0]      seg_data_4,
  39. 	input[7:0]      seg_data_5
  40. );
  41. parameter SCAN_FREQ = 200;     //scan frequency
  42. parameter CLK_FREQ = 50000000; //clock frequency
  43.  
  44. parameter SCAN_COUNT = CLK_FREQ /(SCAN_FREQ * 6) - 1;
  45.  
  46. reg[31:0] scan_timer;  //scan time counter
  47. reg[3:0] scan_sel;     //Scan select counter
  48. always@(posedge clk or negedge rst_n)
  49. begin
  50. 	if(rst_n == 1'b0)
  51. 	begin
  52. 		scan_timer <= 32'd0;
  53. 		scan_sel <= 4'd0;
  54. 	end
  55. 	else if(scan_timer >= SCAN_COUNT)
  56. 	begin
  57. 		scan_timer <= 32'd0;
  58. 		if(scan_sel == 4'd5)
  59. 			scan_sel <= 4'd0;
  60. 		else
  61. 			scan_sel <= scan_sel + 4'd1;
  62. 	end
  63. 	else
  64. 		begin
  65. 			scan_timer <= scan_timer + 32'd1;
  66. 		end
  67. end
  68. always@(posedge clk or negedge rst_n)
  69. begin
  70. 	if(rst_n == 1'b0)
  71. 	begin
  72. 		seg_sel <= 6'b111111;
  73. 		seg_data <= 8'hff;
  74. 	end
  75. 	else
  76. 	begin
  77. 		case(scan_sel)
  78. 			//first digital led
  79. 			4'd0:
  80. 			begin
  81. 				seg_sel <= 6'b11_1110;
  82. 				seg_data <= seg_data_0;
  83. 			end
  84. 			//second digital led
  85. 			4'd1:
  86. 			begin
  87. 				seg_sel <= 6'b11_1101;
  88. 				seg_data <= seg_data_1;
  89. 			end
  90. 			//...
  91. 			4'd2:
  92. 			begin
  93. 				seg_sel <= 6'b11_1011;
  94. 				seg_data <= seg_data_2;
  95. 			end
  96. 			4'd3:
  97. 			begin
  98. 				seg_sel <= 6'b11_0111;
  99. 				seg_data <= seg_data_3;
  100. 			end
  101. 			4'd4:
  102. 			begin
  103. 				seg_sel <= 6'b10_1111;
  104. 				seg_data <= seg_data_4;
  105. 			end
  106. 			4'd5:
  107. 			begin
  108. 				seg_sel <= 6'b01_1111;
  109. 				seg_data <= seg_data_5;
  110. 			end
  111. 			default:
  112. 			begin
  113. 				seg_sel <= 6'b11_1111;
  114. 				seg_data <= 8'hff;
  115. 			end
  116. 		endcase
  117. 	end
  118. end
  120. endmodule

7 实验结果

下载实验程序后，可以看到数码管显示一个数字，这个数字是存储在 sd 卡中第一扇区的第一
个数据，数据是随机的，这个时候按键 KEY1 按下，数字加一，并写入了 sd 卡，再次下载程序，
可以看到直接显示更新后的数据。

8 参考资料

【1】百度百科：EEPROM

【2】百度百科：NOR FLASH

【3】百度百科：NAND FLASH

【4】黑金社区

【5】基于FPGA的SD卡的数据读写实现（SD NAND FLASH）

需要工程文件（Quartus工程文件）的小伙伴也可以在公众号“Alex的书桌与实验室”回复“1SD”获取下载链接~

这就是本期的全部内容啦，如果你喜欢我的文章，不要忘了点赞+收藏+关注，分享给身边的朋友哇~

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/533825
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号