21ic电子技术开发论坛 › 单片机与嵌入式系统 › GigaDevice GD32 MCU › 【GD32H757Z海棠派使用手册】第十二讲 SDIO-SD卡读写实 ...
返回列表 发新帖我要提问

[研电赛技术支持] 【GD32H757Z海棠派使用手册】第十二讲 SDIO-SD卡读写实验

[复制链接]
2255|0
 楼主| 聚沃科技 发表于 2024-6-5 10:26 | 显示全部楼层 |阅读模式
GD32H7, 使用手册, GD32, MCU, SD卡读写, SD卡
H757首图.png
12.1 实验内容
通过本实验主要学习以下内容：
• SDIO操作原理
• SD卡读写实现
12.2 实验原理
SD卡是一种主要以Nand Flash作为存储介质，具有体积小、数据传输速度快以及支持热插拔的优点。如今，已被广泛应用于数码相机、便携式移动设备以及手机等多种设备中。SD卡的驱动一般有SPI接口或SDIO接口，本例程介绍使用GD32F4xx的SDIO接口驱动SD卡的实现。
12.2.1 SD卡基础知识
SD卡:secure digital memory card是一种安全存储器件。属性是快闪存储器（flash eeprom），功能用来存储数据。
图片1.png
SD卡虽然是薄薄的一片，但是它并不是一个整体，而是由大量的集成电路组成。SD卡的内部结构如下图所示，主要由信号端子，接口控制器和存储区组成。
图片2.png
SD卡主要有两种模式，SD模式和SPI模式。不同模式下，接口定义不同。下面是SD卡的引脚。
图片3.png
两种模式的接口定义如下
图片4.png
SD模式中，主要由VCC(电源)，VSS(GND)，CLK（时钟，由主控提供)，CMD(命令)，DAT0-3(数据输入输出)，由6线制组成进行通信。SPI模式，主要采用4线制通信，除了电源地外，由MISO，MOSI，CLK，CS组成。下面简单介绍SD模式的操作。
要驱动SD卡工作，主要涉及两个步骤。第一个步骤是SD卡的识别过程。第二个步骤是对SD卡进行读写过程，即主机控制器和SD卡之间进行数据传输的过程。
要使SD卡能正常工作，一是要给SD卡供给稳定的电压，二是要SD卡按用户规定的方式工作。这两项工作的实现，都是主机控制器通过给SD卡发送控制命令来实现的。
主机（SDIO控制器）要驱动SD卡工作，要使用许多的命令，包括应用层命令ACMD 和 通用命令 CMD. 主机（SDIO控制器）把命令发送给SD卡，SD卡会作出回应，这里的回应叫做响应，响应命令分为6类，分别是R1、R1b、R2、R3、R6、R7。主机（SDIO控制器）给SD卡发送命令之后，SD卡会作出响应，响应中包含主机（SDIO控制器）需要的数据，这些数据有SD的信息，容量，和存储数据等等。上面已经提到了，SD卡工作，主要是识别和数据传输，它的识别过程有些复杂，写代码的时候，可以参考协议给的初始化流程图。数据传输包括读和写，单字节和多字节读写。下两节描述识别初始化流程图和数据读写时序图。
1、读写数据的时序图
SDIO与SD卡通信一般以数据块的形式进行传输，SDIO(多)数据块读操作，如下图所示。
图片5.png
SDIO(多)数据块写操作，如下图所示。
图片6.png
2、命令格式
SDIO所有的命令和响应都是在SDIO_CMD引脚上面传输的，命令长度固定为48位，SDIO命令格式如下表所示。
图片7.png
3、寄存器
SDIO控制器的寄存器，主要设置SDIO控制器和命令的索引与参数。SD卡有5个寄存器CID,RCA,CSD,SCR.OCR。SD卡的信息从SD卡寄存器中获取。
SD卡正常工作，就是根据SD卡初始化流程图，发送命令，收到回复，直到流程结束。传输数据，也是根据读写时序图，将要发送的数据放进命令中发送出去。
12.2.2 SDIO模块原理
SDIO为安全的数字输入输出接口，可以用于驱动SD卡、EMMC等，主要特征如下：
◼ e*MMC： 与多媒体卡系统规格书 V4.2 及之前的版本全兼容。有三种不同的数据总线模式：1 位(默认)、 4 位和 8 位；
◼ SD 卡： 与SD 存储卡规格版本3.0 全兼容；
◼ SD I/O： 与 SD I/O 卡规格版本 3.0 全兼容，有两种不同的数据总线模式： 1 位(默认)和4位（包括SDR和DDR）；
◼ 104MHz 数据传输频率和8 位数据传输模式；
◼ 中断和 DMA 请求；
◼ 数据传输支持 DDR 模式。  
SDIO模块结构框图如下所示。主要包括以下三个部分：SDIO 适配器：由控制单元、命令单元和数据单元组成，控制单元管理时钟信号，命令单元管理命令的传输，数据单元管理数据的传输； AHB 接口：包括通过 AHB 总线访问的寄存器、用于数据传输的 FIFO 单元以及产生中断和 DMA 请求信号； 内部 DMA（IDMA）以及 AHB 主机接口  。
图片8.png
SDIO模块可以实现对SD卡的完全驱动以及协议的实现，包括命令、响应等相关操作，本例程实现使用SDIO驱动SD卡初始化以及读写测试等相关操作，具体实现可以参考GD32H7用户手册以及代码解析等。
12.3 硬件设计
SD卡相关硬件电路如下图所示，实验板上具有SD卡卡座，信号线上有四根数据线，一根CMD命令线以及一根CLK时钟线，所有信号线通过10K电阻进行上拉，电源地信号线具有10uf以及100nf电容，SD卡插入时，金属接触点朝下插入。
图片9.png
12.4 代码解析
12.4.1 SDIO初始化配置函数
SDIO初始化配置在sd_io_init（）函数中，其中包括sd_init()初始化、sd_card_information_get（）SD卡信息获取、sd_card_select_deselect（）SD卡选择、sd_cardstatus_get（）SD卡状态获取、sd_bus_mode_config（）SD卡总线宽度配置以及sd_transfer_mode_config（）SD卡通信模式配置，历程中选择了4线查询模式。
复制
  1. C
    

  2. sd_error_enum sd_io_init(void)
    

  3. {
    

  4.     sd_error_enum status = SD_OK;
    

  5.     uint32_t cardstate = 0;
    


  6. 

  7.     status = sd_init();
    

  8.     if(SD_OK == status) {
    

  9.         status = sd_card_information_get(&sd_cardinfo);
    

  10.     }
    

  11.     if(SD_OK == status) {
    

  12.         status = sd_card_select_deselect(sd_cardinfo.card_rca);
    

  13.     }
    

  14.     status = sd_cardstatus_get(&cardstate);
    

  15.     if(cardstate & 0x02000000) {
    

  16.         printf_log("\r\n the card is locked!");
    


  17. 

  18.         status = sd_lock_unlock(SD_UNLOCK);
    

  19.         if(status != SD_OK) {
    

  20.             return SD_LOCK_UNLOCK_FAILED;
    

  21.         } else {
    

  22.             printf_log("\r\n the card is unlocked successfully!");
    

  23.         }
    

  24.     }
    


  25. 

  26.     if((SD_OK == status) && (!(cardstate & 0x02000000))) {
    

  27.         /* set bus mode */
    

  28. #if (SDIO_BUSMODE == BUSMODE_4BIT)
    

  29.         status = sd_bus_mode_config(SDIO_BUSMODE_4BIT, SDIO_SPEEDMODE);
    

  30. #else
    

  31.         status = sd_bus_mode_config(SDIO_BUSMODE_1BIT, SDIO_SPEEDMODE);
    

  32. #endif
    

  33.     }
    


  34. 

  35. #ifdef USE_18V_SWITCH
    

  36.     if(SD_OK == status) {
    

  37.         /* UHS-I Hosts can perform sampling point tuning using tuning command   */
    

  38.         status = sd_tuning();
    

  39.     }
    

  40. #endif /* USE_18V_SWITCH */
    


  41. 

  42.     if(SD_OK == status) {
    

  43.         /* set data transfer mode */
    

  44.         /* if use 1.8V high speed mode, please select the DMA mode */
    

  45.         status = sd_transfer_mode_config(SDIO_DTMODE);
    

  46.     }
    

  47.     return status;
    

  48. }
