SPI协议—读写串行FLASH（详细讲解+代码）

已于 2023-10-27 14:00:40 修改
阅读量7.3k 收藏 85
点赞数 44
文章标签： stm32 单片机 嵌入式硬件 arm
于 2023-06-07 16:48:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61384226/article/details/131087068
版权

目录

前言

SPI总线协议

什么是SPI

SPI的特点

物理层

协议层

SPI通讯过程

总结

前言

         本章所运用的知识点都是博主从各个网站搜集来的（侵删@小麦大叔@野火），也附带一点自己的看法。本章所用到的开发板是野火的霸道F103系列开发板，需要完整可运行代码的同学也可以找@我拿。

        总所周知，学习单片机离不开协议，上章我们讲述了I2C的作用、时序、以及基本代码。相信大家或多或少也了解完了，那么现在跟着我一起来学习同样重要且应用广泛的协议——SPI。

SPI总线协议

什么是SPI

        SPI，是英语 Serial Peripheral Interface 的缩写，顾名思义就是串行外围设备接口。SPI，是一种高速的，全双工，同步的通信总线，

        并且在芯片的管脚上只占用四根线（根据实际情况，也有公司用到无根线），节约了芯片的
管脚，同时为 PCB 的布局上节省空间，提供方便，正是出于这种简单易用的特性，现 在越来越多的芯片集成了这种通信协议。

SPI的特点

物理层

 如上图所示：

SPI协议传输是主机MCU与从机（1、2、3......）进行数据传输，一个主机可以与多个从机通信（但不能同时通信，会出现数据报错），通信要求则是SS线的电平拉低。下面我们来介绍一下主机上的四根线

SS: 从设备选择信号线，常称为 片选信号线 ，也称为NSS 、 CS 。
SCK (Serial Clock)： 时钟信号线 ，用于通讯数据同步。
MOSI (Master Output， Slave Input) ： 主设备输出/从设备输入引脚 。
MISO(Master Input,，Slave Output) ： 主设备输入/从设备输出引脚 。
SS:
        每个从设备都有独立的这一条SS信号线， 本信号线独占主机的一个引脚，即有多少
个从设备，就有多少条片选信号线。 I2C 协议中通过设备地址来寻址、选中总线上
的某个设备并与其进行通讯；而 SPI 协议 中没有设备地址，它使用SS 信号线来寻址，
当主机要选择从设备时，把该从设备的 SS 信号线设置为低电平，该从设备即被选中，
即片选有效，接着主机开始与被选中的从 设备进行SPI 通讯。所以 SPI 通讯以 SS 线
置低电平为开始信号，以 SS 线被拉高作为 结束信号。
SCK (Serial Clock)：
        它由通讯主机产生，决定了通讯的速率，不同的设备支持的最高时钟频率不一样，如STM32的SPI时钟频率最大为fpclk/2，两个设备之间通讯时，通讯速率受限于低速设备。
MOSI (Master Output， Slave Input) ：
        主机的数据从这条信号线输出，从机由这条信号线读入主机发送的数据，即这条线上数据的方向为主机到从机。
MISO(Master Input,，Slave Output) ：
        主机从这条信号线读入数据，从机的数 据由这条信号线输出到主机，即在这条线上数据的方向为从机到主机。  

协议层

SPI协议定义了通讯的起始和停止信号、数据有效性、时钟同 步等环节。
1.SPI 基本通讯过程

2. 通讯的起始和停止信号

  • 标号① 处， NSS 信号线由高变低，是 SPI 通讯的起始信号。 NSS 是每个从机各 自独占的信号线，当从机检在自己的NSS 线检测到起始信号后，就知道自己 被主机选中了，开始准备与主机通讯。
  • 在图中的标号 ⑥ 处， NSS 信号由低变高，是 SPI 通讯的停止信号，表示本次通 讯结束，从机的选中状态被取消 。
