nRF52832学习记录（十二、SPI接口的应用 Micro SD卡读写测试）

最新推荐文章于 2024-07-08 10:21:49 发布
最新推荐文章于 2024-07-08 10:21:49 发布
阅读量4.6k 收藏 30
点赞数 5
分类专栏： nRF52xxx 系列芯片 文章标签： 蓝牙
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42328389/article/details/120709533
版权
本文详细介绍了nRF52系列微控制器上的SPI接口，包括SPI的基础知识、寄存器配置、库函数使用，以及如何初始化和传输数据。通过具体的nRF52832 SPI配置示例，展示了SPI与W25qxx SPI Flash和MicroSD卡的读写操作。此外，还探讨了MicroSD卡在SPI模式下的工作原理和移植测试。
摘要由CSDN通过智能技术生成

目录

1、nRF52xx SPI介绍

SPI接口基础介绍

SPI，支持全双工通信，我们这里主要介绍一下nRF52系列处理器上的SPI资源。
在nRF52832处理器中，有3个SPI 模块，SPI0 、SPI1、SPI2。
如果 SPI 作为主机使用 带有 EasyDMA 则称为 SPIM。
如果 SPI 作为从机使用 带有 EasyDMA 则称为 SPIS。

SPI的4根线：

  • SDO/MOSI – 主设备数据输出，从设备数据输入;
  • SDI/MISO – 主设备数据输入，从设备数据输出;
  • SCLK – 时钟信号，由主设备产生;
  • CS/SS – 从设备使能信号，由主设备控制。当有多个从设备的时候，因为每个从设备上都有一个片选引脚接入到主设备机中，当我们的主设备和某个从设备通信时将需要将从设备对应的片选引脚电平拉低或者是拉高（一般来说是低电平选中）。

SPi的四种模式：

CPOL=0，表示当SCLK=0时处于空闲态，空闲低电平，所以有效状态就是SCLK处于高电平时
CPOL=1，表示当SCLK=1时处于空闲态，空闲高电平，所以有效状态就是SCLK处于低电平时
CPHA=0，表示数据采样是在第1个边沿
CPHA=1，表示数据采样是在第2个边沿

主设备能够控制时钟，因为SPI通信并不像UART或者IIC通信那样有专门的通信周期，起始信号，结束信号；所以SPI协议能够通过控制时钟信号线，当没有数据交流的时候我们的时钟线要么是保持高电平要么是保持低电平。

不同的从设备可能在出厂时由工厂配置为某种通信模式，无法改变，所以我们得根据从设备的通讯模式来设置主设备的模式。

我们还是从基本的SPI设备使用介绍开始学习，以后应用需要使用到EasyDMA再做相应的记录。

nRF52832的SPI模式：
在这里插入图片描述

SPI 寄存器

注意 SPI0、SPI1 和 TWI0、TWI1 共有基础地址，两者不能同时使用
在这里插入图片描述

SPI 库函数介绍

先熟悉一下需要用到的库函数，SPI的库函数结构 和 I2C 基本上一致

SPI初始化函数

nrf_drv_spi_init有4个参数：
第一个参数选择使用哪个 SPI 模块（3个） 如果使用 EasyDMA 就是SPIM；
第二个参数是 SPI 的配置；
第三个参数是 自定义的事件处理函数，如果设置为NULL， 则使能 SPI 的阻塞模式；
第四个参数 写 NULL暂时，不太清楚，也是处理函数。

/*
第一个参数就是定义使用哪一个 SPI 或者是 SPIM(如果使用EasyDMA的话):
typedef struct
{
    uint8_t inst_idx;
    union
    {
#ifdef SPIM_PRESENT
        nrfx_spim_t spim;
#endif
#ifdef SPI_PRESENT
        nrfx_spi_t  spi;
#endif
    } u;
    bool    use_easy_dma;
} nrf_drv_spi_t;

nrf_drv_spi_t 结构体中的 nrfx_spi_t 结构体:
typedef struct
{
    NRF_SPI_Type * p_reg;        ///< Pointer to a structure with SPI registers.
    uint8_t        drv_inst_idx; ///< Driver instance index.
} nrfx_spi_t;

nrfx_spi_t 结构体中的  NRF_SPI_Type 就是对应的 SPI 的每个寄存器

第二个参数定义 SPI 的配置：

typedef struct
{
    uint8_t sck_pin;      ///< SCK pin number.
    uint8_t mosi_pin;     ///< MOSI pin number (optional).
                          /**< Set to @ref NRF_DRV_SPI_PIN_NOT_USED
                           *   if this signal is not needed. /
    uint8_t miso_pin;     ///< MISO pin number (optional).
                          /**< Set to @ref NRF_DRV_SPI_PIN_NOT_USED
                           *   if this signal is not needed. /
    uint8_t ss_pin;       ///< Slave Select pin number (optional).
                          /**< Set to @ref NRF_DRV_SPI_PIN_NOT_USED
                           *   if this signal is not needed. The driver
                           *   supports only active low for this signal.
                           *   If the signal should be active high,
                           *   it must be controlled externally. /
    uint8_t irq_priority; ///< Interrupt priority.
    uint8_t orc;          ///< Over-run character.
                          /**< This character is used when all bytes from the TX buffer are sent,
                               but the transfer continues due to RX. /
    nrf_drv_spi_frequency_t frequency; ///< SPI frequency.
    nrf_drv_spi_mode_t      mode;      ///< SPI mode.
    nrf_drv_spi_bit_order_t bit_order; ///< SPI bit order.
} nrf_drv_spi_config_t;

其中nrf_drv_spi_bit_order_t bit_order; ///< SPI bit order.
表示每个数据是高位先发还是地位先发

第三个参数是 用户提供的事件处理程序，如果为空，使用阻塞模式。

第四个参数是 传递给事件处理的上下文。

整体结构和I2C一样

*/
ret_code_t nrf_drv_spi_init(nrf_drv_spi_t const * const p_instance,
                            nrf_drv_spi_config_t const * p_config,
                            nrf_drv_spi_evt_handler_t    handler,
                            void *                       p_context)