12.4.2 获取SD卡信息函数
获取SD卡信息的函数如下所示，card_info_get（）。
复制
  1. C
    

  2. void card_info_get(void)
    

  3. {
    

  4.     uint8_t sd_spec, sd_spec3, sd_spec4, sd_security;
    

  5.     uint32_t block_count, block_size;
    

  6.     uint16_t temp_ccc;
    

  7.     printf_log("\r\n Card information:");
    

  8.     sd_spec = (sd_scr[1] & 0x0F000000) >> 24;
    

  9.     sd_spec3 = (sd_scr[1] & 0x00008000) >> 15;
    

  10.     sd_spec4 = (sd_scr[1] & 0x00000400) >> 10;
    

  11.     if(2 == sd_spec) {
    

  12.         if(1 == sd_spec3) {
    

  13.             if(1 == sd_spec4) {
    

  14.                 printf_log("\r\n## Card version 4.xx ##");
    

  15.             } else {
    

  16.                 printf_log("\r\n## Card version 3.0x ##");
    

  17.             }
    

  18.         } else {
    

  19.             printf_log("\r\n## Card version 2.00 ##");
    

  20.         }
    

  21.     } else if(1 == sd_spec) {
    

  22.         printf_log("\r\n## Card version 1.10 ##");
    

  23.     } else if(0 == sd_spec) {
    

  24.         printf_log("\r\n## Card version 1.0x ##");
    

  25.     }
    


  26. 

  27.     sd_security = (sd_scr[1] & 0x00700000) >> 20;
    

  28.     if(2 == sd_security) {
    

  29.         printf_log("\r\n## security v1.01 ##");
    

  30.     } else if(3 == sd_security) {
    

  31.         printf_log("\r\n## security v2.00 ##");
    

  32.     } else if(4 == sd_security) {
    

  33.         printf_log("\r\n## security v3.00 ##");
    

  34.     }
    


  35. 

  36.     block_count = (sd_cardinfo.card_csd.c_size + 1) * 1024;
    

  37.     block_size = 512;
    

  38.     printf_log("\r\n## Device size is %dKB ##", sd_card_capacity_get());
    

  39.     printf_log("\r\n## Block size is %dB ##", block_size);
    

  40.     printf_log("\r\n## Block count is %d ##", block_count);
    


  41. 

  42.     if(sd_cardinfo.card_csd.read_bl_partial) {
    

  43.         printf_log("\r\n## Partial blocks for read allowed ##");
    

  44.     }
    

  45.     if(sd_cardinfo.card_csd.write_bl_partial) {
    

  46.         printf_log("\r\n## Partial blocks for write allowed ##");
    

  47.     }
    

  48.     temp_ccc = sd_cardinfo.card_csd.ccc;
    

  49.     printf_log("\r\n## CardCommandClasses is: %x ##", temp_ccc);
    

  50.     if((SD_CCC_BLOCK_READ & temp_ccc) && (SD_CCC_BLOCK_WRITE & temp_ccc)) {
    

  51.         printf_log("\r\n## Block operation supported ##");
    

  52.     }
    

  53.     if(SD_CCC_ERASE & temp_ccc) {
    

  54.         printf_log("\r\n## Erase supported ##");
    

  55.     }
    

  56.     if(SD_CCC_WRITE_PROTECTION & temp_ccc) {
    

  57.         printf_log("\r\n## Write protection supported ##");
    

  58.     }
    

  59.     if(SD_CCC_LOCK_CARD & temp_ccc) {
    

  60.         printf_log("\r\n## Lock unlock supported ##");
    

  61.     }
    

  62.     if(SD_CCC_APPLICATION_SPECIFIC & temp_ccc) {
    

  63.         printf_log("\r\n## Application specific supported ##");
    

  64.     }
    

  65.     if(SD_CCC_IO_MODE & temp_ccc) {
    

  66.         printf_log("\r\n## I/O mode supported ##");
    

  67.     }
    

  68.     if(SD_CCC_SWITCH & temp_ccc) {
    

  69.         printf_log("\r\n## Switch function supported ##");
    

  70.     }
    

  71. }