3. 数据有效性
  • SPI 使用 MOSI 及 MISO 信号线来传输数据，使用 SCK 信号线进行数据同步。 MOSI及 MISO 数据线在 SCK 的每个时钟周期传输一位数据，且数据输入输出 是同时进行的。

 4.CPOL/CPHA及通讯模式

  • 时钟极性CPOL： 是指 SPI 通讯设备处于空闲状态时， SCK 信号线的电平信号 (即 SPI 通讯开始前、 NSS 线为高电平时 SCK 的状态 ) 。 CPOL=0 时， SCK 在空闲状态时为低电平，CPOL=1 时，则相反。
  • 时钟相位CPHA： 是指数据的采样的时刻，当 CPHA=0 时， MOSI 或 MISO 数 据线上的信号将会在SCK 时钟线的“奇数边沿”被采样。当 CPHA=1 时， 数据线在SCK 的“偶数边沿”采样。

 5.CPOL/CPHA及通讯模式

  • CK 信号线在空闲状态为低电平时， CPOL=0 ；空闲状态为高电平时， CPOL=1 。
  • CPHA=0 ， MOSI 和 MISO 数据线的有效信号在 SCK 的奇数边沿保持不变，数据信 号将在SCK 奇数边沿时被采样，在非采样时刻， MOSI 和 MISO 的有效信号才发生 切换。 

6.CPOL/CPHA及通讯模式  

由 CPOL 及 CPHA 的不同状态， SPI 分成了四种模式，主机与从机需要工作 在相同的模式下才可以正常通讯，实际中采用较多的是“模式0 ”与“模式 3 ”。

SPI通讯过程

  • 控制NSS信号线，产生起始信号(图中没有画出)；
  • 把要发送的数据写入到“数据寄存器DR”中，该数据会被存储到发 送缓冲区；
  • 通讯开始，SCK时钟开始运行。MOSI把发送缓冲区中的数据一位 一位地传输出去；MISO则把数据一位一位地存储进接收缓冲区中；
  • 当发送完一帧数据的时候，“状态寄存器SR”中的“TXE标志位” 会被置1，表示传输完一帧，发送缓冲区已空；类似地，当接收完 一帧数据的时候，“RXNE标志位”会被置1，表示传输完一帧，接 收缓冲区非空；
  • 等待到“TXE标志位”为1时，若还要继续发送数据，则再次往 “数据寄存器DR”写入数据即可；等待到“RXNE标志位”为1时， 通过读取“数据寄存器DR”可以获取接收缓冲区中的内容。
        假如使能了TXE 或RXNE中断，TXE或RXNE置1时会产生SPI中断信号， 进入同一个中断服务函数，到SPI中断服务程序后，可通过检查寄存器 位来了解是哪一个事件，再分别进行处理。也可以使用DMA方式来收 发“数据寄存器DR”中的数据。

SPI通讯的优势
使SPI作为串行通信接口脱颖而出的原因很多；

  • 全双工串行通信；
  • 高速数据传输速率。
  • 简单的软件配置；
  • 极其灵活的数据传输，不限于8位，它可以是任意大小的字；
  • 非常简单的硬件结构。从站不需要唯一地址（与I2C不同）。从机使用主机时钟，不需要精密时钟振荡器/晶振（与UART不同）。不需要收发器（与CAN不同）。

SPI的缺点

  • 没有硬件从机应答信号（主机可能在不知情的情况下无处发送）；
  • 通常仅支持一个主设备；
  • 需要更多的引脚（与I2C不同）；
  • 没有定义硬件级别的错误检查协议；
  • 与RS-232和CAN总线相比，只能支持非常短的距离；

 部分关键代码：

初始化SPI

/**
  * @brief  SPI_FLASH初始化
  * @param  无
  * @retval 无
  */