nrf_drv_spi_config_t SPI默认配置如下：

#define NRF_DRV_SPI_DEFAULT_CONFIG                           \
{                                                            \
    .sck_pin      = NRF_DRV_SPI_PIN_NOT_USED,                \
    .mosi_pin     = NRF_DRV_SPI_PIN_NOT_USED,                \
    .miso_pin     = NRF_DRV_SPI_PIN_NOT_USED,                \
    .ss_pin       = NRF_DRV_SPI_PIN_NOT_USED,                \
    .irq_priority = SPI_DEFAULT_CONFIG_IRQ_PRIORITY,         \
    .orc          = 0xFF,                                    \
    .frequency    = NRF_DRV_SPI_FREQ_4M,                     \
    .mode         = NRF_DRV_SPI_MODE_0,                      \
    .bit_order    = NRF_DRV_SPI_BIT_ORDER_MSB_FIRST,         \
}

SPI数据传输函数

nrf_drv_spi_transfer有5个参数：
第一个参数，和上面介绍的一样，哪个SPI 模块；
第二个参数 ，指向传输缓冲区的指针；
第三个参数，为 传输缓冲区的长度；
第四个参数，指向接收缓冲区的指针；
第五个参数，为 接收缓冲区的长度；

/*
第一个参数， 和初始化一样
使用哪一个 SPI 或者是 SPIM(如果使用EasyDMA的话):

第二个参数指向传输缓冲区的指针。没有则可以为空。

第三个数据 为 传输缓冲区的长度

第四个数据 接收缓冲区

5长度

*/
__STATIC_INLINE
ret_code_t nrf_drv_spi_transfer(nrf_drv_spi_t const * const p_instance,
                                uint8_t const * p_tx_buffer,
                                uint8_t         tx_buffer_length,
                                uint8_t       * p_rx_buffer,
                                uint8_t         rx_buffer_length)

2、nRF52xx SPI 使用示例

w25qxx SPI Flash读写

这里只放Flash的驱动部分.c文件部分，至于里面的CMD，是在.h文件里面定义的，不同的SPI设备不同，这里是为了给出使用示例，所以不贴全部代码，代码是 清风蓝牙教程的demo：

w25qxx.c 驱动：

#include <string.h>
#include "nrf_drv_common.h"
#include "nrf_drv_spi.h"
#include "app_util_platform.h"
#include "app_error.h"
#include "w25q16.h"
#include "nrf_gpio.h"
#include "boards.h"
#include "nrf_delay.h"

#define SPI_INSTANCE  0 /**< SPI instance index. */


static volatile bool spi_xfer_done;  //SPI数据传输完成标志
static const nrf_drv_spi_t spi = NRF_DRV_SPI_INSTANCE(SPI_INSTANCE);  /**< SPI instance. */

static uint8_t    spi_tx_buf[256];   /**< TX buffer. */
static uint8_t    spi_rx_buf[256];   /**< RX buffer. */


/**
 * @brief SPI user event handler.
 * @param event
 */
void spi_event_handler(nrf_drv_spi_evt_t const * p_event,
                       void *                    p_context)
{
  spi_xfer_done = true;
}


void hal_spi_init(void)
{
//	nrf_drv_spi_config_t spi_config = NRF_DRV_SPI_DEFAULT_CONFIG(SPI_INSTANCE);
//  spi_config.ss_pin = SPI_CS_PIN;
//  APP_ERROR_CHECK(nrf_drv_spi_init(&spi, &spi_config, spi_event_handler));	
		
	nrf_drv_spi_config_t spi_config = NRF_DRV_SPI_DEFAULT_CONFIG;
    spi_config.ss_pin   = SPI_SS_PIN;
    spi_config.miso_pin = SPI_MISO_PIN;
    spi_config.mosi_pin = SPI_MOSI_PIN;
    spi_config.sck_pin  = SPI_SCK_PIN;
    APP_ERROR_CHECK(nrf_drv_spi_init(&spi, &spi_config, spi_event_handler, NULL));
}