12.4.3 SD卡数据块写入函数
SD卡数据块写入函数如下所示，通过该函数可实现SD卡数据块的数据写入。
复制
  1. C
    

  2. sd_error_enum sd_block_write(uint32_t *pwritebuffer, uint32_t writeaddr, uint16_t blocksize)
    

  3. {
    

  4.     /* initialize the variables */
    

  5.     sd_error_enum status = SD_OK;
    

  6.     uint8_t cardstate = 0U;
    

  7.     uint32_t count = 0U, align = 0U, datablksize = SDIO_DATABLOCKSIZE_1BYTE, *ptempbuff = pwritebuffer;
    

  8.     uint32_t transbytes = 0U, restwords = 0U, response = 0U;
    

  9.     __IO uint32_t timeout = 0U;
    


  10. 

  11.     if(NULL == pwritebuffer) {
    

  12.         status = SD_PARAMETER_INVALID;
    

  13.         return status;
    

  14.     }
    


  15. 

  16.     transerror = SD_OK;
    

  17.     transend = 0U;
    

  18.     totalnumber_bytes = 0U;
    

  19.     /* clear all DSM configuration */
    

  20.     sdio_data_config(SDIO, 0U, 0U, SDIO_DATABLOCKSIZE_1BYTE);
    

  21.     sdio_data_transfer_config(SDIO, SDIO_TRANSMODE_BLOCKCOUNT, SDIO_TRANSDIRECTION_TOCARD);
    

  22.     sdio_dsm_disable(SDIO);
    

  23.     sdio_idma_disable(SDIO);
    


  24. 

  25.     /* check whether the card is locked */
    

  26.     if(sdio_response_get(SDIO, SDIO_RESPONSE0) & SD_CARDSTATE_LOCKED) {
    

  27.         status = SD_LOCK_UNLOCK_FAILED;
    

  28.         return status;
    

  29.     }
    


  30. 

  31.     /* blocksize is fixed in 512B for SDHC card */
    

  32.     if(SDIO_HIGH_CAPACITY_SD_CARD != cardtype) {
    

  33.         writeaddr *= 512U;
    

  34.     } else {
    

  35.         blocksize = 512U;
    

  36.     }
    


  37. 

  38.     align = blocksize & (blocksize - 1U);
    

  39.     if((blocksize > 0U) && (blocksize <= 2048U) && (0U == align)) {
    

  40.         datablksize = sd_datablocksize_get(blocksize);
    

  41.         /* send CMD16(SET_BLOCKLEN) to set the block length */
    

  42.         sdio_command_response_config(SDIO, SD_CMD_SET_BLOCKLEN, (uint32_t)blocksize, SDIO_RESPONSETYPE_SHORT);
    

  43.         sdio_wait_type_set(SDIO, SDIO_WAITTYPE_NO);
    

  44.         sdio_csm_enable(SDIO);
    


  45. 

  46.         /* check if some error occurs */
    

  47.         status = r1_error_check(SD_CMD_SET_BLOCKLEN);
    

  48.         if(SD_OK != status) {
    

  49.             return status;
    

  50.         }
    

  51.     } else {
    

  52.         status = SD_PARAMETER_INVALID;
    

  53.         return status;
    

  54.     }
    


  55. 

  56.     /* send CMD13(SEND_STATUS), addressed card sends its status registers */
    

  57.     sdio_command_response_config(SDIO, SD_CMD_SEND_STATUS, (uint32_t)sd_rca << SD_RCA_SHIFT, SDIO_RESPONSETYPE_SHORT);
    

  58.     sdio_wait_type_set(SDIO, SDIO_WAITTYPE_NO);
    

  59.     sdio_csm_enable(SDIO);
    

  60.     /* check if some error occurs */
    

  61.     status = r1_error_check(SD_CMD_SEND_STATUS);
    

  62.     if(SD_OK != status) {
    

  63.         return status;
    

  64.     }
    


  65. 

  66.     response = sdio_response_get(SDIO, SDIO_RESPONSE0);
    

  67.     timeout = 100000U;
    


  68. 

  69.     while((0U == (response & SD_R1_READY_FOR_DATA)) && (timeout > 0U)) {
    

  70.         /* continue to send CMD13 to polling the state of card until buffer empty or timeout */
    

  71.         --timeout;
    

  72.         /* send CMD13(SEND_STATUS), addressed card sends its status registers */
    

  73.         sdio_command_response_config(SDIO, SD_CMD_SEND_STATUS, (uint32_t)sd_rca << SD_RCA_SHIFT, SDIO_RESPONSETYPE_SHORT);
    

  74.         sdio_wait_type_set(SDIO, SDIO_WAITTYPE_NO);
    

  75.         sdio_csm_enable(SDIO);
    

  76.         /* check if some error occurs */
    

  77.         status = r1_error_check(SD_CMD_SEND_STATUS);
    

  78.         if(SD_OK != status) {
    

  79.             return status;
    

  80.         }
    

  81.         response = sdio_response_get(SDIO, SDIO_RESPONSE0);
    

  82.     }
    

  83.     if(0U == timeout) {
    

  84.         return SD_ERROR;
    

  85.     }
    


  86. 

  87.     stopcondition = 0U;
    

  88.     totalnumber_bytes = blocksize;
    


  89. 

  90.     /* configure the SDIO data transmisson */
    

  91.     sdio_data_config(SDIO, SD_DATATIMEOUT, totalnumber_bytes, datablksize);
    

  92.     sdio_data_transfer_config(SDIO, SDIO_TRANSMODE_BLOCKCOUNT, SDIO_TRANSDIRECTION_TOCARD);
    

  93.     sdio_trans_start_enable(SDIO);
    


  94. 

  95.     if(SD_POLLING_MODE == transmode) {
    

  96.         /* send CMD24(WRITE_BLOCK) to write a block */
    

  97.         sdio_command_response_config(SDIO, SD_CMD_WRITE_BLOCK, writeaddr, SDIO_RESPONSETYPE_SHORT);
    

  98.         sdio_wait_type_set(SDIO, SDIO_WAITTYPE_NO);
    

  99.         sdio_csm_enable(SDIO);
    

  100.         /* check if some error occurs */
    

  101.         status = r1_error_check(SD_CMD_WRITE_BLOCK);
    

  102.         if(SD_OK != status) {
    

  103.             return status;
    

  104.         }
    


  105. 

  106.         /* polling mode */
    

  107.         while(!sdio_flag_get(SDIO, SDIO_FLAG_DTCRCERR | SDIO_FLAG_DTTMOUT | SDIO_FLAG_TXURE | SDIO_FLAG_DTBLKEND | SDIO_FLAG_DTEND)) {
    

  108.             if(RESET != sdio_flag_get(SDIO, SDIO_FLAG_TFH)) {
    

  109.                 /* at least 8 words can be written into the FIFO */
    

  110.                 if((totalnumber_bytes - transbytes) < SD_FIFOHALF_BYTES) {
    

  111.                     restwords = (totalnumber_bytes - transbytes) / 4U + (((totalnumber_bytes - transbytes) % 4U == 0U) ? 0U : 1U);
    

  112.                     for(count = 0U; count < restwords; count++) {
    

  113.                         sdio_data_write(SDIO, *ptempbuff);
    

  114.                         ++ptempbuff;
    

  115.                         transbytes += 4U;
    

  116.                     }
    

  117.                 } else {
    

  118.                     for(count = 0U; count < SD_FIFOHALF_WORDS; count++) {
    

  119.                         sdio_data_write(SDIO, *(ptempbuff + count));
    

  120.                     }
    

  121.                     /* 8 words(32 bytes) has been transferred */
    

  122.                     ptempbuff += SD_FIFOHALF_WORDS;
    

  123.                     transbytes += SD_FIFOHALF_BYTES;
    

  124.                 }
    

  125.             }
    

  126.         }
    

  127.         sdio_trans_start_disable(SDIO);
    

  128.         /* whether some error occurs and return it */
    

  129.         if(RESET != sdio_flag_get(SDIO, SDIO_FLAG_DTCRCERR)) {
    

  130.             status = SD_DATA_CRC_ERROR;
    

  131.             sdio_flag_clear(SDIO, SDIO_FLAG_DTCRCERR);
    

  132.             return status;
    

  133.         } else if(RESET != sdio_flag_get(SDIO, SDIO_FLAG_DTTMOUT)) {
    

  134.             status = SD_DATA_TIMEOUT;
    

  135.             sdio_flag_clear(SDIO, SDIO_FLAG_DTTMOUT);
    

  136.             return status;
    

  137.         } else if(RESET != sdio_flag_get(SDIO, SDIO_FLAG_TXURE)) {
    

  138.             status = SD_TX_UNDERRUN_ERROR;
    

  139.             sdio_flag_clear(SDIO, SDIO_FLAG_TXURE);
    

  140.             return status;
    

  141.         } else {
    

  142.             /* if else end */
    

  143.         }
    


  144. 

  145.     } else if(SD_DMA_MODE == transmode) {
    

  146.         /* DMA mode */
    

  147.         /* enable the SDIO corresponding interrupts and DMA */
    

  148.         sdio_interrupt_enable(SDIO, SDIO_INT_DTCRCERR | SDIO_INT_DTTMOUT | SDIO_INT_TXURE | SDIO_INT_DTEND);
    

  149.         dma_config(pwritebuffer, (uint32_t)(blocksize >> 5));
    

  150.         sdio_idma_enable(SDIO);
    


  151. 

  152.         /* send CMD24(WRITE_BLOCK) to write a block */
    

  153.         sdio_command_response_config(SDIO, SD_CMD_WRITE_BLOCK, writeaddr, SDIO_RESPONSETYPE_SHORT);
    

  154.         sdio_wait_type_set(SDIO, SDIO_WAITTYPE_NO);
    

  155.         sdio_csm_enable(SDIO);
    

  156.         /* check if some error occurs */
    

  157.         status = r1_error_check(SD_CMD_WRITE_BLOCK);
    

  158.         if(SD_OK != status) {
    

  159.             return status;
    

  160.         }
    


  161. 

  162.         while((0U == transend) && (SD_OK == transerror)) {
    

  163.         }
    


  164. 

  165.         if(SD_OK != transerror) {
    

  166.             return transerror;
    

  167.         }
    

  168.     } else {
    

  169.         status = SD_PARAMETER_INVALID;
    

  170.         return status;
    

  171.     }
    


  172. 

  173.     /* clear the DATA_FLAGS flags */
    

  174.     sdio_flag_clear(SDIO, SDIO_MASK_DATA_FLAGS);
    

  175.     /* get the card state and wait the card is out of programming and receiving state */
    

  176.     status = sd_card_state_get(&cardstate);
    

  177.     while((SD_OK == status) && ((SD_CARDSTATE_PROGRAMMING == cardstate) || (SD_CARDSTATE_RECEIVING == cardstate))) {
    

  178.         status = sd_card_state_get(&cardstate);
    

  179.     }
    

  180.     return status;
    

  181. }