void SPI_FLASH_Init(void)
{
  SPI_InitTypeDef  SPI_InitStructure;
  GPIO_InitTypeDef GPIO_InitStructure;
	
	/* 使能SPI时钟 */
	FLASH_SPI_APBxClock_FUN ( FLASH_SPI_CLK, ENABLE );
	
	/* 使能SPI引脚相关的时钟 */
 	FLASH_SPI_CS_APBxClock_FUN ( FLASH_SPI_CS_CLK|FLASH_SPI_SCK_CLK|
																	FLASH_SPI_MISO_PIN|FLASH_SPI_MOSI_PIN, ENABLE );
	
  /* 配置SPI的 CS引脚，普通IO即可 */
  GPIO_InitStructure.GPIO_Pin = FLASH_SPI_CS_PIN;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_Init(FLASH_SPI_CS_PORT, &GPIO_InitStructure);
	
  /* 配置SPI的 SCK引脚*/
  GPIO_InitStructure.GPIO_Pin = FLASH_SPI_SCK_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(FLASH_SPI_SCK_PORT, &GPIO_InitStructure);

  /* 配置SPI的 MISO引脚*/
  GPIO_InitStructure.GPIO_Pin = FLASH_SPI_MISO_PIN;
  GPIO_Init(FLASH_SPI_MISO_PORT, &GPIO_InitStructure);

  /* 配置SPI的 MOSI引脚*/
  GPIO_InitStructure.GPIO_Pin = FLASH_SPI_MOSI_PIN;
  GPIO_Init(FLASH_SPI_MOSI_PORT, &GPIO_InitStructure);

  /* 停止信号 FLASH: CS引脚高电平*/
  SPI_FLASH_CS_HIGH();

  /* SPI 模式配置 */
  // FLASH芯片 支持SPI模式0及模式3，据此设置CPOL CPHA
  SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
  SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
  SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
  SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
  SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
  SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
  SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
  SPI_InitStructure.SPI_CRCPolynomial = 7;
  SPI_Init(FLASH_SPIx , &SPI_InitStructure);

  /* 使能 SPI  */
  SPI_Cmd(FLASH_SPIx , ENABLE);
	
}

Flash扇区擦除

/**
  * @brief  擦除FLASH扇区
  * @param  SectorAddr：要擦除的扇区地址
  * @retval 无
  */
void SPI_FLASH_SectorErase(u32 SectorAddr)
{
  /* 发送FLASH写使能命令 */
  SPI_FLASH_WriteEnable();
  SPI_FLASH_WaitForWriteEnd();
  /* 擦除扇区 */
  /* 选择FLASH: CS低电平 */
  SPI_FLASH_CS_LOW();
  /* 发送扇区擦除指令*/
  SPI_FLASH_SendByte(W25X_SectorErase);
  /*发送擦除扇区地址的高位*/
  SPI_FLASH_SendByte((SectorAddr & 0xFF0000) >> 16);
  /* 发送擦除扇区地址的中位 */
  SPI_FLASH_SendByte((SectorAddr & 0xFF00) >> 8);
  /* 发送擦除扇区地址的低位 */
  SPI_FLASH_SendByte(SectorAddr & 0xFF);
  /* 停止信号 FLASH: CS 高电平 */
  SPI_FLASH_CS_HIGH();
  /* 等待擦除完毕*/
  SPI_FLASH_WaitForWriteEnd();
}

 /**
  * @brief  擦除FLASH扇区，整片擦除
  * @param  无
  * @retval 无
  */
void SPI_FLASH_BulkErase(void)
{
  /* 发送FLASH写使能命令 */
  SPI_FLASH_WriteEnable();

  /* 整块 Erase */
  /* 选择FLASH: CS低电平 */
  SPI_FLASH_CS_LOW();
  /* 发送整块擦除指令*/
  SPI_FLASH_SendByte(W25X_ChipErase);
  /* 停止信号 FLASH: CS 高电平 */
  SPI_FLASH_CS_HIGH();

  /* 等待擦除完毕*/
  SPI_FLASH_WaitForWriteEnd();
}

对Flash进行写入（包括页写入）

/**
  * @brief  对FLASH按页写入数据，调用本函数写入数据前需要先擦除扇区
  * @param	pBuffer，要写入数据的指针
  * @param WriteAddr，写入地址
  * @param  NumByteToWrite，写入数据长度，必须小于等于SPI_FLASH_PerWritePageSize
  * @retval 无
  */