/*****************************************************************************
** 描  述：读出一个字节
** 入  参：无
** 返回值：读出的数据
******************************************************************************/
uint8_t SpiFlash_ReadOneByte(void) 
{
    uint8_t len = 1;

	spi_tx_buf[0] = 0xFF;
	spi_xfer_done = false;
	APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, spi_tx_buf, len, spi_rx_buf, len));
	while(!spi_xfer_done);
    return (spi_rx_buf[0]);
}
/*****************************************************************************
** 描  述：写入一个字节
** 入  参：Dat：待写入的数据
** 返回值：无
******************************************************************************/
void SpiFlash_WriteOneByte(uint8_t Dat)
{
    uint8_t len = 1;
	
    spi_tx_buf[0] = Dat;
	spi_xfer_done = false;
	APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, spi_tx_buf, len, spi_rx_buf, len));
    while(!spi_xfer_done);
}

/*****************************************************************************
** 描  述：写入命令
** 入  参：*CMD：指向待写入的命令
** 返回值：RET_SUCCESS
******************************************************************************/
uint8_t SpiFlash_Write_CMD(uint8_t *CMD)
{
	uint8_t len = 3;

	spi_tx_buf[0] = *CMD;
	spi_tx_buf[1] = *(CMD+1);
	spi_tx_buf[2] = *(CMD+2);
	spi_xfer_done = false;
	APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, spi_tx_buf, len, spi_rx_buf, len));
	while(!spi_xfer_done);
    return RET_SUCCESS;
}
/*****************************************************************************
** 描  述：写使能
** 入  参：无
** 返回值：无
******************************************************************************/
void SpiFlash_Write_Enable(void)
{
	spi_xfer_done = false;
	SpiFlash_WriteOneByte(SPIFlash_WriteEnable_CMD);
	while(!spi_xfer_done);
}
/*****************************************************************************
** 描  述：擦除扇区，W25Q128FVSIG最小的擦除单位是扇区
** 入  参：Block_Num：块号
**         Sector_Number：扇区号
** 返回值：
******************************************************************************/
void SPIFlash_Erase_Sector(uint8_t Block_Num,uint8_t Sector_Number)
{
	SpiFlash_Write_Enable();

	spi_tx_buf[0] = SPIFlash_SecErase_CMD;
	spi_tx_buf[1] = Block_Num;
	spi_tx_buf[2] = Sector_Number<<4;
	spi_tx_buf[3] = 0x00;
	spi_xfer_done = false;
	APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, spi_tx_buf, 4, spi_rx_buf, 4));
	while(!spi_xfer_done);	
	nrf_delay_ms(10);    //每次擦除数据都要延时等待写入结束
    return ;
}
/*****************************************************************************
** 描  述：向指定的地址写入数据
**         *pBuffer:指向待写入的数据
**         WriteAddr:写入的起始地址
**         WriteBytesNum:读出的字节数
** 返回值：RET_SUCCESS
******************************************************************************/
uint8_t SpiFlash_Write_Page(uint8_t *pBuffer, uint32_t WriteAddr, uint32_t WriteBytesNum)
{
	uint8_t len;

	SpiFlash_Write_Enable();

	spi_tx_buf[0] = SPIFlash_PageProgram_CMD;
	spi_tx_buf[1] = (uint8_t)((WriteAddr&0x00ff0000)>>16);
	spi_tx_buf[2] = (uint8_t)((WriteAddr&0x0000ff00)>>8);
	spi_tx_buf[3] = (uint8_t)WriteAddr;

	memcpy(&spi_tx_buf[4],pBuffer,WriteBytesNum);

	len = WriteBytesNum + 4;
	spi_xfer_done = false;
	APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, spi_tx_buf, len, spi_rx_buf, 0));
	while(!spi_xfer_done);	

	return RET_SUCCESS;
}
/*****************************************************************************
** 描  述：从指定的地址读出指定长度的数据
** 入  参：pBuffer：指向存放读出数据的首地址       
**         ReadAddr：待读出数据的起始地址
**         ReadBytesNum：读出的字节数
** 返回值：
******************************************************************************/
uint8_t SpiFlash_Read(uint8_t *pBuffer,uint32_t ReadAddr,uint32_t ReadBytesNum)
{
	uint8_t len;

	spi_tx_buf[0] = SPIFlash_ReadData_CMD;
	spi_tx_buf[1] = (uint8_t)((ReadAddr&0x00ff0000)>>16);
	spi_tx_buf[2] = (uint8_t)((ReadAddr&0x0000ff00)>>8);
	spi_tx_buf[3] = (uint8_t)ReadAddr;

	len = ReadBytesNum + 4;
	spi_xfer_done = false;
	APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, spi_tx_buf, len, spi_rx_buf, len));
	while(!spi_xfer_done);	
	memcpy(pBuffer,&spi_rx_buf[4],ReadBytesNum);

	return RET_SUCCESS;
}
/********************************************END FILE*******************************************/