12.4.4 SD卡数据块读取函数
SD卡数据块读取函数如下所示。
复制
  1. C
    

  2. sd_error_enum sd_block_read(uint32_t *preadbuffer, uint32_t readaddr, uint16_t blocksize)
    

  3. {
    

  4.     /* initialize the variables */
    

  5.     sd_error_enum status = SD_OK;
    

  6.     uint32_t count = 0U, align = 0U, datablksize = SDIO_DATABLOCKSIZE_1BYTE, *ptempbuff = preadbuffer;
    

  7.     __IO uint32_t timeout = 0U;
    


  8. 

  9.     if(NULL == preadbuffer) {
    

  10.         status = SD_PARAMETER_INVALID;
    

  11.         return status;
    

  12.     }
    


  13. 

  14.     transerror = SD_OK;
    

  15.     transend = 0U;
    

  16.     totalnumber_bytes = 0U;
    

  17.     /* clear all DSM configuration */
    

  18.     sdio_data_config(SDIO, 0U, 0U, SDIO_DATABLOCKSIZE_1BYTE);
    

  19.     sdio_data_transfer_config(SDIO, SDIO_TRANSMODE_BLOCKCOUNT, SDIO_TRANSDIRECTION_TOCARD);
    

  20.     sdio_dsm_disable(SDIO);
    

  21.     sdio_idma_disable(SDIO);
    


  22. 

  23.     /* check whether the card is locked */
    

  24.     if(sdio_response_get(SDIO, SDIO_RESPONSE0) & SD_CARDSTATE_LOCKED) {
    

  25.         status = SD_LOCK_UNLOCK_FAILED;
    

  26.         return status;
    

  27.     }
    


  28. 

  29.     /* blocksize is fixed in 512B for SDHC card */
    

  30.     if(SDIO_HIGH_CAPACITY_SD_CARD != cardtype) {
    

  31.         readaddr *= 512U;
    

  32.     } else {
    

  33.         blocksize = 512U;
    

  34.     }
    


  35. 

  36.     align = blocksize & (blocksize - 1U);
    


  37. 

  38.     if((blocksize > 0U) && (blocksize <= 2048U) && (0U == align)) {
    

  39.         datablksize = sd_datablocksize_get(blocksize);
    

  40.         /* send CMD16(SET_BLOCKLEN) to set the block length */
    

  41.         sdio_command_response_config(SDIO, SD_CMD_SET_BLOCKLEN, (uint32_t)blocksize, SDIO_RESPONSETYPE_SHORT);
    

  42.         sdio_wait_type_set(SDIO, SDIO_WAITTYPE_NO);
    

  43.         sdio_csm_enable(SDIO);
    


  44. 

  45.         /* check if some error occurs */
    

  46.         status = r1_error_check(SD_CMD_SET_BLOCKLEN);
    

  47.         if(SD_OK != status) {
    

  48.             return status;
    

  49.         }
    

  50.     } else {
    

  51.         status = SD_PARAMETER_INVALID;
    

  52.         return status;
    

  53.     }
    


  54. 

  55.     stopcondition = 0U;
    

  56.     totalnumber_bytes = (uint32_t)blocksize;
    


  57. 

  58.     if(SD_POLLING_MODE == transmode) {
    


  59. 

  60.         /* configure SDIO data transmisson */
    

  61.         sdio_data_config(SDIO, SD_DATATIMEOUT, totalnumber_bytes, datablksize);
    

  62.         sdio_data_transfer_config(SDIO, SDIO_TRANSMODE_BLOCKCOUNT, SDIO_TRANSDIRECTION_TOSDIO);
    

  63.         sdio_trans_start_enable(SDIO);
    


  64. 


  65. 

  66.         /* send CMD17(READ_SINGLE_BLOCK) to read a block */
    

  67.         sdio_command_response_config(SDIO, SD_CMD_READ_SINGLE_BLOCK, (uint32_t)readaddr, SDIO_RESPONSETYPE_SHORT);
    

  68.         sdio_wait_type_set(SDIO, SDIO_WAITTYPE_NO);
    

  69.         sdio_csm_enable(SDIO);
    

  70.         /* check if some error occurs */
    

  71.         status = r1_error_check(SD_CMD_READ_SINGLE_BLOCK);
    

  72.         if(SD_OK != status) {
    

  73.             return status;
    

  74.         }
    


  75. 

  76.         /* polling mode */
    

  77.         while(!sdio_flag_get(SDIO, SDIO_FLAG_DTCRCERR | SDIO_FLAG_DTTMOUT | SDIO_FLAG_RXORE | SDIO_FLAG_DTBLKEND | SDIO_FLAG_DTEND)) {
    

  78.             if(RESET != sdio_flag_get(SDIO, SDIO_FLAG_RFH)) {
    

  79.                 /* at least 8 words can be read in the FIFO */
    

  80.                 for(count = 0U; count < SD_FIFOHALF_WORDS; count++) {
    

  81.                     *(ptempbuff + count) = sdio_data_read(SDIO);
    

  82.                 }
    

  83.                 ptempbuff += SD_FIFOHALF_WORDS;
    

  84.             }
    

  85.         }
    


  86. 

  87.         sdio_trans_start_disable(SDIO);
    


  88. 

  89.         /* whether some error occurs and return it */
    

  90.         if(RESET != sdio_flag_get(SDIO, SDIO_FLAG_DTCRCERR)) {
    

  91.             status = SD_DATA_CRC_ERROR;
    

  92.             sdio_flag_clear(SDIO, SDIO_FLAG_DTCRCERR);
    

  93.             return status;
    

  94.         } else if(RESET != sdio_flag_get(SDIO, SDIO_FLAG_DTTMOUT)) {
    

  95.             status = SD_DATA_TIMEOUT;
    

  96.             sdio_flag_clear(SDIO, SDIO_FLAG_DTTMOUT);
    

  97.             return status;
    

  98.         } else if(RESET != sdio_flag_get(SDIO, SDIO_FLAG_RXORE)) {
    

  99.             status = SD_RX_OVERRUN_ERROR;
    

  100.             sdio_flag_clear(SDIO, SDIO_FLAG_RXORE);
    

  101.             return status;
    

  102.         } else {
    

  103.             /* if else end */
    

  104.         }
    


  105. 

  106.         while((SET != sdio_flag_get(SDIO, SDIO_FLAG_RFE)) && (SET == sdio_flag_get(SDIO, SDIO_FLAG_DATSTA))) {
    

  107.             *ptempbuff = sdio_data_read(SDIO);
    

  108.             ++ptempbuff;
    

  109.         }
    

  110.         /* clear the DATA_FLAGS flags */
    

  111.         sdio_flag_clear(SDIO, SDIO_MASK_DATA_FLAGS);
    

  112.     } else if(SD_DMA_MODE == transmode) {
    

  113.         /* DMA mode */
    

  114.         /* enable the SDIO corresponding interrupts and DMA function */
    

  115.         sdio_interrupt_enable(SDIO, SDIO_INT_CCRCERR | SDIO_INT_DTTMOUT | SDIO_INT_RXORE | SDIO_INT_DTEND);
    

  116.         dma_config(preadbuffer, (uint32_t)(blocksize >> 5));
    

  117.         sdio_idma_enable(SDIO);
    


  118. 

  119.         /* configure SDIO data transmisson */
    

  120.         sdio_data_config(SDIO, SD_DATATIMEOUT, totalnumber_bytes, datablksize);
    

  121.         sdio_data_transfer_config(SDIO, SDIO_TRANSMODE_BLOCKCOUNT, SDIO_TRANSDIRECTION_TOSDIO);
    

  122.         sdio_trans_start_enable(SDIO);
    


  123. 

  124.         /* send CMD17(READ_SINGLE_BLOCK) to read a block */
    

  125.         sdio_command_response_config(SDIO, SD_CMD_READ_SINGLE_BLOCK, (uint32_t)readaddr, SDIO_RESPONSETYPE_SHORT);
    

  126.         sdio_wait_type_set(SDIO, SDIO_WAITTYPE_NO);
    

  127.         sdio_csm_enable(SDIO);
    

  128.         /* check if some error occurs */
    

  129.         status = r1_error_check(SD_CMD_READ_SINGLE_BLOCK);
    

  130.         if(SD_OK != status) {
    

  131.             return status;
    

  132.         }
    


  133. 

  134.         while((0U == transend) && (SD_OK == transerror)) {
    

  135.         }
    

  136.         if(SD_OK != transerror) {
    

  137.             return transerror;
    

  138.         }
    

  139.     } else {
    

  140.         status = SD_PARAMETER_INVALID;
    

  141.     }
    

  142.     return status;
    

  143. }