void SPI_FLASH_PageWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)
{
  /* 发送FLASH写使能命令 */
  SPI_FLASH_WriteEnable();

  /* 选择FLASH: CS低电平 */
  SPI_FLASH_CS_LOW();
  /* 写页写指令*/
  SPI_FLASH_SendByte(W25X_PageProgram);
  /*发送写地址的高位*/
  SPI_FLASH_SendByte((WriteAddr & 0xFF0000) >> 16);
  /*发送写地址的中位*/
  SPI_FLASH_SendByte((WriteAddr & 0xFF00) >> 8);
  /*发送写地址的低位*/
  SPI_FLASH_SendByte(WriteAddr & 0xFF);

  if(NumByteToWrite > SPI_FLASH_PerWritePageSize)
  {
     NumByteToWrite = SPI_FLASH_PerWritePageSize;
     FLASH_ERROR("SPI_FLASH_PageWrite too large!"); 
  }

  /* 写入数据*/
  while (NumByteToWrite--)
  {
    /* 发送当前要写入的字节数据 */
    SPI_FLASH_SendByte(*pBuffer);
    /* 指向下一字节数据 */
    pBuffer++;
  }

  /* 停止信号 FLASH: CS 高电平 */
  SPI_FLASH_CS_HIGH();

  /* 等待写入完毕*/
  SPI_FLASH_WaitForWriteEnd();
}

 /**
  * @brief  对FLASH写入数据，调用本函数写入数据前需要先擦除扇区
  * @param	pBuffer，要写入数据的指针
  * @param  WriteAddr，写入地址
  * @param  NumByteToWrite，写入数据长度
  * @retval 无
  */
void SPI_FLASH_BufferWrite(u8* pBuffer, u32 WriteAddr, u16 NumByteToWrite)
{
  u8 NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
	
	/*mod运算求余，若writeAddr是SPI_FLASH_PageSize整数倍，运算结果Addr值为0*/
  Addr = WriteAddr % SPI_FLASH_PageSize;
	
	/*差count个数据值，刚好可以对齐到页地址*/
  count = SPI_FLASH_PageSize - Addr;
	/*计算出要写多少整数页*/
  NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
	/*mod运算求余，计算出剩余不满一页的字节数*/
  NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
	
	/* Addr=0,则WriteAddr 刚好按页对齐 aligned  */
  if (Addr == 0)
  {
		/* NumByteToWrite < SPI_FLASH_PageSize */
    if (NumOfPage == 0) 
    {
      SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
    }
    else /* NumByteToWrite > SPI_FLASH_PageSize */
    { 
			/*先把整数页都写了*/
      while (NumOfPage--)
      {
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
        WriteAddr +=  SPI_FLASH_PageSize;
        pBuffer += SPI_FLASH_PageSize;
      }
			/*若有多余的不满一页的数据，把它写完*/
      SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
    }
  }
	/* 若地址与 SPI_FLASH_PageSize 不对齐  */
  else 
  {
		/* NumByteToWrite < SPI_FLASH_PageSize */
    if (NumOfPage == 0)
    {
			/*当前页剩余的count个位置比NumOfSingle小，一页写不完*/
      if (NumOfSingle > count) 
      {
        temp = NumOfSingle - count;
				/*先写满当前页*/
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
				
        WriteAddr +=  count;
        pBuffer += count;
				/*再写剩余的数据*/
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, temp);
      }
      else /*当前页剩余的count个位置能写完NumOfSingle个数据*/
      {
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
      }
    }
    else /* NumByteToWrite > SPI_FLASH_PageSize */
    {
			/*地址不对齐多出的count分开处理，不加入这个运算*/
      NumByteToWrite -= count;
      NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
      NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
			
			/* 先写完count个数据，为的是让下一次要写的地址对齐 */
      SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
			
			/* 接下来就重复地址对齐的情况 */
      WriteAddr +=  count;
      pBuffer += count;
			/*把整数页都写了*/
      while (NumOfPage--)
      {
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
        WriteAddr +=  SPI_FLASH_PageSize;
        pBuffer += SPI_FLASH_PageSize;
      }
			/*若有多余的不满一页的数据，把它写完*/
      if (NumOfSingle != 0)
      {
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
      }
    }
  }
}

读Flash

 /**
  * @brief  读取FLASH数据
  * @param 	pBuffer，存储读出数据的指针
  * @param   ReadAddr，读取地址
  * @param   NumByteToRead，读取数据长度
  * @retval 无
  */
void SPI_FLASH_BufferRead(u8* pBuffer, u32 ReadAddr, u16 NumByteToRead)
{
  /* 选择FLASH: CS低电平 */
  SPI_FLASH_CS_LOW();

  /* 发送 读 指令 */
  SPI_FLASH_SendByte(W25X_ReadData);

  /* 发送 读 地址高位 */
  SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
  /* 发送 读 地址中位 */
  SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
  /* 发送 读 地址低位 */
  SPI_FLASH_SendByte(ReadAddr & 0xFF);
	
	/* 读取数据 */
  while (NumByteToRead--) /* while there is data to be read */
  {
    /* 读取一个字节*/
    *pBuffer = SPI_FLASH_SendByte(Dummy_Byte);
    /* 指向下一个字节缓冲区 */
    pBuffer++;
  }

  /* 停止信号 FLASH: CS 高电平 */
  SPI_FLASH_CS_HIGH();
}

