STM32F767 QSPI W25Q256 四线读写 Quad SPI Lines模式 32位地址模式 中断模式

已于 2022-12-01 21:45:29 修改
阅读量482 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： STM32 文章标签： stm32 单片机 c语言
于 2021-11-17 16:51:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/smallerlang/article/details/121382229 
/* Private variables ---------------------------------------------------------*/

QSPI_HandleTypeDef hqspi;

/* USER CODE BEGIN PV */


/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_QUADSPI_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

#define DATA_SIZE 10000
#define DATA_ADDR 400

uint8_t flag_tx_done;
uint8_t flag_rx_done;
uint8_t flag_cmd_done;

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_QUADSPI_Init();
  /* USER CODE BEGIN 2 */
	
	//HAL_GPIO_WritePin(GPIOF, GPIO_PIN_6|GPIO_PIN_7, GPIO_PIN_SET);
	
	delay_init(216);
	delay_ms(500);
	
	
	uint8_t stareg2;
	stareg2=W25QXX_ReadSR(&hqspi, 2);		//
	if((stareg2&0X02)==0)			//
	{
		stareg2|=1<<1;				//
		W25QXX_Write_SR(&hqspi, 2,stareg2);	//设置QE丿1
	}
	
	uint8_t stareg3;
	stareg3=W25QXX_ReadSR(&hqspi, 3);      //读取状濁寄存器3，判断地坿模式
	if((stareg3&0X01)==0)			//如果不是4字节地址模式,则进兿4字节地址模式
	{ 
		W25qxx_Cmd(&hqspi, W25X_WriteEnable, QSPI_INSTRUCTION_1_LINE);
		W25qxx_Cmd(&hqspi, W25X_Enable4ByteAddr, QSPI_INSTRUCTION_1_LINE);
	}
	
	static uint16_t W25qxx_Id;
	W25qxx_Id = W25qxx_Read_Id(&hqspi);
	
	W25qxx_Erase_Sector(&hqspi, 0);
	
	static uint8_t pData_wr[DATA_SIZE] = {22,33,44};
	uint32_t i;
	for(i = 0; i < DATA_SIZE; i++)
	{
		pData_wr[i] = i;
	}
	W25QXX_Write(&hqspi, pData_wr, DATA_ADDR, DATA_SIZE);
	
	static uint8_t pData_rd[DATA_SIZE];
	W25qxx_Read_Data(&hqspi, DATA_ADDR, (uint8_t*)pData_rd, DATA_SIZE);
	
	
	for(i = 0; i < DATA_SIZE; i++)
	{
		if((pData_wr[i] & 0xff) != (pData_rd[i] & 0xff)) break;
	}
	if(i < DATA_SIZE)
	{
		HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_RESET);
	}
	else
	{
		HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_SET);
	}
	
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */

  }
  /* USER CODE END 3 */
}

/**
  * @brief QUADSPI Initialization Function
  * @param None
  * @retval None
  */
static void MX_QUADSPI_Init(void)
{

  /* USER CODE BEGIN QUADSPI_Init 0 */

  /* USER CODE END QUADSPI_Init 0 */

  /* USER CODE BEGIN QUADSPI_Init 1 */

  /* USER CODE END QUADSPI_Init 1 */
  /* QUADSPI parameter configuration*/
  hqspi.Instance = QUADSPI;
  hqspi.Init.ClockPrescaler = 2;
  hqspi.Init.FifoThreshold = 4;
  hqspi.Init.SampleShifting = QSPI_SAMPLE_SHIFTING_HALFCYCLE;
  hqspi.Init.FlashSize = 24;
  hqspi.Init.ChipSelectHighTime = QSPI_CS_HIGH_TIME_5_CYCLE;
  hqspi.Init.ClockMode = QSPI_CLOCK_MODE_0;
  hqspi.Init.FlashID = QSPI_FLASH_ID_1;
  hqspi.Init.DualFlash = QSPI_DUALFLASH_DISABLE;
  if (HAL_QSPI_Init(&hqspi) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN QUADSPI_Init 2 */

  /* USER CODE END QUADSPI_Init 2 */

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOF_CLK_ENABLE();
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_RESET);

  /*Configure GPIO pin : PB1 */
  GPIO_InitStruct.Pin = GPIO_PIN_1;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

}