12.4.5 SD卡lock和unlock配置函数
SD卡lock和unlock配置函数如下所示。通过形参实现对SD卡的lock和unlock，若希望lock SD卡，lcokstate配置为SD_LOCK；若希望unlock SD卡，lockstate配置为SD_UNLOCK.
复制
  1. C
    

  2. sd_error_enum sd_lock_unlock(uint8_t lockstate)
    

  3. {
    

  4.     sd_error_enum status = SD_OK;
    

  5.     uint8_t cardstate = 0U, tempbyte = 0U;
    

  6.     uint32_t pwd1 = 0U, pwd2 = 0U, response = 0U, timeout = 0U;
    

  7.     uint16_t tempccc = 0U;
    


  8. 

  9.     /* get the card command classes from CSD */
    

  10.     tempbyte = (uint8_t)((sd_csd[1] & SD_MASK_24_31BITS) >> 24U);
    

  11.     tempccc = ((uint16_t)tempbyte << 4U);
    

  12.     tempbyte = (uint8_t)((sd_csd[1] & SD_MASK_16_23BITS) >> 16U);
    

  13.     tempccc |= (((uint16_t)tempbyte & 0xF0U) >> 4U);
    


  14. 

  15.     if(0U == (tempccc & SD_CCC_LOCK_CARD)) {
    

  16.         /* don't support the lock command */
    

  17.         status = SD_FUNCTION_UNSUPPORTED;
    

  18.         return status;
    

  19.     }
    

  20.     /* password pattern */
    

  21.     pwd1 = (0x01020600U | lockstate);
    

  22.     pwd2 = 0x03040506U;
    


  23. 

  24.     /* clear all DSM configuration */
    

  25.     sdio_data_config(SDIO, 0U, 0U, SDIO_DATABLOCKSIZE_1BYTE);
    

  26.     sdio_data_transfer_config(SDIO, SDIO_TRANSMODE_BLOCKCOUNT, SDIO_TRANSDIRECTION_TOCARD);
    

  27.     sdio_dsm_disable(SDIO);
    

  28.     sdio_idma_disable(SDIO);
    


  29. 

  30.     /* send CMD16(SET_BLOCKLEN) to set the block length */
    

  31.     sdio_command_response_config(SDIO, SD_CMD_SET_BLOCKLEN, (uint32_t)8U, SDIO_RESPONSETYPE_SHORT);
    

  32.     sdio_wait_type_set(SDIO, SDIO_WAITTYPE_NO);
    

  33.     sdio_csm_enable(SDIO);
    

  34.     /* check if some error occurs */
    

  35.     status = r1_error_check(SD_CMD_SET_BLOCKLEN);
    

  36.     if(SD_OK != status) {
    

  37.         return status;
    

  38.     }
    


  39. 

  40.     /* send CMD13(SEND_STATUS), addressed card sends its status register */
    

  41.     sdio_command_response_config(SDIO, SD_CMD_SEND_STATUS, (uint32_t)sd_rca << SD_RCA_SHIFT, SDIO_RESPONSETYPE_SHORT);
    

  42.     sdio_wait_type_set(SDIO, SDIO_WAITTYPE_NO);
    

  43.     sdio_csm_enable(SDIO);
    

  44.     /* check if some error occurs */
    

  45.     status = r1_error_check(SD_CMD_SEND_STATUS);
    

  46.     if(SD_OK != status) {
    

  47.         return status;
    

  48.     }
    


  49. 

  50.     response = sdio_response_get(SDIO, SDIO_RESPONSE0);
    

  51.     timeout = 100000U;
    

  52.     while((0U == (response & SD_R1_READY_FOR_DATA)) && (timeout > 0U)) {
    

  53.         /* continue to send CMD13 to polling the state of card until buffer empty or timeout */
    

  54.         --timeout;
    

  55.         /* send CMD13(SEND_STATUS), addressed card sends its status registers */
    

  56.         sdio_command_response_config(SDIO, SD_CMD_SEND_STATUS, (uint32_t)sd_rca << SD_RCA_SHIFT, SDIO_RESPONSETYPE_SHORT);
    

  57.         sdio_wait_type_set(SDIO, SDIO_WAITTYPE_NO);
    

  58.         sdio_csm_enable(SDIO);
    

  59.         /* check if some error occurs */
    

  60.         status = r1_error_check(SD_CMD_SEND_STATUS);
    

  61.         if(SD_OK != status) {
    

  62.             return status;
    

  63.         }
    

  64.         response = sdio_response_get(SDIO, SDIO_RESPONSE0);
    

  65.     }
    

  66.     if(0U == timeout) {
    

  67.         status = SD_ERROR;
    

  68.         return status;
    

  69.     }
    


  70. 

  71.     /* send CMD42(LOCK_UNLOCK) to set/reset the password or lock/unlock the card */
    

  72.     sdio_command_response_config(SDIO, SD_CMD_LOCK_UNLOCK, (uint32_t)0x0, SDIO_RESPONSETYPE_SHORT);
    

  73.     sdio_wait_type_set(SDIO, SDIO_WAITTYPE_NO);
    

  74.     sdio_csm_enable(SDIO);
    

  75.     /* check if some error occurs */
    

  76.     status = r1_error_check(SD_CMD_LOCK_UNLOCK);
    

  77.     if(SD_OK != status) {
    

  78.         return status;
    

  79.     }
    


  80. 

  81.     response = sdio_response_get(SDIO, SDIO_RESPONSE0);
    


  82. 

  83.     /* configure the SDIO data transmisson */
    

  84.     sdio_data_config(SDIO, SD_DATATIMEOUT, (uint32_t)8, SDIO_DATABLOCKSIZE_8BYTES);
    

  85.     sdio_data_transfer_config(SDIO, SDIO_TRANSMODE_BLOCKCOUNT, SDIO_TRANSDIRECTION_TOCARD);
    

  86.     sdio_dsm_enable(SDIO);
    


  87. 

  88.     /* write password pattern */
    

  89.     sdio_data_write(SDIO, pwd1);
    

  90.     sdio_data_write(SDIO, pwd2);
    


  91. 

  92.     /* whether some error occurs and return it */
    

  93.     if(RESET != sdio_flag_get(SDIO, SDIO_FLAG_DTCRCERR)) {
    

  94.         status = SD_DATA_CRC_ERROR;
    

  95.         sdio_flag_clear(SDIO, SDIO_FLAG_DTCRCERR);
    

  96.         return status;
    

  97.     } else if(RESET != sdio_flag_get(SDIO, SDIO_FLAG_DTTMOUT)) {
    

  98.         status = SD_DATA_TIMEOUT;
    

  99.         sdio_flag_clear(SDIO, SDIO_FLAG_DTTMOUT);
    

  100.         return status;
    

  101.     } else if(RESET != sdio_flag_get(SDIO, SDIO_FLAG_TXURE)) {
    

  102.         status = SD_TX_UNDERRUN_ERROR;
    

  103.         sdio_flag_clear(SDIO, SDIO_FLAG_TXURE);
    

  104.         return status;
    

  105.     } else {
    

  106.         /* if else end */
    

  107.     }
    


  108. 

  109.     /* clear the SDIO_INTC flags */
    

  110.     sdio_flag_clear(SDIO, SDIO_MASK_INTC_FLAGS);
    

  111.     /* get the card state and wait the card is out of programming and receiving state */
    

  112.     status = sd_card_state_get(&cardstate);
    

  113.     while((SD_OK == status) && ((SD_CARDSTATE_PROGRAMMING == cardstate) || (SD_CARDSTATE_RECEIVING == cardstate))) {
    

  114.         status = sd_card_state_get(&cardstate);
    

  115.     }
    

  116.     return status;
    

  117. }