读取Flash ID以及FLASH Device ID

 /**
  * @brief  读取FLASH ID
  * @param 	无
  * @retval FLASH ID
  */
u32 SPI_FLASH_ReadID(void)
{
  u32 Temp = 0, Temp0 = 0, Temp1 = 0, Temp2 = 0;

  /* 开始通讯：CS低电平 */
  SPI_FLASH_CS_LOW();

  /* 发送JEDEC指令，读取ID */
  SPI_FLASH_SendByte(W25X_JedecDeviceID);

  /* 读取一个字节数据 */
  Temp0 = SPI_FLASH_SendByte(Dummy_Byte);

  /* 读取一个字节数据 */
  Temp1 = SPI_FLASH_SendByte(Dummy_Byte);

  /* 读取一个字节数据 */
  Temp2 = SPI_FLASH_SendByte(Dummy_Byte);

 /* 停止通讯：CS高电平 */
  SPI_FLASH_CS_HIGH();

  /*把数据组合起来，作为函数的返回值*/
	Temp = (Temp0 << 16) | (Temp1 << 8) | Temp2;

  return Temp;
}
 /**
  * @brief  读取FLASH Device ID
  * @param 	无
  * @retval FLASH Device ID
  */
u32 SPI_FLASH_ReadDeviceID(void)
{
  u32 Temp = 0;

  /* Select the FLASH: Chip Select low */
  SPI_FLASH_CS_LOW();

  /* Send "RDID " instruction */
  SPI_FLASH_SendByte(W25X_DeviceID);
  SPI_FLASH_SendByte(Dummy_Byte);
  SPI_FLASH_SendByte(Dummy_Byte);
  SPI_FLASH_SendByte(Dummy_Byte);
  
  /* Read a byte from the FLASH */
  Temp = SPI_FLASH_SendByte(Dummy_Byte);

  /* Deselect the FLASH: Chip Select high */
  SPI_FLASH_CS_HIGH();

  return Temp;
}

主函数MAIN

typedef enum { FAILED = 0, PASSED = !FAILED} TestStatus;

/* 获取缓冲区的长度 */
#define TxBufferSize1   (countof(TxBuffer1) - 1)
#define RxBufferSize1   (countof(TxBuffer1) - 1)
#define countof(a)      (sizeof(a) / sizeof(*(a)))
#define  BufferSize (countof(Tx_Buffer)-1)

#define  FLASH_WriteAddress     0x00000
#define  FLASH_ReadAddress      FLASH_WriteAddress
#define  FLASH_SectorToErase    FLASH_WriteAddress

     

/* 发送缓冲区初始化 */
uint8_t Tx_Buffer[] = "感谢\r\n";
uint8_t Rx_Buffer[BufferSize];

__IO uint32_t DeviceID = 0;
__IO uint32_t FlashID = 0;
__IO TestStatus TransferStatus1 = FAILED;

// 函数原型声明
void Delay(__IO uint32_t nCount);
TestStatus Buffercmp(uint8_t* pBuffer1,uint8_t* pBuffer2, uint16_t BufferLength);

/*
 * 函数名：main
 * 描述  ：主函数
 * 输入  ：无
 * 输出  ：无
 */