/******************************************************************************/
/* STM32F7xx Peripheral Interrupt Handlers                                    */
/* Add here the Interrupt Handlers for the used peripherals.                  */
/* For the available peripheral interrupt handler names,                      */
/* please refer to the startup file (startup_stm32f7xx.s).                    */
/******************************************************************************/

/**
  * @brief This function handles QUADSPI global interrupt.
  */
void QUADSPI_IRQHandler(void)
{
  /* USER CODE BEGIN QUADSPI_IRQn 0 */

  /* USER CODE END QUADSPI_IRQn 0 */
  HAL_QSPI_IRQHandler(&hqspi);
  /* USER CODE BEGIN QUADSPI_IRQn 1 */

  /* USER CODE END QUADSPI_IRQn 1 */
}

/* USER CODE BEGIN 1 */

/**
  * @brief  Tx Transfer completed callback.
  * @param  hqspi : QSPI handle
  * @retval None
  */
void HAL_QSPI_TxCpltCallback(QSPI_HandleTypeDef *hqspi)
{
	flag_tx_done = 1;
}

/**
  * @brief  Rx Transfer completed callback.
  * @param  hqspi : QSPI handle
  * @retval None
  */
void HAL_QSPI_RxCpltCallback(QSPI_HandleTypeDef *hqspi)
{
	flag_rx_done = 1;
}

/**
  * @brief  Command completed callback.
  * @param  hqspi : QSPI handle
  * @retval None
  */
void HAL_QSPI_CmdCpltCallback(QSPI_HandleTypeDef *hqspi)
{
	flag_cmd_done = 1; 
}

#ifndef __BSP_W25QXX_H
#define __BSP_W25QXX_H

#include "main.h"

//W25XϵÁЯQϵÁА¾ƬÁб퉠  
//W25Q80  ID  0XEF13
//W25Q16  ID  0XEF14
//W25Q32  ID  0XEF15
//W25Q64  ID  0XEF16	
//W25Q128 ID  0XEF17	
//W25Q256 ID  0XEF18
#define W25Q80 	0XEF13 	
#define W25Q16 	0XEF14
#define W25Q32 	0XEF15
#define W25Q64 	0XEF16
#define W25Q128	0XEF17
#define W25Q256 0XEF18

extern uint16_t W25QXX_TYPE;					//¶¨ҥW25QXXоƬЍºʼn

////////////////////////////////////////////////////////////////////////////////// 
//ָÁ
#define W25X_WriteEnable		0x06 
#define W25X_WriteDisable		0x04 
#define W25X_ReadStatusReg1		0x05 
#define W25X_ReadStatusReg2		0x35 
#define W25X_ReadStatusReg3		0x15 
#define W25X_WriteStatusReg1    0x01 
#define W25X_WriteStatusReg2    0x31 
#define W25X_WriteStatusReg3    0x11 
#define W25X_ReadData			0x03 
#define W25X_FastReadData		0x0B 
#define W25X_FastReadDual		0x3B 
#define W25X_PageProgram		0x02 
#define W25X_BlockErase			0xD8 
#define W25X_SectorErase		0x20 
#define W25X_ChipErase			0xC7 
#define W25X_PowerDown			0xB9 
#define W25X_ReleasePowerDown	0xAB 
#define W25X_DeviceID			0xAB 
#define W25X_ManufactDeviceID	0x90 
#define W25X_JedecDeviceID		0x9F 
#define W25X_Enable4ByteAddr    0xB7
#define W25X_Exit4ByteAddr      0xE9
#define W25X_SetReadParam		0xC0 
#define W25X_EnterQPIMode       0x38
#define W25X_ExitQPIMode        0xFF

/** 
  * @brief  HAL Status structures definition  
  */  
typedef enum 
{
  Status_Busy       = 0x00U,
  Status_Free    = 0x01U
} Busy_StatusTypeDef;