12.4.6 SD卡erase擦除操作函数
SD卡擦除操作函数如下，其形参为擦除起始地址以及结束地址。
复制
  1. C
    

  2. sd_error_enum sd_erase(uint32_t startaddr, uint32_t endaddr)
    

  3. {
    

  4.     /* initialize the variables */
    

  5.     sd_error_enum status = SD_OK;
    

  6.     uint32_t count = 0U, clkdiv = 0U;
    

  7.     __IO uint32_t delay = 0U;
    

  8.     uint8_t cardstate = 0U, tempbyte = 0U;
    

  9.     uint16_t tempccc = 0U;
    


  10. 

  11.     /* get the card command classes from CSD */
    

  12.     tempbyte = (uint8_t)((sd_csd[1] & SD_MASK_24_31BITS) >> 24U);
    

  13.     tempccc = (uint16_t)((uint16_t)tempbyte << 4U);
    

  14.     tempbyte = (uint8_t)((sd_csd[1] & SD_MASK_16_23BITS) >> 16U);
    

  15.     tempccc |= ((uint16_t)tempbyte & 0xF0U) >> 4U;
    

  16.     if(0U == (tempccc & SD_CCC_ERASE)) {
    

  17.         /* don't support the erase command */
    

  18.         status = SD_FUNCTION_UNSUPPORTED;
    

  19.         return status;
    

  20.     }
    

  21.     clkdiv = (SDIO_CLKCTL(SDIO) & SDIO_CLKCTL_DIV);
    

  22.     clkdiv *= 2U;
    

  23.     delay = 168000U / clkdiv;
    


  24. 

  25.     /* check whether the card is locked */
    

  26.     if(sdio_response_get(SDIO, SDIO_RESPONSE0) & SD_CARDSTATE_LOCKED) {
    

  27.         status = SD_LOCK_UNLOCK_FAILED;
    

  28.         return(status);
    

  29.     }
    


  30. 

  31.     /* blocksize is fixed in 512B for SDHC card */
    

  32.     if(SDIO_HIGH_CAPACITY_SD_CARD != cardtype) {
    

  33.         startaddr *= 512U;
    

  34.         endaddr *= 512U;
    

  35.     }
    


  36. 

  37.     if((SDIO_STD_CAPACITY_SD_CARD_V1_1 == cardtype) || (SDIO_STD_CAPACITY_SD_CARD_V2_0 == cardtype) ||
    

  38.             (SDIO_HIGH_CAPACITY_SD_CARD == cardtype)) {
    

  39.         /* send CMD32(ERASE_WR_BLK_START) to set the address of the first write block to be erased */
    

  40.         sdio_command_response_config(SDIO, SD_CMD_ERASE_WR_BLK_START, startaddr, SDIO_RESPONSETYPE_SHORT);
    

  41.         sdio_wait_type_set(SDIO, SDIO_WAITTYPE_NO);
    

  42.         sdio_csm_enable(SDIO);
    

  43.         /* check if some error occurs */
    

  44.         status = r1_error_check(SD_CMD_ERASE_WR_BLK_START);
    

  45.         if(SD_OK != status) {
    

  46.             return status;
    

  47.         }
    


  48. 

  49.         /* send CMD33(ERASE_WR_BLK_END) to set the address of the last write block of the continuous range to be erased */
    

  50.         sdio_command_response_config(SDIO, SD_CMD_ERASE_WR_BLK_END, endaddr, SDIO_RESPONSETYPE_SHORT);
    

  51.         sdio_wait_type_set(SDIO, SDIO_WAITTYPE_NO);
    

  52.         sdio_csm_enable(SDIO);
    

  53.         /* check if some error occurs */
    

  54.         status = r1_error_check(SD_CMD_ERASE_WR_BLK_END);
    

  55.         if(SD_OK != status) {
    

  56.             return status;
    

  57.         }
    

  58.     }
    


  59. 

  60.     /* send CMD38(ERASE) to set the address of the first write block to be erased */
    

  61.     sdio_command_response_config(SDIO, SD_CMD_ERASE, (uint32_t)0x0, SDIO_RESPONSETYPE_SHORT);
    

  62.     sdio_wait_type_set(SDIO, SDIO_WAITTYPE_NO);
    

  63.     sdio_csm_enable(SDIO);
    

  64.     /* check if some error occurs */
    

  65.     status = r1_error_check(SD_CMD_ERASE);
    

  66.     if(SD_OK != status) {
    

  67.         return status;
    

  68.     }
    

  69.     /* loop until the counter is reach to the calculated time */
    

  70.     for(count = 0U; count < delay; count++) {
    

  71.     }
    

  72.     /* get the card state and wait the card is out of programming and receiving state */
    

  73.     status = sd_card_state_get(&cardstate);
    

  74.     while((SD_OK == status) && ((SD_CARDSTATE_PROGRAMMING == cardstate) || (SD_CARDSTATE_RECEIVING == cardstate))) {
    

  75.         status = sd_card_state_get(&cardstate);
    

  76.     }
    

  77.     return status;
    

  78. }