MicroSD卡（TF卡）SPI测试

SD卡往往有多种通讯方式（上电后需要主机告诉SD卡采用什么方式，所以需要SD卡初始化程序）：

  • 标准的SPI
  • SD模式 —— 一根线的SDIO接口
  • SD模式 —— 四根线的SDIO接口，一次可以4个数据出，4个数据回

Micro SD卡SPI模式基础知识

Micro SD（TF）卡的引脚说明：
在这里插入图片描述
Micro SD卡只有8个引脚是比SD卡少了一个Vss。可以买个SD卡套套在Micro SD卡上，这样一来大小就和SD卡一样大，这时候卡套上的9个引脚就和SD卡一样了，可以完全当做SD卡来操作。
在《SD卡接口规范》文档中，有SD卡工作在SPI模式的引脚定义：
在这里插入图片描述SD卡和Micro SD卡的SPI操作方式是一样的。

SD卡的 SPI 时钟空闲时为高电平，在时钟的第二个边沿，也就是时钟线的电平由低变高时 采集数据，所以配置 SPI 的极性和相位： CPOL = 1， CPHA = 1。由上面第一章的内容可知 读取SD卡 nRF52832工作在模式 3。

下面的图片参考博文：MicroSD卡（TF卡）SPI模式实现方法
在这里插入图片描述在这里插入图片描述在这里插入图片描述

Micro SD卡SPI 程序移植测试

研究了这么多，最好还是回到当初STM32正点原子的教程里面有SD的读写，驱动，想着直接移植过来试试，最后应该是成功了，没有做过多的测试读写，只是读了一下扇区大小。

  • 程序中主要注意 读取SD卡 nRF52832工作在模式 3；
  • 速度设置需要额外更改；

.h部分

//省略

typedef unsigned char      u8;  
typedef unsigned long int  u32;
typedef unsigned int       u16;
								    	 
// SD卡类型定义  
#define SD_TYPE_ERR     0X00
#define SD_TYPE_MMC     0X01
#define SD_TYPE_V1      0X02
#define SD_TYPE_V2      0X04
#define SD_TYPE_V2HC    0X06	   
// SD卡指令表  	   
#define CMD0    0       //卡复位
#define CMD1    1
#define CMD8    8       //命令8 ，SEND_IF_COND
#define CMD9    9       //命令9 ，读CSD数据
#define CMD10   10      //命令10，读CID数据
#define CMD12   12      //命令12，停止数据传输
#define CMD16   16      //命令16，设置SectorSize 应返回0x00
#define CMD17   17      //命令17，读sector
#define CMD18   18      //命令18，读Multi sector
#define CMD23   23      //命令23，设置多sector写入前预先擦除N个block
#define CMD24   24      //命令24，写sector
#define CMD25   25      //命令25，写Multi sector
#define CMD41   41      //命令41，应返回0x00
#define CMD55   55      //命令55，应返回0x01
#define CMD58   58      //命令58，读OCR信息
#define CMD59   59      //命令59，使能/禁止CRC，应返回0x00
//数据写入回应字意义
#define MSD_DATA_OK                0x05
#define MSD_DATA_CRC_ERROR         0x0B
#define MSD_DATA_WRITE_ERROR       0x0D
#define MSD_DATA_OTHER_ERROR       0xFF
//SD卡回应标记字
#define MSD_RESPONSE_NO_ERROR      0x00
#define MSD_IN_IDLE_STATE          0x01
#define MSD_ERASE_RESET            0x02
#define MSD_ILLEGAL_COMMAND        0x04
#define MSD_COM_CRC_ERROR          0x08
#define MSD_ERASE_SEQUENCE_ERROR   0x10
#define MSD_ADDRESS_ERROR          0x20
#define MSD_PARAMETER_ERROR        0x40
#define MSD_RESPONSE_FAILURE       0xFF

void hal_spi_init(void);
uint8_t SpiFlash_ReadOneByte(void);
void SpiFlash_WriteOneByte(uint8_t Dat);
void spi_set_highspeed(void);
u8 SD_SendCmd(u8 cmd, u32 arg, u8 crc);
u8 SD_Initialize(void);
u8 SD_GetResponse(u8 Response);
u8 SD_RecvData(u8*buf,u16 len);
u8 SD_GetCSD(u8 *csd_data);
u32 SD_GetSectorCount(void);

//省略

.c部分

//省略

#define SPI_INSTANCE  0 /**< SPI instance index. */
#define SDCARD  1
u8  SD_Type=0;//SD卡的类型 

static volatile bool spi_xfer_done;  //SPI数据传输完成标志
static const nrf_drv_spi_t spi = NRF_DRV_SPI_INSTANCE(SPI_INSTANCE);  /**< SPI instance. */