HAL_StatusTypeDef W25qxx_Cmd(QSPI_HandleTypeDef *hqspi, uint32_t Instruction, uint32_t InstructionMode);
uint16_t W25qxx_Read_Id(QSPI_HandleTypeDef *hqspi);
HAL_StatusTypeDef W25qxx_Read_Data(QSPI_HandleTypeDef *hqspi, uint32_t Addr, uint8_t *pData, uint32_t Data_Count);
HAL_StatusTypeDef W25qxx_Erase_Sector(QSPI_HandleTypeDef *hqspi, uint32_t Sector);
Busy_StatusTypeDef W25qxx_Is_Busy(QSPI_HandleTypeDef *hqspi);
void W25QXX_Write_Page(QSPI_HandleTypeDef *hqspi, uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);
void W25QXX_Write_NoCheck(QSPI_HandleTypeDef *hqspi, uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)  ;
void W25QXX_Write(QSPI_HandleTypeDef *hqspi, uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite);
uint8_t W25QXX_ReadSR(QSPI_HandleTypeDef *hqspi, uint8_t regno);
void W25QXX_Write_SR(QSPI_HandleTypeDef *hqspi, uint8_t regno,uint8_t sr);




#endif	//__BSP_W25QXX_H



#include "bsp_w25qxx.h"


uint16_t W25QXX_TYPE;					//定义W25QXX芯片型号	

HAL_StatusTypeDef W25qxx_Cmd(QSPI_HandleTypeDef *hqspi, uint32_t Instruction, uint32_t InstructionMode) 
{
	QSPI_CommandTypeDef cmd;
	HAL_StatusTypeDef status;
	
	cmd.Instruction = Instruction;
	cmd.Address = 0;
	cmd.AlternateBytes = 0;
	cmd.AddressSize = 0;
	cmd.AlternateBytesSize = 0;
	cmd.DummyCycles = 0;
	cmd.InstructionMode = /*QSPI_INSTRUCTION_1_LINE*/InstructionMode;
	cmd.AddressMode = QSPI_ADDRESS_NONE;
	cmd.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
	cmd.DataMode = QSPI_DATA_NONE;
	cmd.NbData = 0;
	cmd.DdrMode = QSPI_DDR_MODE_DISABLE;
	cmd.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
	cmd.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;
	
	flag_cmd_done = 0;
	status = HAL_QSPI_Command_IT(hqspi, &cmd);
	while(!flag_cmd_done)
	{
	
	}
	
	return status;
}

uint16_t W25qxx_Read_Id(QSPI_HandleTypeDef *hqspi) 
{
	uint16_t id;
	QSPI_CommandTypeDef cmd;
	HAL_StatusTypeDef status;
	uint8_t pData[6];
	
	W25qxx_Cmd(hqspi, W25X_WriteEnable, QSPI_INSTRUCTION_1_LINE);
	
	cmd.Instruction = /*W25X_ManufactDeviceID*/0x94;
	cmd.Address = 0;
	cmd.AlternateBytes = 1;
	cmd.AddressSize = QSPI_ADDRESS_32_BITS;
	cmd.AlternateBytesSize = QSPI_ALTERNATE_BYTES_8_BITS;
	cmd.DummyCycles = 4;
	cmd.InstructionMode = QSPI_INSTRUCTION_1_LINE;
	cmd.AddressMode = QSPI_ADDRESS_4_LINES;
	cmd.AlternateByteMode = QSPI_ALTERNATE_BYTES_4_LINES;
	cmd.DataMode = QSPI_DATA_4_LINES;
	cmd.NbData = 6;
	cmd.DdrMode = QSPI_DDR_MODE_DISABLE;
	cmd.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
	cmd.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;
	
	status = HAL_QSPI_Command_IT(hqspi, &cmd);
	
	flag_rx_done = 0;
	status = HAL_QSPI_Receive_IT(hqspi, pData);
	while(!flag_rx_done);
	
	id = (pData[0] << 8) | pData[1];
	
	while(W25qxx_Is_Busy(hqspi) == Status_Busy)
	{
		
	}
	
	return id;
}