int main(void)
{ 	
	LED_GPIO_Config();
	LED_BLUE;
	
	/* 配置串口为：115200 8-N-1 */
	USART_Config();
	printf("\r\n 这是一个8Mbyte串行flash(W25Q64)实验 \r\n");
	
	/* 8M串行flash W25Q64初始化 */
	SPI_FLASH_Init();
	
	/* 获取 Flash Device ID */
	DeviceID = SPI_FLASH_ReadDeviceID();	
	Delay( 200 );
	
	/* 获取 SPI Flash ID */
	FlashID = SPI_FLASH_ReadID();	
	printf("\r\n FlashID is 0x%X,\
	Manufacturer Device ID is 0x%X\r\n", FlashID, DeviceID);
	
	/* 检验 SPI Flash ID */
	if (FlashID == sFLASH_ID)
	{	
		printf("\r\n 检测到串行flash W25Q64 !\r\n");
		
		/* 擦除将要写入的 SPI FLASH 扇区，FLASH写入前要先擦除 */
		// 这里擦除4K，即一个扇区，擦除的最小单位是扇区
		SPI_FLASH_SectorErase(FLASH_SectorToErase);	 	 
		
		/* 将发送缓冲区的数据写到flash中 */
		// 这里写一页，一页的大小为256个字节
		SPI_FLASH_BufferWrite(Tx_Buffer, FLASH_WriteAddress, BufferSize);		
		printf("\r\n 写入的数据为：%s \r\t", Tx_Buffer);
		
		/* 将刚刚写入的数据读出来放到接收缓冲区中 */
		SPI_FLASH_BufferRead(Rx_Buffer, FLASH_ReadAddress, BufferSize);
		printf("\r\n 读出的数据为：%s \r\n", Rx_Buffer);
		
		/* 检查写入的数据与读出的数据是否相等 */
		TransferStatus1 = Buffercmp(Tx_Buffer, Rx_Buffer, BufferSize);
		
		if( PASSED == TransferStatus1 )
		{ 
			LED_GREEN;
			printf("\r\n 8M串行flash(W25Q64)测试成功!\n\r");
		}
		else
		{        
			LED_RED;
			printf("\r\n 8M串行flash(W25Q64)测试失败!\n\r");
		}
	}// if (FlashID == sFLASH_ID)
	else// if (FlashID == sFLASH_ID)
	{ 
		LED_RED;
		printf("\r\n 获取不到 W25Q64 ID!\n\r");
	}
	
	while(1);  
}

/*
 * 函数名：Buffercmp
 * 描述  ：比较两个缓冲区中的数据是否相等
 * 输入  ：-pBuffer1     src缓冲区指针
 *         -pBuffer2     dst缓冲区指针
 *         -BufferLength 缓冲区长度
 * 输出  ：无
 * 返回  ：-PASSED pBuffer1 等于   pBuffer2
 *         -FAILED pBuffer1 不同于 pBuffer2
 */
TestStatus Buffercmp(uint8_t* pBuffer1, uint8_t* pBuffer2, uint16_t BufferLength)
{
  while(BufferLength--)
  {
    if(*pBuffer1 != *pBuffer2)
    {
      return FAILED;
    }

    pBuffer1++;
    pBuffer2++;
  }
  return PASSED;
}

void Delay(__IO uint32_t nCount)
{
  for(; nCount != 0; nCount--);
}

总结

以上就是SPI的全部内容，本文简单介绍了SPI的使用，希望对大家有帮助！