12.4.7 主函数
SD卡主函数如下，可实现对SD卡的擦写读以及加锁解锁操作。
复制
  1. C
    

  2. int main()
    

  3. {
    

  4.     sd_error_enum sd_error;
    

  5.     Drv_Err state = DRV_ERROR;
    


  6. 

  7.     uint16_t i = 5;
    

  8. #ifdef DATA_PRINT
    

  9.     uint8_t *pdata;
    

  10. #endif /* DATA_PRINT */
    


  11. 

  12.     /* enable the CPU Cache */
    

  13.     driver_init();
    


  14. 

  15.     /* configure the NVIC and USART */
    

  16.     nvic_config();
    

  17.     
    

  18.     bsp_led_group_init();
    


  19. 

  20.     /* turn off all the LEDs */
    

  21.     bsp_led_off(&LED1);
    

  22.     bsp_led_off(&LED2);
    


  23. 

  24.     /* initialize the card */                  
    

  25.     do {
    

  26.         sd_error = sd_io_init();
    

  27.     } while((SD_OK != sd_error) && (--i));
    


  28. 

  29.     if(i) {
    

  30.         printf_log("\r\n Card init success!\r\n");
    

  31.     } else {
    

  32.         printf_log("\r\n Card init failed!\r\n");
    

  33.         /* turn on LED1, LED2 */
    

  34.         bsp_led_on(&LED1);
    

  35.         bsp_led_on(&LED2);
    

  36.         while(1) {
    

  37.         }
    

  38.     }
    


  39. 

  40.     /* get the information of the card and print it out by USART */
    

  41.     card_info_get();
    


  42. 


  43. 

  44.     /* init the write buffer */
    

  45.     for(i = 0; i < 512; i++) {
    

  46.         buf_write[i] = i;
    

  47.     }
    


  48. 

  49.     /* clean and invalidate buffer in D-Cache */
    

  50.     SCB_CleanInvalidateDCache_by_Addr(buf_write, 512 * 4);
    


  51. 

  52.     printf_log("\r\n\r\n Card test:");
    

  53.     /* single block operation test */
    

  54.     sd_error = sd_block_write(buf_write, 100, 512);
    

  55.     if(SD_OK != sd_error) {
    

  56.         printf_log("\r\n Block write fail!");
    

  57.         /* turn on LED1, LED2 */
    

  58.         bsp_led_on(&LED1);
    

  59.         bsp_led_on(&LED2);
    

  60.         while(1) {
    

  61.         }
    

  62.     } else {
    

  63.         printf_log("\r\n Block write success!");
    

  64.     }
    


  65. 

  66.     sd_error = sd_block_read(buf_read, 100, 512);
    

  67.     if(SD_OK != sd_error) {
    

  68.         printf_log("\r\n Block read fail!");
    

  69.         /* turn on LED1, LED2 */
    

  70.         bsp_led_on(&LED1);
    

  71.         bsp_led_on(&LED2);
    

  72.         while(1) {
    

  73.         }
    

  74.     } else {
    

  75.         printf_log("\r\n Block read success!");
    

  76. #ifdef DATA_PRINT
    

  77.         SCB_CleanInvalidateDCache_by_Addr(buf_read, 512 * 4);
    

  78.         pdata = (uint8_t *)buf_read;
    

  79.         /* print data by USART */
    

  80.         printf_log("\r\n");
    

  81.         for(i = 0; i < 128; i++) {
    

  82.             printf_log(" %3d %3d %3d %3d ", *pdata, *(pdata + 1), *(pdata + 2), *(pdata + 3));
    

  83.             pdata += 4;
    

  84.             if(0 == (i + 1) % 4) {
    

  85.                 printf_log("\r\n");
    

  86.             }
    

  87.         }
    

  88. #endif /* DATA_PRINT */
    

  89.     }
    


  90. 

  91.     /* compare the write date and the read data */
    

  92.     state = memory_compare((uint8_t *)buf_write, (uint8_t *)buf_read, 128*4);
    

  93.     if(SUCCESS == state) {
    

  94.         printf_log("\r\n Single block read compare successfully!");
    

  95.     } else {
    

  96.         printf_log("\r\n Single block read compare fail!");
    

  97.         /* turn on LED1, LED2 */
    

  98.         bsp_led_on(&LED1);
    

  99.         bsp_led_on(&LED2);
    

  100.         while(1) {
    

  101.         }
    

  102.     }
    


  103. 

  104.     /* lock and unlock operation test */
    

  105.     if(SD_CCC_LOCK_CARD & sd_cardinfo.card_csd.ccc) {
    

  106.         /* lock the card */
    

  107.         sd_error = sd_lock_unlock(SD_LOCK);
    

  108.         if(SD_OK != sd_error) {
    

  109.             printf_log("\r\n Lock failed!");
    

  110.             /* turn on LED1, LED2 */
    

  111.             bsp_led_on(&LED1);
    

  112.             bsp_led_on(&LED2);
    

  113.             while(1) {
    

  114.             }
    

  115.         } else {
    

  116.             printf_log("\r\n The card is locked!");
    

  117.         }
    

  118.         sd_error = sd_erase(100, 101);
    

  119.         if(SD_OK != sd_error) {
    

  120.             printf_log("\r\n Erase failed!");
    

  121.         } else {
    

  122.             printf_log("\r\n Erase success!");
    

  123.         }
    


  124. 

  125.         /* unlock the card */
    

  126.         sd_error = sd_lock_unlock(SD_UNLOCK);
    

  127.         if(SD_OK != sd_error) {
    

  128.             printf_log("\r\n Unlock failed!");
    

  129.             /* turn on LED1, LED2 */
    

  130.             bsp_led_on(&LED1);
    

  131.             bsp_led_on(&LED2);
    

  132.             while(1) {
    

  133.             }
    

  134.         } else {
    

  135.             printf_log("\r\n The card is unlocked!");
    

  136.         }
    

  137.         sd_error = sd_erase(100, 101);
    

  138.         if(SD_OK != sd_error) {
    

  139.             printf_log("\r\n Erase failed!");
    

  140.         } else {
    

  141.             printf_log("\r\n Erase success!");
    

  142.         }
    


  143. 

  144.         sd_error = sd_block_read(buf_read, 100, 512);
    

  145.         if(SD_OK != sd_error) {
    

  146.             printf_log("\r\n Block read fail!");
    

  147.             /* turn on LED1, LED2 */
    

  148.             bsp_led_on(&LED1);
    

  149.             bsp_led_on(&LED2);
    

  150.             while(1) {
    

  151.             }
    

  152.         } else {
    

  153.             printf_log("\r\n Block read success!");
    

  154. #ifdef DATA_PRINT
    

  155.             SCB_CleanInvalidateDCache_by_Addr(buf_read, 512 * 4);
    

  156.             pdata = (uint8_t *)buf_read;
    

  157.             /* print data by USART */
    

  158.             printf_log("\r\n");
    

  159.             for(i = 0; i < 128; i++) {
    

  160.                 printf_log(" %3d %3d %3d %3d ", *pdata, *(pdata + 1), *(pdata + 2), *(pdata + 3));
    

  161.                 pdata += 4;
    

  162.                 if(0 == (i + 1) % 4) {
    

  163.                     printf_log("\r\n");
    

  164.                 }
    

  165.             }
    

  166. #endif /* DATA_PRINT */
    

  167.         }
    

  168.     }
    


  169. 

  170.     /* multiple blocks operation test */
    

  171.     sd_error = sd_multiblocks_write(buf_write, 200, 512, 3);
    

  172.     if(SD_OK != sd_error) {
    

  173.         printf_log("\r\n Multiple block write fail!");
    

  174.         /* turn on LED1, LED2 */
    

  175.         bsp_led_on(&LED1);
    

  176.         bsp_led_on(&LED2);
    

  177.         while(1) {
    

  178.         }
    

  179.     } else {
    

  180.         printf_log("\r\n Multiple block write success!");
    

  181.     }
    


  182. 

  183.     sd_error = sd_multiblocks_read(buf_read, 200, 512, 3);
    

  184.     if(SD_OK != sd_error) {
    

  185.         printf_log("\r\n Multiple block read fail!");
    

  186.         /* turn on LED1, LED2 */
    

  187.         bsp_led_on(&LED1);
    

  188.         bsp_led_on(&LED2);
    

  189.         while(1) {
    

  190.         }
    

  191.     } else {
    

  192.         printf_log("\r\n Multiple block read success!");
    

  193. #ifdef DATA_PRINT
    

  194.         SCB_CleanInvalidateDCache_by_Addr(buf_read, 512 * 4);
    

  195.         pdata = (uint8_t *)buf_read;
    

  196.         /* print data by USART */
    

  197.         printf_log("\r\n");
    

  198.         for(i = 0; i < 512; i++) {
    

  199.             printf_log(" %3d %3d %3d %3d ", *pdata, *(pdata + 1), *(pdata + 2), *(pdata + 3));
    

  200.             pdata += 4;
    

  201.             if(0 == (i + 1) % 4) {
    

  202.                 printf_log("\r\n");
    

  203.             }
    

  204.         }
    

  205. #endif /* DATA_PRINT */
    

  206.     }
    

  207.     /* compare the write date and the read data */
    

  208.     state = memory_compare((uint8_t *)buf_write, (uint8_t *)buf_read, 128*3*4);
    

  209.     
    

  210.     if(SUCCESS == state) {
    

  211.         printf_log("\r\n Multiple block read compare successfully!");
    

  212.     } else {
    

  213.         printf_log("\r\n Multiple block read compare fail!");
    

  214.         /* turn on LED1, LED2 */
    

  215.         bsp_led_on(&LED1);
    

  216.         bsp_led_on(&LED2);
    

  217.         while(1) {
    

  218.         }
    

  219.     }
    

  220.     printf_log("\r\n SD card test successfully!");
    

  221.     while(1) {};
    

  222. }
12.5 实验结果
将SD卡读写实验例程烧录到海棠派开发板中，并在卡槽中插入SD卡，在液晶屏上，将会观察到SD卡相关操作结果。
本教程由GD32 MCU方案商聚沃科技原创发布，了解更多GD32 MCU教程，关注聚沃科技官网，GD32MCU技术交流群：859440462

回复

收藏 举报

相关帖子
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

聚沃科技

170

主题

190

帖子

13

粉丝
快速回复 在线客服 返回列表 返回顶部