void W25QXX_Write_Page(QSPI_HandleTypeDef *hqspi, uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)
{
	QSPI_CommandTypeDef cmd;
	
	W25qxx_Cmd(hqspi, W25X_WriteEnable, QSPI_INSTRUCTION_1_LINE);
	
	cmd.Instruction = /*W25X_PageProgram*/0x32;
	cmd.Address = WriteAddr;
	cmd.AlternateBytes = 0;
	cmd.AddressSize = QSPI_ADDRESS_32_BITS;
	cmd.AlternateBytesSize = 0;
	cmd.DummyCycles = 0;
	cmd.InstructionMode = QSPI_INSTRUCTION_1_LINE;
	cmd.AddressMode = QSPI_ADDRESS_1_LINE;
	cmd.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
	cmd.DataMode = QSPI_DATA_4_LINES;
	cmd.NbData = NumByteToWrite;
	cmd.DdrMode = QSPI_DDR_MODE_DISABLE;
	cmd.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
	cmd.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;

	HAL_QSPI_Command_IT(hqspi, &cmd);

	flag_tx_done = 0;
	HAL_QSPI_Transmit_IT(hqspi, pBuffer);
	while(!flag_tx_done);
	
	while(W25qxx_Is_Busy(hqspi) == Status_Busy)
	{
		
	}
} 