static uint8_t    spi_tx_buf[256];   /**< TX buffer. */
static uint8_t    spi_rx_buf[256];   /**< RX buffer. */

static nrf_drv_spi_config_t spi_config = NRF_DRV_SPI_DEFAULT_CONFIG;
/**
 * @brief SPI user event handler.
 * @param event
 */
void spi_event_handler(nrf_drv_spi_evt_t const * p_event,
                       void *                    p_context)
{
  spi_xfer_done = true;
}

void hal_spi_init(void)
{
    spi_config.ss_pin   = SPI_SS_PIN;
    spi_config.miso_pin = SPI_MISO_PIN;
    spi_config.mosi_pin = SPI_MOSI_PIN;
    spi_config.sck_pin  = SPI_SCK_PIN;
	spi_config.frequency = NRF_DRV_SPI_FREQ_250K;
	#ifdef   SDCARD
	spi_config.mode = NRF_DRV_SPI_MODE_3;
	#endif
    APP_ERROR_CHECK(nrf_drv_spi_init(&spi, &spi_config, spi_event_handler, NULL));
}

void spi_set_highspeed(void)
{
	nrf_drv_spi_uninit(&spi);	//改之前必须uninit
	spi_config.frequency = NRF_DRV_SPI_FREQ_4M;
   	APP_ERROR_CHECK(nrf_drv_spi_init(&spi, &spi_config, spi_event_handler, NULL));
}

/*****************************************************************************
** 描  述：读出一个字节
** 入  参：无
** 返回值：读出的数据
******************************************************************************/
uint8_t SpiFlash_ReadOneByte(void) 
{
    uint8_t len = 1;

	spi_tx_buf[0] = 0xFF;
	spi_xfer_done = false;
	APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, spi_tx_buf, len, spi_rx_buf, len));
	while(!spi_xfer_done);
    return (spi_rx_buf[0]);
}

/*****************************************************************************
** 描  述：写入一个字节
** 入  参：Dat：待写入的数据
** 返回值：无
******************************************************************************/
void SpiFlash_WriteOneByte(uint8_t Dat)
{
    uint8_t len = 1;
	
    spi_tx_buf[0] = Dat;
	spi_xfer_done = false;
	APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, spi_tx_buf, len, spi_rx_buf, len));
    while(!spi_xfer_done);
}

//向SD卡发送一个命令
//输入: u8 cmd   命令 
//      u32 arg  命令参数
//      u8 crc   crc校验值	   
//返回值:SD卡返回的响应															  
u8 SD_SendCmd(u8 cmd, u32 arg, u8 crc)
{
    u8 r1;	
	u8 Retry=0; 
	// SD_DisSelect();//取消上次片选
	// if(SD_Select())return 0XFF;//片选失效 
	//发送
    SpiFlash_WriteOneByte(cmd | 0x40);//分别写入命令
    SpiFlash_WriteOneByte(arg >> 24);
    SpiFlash_WriteOneByte(arg >> 16);
    SpiFlash_WriteOneByte(arg >> 8);
    SpiFlash_WriteOneByte(arg);	  
    SpiFlash_WriteOneByte(crc); 
	if(cmd==CMD12)SpiFlash_WriteOneByte(0xff);//Skip a stuff byte when stop reading
    //等待响应，或超时退出
	Retry=0X1F;
	do
	{
		r1=SpiFlash_ReadOneByte();
	}while((r1&0X80) && Retry--);	 
	//返回状态值
    return r1;
}		

u8 SD_Initialize(void)
{
    u8 r1;      // 存放SD卡的返回值
    u16 retry;  // 用来进行超时计数
    u8 buf[4];  
	u16 i;

	hal_spi_init();

 	for(i=0;i<10;i++)SpiFlash_WriteOneByte(0XFF);//发送最少74个脉冲
	retry=20;
	do
	{
		r1=SD_SendCmd(CMD0,0,0x95);//进入IDLE状态
	}while((r1!=0X01) && retry--);
 	SD_Type=0;//默认无卡
	if(r1==0X01)
	{
		if(SD_SendCmd(CMD8,0x1AA,0x87)==1)//SD V2.0
		{
			for(i=0;i<4;i++)buf[i]=SpiFlash_ReadOneByte();	//Get trailing return value of R7 resp
			if(buf[2]==0X01&&buf[3]==0XAA)//卡是否支持2.7~3.6V
			{
				retry=0XFFFE;
				do
				{
					SD_SendCmd(CMD55,0,0X01);	//发送CMD55
					r1=SD_SendCmd(CMD41,0x40000000,0X01);//发送CMD41
				}while(r1&&retry--);
				if(retry&&SD_SendCmd(CMD58,0,0X01)==0)//鉴别SD2.0卡版本开始
				{
					for(i=0;i<4;i++)buf[i]=SpiFlash_ReadOneByte();//得到OCR值
					if(buf[0]&0x40)SD_Type=SD_TYPE_V2HC;    //检查CCS
					else SD_Type=SD_TYPE_V2;   
				}
			}
		}else//SD V1.x/ MMC	V3
		{
			SD_SendCmd(CMD55,0,0X01);		//发送CMD55
			r1=SD_SendCmd(CMD41,0,0X01);	//发送CMD41
			if(r1<=1)
			{		
				SD_Type=SD_TYPE_V1;
				retry=0XFFFE;
				do //等待退出IDLE模式
				{
					SD_SendCmd(CMD55,0,0X01);	//发送CMD55
					r1=SD_SendCmd(CMD41,0,0X01);//发送CMD41
				}while(r1&&retry--);
			}else
			{
				SD_Type=SD_TYPE_MMC;//MMC V3
				retry=0XFFFE;
				do //等待退出IDLE模式
				{											    
					r1=SD_SendCmd(CMD1,0,0X01);//发送CMD1
				}while(r1&&retry--);  
			}
			if(retry==0||SD_SendCmd(CMD16,512,0X01)!=0)SD_Type=SD_TYPE_ERR;//错误的卡
		}
	}
	// SD_DisSelect();//取消片选
	spi_set_highspeed();//高速
	if(SD_Type)return 0;
	else if(r1)return r1; 	   
	return 0xaa;//其他错误
}