LED失控玩家
关注
SPI读写外部FLASH
chengcao123的博客
12-16 1949
前言 1、SPI高速全双工同步的通信总线 2、主机发送一个字节数据到从机，同时从机也会发送一个字节数据到主机（写操作和读操作是同步完成的，如果只想进行写操作，只需忽略接收到的字节即可。如果要读一个字节，就需要发送一个空字节来引发从机的传输） 3、W25Q128将16M的容量分为256个块（block），每个块大小为64K字节，每个块又分为16个扇区（sector），每个扇区4K字节。W25Q128的最小擦除单位为一个扇区，也就是每次必须擦除4k字节。这样我们需要给W25Q128开辟一个至少4K的缓存区，这样
实现简单的SPI读写FLASH
zyxnb的博客
07-02 8998
实现简单的SPI读写FLASH 一、前言 继上篇文章SPI的相关知识，本章主要介绍使用SPI协议实现简单的读写FLASH,写入功能主要介绍的是定量数据的页写入，在文章末尾有不定量数据写入的代码例子。使用的开发板是STM32f10x系列，Flash芯片是W25Q64。 二、简介 Flash是属于非易失性存储器，又称为闪存，和EEPROM一样都是掉电后数据不会丢失的存储器。不过，Flash和EEPROM的区别在于，①Flash的存储容量大于EEPROM，②Flash在写入之前的擦除操作时，需要以扇区为最小单位擦
SPI协议的Flash
weixin_45589030的博客
03-24 4527
简介 不是所有的flash都是spi协议，本节学习用SPI协议传输数据的flash SPI是摩托罗拉公司提出的通讯协议，和IIC一样，也是板级的协议，但是速度要比IIC快得多。 SPI是全双工通信 SPI物理层特性 SPI有三条公共总线：SCK、MOSI、MISO、和一条信号选择线 SS。 SPI协议使用SS信号线来寻址，当主机选择从设备时，就把对应的SS信号线置位0，SS被拉高标志着结束信号。 SCK时钟信号线，有主机产生，时钟频率是总线的一半，18M或者36M MOSI根据英文缩写可知，主输出从输入
三大低速总线之SPI
最新发布
Qqyangleiyu的博客
08-25 876
SPI（串行外设接口）以其高速度而著称，使其成为快速通信的首选。与 I2C 不同，SPI 使用四线工作：MISO（主输入从输出）、MOSI（主输出从输入）、SCK（串行时钟）和 SS（从选择），允许全双工通信（发送和同时接收）。尽管简单且速度快，但 SPI 比 I2C 需要更多的引脚，这可能是电路设计中需要考虑的一个因素。高速：SPI通信速度较快，适用于对速度要求较高的应用。**全双工：**SPI支持全双工通信，可以同时进行数据发送和接收。
SPI驱动代码
qq_36450449的博客
07-28 806
这里以模式0举例（CPOL=0,CPHA=0）,当处于空闲状态时，spi_clk为低，采集数据的边沿在时钟的第一个边沿，也就是上升沿；spi_clk在运行状态下为输入时钟的二分频，为了表明上升沿或者下降沿，做了一个spi_cnt，当spi_cnt == 1 时，表明为spi_clk的下降沿；以下是发送数据接受数据的代码段；SPI通常有四根线，分别是CS（片选），spi_clk（spi时钟），mosi（主输出从输入）以及miso（主输入从输出），这里的M代表FPGA，S代表外围SPI设备例如Flash。
STM32第十八课：SPI&Flash
小白橘颂的博客
07-11 1708
一般能够支持SPI模式0的设备也支持SPI模式3，支持模式1的设备也支持模式2。一般的传输数据时候采用的就是8位进行，高位先传还是低位先传，传输的速度。3.循环往FLash发送数据（无所谓什么数据，只是为了置换出FLash状态寄存器的值），判断寄存器的第0位BUSY是否为0，为0时就代表Flash为空闲状态，可以执行其他操作。：判断接收缓冲器非空(RXNE)是否为0，为0表示接受缓冲区为空，没数据，此时持续等待数据到来。CPHA：时钟相位， CPHA=0时，在时钟的第一个边沿进行采样，第二个边沿进行输出。
SPI控制Flash读写
weixin_56481118的博客
03-27 4125
1.SPI(Serial Peripheral Interface)是一种高速、全双工、同步串行通信总线，由摩托摩拉公司推出。2.优缺点：全双工通信，通信方式简单，相对数据传输速度较快；SPI没有应答机制确认数据是否接收，数据可靠性上有一定缺陷。（相对IIC协议）。16Mbit，一共32个扇区，每个扇区256页，每页256字节，Flash断电后数据不会擦除1.2 SPI模式支持：M25P16支持SPI模式0和模式31.3 引脚。
STM32 SPI读写FLASH
乱学一气
09-09 4034
SPI协议   Serial Peripheral Interface，串行外围设备接口。SPI 是串行同步全双工通信协议。一般用于控制器和控制器之间的数据传输。 物理层   每个从机都有四条线和主机相连，不同从机的 MISO MOSI SCK 连接的是主机统一个端口，SS 线，连接不同端口 SS ：（Slave Select）从机选择。当主机想和某个从机通讯时，就把从机的 SS 条线的电平拉低。 SCK ：（Serial Clock）时钟信号线。由主机产生，f103的SPI挂载在不同的总线上，最大频
SPI-读写FLASH
Lagligelang的博客
07-02 7794
SPI-读写FLASH SPI协议层 ​ SPI协议是由摩托罗拉公司提出的通讯协议(Serial Peripheral Interface)，即串行外围设备接口，是一种高速全双工的通讯总线。它广泛地使用在ADC、LCD等设备与MCU间，要求通讯速率较高的场合。 SPI物理层 ​ SPI通讯设备之间的常用连接方式如下图所示： ​ SPI通讯使用3条总线及片选线，3条总线分别为：SCL、MOSI、MISO，片选线为：SS#，他们的作用介绍如下： 1、SS#(Slave Select)：从设备选择信号线，常称
SPI协议读取FLASH【FPGA】
xyf_fate的博客
09-14 4446
spi_flash
STM32学习之SPI协议（读写FLASH）
图个吉利儿的博客
03-04 1686
关于STM32学习分享 第八章 SPI协议（读写FLASH） 文章目录关于STM32学习分享前言二、代码1.spi_flash.c2.spi_flash.h3.main.c总结 前言 开始！开始！单片机的SPI协议（读写FLASH）。 # 一、SPI协议（读写FLASH） 1、SCLK 2、MOSI 3、MISO 4、CS 二、代码 1.spi_flash.c 代码如下（示例）： #include "./flash/spi_flash.h" static __IO uint32_t SPIT
( SPI读取Flash.zip
06-06
( SPI读取Flash.zip
spi flash读写程序
11-29
spi的flash读写程序，各种操作方式的实现
SPI FLASH 协议
12-30
SPI FLASH 协议（FPGA新手的学习笔记：dengkanwen.com）
自已写的FPGA使用SPI模式读写FLASH
10-10
自已写的FPGA使用SPI模式读写FLASH ，Flash型号W25Q128BV。
SPI_Flash读写试验源代码
10-14
神州1号开发板附带例程 SPI FLASH（W25X16）读写程序实验（神舟I号）
第24章 SPI—读写串行FLASH—零死角玩转STM32-F429系列
flyleaf91的专栏
08-26 9229
第24章     SPI—读写串行FLASH 全套200集视频教程和1000页PDF教程请到秉火论坛下载：www.firebbs.cn 野火视频教程优酷观看网址：http://i.youku.com/firege     本章参考资料：《STM32F4xx 中文参考手册》、《STM32F4xx规格书》、库帮助文档《stm32f4xx_dsp_stdperiph_lib_um.chm》
STM32的串行Flash读写例程，亲测能用
11-25
串行Flash读写例程，亲测能用。内有详细的讲解文档，很好的学习资料。
使用STLINK读写外挂FLASH
12-18
本文将详细讲解如何使用STLINK来实现这一功能，以M25Q32这款常见的SPI接口Flash为例。 首先，M25Q32是一款32Mbit的串行闪存芯片，它通过SPI（Serial Peripheral Interface）接口与微控制器通信，常用于存储程序代码...
spi读写串行flash
05-05
SPI（Serial Peripheral Interface）是一种串行通信协议，常用于连接微控制器和外部设备，如串行Flash。下面是使用SPI读写串行Flash的基本步骤： 1. 初始化SPI接口，设置SPI的模式、速率等参数。 2. 选中串行Flash，向其发送读、写命令，以及要读写的地址。 3. 发送读、写数据，接收Flash返回的数据。 4. 取消Flash的选中状态，释放SPI总线。 下面是一个读取串行Flash中数据的例子： ``` #include <SPI.h> #define FLASH_CS 10 // SPI Flash的片选引脚 #define READ_CMD 0x03 // 读取数据命令 void setup() { // 初始化SPI接口 SPI.begin(); SPI.setBitOrder(MSBFIRST); SPI.setDataMode(SPI_MODE0); SPI.setClockDivider(SPI_CLOCK_DIV16); pinMode(FLASH_CS, OUTPUT); digitalWrite(FLASH_CS, HIGH); // 默认不选中Flash } void loop() { byte data[256]; // 读取的数据缓存 int addr = 0; // 读取的Flash地址 digitalWrite(FLASH_CS, LOW); // 选中Flash SPI.transfer(READ_CMD); // 发送读命令 SPI.transfer(addr >> 16 & 0xFF); // 发送地址高8位 SPI.transfer(addr >> 8 & 0xFF); // 发送地址中8位 SPI.transfer(addr & 0xFF); // 发送地址低8位 for (int i = 0; i < 256; i++) { data[i] = SPI.transfer(0x00); // 读取数据 } digitalWrite(FLASH_CS, HIGH); // 取消Flash的选中状态 // 处理读取的数据 // ... } ``` 其中，READ_CMD是读取数据的命令，地址分高中低三个部分，每次读取256字节的数据。写入数据的流程类似，只需要将读取命令和数据换成写入命令和数据即可。
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值