void W25QXX_Write_NoCheck(QSPI_HandleTypeDef *hqspi, uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)   
{ 			 		 
	uint16_t pageremain;	   
	pageremain=256-WriteAddr%256; //单页剩余的字节数		 	    
	if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
	while(1)
	{	   
		W25QXX_Write_Page(hqspi, pBuffer,WriteAddr,pageremain);
		if(NumByteToWrite==pageremain)break;//写入结束了
	 	else //NumByteToWrite>pageremain
		{
			pBuffer+=pageremain;
			WriteAddr+=pageremain;	

			NumByteToWrite-=pageremain;			  //减去已经写入了的字节数
			if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
			else pageremain=NumByteToWrite; 	  //不够256个字节了
		}
	}   
}

	 
void W25QXX_Write(QSPI_HandleTypeDef *hqspi, uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)   
{ 
	uint32_t secpos;
	uint16_t secoff;
	uint16_t secremain;	   
 	uint16_t i;    
	uint8_t * W25QXX_BUF;	 
	static uint8_t W25QXX_BUFFER[4096];	
	
	W25QXX_BUF=W25QXX_BUFFER;	     
	secpos=WriteAddr/4096;//扇区地址  
	secoff=WriteAddr%4096;//在扇区内的偏移
	secremain=4096-secoff;//扇区剩余空间大小   

 	if(NumByteToWrite<=secremain)secremain=NumByteToWrite;//不大于4096个字节
	while(1) 
	{	
		W25qxx_Read_Data(hqspi, secpos*4096, W25QXX_BUF, 4096);//读出整个扇区的内容
		while(W25qxx_Is_Busy(hqspi) == Status_Busy)
		{
			
		}
		
		for(i=0;i<secremain;i++)//校验数据
		{
			if(W25QXX_BUF[secoff+i]!=0XFF)break;//需要擦除  	  
		}
		if(i<secremain)//需要擦除
		{
			W25qxx_Erase_Sector(hqspi, secpos);//擦除这个扇区
			while(W25qxx_Is_Busy(hqspi) == Status_Busy)
			{
				
			}
			for(i=0;i<secremain;i++)	   //复制
			{
				W25QXX_BUF[i+secoff]=pBuffer[i];	  
			}
			
			W25QXX_Write_NoCheck(hqspi, W25QXX_BUF,secpos*4096,4096);//写入整个扇区  
			
		}else W25QXX_Write_NoCheck(hqspi, pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间. 		

		while(W25qxx_Is_Busy(hqspi) == Status_Busy)
		{
			
		}
		
		if(NumByteToWrite==secremain)break;//写入结束了
		else//写入未结束
		{
			secpos++;//扇区地址增1
			secoff=0;//偏移位置为0 	 

		   	pBuffer+=secremain;  //指针偏移
			WriteAddr+=secremain;//写地址偏移	   
		   	NumByteToWrite-=secremain;				//字节数递减
			if(NumByteToWrite>4096)secremain=4096;	//下一个扇区还是写不完
			else secremain=NumByteToWrite;			//下一个扇区可以写完了
		}	 
	};	 
}

HAL_StatusTypeDef W25qxx_Read_Data(QSPI_HandleTypeDef *hqspi, uint32_t Addr, uint8_t *pData, uint32_t Data_Count)
{
	QSPI_CommandTypeDef cmd;
	HAL_StatusTypeDef status;
	
	W25qxx_Cmd(hqspi, W25X_WriteEnable, QSPI_INSTRUCTION_1_LINE);
	
	cmd.Instruction = /*W25X_ReadData*/0xeb;
	cmd.Address = Addr;
	cmd.AlternateBytes = 0xff;
	cmd.AddressSize = QSPI_ADDRESS_32_BITS;
	cmd.AlternateBytesSize = QSPI_ALTERNATE_BYTES_8_BITS;
	cmd.DummyCycles = 4;
	cmd.InstructionMode = QSPI_INSTRUCTION_1_LINE;
	cmd.AddressMode = QSPI_ADDRESS_4_LINES;
	cmd.AlternateByteMode = QSPI_ALTERNATE_BYTES_4_LINES;
	cmd.DataMode = QSPI_DATA_4_LINES;
	cmd.NbData = Data_Count;
	cmd.DdrMode = QSPI_DDR_MODE_DISABLE;
	cmd.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
	cmd.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;
	
	status = HAL_QSPI_Command_IT(hqspi, &cmd);
	
	flag_rx_done = 0;
	status = HAL_QSPI_Receive_IT(hqspi, pData);
	while(!flag_rx_done);
	
	while(W25qxx_Is_Busy(hqspi) == Status_Busy)
	{
		
	}
	
	return status;
}

HAL_StatusTypeDef W25qxx_Erase_Sector(QSPI_HandleTypeDef *hqspi, uint32_t Sector)
{
	QSPI_CommandTypeDef cmd;
	HAL_StatusTypeDef status;
	
	W25qxx_Cmd(hqspi, W25X_WriteEnable, QSPI_INSTRUCTION_1_LINE);
	
	cmd.Instruction = W25X_SectorErase;
	cmd.Address = Sector * 4096;
	cmd.AlternateBytes = 0;
	cmd.AddressSize = QSPI_ADDRESS_32_BITS;
	cmd.AlternateBytesSize = 0;
	cmd.DummyCycles = 0;
	cmd.InstructionMode = QSPI_INSTRUCTION_1_LINE;
	cmd.AddressMode = QSPI_ADDRESS_1_LINE;
	cmd.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
	cmd.DataMode = QSPI_DATA_NONE;
	cmd.NbData = 0;
	cmd.DdrMode = QSPI_DDR_MODE_DISABLE;
	cmd.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
	cmd.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;
	
	flag_cmd_done = 0;
	status = HAL_QSPI_Command_IT(hqspi, &cmd);
	while(!flag_cmd_done);
	
	while(W25qxx_Is_Busy(hqspi) == Status_Busy)
	{
		
	}
	
	return status;
}

Busy_StatusTypeDef W25qxx_Is_Busy(QSPI_HandleTypeDef *hqspi)
{
	QSPI_CommandTypeDef cmd;
	HAL_StatusTypeDef status;
	uint8_t Data;
	
	cmd.Instruction = W25X_ReadStatusReg1;
	cmd.Address = 0;
	cmd.AlternateBytes = 0;
	cmd.AddressSize = QSPI_ADDRESS_24_BITS;
	cmd.AlternateBytesSize = 0;
	cmd.DummyCycles = 0;
	cmd.InstructionMode = QSPI_INSTRUCTION_1_LINE;
	cmd.AddressMode = QSPI_ADDRESS_1_LINE;
	cmd.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
	cmd.DataMode = QSPI_DATA_1_LINE;
	cmd.NbData = 1;
	cmd.DdrMode = QSPI_DDR_MODE_DISABLE;
	cmd.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
	cmd.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;
	
	status = HAL_QSPI_Command_IT(hqspi, &cmd);
	
	flag_rx_done = 0;
	status = HAL_QSPI_Receive_IT(hqspi, &Data);
	while(!flag_rx_done);
	
	if(Data & 0x01) return Status_Busy;
	else return Status_Free;
} 

uint8_t W25QXX_ReadSR(QSPI_HandleTypeDef *hqspi, uint8_t regno)   
{  
	QSPI_CommandTypeDef cmd;
	HAL_StatusTypeDef status;
	uint8_t Data;
	
	W25qxx_Cmd(hqspi, W25X_WriteEnable, QSPI_INSTRUCTION_1_LINE);
	
	switch(regno)
	{
			case 1:
					cmd.Instruction=W25X_ReadStatusReg1;    //读状态寄存器1指令
					break;
			case 2:
					cmd.Instruction=W25X_ReadStatusReg2;    //读状态寄存器2指令
					break;
			case 3:
					cmd.Instruction=W25X_ReadStatusReg3;    //读状态寄存器3指令
					break;
			default:
					cmd.Instruction=W25X_ReadStatusReg1;    
					break;
	}
	cmd.Address = 0;
	cmd.AlternateBytes = 0;
	cmd.AddressSize = QSPI_ADDRESS_24_BITS;
	cmd.AlternateBytesSize = 0;
	cmd.DummyCycles = 0;
	cmd.InstructionMode = QSPI_INSTRUCTION_1_LINE;
	cmd.AddressMode = QSPI_ADDRESS_NONE;
	cmd.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
	cmd.DataMode = QSPI_DATA_1_LINE;
	cmd.NbData = 1;
	cmd.DdrMode = QSPI_DDR_MODE_DISABLE;
	cmd.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
	cmd.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;
	
	status = HAL_QSPI_Command_IT(hqspi, &cmd);
	
	flag_rx_done = 0;
	status = HAL_QSPI_Receive_IT(hqspi, &Data);
	while(!flag_rx_done);
     
	return Data;   
}

void W25QXX_Write_SR(QSPI_HandleTypeDef *hqspi, uint8_t regno,uint8_t sr)   
{   
	QSPI_CommandTypeDef cmd;
	HAL_StatusTypeDef status;
	uint8_t Data;
	
	W25qxx_Cmd(hqspi, W25X_WriteEnable, QSPI_INSTRUCTION_1_LINE);

	switch(regno)
	{
		case 1:
				cmd.Instruction=W25X_WriteStatusReg1;    //写状态寄存器1指令
				break;
		case 2:
				cmd.Instruction=W25X_WriteStatusReg2;    //写状态寄存器2指令
				break;
		case 3:
				cmd.Instruction=W25X_WriteStatusReg3;    //写状态寄存器3指令
				break;
		default:
				cmd.Instruction=W25X_WriteStatusReg1;    
				break;
	}   
	cmd.Address = 0;
	cmd.AlternateBytes = 0;
	cmd.AddressSize = QSPI_ADDRESS_24_BITS;
	cmd.AlternateBytesSize = 0;
	cmd.DummyCycles = 0;
	cmd.InstructionMode = QSPI_INSTRUCTION_1_LINE;
	cmd.AddressMode = QSPI_ADDRESS_NONE;
	cmd.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
	cmd.DataMode = QSPI_DATA_1_LINE;
	cmd.NbData = 1;
	cmd.DdrMode = QSPI_DDR_MODE_DISABLE;
	cmd.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
	cmd.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;
	
	status = HAL_QSPI_Command_IT(hqspi, &cmd); 
	
	flag_tx_done = 0;
	status = HAL_QSPI_Transmit_IT(hqspi, &sr);
	while(!flag_tx_done);
         	      
}

总结：
1、从地址DATA_ADDR开始写DATA_SIZE个字节数据，然后从地址DATA_ADDR开始读DATA_SIZE个字节数据，并进行比较，结果均相同
2、
在这里插入图片描述
3、
在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值