//等待SD卡回应
//Response:要得到的回应值
//返回值:0,成功得到了该回应值
//    其他,得到回应值失败
u8 SD_GetResponse(u8 Response)
{
	u16 Count=0xFFFF;//等待次数	   						  
	while ((SpiFlash_ReadOneByte()!=Response)&&Count)Count--;//等待得到准确的回应  	  
	if (Count==0)return MSD_RESPONSE_FAILURE;//得到回应失败   
	else return MSD_RESPONSE_NO_ERROR;//正确回应
}

//从sd卡读取一个数据包的内容
//buf:数据缓存区
//len:要读取的数据长度.
//返回值:0,成功;其他,失败;	
u8 SD_RecvData(u8*buf,u16 len)
{			  	  
	if(SD_GetResponse(0xFE))return 1;//等待SD卡发回数据起始令牌0xFE
    while(len--)//开始接收数据
    {
        *buf=SpiFlash_ReadOneByte();
        buf++;
    }
    //下面是2个伪CRC（dummy CRC）
    SpiFlash_WriteOneByte(0xFF);
    SpiFlash_WriteOneByte(0xFF);									  					    
    return 0;//读取成功
}

//获取SD卡的CSD信息，包括容量和速度信息
//输入:u8 *cid_data(存放CID的内存，至少16Byte）	    
//返回值:0：NO_ERR
//		 1：错误														   
u8 SD_GetCSD(u8 *csd_data)
{
    u8 r1;	 
    r1=SD_SendCmd(CMD9,0,0x01);//发CMD9命令，读CSD
    if(r1==0)
	{
    	r1=SD_RecvData(csd_data, 16);//接收16个字节的数据 
    }
	// SD_DisSelect();//取消片选
	if(r1)return 1;
	else return 0;
}  

//获取SD卡的总扇区数（扇区数）   
//返回值:0： 取容量出错 
//       其他:SD卡的容量(扇区数/512字节)
//每扇区的字节数必为512，因为如果不是512，则初始化不能通过.														  
u32 SD_GetSectorCount(void)
{
    u8 csd[16];
    u32 Capacity;  
    u8 n;
	u16 csize;  					    
	//取CSD信息，如果期间出错，返回0
    if(SD_GetCSD(csd)!=0) return 0;	    
    //如果为SDHC卡，按照下面方式计算
    if((csd[0]&0xC0)==0x40)	 //V2.00的卡
    {	
		csize = csd[9] + ((u16)csd[8] << 8) + 1;
		Capacity = (u32)csize << 10;//得到扇区数	 		   
    }else//V1.XX的卡
    {	
		n = (csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2;
		csize = (csd[8] >> 6) + ((u16)csd[7] << 2) + ((u16)(csd[6] & 3) << 10) + 1;
		Capacity= (u32)csize << (n - 9);//得到扇区数   
    }
    return Capacity;
}
/********************************************END FILE*******************************************/

最后测试是在主函数调用SD_GetSectorCount函数计算扇区大小：
在这里插入图片描述在这里插入图片描述
换了一个512MB的卡：
在这里插入图片描述

最后的疑问

在这里插入图片描述
最后还是有一个问题的，我开始读取的是 8G的卡，扇区读出来正常，但是变成 MB 就是3290MB 了，看到网上有个视频教学也是使用的这个驱动，读取8G的卡居然和我这个数据一样 3290 MB。4G和512MB的卡读出来计算出来都正常，感觉是数据类型 低级问题导致的，但是一下子还真不知道，还希望有人能够指点……

矜辰所致
关注
  • 5
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
NRF52832：嵌入式系统中的SPI接口使用
weixin_50547796的博客
05-30 122
SPI接口是一种同步的、全双工的串行通信接口，通常由一个主设备和一个或多个从设备组成。在SPI中，数据通过一个主设备和一个或多个从设备之间的多个信号线进行传输。NRF52832是一款功能强大的低功耗无线SoC芯片，内部集成了多个外设模块，包括SPI接口。首先，需要配置芯片的GPIO引脚作为SPI接口的引脚。具体的引脚配置可以参考芯片的数据手册。在使用SPI接口之前，需要对SPI接口进行初始化配置。SPI接口配置完成后，可以开始进行数据传输。寄存器写入发送数据。上使用SPI接口，并提供相应的源代码示例。
NRF52832学习笔记（5）——SPI(主机)接口使用
热门推荐
Leung的博客
12-24 1万+
一、硬件连接 功能口 引脚 MISO 17 MOSI 18 CLK 20 CSN 19 二、移植文件 链接：https://pan.baidu.com/s/1AP3VuZz2v5gN47zDDTqCVA 提取码：d84r 将 board_spi.c 和 board_spi.h 两个文件加入工程的Application文件夹下 2.1 board_spi.c /*...
nrf52832之SPI
qq_27182175的博客
05-18 2427
3种SPI 1.SPI：不含DMA的SPI主机，不推荐使用 2.SPIM：带DMA的SPI主机，单次最大传输255字节 3.SPIS：带DMA的从机 4.以上3者共享寄存器，所以只能使用其中一个，无法共存 5.支持3路SPI 6.为了降低功耗，先停止SPIM，然后禁用SPIM外设 7.看sdk_config就知道是SPI还是SPIM 8.如果初始化提供回调了就是非阻塞模式，为NULL就是阻塞 9.通过APP程序控制CS ...
nrf52840笔记-AAR（Accelerated Address Resolver）加速地址解析器
最新发布
liujie49992的博客
07-08 696
这意味着AAR模块会按照预设的IRK列表进行地址解析尝试，直到找到匹配的IRK并成功解析地址，或者尝试了所有可用的IRK（最多NIRK个）仍未成功解析为止。（加速地址解析）会遍历IRK数据结构中的可用IRK列表，并根据蓝牙核心规范v4.0 [Vol 3]第10.8.2.3章描述的可解析私有地址解析程序，为每个IRK尝试解析地址。解析可解析地址涉及使用特定的密钥和算法来将可解析的随机地址转换回其对应的真实地址或设备标识。（加速地址解析）仅将接收到的地址与模块中编程的地址进行比较，而不检查地址的类型。
nrf52832的spi通信
yangyang_1024的博客
04-18 5163
spi使用4根线，sck，mosi，miso，cs四根线直接相连，不需要讲mosi和miso交叉MOSI：Master Input Slave OutputMISO：Master Output Slave Input 
使用nrf52832的SPI驱动LIS3DH,参考android,java版的算法，移植过来，计步准确。
02-27
计步算法参考githhub上找的android手机Java版的算法，移植过来，准确率还不错。
spi - sd.zip_52832文件系统_nfr52832 sd卡_nrf52832 sdk14_nrf52832 sd卡_
07-15
使用nrf52832，通过文件系统操作sd卡， sdk14.0，将此文件直接放到examples\ble_peripheral文件夹下即可
nrf52832 SPi方式无操作系统与SD卡通信
shouwang1994的博客
12-11 4266
在使用nrf52832开发不带操作系统SPI通信方式操作SD卡时，遇到了许多问题，现慢慢将这些问题整理出来，方便日后开发不会遇到同样的错误。 首先是SPi的初始化， void SPI_SD_Init(void) { ret_code_t error; nrf_gpio_cfg_output(SPIM0_SS_PIN); SPI_CS_HIGH(); nrf_drv_spi_config
nrf51822蓝牙SPI对microSD卡读写
一颗偏执的心
11-08 4988
基于nrf51822 SDK10的蓝牙串口工程 ,增加SPI的资源文件到工程，定义SPI0使能，以及定义IO口，和CS引脚电平，新建drv_sd_api.c文件如下即可在主函数调用接口函数对SD卡进行操作，此接口函数是官方提供的一个我只是修改一下，使用前对SD卡的指令以及一些注意事项说明如下： SD卡的命令格式如下，6字节共48位，传输时最高位(MSB)先传输：     SD卡的c
nRF52832驱动SPI电子墨水屏例程.zip
08-07
nRF52832-QFAA通过SPI接口驱动大连佳显的GDEH0154D27型1.54英寸电子墨水屏的代码。硬件连接关系可通过xz_dk1002.h得知。
nrf52832读写外部nandflash
10-18
nrf52832基于sdk提供的spi库读写外部nandflash，代码支持（MX25R4035h & FM25Q04）
【雕爷学编程】MicroPython手册之 ESP32 硬件SPI总线
雕爷学编程
09-26 927
在上述示例中，我们使用machine.SPI()初始化ESP32的硬件SPI总线对象，参数1指定使用HSPI总线。最后，我们打印接收到的数据。4、外设：12 位 SAR ADC 最多支持 18 个通道，2 个 8 位 DAC，10 个触摸传感器，4 个 SPI，2 个 I2S，2 个 I2C，3 个 UART，SD/SDIO/MMC 主机控制器，SDIO/SPI 从设备控制器，以太网 MAC 接口，CAN 总线 2.0，红外远程控制器，电机 PWM，LED PWM 最多支持 16 通道。
【雕爷学编程】MicroPython手册之 SAMD21 硬件SPI总线
雕爷学编程
09-30 193
需要注意的是，要使用这个代码，你需要将从设备的命令和亮度值编码为字节数组，并将其发送到从设备的相应寄存器。需要注意的是，要使用这个代码，你需要将从设备的寄存器地址和命令编码为字节数组，并将其发送到从设备的相应寄存器。在使用SAMD21硬件SPI总线时，需要注意正确配置引脚、合理设置时钟和相位，并在需要使用DMA时进行适当的配置和管理，以确保SPI通信的稳定性和可靠性。需要注意的是，要使用这个代码，你需要将主设备的MOSI、MISO和SCK引脚连接到从设备的相应引脚，并将这些引脚配置为硬件SPI模式。
NRF52832学习笔记（37）——SPI(从机)接口使用
Leung的博客
05-18 3984
一、SPI简介 SPI（Serial Peripheral Interface） 协议是由摩托罗拉公司提出的通讯协议，即串行外围设备接口，是一种高速全双工的通信总线。它被广泛地使用在 ADC、LCD 等设备与 MCU 间，要求通讯速率较高的场合。 芯片的管脚上只占用四根线。 MISO： 主器件数据输出，从器件数据输入。 MOSI：主器件数据输入，从器件数据输出。 SCK： 时钟信号，由主设备控制发出。 NSS（CS）： 从设备选择信号，由主设备控制。当NSS为低电平则选中从器件。 二、API说明 以下
NRF52832学习笔记: 嵌入式系统中的SPI接口应用
weixin_50547796的博客
04-09 87
当然，具体的代码实现可能会根据不同的硬件和应用需求而有所不同，但基本的原理和步骤是相似的。函数，用于发送和接收数据。首先，我们清除SPI事件标志位，设置发送缓冲区的第一个字节，并使能SPI接口。）接收从设备（外部设备）发送的数据，MOSI代表主设备发送数据给从设备，CS代表片选信号，用于选择从设备。最后，我们等待SPI传输结束，清除SPI事件标志位，并禁用SPI接口。最后，我们可以根据具体的应用需求处理接收到的数据，并在主程序逻辑中执行其他操作。在这个示例中，我们使用NRF SPI库提供的函数进行初始化。
nRF52832学习记录（十二、SPI接口的应用 Micro SD卡读写测试）_nrf52832 spi(2)
2401_84558983的博客
05-16 940
其中nrf_drv_spi_bit_order_t bit_order;///< SPI bit order.//SPI数据传输完成标志。nrfx_spi_t 结构体中的 NRF_SPI_Type 就是对应的 SPI 的每个寄存器。#define CMD59 59 //命令59，使能/禁止CRC，应返回0x00。#define CMD8 8 //命令8 ，SEND_IF_COND。
nrf52832学习笔记
09-01
nRF52832是一款由Nordic Semiconductor开发的低功耗蓝牙（Bluetooth Low Energy）SoC（系统级芯片）。它被广泛应用于物联网设备、传感器网络和可穿戴设备等领域。 学习nRF52832可以从以下几个方面入手： 1. 学习nRF52832的硬件架构和功能特性：了解nRF52832的主要硬件组成部分，如ARM Cortex-M4处理器、内存、GPIO和外设等。还要了解其支持的蓝牙协议栈和其他通信协议。 2. 学习开发环境和工具链：nRF52832常用的开发环境是Nordic官方提供的nRF5 SDK，辅助编译工具链为GCC或Keil。了解如何配置和使用这些工具，以便进行代码开发、编译和调试。 3. 学习编程语言和API：nRF52832的开发可以使用C或C++编程语言。掌握相关的编程语言知识，并熟悉nRF52832提供的API和库函数，以便进行应用程序的开发。 4. 学习蓝牙开发：由于nRF52832主要用于蓝牙设备开发，因此需要学习蓝牙协议栈和相关的开发知识。了解蓝牙的基本原理、协议和特性，掌握如何进行蓝牙设备的连接和通信。 5. 实践项目和示例代码：通过做一些实际的项目和使用示例代码，加深对nRF52832的理解和应用能力。可以尝试编写简单的应用程序、传感器接口和通信功能等。 这些是学习nRF52832的一些基本方向，希望能对你有所帮助。如果你有具体的问题或需要更深入的指导，请随时提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

矜辰所致

您们的鼓励是我奋斗的动力！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值