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

STM32F4xx系列使用HAL库配置SPI-读写FLASH_hal_spi_mspinit

作者：AI算法诗人 | 2024-01-31 14:05:47

赞

踩

hal_spi_mspinit

SPI协议简介

SPI物理层特点

  

SPI协议层

 

 

 

 

 QSPI协议简介

 

 

 

 SPI框图

 Flash写入与EEPROM有点相似，不同的是FLASH写入需要软件手动擦除，而EEPROM不用

 SPI配置流程

1、初始化通讯使用的目标引脚及端口时钟

2、使能SPI外设的时钟

3、配置SPI外设的模式、地址、速率等参数并使能SPI外设

4、编写基本SPI按字节收发的函数

将片选信号拉低

查看数据发送完成标志，如果标志不存在

将数据写入SPI数据寄存器

5、编写对FLASH擦除及读写操作的函数

6、编写测试程序，对读写数据进行校验

HAL库读写串行FLASH(W125Q128)实验

 

 flash 0xAB指令

 flash 0x90指令

 注意FLASH地址是24位的

 这里直接放spi_flash的板级支持包，直接调用即可

可以直接将CubeMX生成的源文件spi.c和spi.h替换成下述文件即可

spi.c

  1. /**
  2.   ******************************************************************************
  3.   * @file    spi.c
  4.   * @brief   This file provides code for the configuration
  5.   *          of the SPI instances.
  6.   ******************************************************************************
  7.   * @attention
  8.   *
  9.   * <h2><center>&copy; Copyright (c) 2022 STMicroelectronics.
  10.   * All rights reserved.</center></h2>
  11.   *
  12.   * This software component is licensed by ST under BSD 3-Clause license,
  13.   * the "License"; You may not use this file except in compliance with the
  14.   * License. You may obtain a copy of the License at:
  15.   *                        opensource.org/licenses/BSD-3-Clause
  16.   *
  17.   ******************************************************************************
  18.   */
  20. /* Includes ------------------------------------------------------------------*/
  21. #include "spi.h"
  22.  
  23. /* USER CODE BEGIN 0 */
  24.  
  25. /* USER CODE END 0 */
  26.  
  27. SPI_HandleTypeDef SpiHandle;
  28.  
  29. static __IO uint32_t  SPITimeout = SPIT_LONG_TIMEOUT;   
  30.  
  31. static uint16_t SPI_TIMEOUT_UserCallback(uint8_t errorCode);
  32.  
  33. /**
  34.   * @brief SPI MSP Initialization 
  35.   *        This function configures the hardware resources used in this example: 
  36.   *           - Peripheral's clock enable
  37.   *           - Peripheral's GPIO Configuration  
  38.   * @param hspi: SPI handle pointer
  39.   * @retval None
  40.   */
  41. void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi)
  42. {
  43.   GPIO_InitTypeDef  GPIO_InitStruct;
  44.   
  45.   /*##-1- Enable peripherals and GPIO Clocks #################################*/
  46.   /* Enable GPIO TX/RX clock */
  47.   SPIx_SCK_GPIO_CLK_ENABLE();
  48.   SPIx_MISO_GPIO_CLK_ENABLE();
  49.   SPIx_MOSI_GPIO_CLK_ENABLE();
  50.   SPIx_CS_GPIO_CLK_ENABLE();
  51.   /* Enable SPI clock */
  52.   SPIx_CLK_ENABLE(); 
  53.   
  54.   /*##-2- Configure peripheral GPIO ##########################################*/  
  55.   /* SPI SCK GPIO pin configuration  */
  56.   GPIO_InitStruct.Pin       = SPIx_SCK_PIN;
  57.   GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
  58.   GPIO_InitStruct.Pull      = GPIO_PULLUP;
  59.   GPIO_InitStruct.Speed     = GPIO_SPEED_FAST;
  60.   GPIO_InitStruct.Alternate = SPIx_SCK_AF;
  61.   
  62.   HAL_GPIO_Init(SPIx_SCK_GPIO_PORT, &GPIO_InitStruct);
  63.     
  64.   /* SPI MISO GPIO pin configuration  */
  65.   GPIO_InitStruct.Pin = SPIx_MISO_PIN;
  66.   GPIO_InitStruct.Alternate = SPIx_MISO_AF;
  67.   
  68.   HAL_GPIO_Init(SPIx_MISO_GPIO_PORT, &GPIO_InitStruct);
  69.   
  70.   /* SPI MOSI GPIO pin configuration  */
  71.   GPIO_InitStruct.Pin = SPIx_MOSI_PIN;
  72.   GPIO_InitStruct.Alternate = SPIx_MOSI_AF;  
  73.   HAL_GPIO_Init(SPIx_MOSI_GPIO_PORT, &GPIO_InitStruct);   
  74.  
  75.   GPIO_InitStruct.Pin = FLASH_CS_PIN ;
  76.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  77.   HAL_GPIO_Init(FLASH_CS_GPIO_PORT, &GPIO_InitStruct); 
  78. }
  79.  
  80. void SPI_FLASH_Init(void)
  81. {
  82.    /*##-1- Configure the SPI peripheral #######################################*/
  83.   /* Set the SPI parameters */
  84.   SpiHandle.Instance               = SPIx;
  85.   SpiHandle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
  86.   SpiHandle.Init.Direction         = SPI_DIRECTION_2LINES;
  87.   SpiHandle.Init.CLKPhase          = SPI_PHASE_2EDGE;
  88.   SpiHandle.Init.CLKPolarity       = SPI_POLARITY_HIGH;
  89.   SpiHandle.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE;
  90.   SpiHandle.Init.CRCPolynomial     = 7;
  91.   SpiHandle.Init.DataSize          = SPI_DATASIZE_8BIT;
  92.   SpiHandle.Init.FirstBit          = SPI_FIRSTBIT_MSB;
  93.   SpiHandle.Init.NSS               = SPI_NSS_SOFT;
  94.   SpiHandle.Init.TIMode            = SPI_TIMODE_DISABLE;
  95.   
  96.   SpiHandle.Init.Mode = SPI_MODE_MASTER;
  97.  
  98.   HAL_SPI_Init(&SpiHandle); 
  99.   
  100.   __HAL_SPI_ENABLE(&SpiHandle);     
  101. }
  102.  
  103.  
  104.  /**
  105.   * @brief  擦除FLASH扇区
  106.   * @param  SectorAddr：要擦除的扇区地址
  107.   * @retval 无
  108.   */
  109. void SPI_FLASH_SectorErase(uint32_t SectorAddr)
  110. {
  111.   /* 发送FLASH写使能命令 */
  112.   SPI_FLASH_WriteEnable();
  113.   SPI_FLASH_WaitForWriteEnd();
  114.   /* 擦除扇区 */
  115.   /* 选择FLASH: CS低电平 */
  116.   SPI_FLASH_CS_LOW();
  117.   /* 发送扇区擦除指令*/
  118.   SPI_FLASH_SendByte(W25X_SectorErase);
  119.   /*发送擦除扇区地址的高位*/
  120.   SPI_FLASH_SendByte((SectorAddr & 0xFF0000) >> 16);
  121.   /* 发送擦除扇区地址的中位 */
  122.   SPI_FLASH_SendByte((SectorAddr & 0xFF00) >> 8);
  123.   /* 发送擦除扇区地址的低位 */
  124.   SPI_FLASH_SendByte(SectorAddr & 0xFF);
  125.   /* 停止信号 FLASH: CS 高电平 */
  126.   SPI_FLASH_CS_HIGH();
  127.   /* 等待擦除完毕*/
  128.   SPI_FLASH_WaitForWriteEnd();
  129. }
  130.  
  131.  
  132.  /**
  133.   * @brief  擦除FLASH扇区，整片擦除
  134.   * @param  无
  135.   * @retval 无
  136.   */
  137. void SPI_FLASH_BulkErase(void)
  138. {
  139.   /* 发送FLASH写使能命令 */
  140.   SPI_FLASH_WriteEnable();
  141.  
  142.   /* 整块 Erase */
  143.   /* 选择FLASH: CS低电平 */
  144.   SPI_FLASH_CS_LOW();
  145.   /* 发送整块擦除指令*/
  146.   SPI_FLASH_SendByte(W25X_ChipErase);
  147.   /* 停止信号 FLASH: CS 高电平 */
  148.   SPI_FLASH_CS_HIGH();
  149.  
  150.   /* 等待擦除完毕*/
  151.   SPI_FLASH_WaitForWriteEnd();
  152. }
  153.  
  154.  /**
  155.   * @brief  对FLASH按页写入数据，调用本函数写入数据前需要先擦除扇区
  156.   * @param	pBuffer，要写入数据的指针
  157.   * @param WriteAddr，写入地址
  158.   * @param  NumByteToWrite，写入数据长度，必须小于等于SPI_FLASH_PerWritePageSize
  159.   * @retval 无
  160.   */
  161. void SPI_FLASH_PageWrite(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
  162. {
  163.   /* 发送FLASH写使能命令 */
  164.   SPI_FLASH_WriteEnable();
  165.  
  166.   /* 选择FLASH: CS低电平 */
  167.   SPI_FLASH_CS_LOW();
  168.   /* 写页写指令*/
  169.   SPI_FLASH_SendByte(W25X_PageProgram);
  170.   /*发送写地址的高位*/
  171.   SPI_FLASH_SendByte((WriteAddr & 0xFF0000) >> 16);
  172.   /*发送写地址的中位*/
  173.   SPI_FLASH_SendByte((WriteAddr & 0xFF00) >> 8);
  174.   /*发送写地址的低位*/
  175.   SPI_FLASH_SendByte(WriteAddr & 0xFF);
  176.  
  177.   if(NumByteToWrite > SPI_FLASH_PerWritePageSize)
  178.   {
  179.      NumByteToWrite = SPI_FLASH_PerWritePageSize;
  180.      FLASH_ERROR("SPI_FLASH_PageWrite too large!");
  181.   }
  182.  
  183.   /* 写入数据*/
  184.   while (NumByteToWrite--)
  185.   {
  186.     /* 发送当前要写入的字节数据 */
  187.     SPI_FLASH_SendByte(*pBuffer);
  188.     /* 指向下一字节数据 */
  189.     pBuffer++;
  190.   }
  191.  
  192.   /* 停止信号 FLASH: CS 高电平 */
  193.   SPI_FLASH_CS_HIGH();
  194.  
  195.   /* 等待写入完毕*/
  196.   SPI_FLASH_WaitForWriteEnd();
  197. }
  198.  
  199.  
  200.  /**
  201.   * @brief  对FLASH写入数据，调用本函数写入数据前需要先擦除扇区
  202.   * @param	pBuffer，要写入数据的指针
  203.   * @param  WriteAddr，写入地址
  204.   * @param  NumByteToWrite，写入数据长度
  205.   * @retval 无
  206.   */
  207. void SPI_FLASH_BufferWrite(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
  208. {
  209.   uint8_t NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
  210. 	
  211. 	/*mod运算求余，若writeAddr是SPI_FLASH_PageSize整数倍，运算结果Addr值为0*/
  212.   Addr = WriteAddr % SPI_FLASH_PageSize;
  213. 	
  214. 	/*差count个数据值，刚好可以对齐到页地址*/
  215.   count = SPI_FLASH_PageSize - Addr;	
  216. 	/*计算出要写多少整数页*/
  217.   NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
  218. 	/*mod运算求余，计算出剩余不满一页的字节数*/
  219.   NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
  220.  
  221. 	 /* Addr=0,则WriteAddr 刚好按页对齐 aligned  */
  222.   if (Addr == 0) 
  223.   {
  224. 		/* NumByteToWrite < SPI_FLASH_PageSize */
  225.     if (NumOfPage == 0) 
  226.     {
  227.       SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
  228.     }
  229.     else /* NumByteToWrite > SPI_FLASH_PageSize */
  230.     {
  231. 			/*先把整数页都写了*/
  232.       while (NumOfPage--)
  233.       {
  234.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
  235.         WriteAddr +=  SPI_FLASH_PageSize;
  236.         pBuffer += SPI_FLASH_PageSize;
  237.       }
  238. 			
  239. 			/*若有多余的不满一页的数据，把它写完*/
  240.       SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
  241.     }
  242.   }
  243. 	/* 若地址与 SPI_FLASH_PageSize 不对齐  */
  244.   else 
  245.   {
  246. 		/* NumByteToWrite < SPI_FLASH_PageSize */
  247.     if (NumOfPage == 0) 
  248.     {
  249. 			/*当前页剩余的count个位置比NumOfSingle小，写不完*/
  250.       if (NumOfSingle > count) 
  251.       {
  252.         temp = NumOfSingle - count;
  253. 				
  254. 				/*先写满当前页*/
  255.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
  256.         WriteAddr +=  count;
  257.         pBuffer += count;
  258. 				
  259. 				/*再写剩余的数据*/
  260.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, temp);
  261.       }
  262.       else /*当前页剩余的count个位置能写完NumOfSingle个数据*/
  263.       {				
  264.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
  265.       }
  266.     }
  267.     else /* NumByteToWrite > SPI_FLASH_PageSize */
  268.     {
  269. 			/*地址不对齐多出的count分开处理，不加入这个运算*/
  270.       NumByteToWrite -= count;
  271.       NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
  272.       NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
  273.  
  274.       SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
  275.       WriteAddr +=  count;
  276.       pBuffer += count;
  277. 			
  278. 			/*把整数页都写了*/
  279.       while (NumOfPage--)
  280.       {
  281.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
  282.         WriteAddr +=  SPI_FLASH_PageSize;
  283.         pBuffer += SPI_FLASH_PageSize;
  284.       }
  285. 			/*若有多余的不满一页的数据，把它写完*/
  286.       if (NumOfSingle != 0)
  287.       {
  288.         SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
  289.       }
  290.     }
  291.   }
  292. }
  293.  
  294.  /**
  295.   * @brief  读取FLASH数据
  296.   * @param 	pBuffer，存储读出数据的指针
  297.   * @param   ReadAddr，读取地址
  298.   * @param   NumByteToRead，读取数据长度
  299.   * @retval 无
  300.   */
  301. void SPI_FLASH_BufferRead(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead)
  302. {
  303.   /* 选择FLASH: CS低电平 */
  304.   SPI_FLASH_CS_LOW();
  305.  
  306.   /* 发送 读 指令 */
  307.   SPI_FLASH_SendByte(W25X_ReadData);
  308.  
  309.   /* 发送 读 地址高位 */
  310.   SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
  311.   /* 发送 读 地址中位 */
  312.   SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
  313.   /* 发送 读 地址低位 */
  314.   SPI_FLASH_SendByte(ReadAddr & 0xFF);
  315.   
  316. 	/* 读取数据 */
  317.   while (NumByteToRead--)
  318.   {
  319.     /* 读取一个字节*/
  320.     *pBuffer = SPI_FLASH_SendByte(Dummy_Byte);
  321.     /* 指向下一个字节缓冲区 */
  322.     pBuffer++;
  323.   }
  324.  
  325.   /* 停止信号 FLASH: CS 高电平 */
  326.   SPI_FLASH_CS_HIGH();
  327. }
  328.  
  329.  
  330.  /**
  331.   * @brief  读取FLASH ID
  332.   * @param 	无
  333.   * @retval FLASH ID
  334.   */
  335. uint32_t SPI_FLASH_ReadID(void)
  336. {
  337.   uint32_t Temp = 0, Temp0 = 0, Temp1 = 0, Temp2 = 0;
  338.  
  339.   /* 开始通讯：CS低电平 */
  340.   SPI_FLASH_CS_LOW();
  341.  
  342.   /* 发送JEDEC指令，读取ID */
  343.   SPI_FLASH_SendByte(W25X_JedecDeviceID);
  344.  
  345.   /* 读取一个字节数据 */
  346.   Temp0 = SPI_FLASH_SendByte(Dummy_Byte);
  347.  
  348.   /* 读取一个字节数据 */
  349.   Temp1 = SPI_FLASH_SendByte(Dummy_Byte);
  350.  
  351.   /* 读取一个字节数据 */
  352.   Temp2 = SPI_FLASH_SendByte(Dummy_Byte);
  353.  
  354.   /* 停止通讯：CS高电平 */
  355.   SPI_FLASH_CS_HIGH();
  356.  
  357. 	/*把数据组合起来，作为函数的返回值*/
  358.   Temp = (Temp0 << 16) | (Temp1 << 8) | Temp2;
  359.  
  360.   return Temp;
  361. }
  362.  
  363.  /**
  364.   * @brief  读取FLASH Device ID
  365.   * @param 	无
  366.   * @retval FLASH Device ID
  367.   */
  368. uint32_t SPI_FLASH_ReadDeviceID(void)
  369. {
  370.   uint32_t Temp = 0;
  371.  
  372.   /* Select the FLASH: Chip Select low */
  373.   SPI_FLASH_CS_LOW();
  374.  
  375.   /* Send "RDID " instruction */
  376.   SPI_FLASH_SendByte(W25X_DeviceID);
  377.   SPI_FLASH_SendByte(Dummy_Byte);
  378.   SPI_FLASH_SendByte(Dummy_Byte);
  379.   SPI_FLASH_SendByte(Dummy_Byte);
  380.   
  381.   /* Read a byte from the FLASH */
  382.   Temp = SPI_FLASH_SendByte(Dummy_Byte);
  383.  
  384.   /* Deselect the FLASH: Chip Select high */
  385.   SPI_FLASH_CS_HIGH();
  386.  
  387.   return Temp;
  388. }
  389. /*******************************************************************************
  390. * Function Name  : SPI_FLASH_StartReadSequence
  391. * Description    : Initiates a read data byte (READ) sequence from the Flash.
  392. *                  This is done by driving the /CS line low to select the device,
  393. *                  then the READ instruction is transmitted followed by 3 bytes
  394. *                  address. This function exit and keep the /CS line low, so the
  395. *                  Flash still being selected. With this technique the whole
  396. *                  content of the Flash is read with a single READ instruction.
  397. * Input          : - ReadAddr : FLASH's internal address to read from.
  398. * Output         : None
  399. * Return         : None
  400. *******************************************************************************/
  401. void SPI_FLASH_StartReadSequence(uint32_t ReadAddr)
  402. {
  403.   /* Select the FLASH: Chip Select low */
  404.   SPI_FLASH_CS_LOW();
  406.   /* Send "Read from Memory " instruction */
  407.   SPI_FLASH_SendByte(W25X_ReadData);
  409.   /* Send the 24-bit address of the address to read from -----------------------*/
  410.   /* Send ReadAddr high nibble address byte */
  411.   SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
  412.   /* Send ReadAddr medium nibble address byte */
  413.   SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
  414.   /* Send ReadAddr low nibble address byte */
  415.   SPI_FLASH_SendByte(ReadAddr & 0xFF);
  416. }
  419.  /**
  420.   * @brief  使用SPI读取一个字节的数据
  421.   * @param  无
  422.   * @retval 返回接收到的数据
  423.   */
  424. uint8_t SPI_FLASH_ReadByte(void)
  425. {
  426.   return (SPI_FLASH_SendByte(Dummy_Byte));
  427. }
  430.  /**
  431.   * @brief  使用SPI发送一个字节的数据
  432.   * @param  byte：要发送的数据
  433.   * @retval 返回接收到的数据
  434.   */
  435. uint8_t SPI_FLASH_SendByte(uint8_t byte)
  436. {
  437.   SPITimeout = SPIT_FLAG_TIMEOUT;
  439.   /* 等待发送缓冲区为空，TXE事件 */
  440.   while (__HAL_SPI_GET_FLAG( &SpiHandle, SPI_FLAG_TXE ) == RESET)
  441.    {
  442.     if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(0);
  443.    }
  445.   /* 写入数据寄存器，把要写入的数据写入发送缓冲区 */
  446.   WRITE_REG(SpiHandle.Instance->DR, byte);
  448.   SPITimeout = SPIT_FLAG_TIMEOUT;
  450.   /* 等待接收缓冲区非空，RXNE事件 */
  451.   while (__HAL_SPI_GET_FLAG( &SpiHandle, SPI_FLAG_RXNE ) == RESET)
  452.    {//发送缓冲区会在下一个周期将数据发送出去
  453.     if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(1);
  454.    }
  456.   /* 读取数据寄存器，获取接收缓冲区数据 */
  457.   return READ_REG(SpiHandle.Instance->DR);
  458. //	static uint8_t Rx_Data[1];
  459. //	static uint8_t Tx_Data[1];
  460. //	Tx_Data[0]=byte;
  461. //	if(HAL_SPI_TransmitReceive(&SpiHandle,Tx_Data,Rx_Data,1,1000)!=HAL_OK)
  462. //	{
  463. //		return 0;
  464. //	}
  465. //	return Rx_Data[0];
  466. }
  468. /*******************************************************************************
  469. * Function Name  : SPI_FLASH_SendHalfWord
  470. * Description    : Sends a Half Word through the SPI interface and return the
  471. *                  Half Word received from the SPI bus.
  472. * Input          : Half Word : Half Word to send.
  473. * Output         : None
  474. * Return         : The value of the received Half Word.
  475. *******************************************************************************/
  476. uint16_t SPI_FLASH_SendHalfWord(uint16_t HalfWord)
  477. {
  478.   
  479.   SPITimeout = SPIT_FLAG_TIMEOUT;
  481.   /* Loop while DR register in not emplty */
  482.   while (__HAL_SPI_GET_FLAG( &SpiHandle,  SPI_FLAG_TXE ) == RESET)
  483.   {
  484.     if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(2);
  485.    }
  487.   /* Send Half Word through the SPIx peripheral */
  488.   WRITE_REG(SpiHandle.Instance->DR, HalfWord);
  490.   SPITimeout = SPIT_FLAG_TIMEOUT;
  492.   /* Wait to receive a Half Word */
  493.   while (__HAL_SPI_GET_FLAG( &SpiHandle, SPI_FLAG_RXNE ) == RESET)
  494.    {
  495.     if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(3);
  496.    }
  497.   /* Return the Half Word read from the SPI bus */
  498.   return READ_REG(SpiHandle.Instance->DR);
  499. }
  502.  /**
  503.   * @brief  向FLASH发送 写使能 命令
  504.   * @param  none
  505.   * @retval none
  506.   */
  507. void SPI_FLASH_WriteEnable(void)
  508. {
  509.   /* 通讯开始：CS低 */
  510.   SPI_FLASH_CS_LOW();
  512.   /* 发送写使能命令*/
  513.   SPI_FLASH_SendByte(W25X_WriteEnable);
  515.   /*通讯结束：CS高 */
  516.   SPI_FLASH_CS_HIGH();
  517. }
  519.  /**
  520.   * @brief  等待WIP(BUSY)标志被置0，即等待到FLASH内部数据写入完毕
  521.   * @param  none
  522.   * @retval none
  523.   */
  524. void SPI_FLASH_WaitForWriteEnd(void)
  525. {
  526.   uint8_t FLASH_Status = 0;
  528.   /* 选择 FLASH: CS 低 */
  529.   SPI_FLASH_CS_LOW();
  531.   /* 发送 读状态寄存器 命令 */
  532.   SPI_FLASH_SendByte(W25X_ReadStatusReg);
  534.   SPITimeout = SPIT_FLAG_TIMEOUT;
  535.   /* 若FLASH忙碌，则等待 */
  536.   do
  537.   {
  538.     /* 读取FLASH芯片的状态寄存器 */
  539.     FLASH_Status = SPI_FLASH_SendByte(Dummy_Byte);	 
  541.     {
  542.       if((SPITimeout--) == 0) 
  543.       {
  544.         SPI_TIMEOUT_UserCallback(4);
  545.         return;
  546.       }
  547.     } 
  548.   }
  549.   while ((FLASH_Status & WIP_Flag) == SET); /* 正在写入标志 */
  551.   /* 停止信号  FLASH: CS 高 */
  552.   SPI_FLASH_CS_HIGH();
  553. }
  556. //进入掉电模式
  557. void SPI_Flash_PowerDown(void)   
  558. { 
  559.   /* 选择 FLASH: CS 低 */
  560.   SPI_FLASH_CS_LOW();
  562.   /* 发送 掉电 命令 */
  563.   SPI_FLASH_SendByte(W25X_PowerDown);
  565.   /* 停止信号  FLASH: CS 高 */
  566.   SPI_FLASH_CS_HIGH();
  567. }   
  569. //唤醒
  570. void SPI_Flash_WAKEUP(void)   
  571. {
  572.   /*选择 FLASH: CS 低 */
  573.   SPI_FLASH_CS_LOW();
  575.   /* 发上 上电 命令 */
  576.   SPI_FLASH_SendByte(W25X_ReleasePowerDown);
  578.   /* 停止信号 FLASH: CS 高 */
  579.   SPI_FLASH_CS_HIGH();                   //等待TRES1
  580. }   
  583. /**
  584.   * @brief  等待超时回调函数
  585.   * @param  None.
  586.   * @retval None.
  587.   */
  588. static  uint16_t SPI_TIMEOUT_UserCallback(uint8_t errorCode)
  589. {
  590.   /* 等待超时后的处理,输出错误信息 */
  591.   FLASH_ERROR("SPI 等待超时!errorCode = %d",errorCode);
  592.   return 0;
  593. }
  594.    
  595. /*********************************************END OF FILE**********************/

spi.h 

  1. /**
  2.   ******************************************************************************
  3.   * @file    spi.h
  4.   * @brief   This file contains all the function prototypes for
  5.   *          the spi.c file
  6.   ******************************************************************************
  7.   * @attention
  8.   *
  9.   * <h2><center>&copy; Copyright (c) 2022 STMicroelectronics.
  10.   * All rights reserved.</center></h2>
  11.   *
  12.   * This software component is licensed by ST under BSD 3-Clause license,
  13.   * the "License"; You may not use this file except in compliance with the
  14.   * License. You may obtain a copy of the License at:
  15.   *                        opensource.org/licenses/BSD-3-Clause
  16.   *
  17.   ******************************************************************************
  18.   */
  19. /* Define to prevent recursive inclusion -------------------------------------*/
  20. #ifndef __SPI_H__
  21. #define __SPI_H__
  22.  
  23. #ifdef __cplusplus
  24. extern "C" {
  25. #endif
  26.  
  27. /* Includes ------------------------------------------------------------------*/
  28. #include "main.h"
  29.  
  30. /* USER CODE BEGIN Includes */
  31.  
  32. /* USER CODE END Includes */
  33.  
  34. #define  sFLASH_ID                       0XEF4018     //W25Q128
  35.  
  36.  
  37. //#define SPI_FLASH_PageSize            4096
  38. #define SPI_FLASH_PageSize              256
  39. #define SPI_FLASH_PerWritePageSize      256
  40.  
  41. /* Private define ------------------------------------------------------------*/
  42. /*命令定义-开头*******************************/
  43. #define W25X_WriteEnable		      0x06 
  44. #define W25X_WriteDisable		      0x04 
  45. #define W25X_ReadStatusReg		    0x05 
  46. #define W25X_WriteStatusReg		  0x01 
  47. #define W25X_ReadData			        0x03 
  48. #define W25X_FastReadData		      0x0B 
  49. #define W25X_FastReadDual		      0x3B 
  50. #define W25X_PageProgram		      0x02 
  51. #define W25X_BlockErase			      0xD8 
  52. #define W25X_SectorErase		      0x20 
  53. #define W25X_ChipErase			      0xC7 
  54. #define W25X_PowerDown			      0xB9 
  55. #define W25X_ReleasePowerDown	  0xAB 
  56. #define W25X_DeviceID			        0xAB 
  57. #define W25X_ManufactDeviceID   	0x90 
  58. #define W25X_JedecDeviceID		    0x9F 
  59.  
  60. #define WIP_Flag                  0x01  /* Write In Progress (WIP) flag */
  61. #define Dummy_Byte                0xFF
  62. /*命令定义-结尾*******************************/
  63.  
  64.  //SPI号及时钟初始化函数
  65. #define SPIx                             SPI1
  66. #define SPIx_CLK_ENABLE()                __HAL_RCC_SPI1_CLK_ENABLE()
  67. #define SPIx_SCK_GPIO_CLK_ENABLE()       __HAL_RCC_GPIOB_CLK_ENABLE()
  68. #define SPIx_MISO_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOB_CLK_ENABLE() 
  69. #define SPIx_MOSI_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOB_CLK_ENABLE() 
  70. #define SPIx_CS_GPIO_CLK_ENABLE()        __HAL_RCC_GPIOG_CLK_ENABLE() 
  71.  
  72. #define SPIx_FORCE_RESET()               __HAL_RCC_SPI1_FORCE_RESET()
  73. #define SPIx_RELEASE_RESET()             __HAL_RCC_SPI1_RELEASE_RESET()
  74.  
  75. //SCK引脚
  76. #define SPIx_SCK_PIN                     GPIO_PIN_3
  77. #define SPIx_SCK_GPIO_PORT               GPIOB
  78. #define SPIx_SCK_AF                      GPIO_AF5_SPI1
  79. //MISO引脚
  80. #define SPIx_MISO_PIN                    GPIO_PIN_4
  81. #define SPIx_MISO_GPIO_PORT              GPIOB
  82. #define SPIx_MISO_AF                     GPIO_AF5_SPI1
  83. //MOSI引脚
  84. #define SPIx_MOSI_PIN                    GPIO_PIN_5
  85. #define SPIx_MOSI_GPIO_PORT              GPIOB
  86. #define SPIx_MOSI_AF                     GPIO_AF5_SPI1
  87. //CS(NSS)引脚
  88. #define FLASH_CS_PIN                     GPIO_PIN_6               
  89. #define FLASH_CS_GPIO_PORT               GPIOG                     
  90. //设置为高电平	
  91. #define	digitalHi(p,i)			    {p->BSRR=i;}		
  92. //输出低电平
  93. #define digitalLo(p,i)			    {p->BSRR=(uint32_t)i << 16;}				
  94. #define SPI_FLASH_CS_LOW()      digitalLo(FLASH_CS_GPIO_PORT,FLASH_CS_PIN )
  95. #define SPI_FLASH_CS_HIGH()     digitalHi(FLASH_CS_GPIO_PORT,FLASH_CS_PIN )
  96. /*SPI接口定义-结尾****************************/
  97.  
  98. /*等待超时时间*/
  99. #define SPIT_FLAG_TIMEOUT         ((uint32_t)0x1000)
  100. #define SPIT_LONG_TIMEOUT         ((uint32_t)(10 * SPIT_FLAG_TIMEOUT))
  101.  
  102. /*信息输出*/
  103. #define FLASH_DEBUG_ON         1
  104.  
  105. #define FLASH_INFO(fmt,arg...)           printf("<<-FLASH-INFO->> "fmt"\n",##arg)
  106. #define FLASH_ERROR(fmt,arg...)          printf("<<-FLASH-ERROR->> "fmt"\n",##arg)
  107. #define FLASH_DEBUG(fmt,arg...)          do{\
  108.                                           if(FLASH_DEBUG_ON)\
  109.                                           printf("<<-FLASH-DEBUG->> [%d]"fmt"\n",__LINE__, ##arg);\
  110.                                           }while(0)
  111.  
  112.  
  113.  
  114. void SPI_FLASH_Init(void);
  115. void SPI_FLASH_SectorErase(uint32_t SectorAddr);
  116. void SPI_FLASH_BulkErase(void);
  117. void SPI_FLASH_PageWrite(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite);
  118. void SPI_FLASH_BufferWrite(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite);
  119. void SPI_FLASH_BufferRead(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead);
  120. uint32_t SPI_FLASH_ReadID(void);
  121. uint32_t SPI_FLASH_ReadDeviceID(void);
  122. void SPI_FLASH_StartReadSequence(uint32_t ReadAddr);
  123. void SPI_Flash_PowerDown(void);
  124. void SPI_Flash_WAKEUP(void);
  125.  
  126.  
  127. uint8_t SPI_FLASH_ReadByte(void);
  128. uint8_t SPI_FLASH_SendByte(uint8_t byte);
  129. uint16_t SPI_FLASH_SendHalfWord(uint16_t HalfWord);
  130. void SPI_FLASH_WriteEnable(void);
  131. void SPI_FLASH_WaitForWriteEnd(void);
  132.  
  133. #endif /* __SPI_FLASH_H */

main.c 

  1. /* USER CODE BEGIN Header */
  2. /**
  3.   ******************************************************************************
  4.   * @file           : main.c
  5.   * @brief          : Main program body
  6.   ******************************************************************************
  7.   * @attention
  8.   *
  9.   * <h2><center>&copy; Copyright (c) 2022 STMicroelectronics.
  10.   * All rights reserved.</center></h2>
  11.   *
  12.   * This software component is licensed by ST under BSD 3-Clause license,
  13.   * the "License"; You may not use this file except in compliance with the
  14.   * License. You may obtain a copy of the License at:
  15.   *                        opensource.org/licenses/BSD-3-Clause
  16.   *
  17.   ******************************************************************************
  18.   */
  19. /* USER CODE END Header */
  20. /* Includes ------------------------------------------------------------------*/
  21. #include "main.h"
  22. #include "spi.h"
  23. #include "usart.h"
  24. #include "gpio.h"
  25. #include <stdio.h>
  26.  
  27. void SystemClock_Config(void);
  28.  
  29. typedef enum { FAILED = 0, PASSED = !FAILED} TestStatus;
  30.  
  31. /* 获取缓冲区的长度 */
  32. #define TxBufferSize1   (countof(TxBuffer1) - 1)
  33. #define RxBufferSize1   (countof(TxBuffer1) - 1)
  34. #define countof(a)      (sizeof(a) / sizeof(*(a)))
  35. #define  BufferSize (countof(Tx_Buffer)-1)
  36. #define  FLASH_WriteAddress     0x00000
  37. #define  FLASH_ReadAddress      FLASH_WriteAddress
  38. #define  FLASH_SectorToErase    FLASH_WriteAddress
  39.  
  40.  
  41. /* 发送缓冲区初始化 */
  42. uint8_t Tx_Buffer[] = "hello world!";
  43. uint8_t Rx_Buffer[BufferSize];
  44.  
  45. //读取的ID存储位置
  46. __IO uint32_t DeviceID = 0;
  47. __IO uint32_t FlashID = 0;
  48. __IO TestStatus TransferStatus1 = FAILED;
  49. TestStatus Buffercmp(uint8_t* pBuffer1, uint8_t* pBuffer2, uint16_t BufferLength);
  50. /**
  51.   * @brief  The application entry point.
  52.   * @retval int
  53.   */
  54. int main(void)
  55. {
  56.  
  57.   HAL_Init();
  58.  
  59.   SystemClock_Config();
  60.   MX_GPIO_Init();
  61.   /* 16M串行flash W25Q128初始化 */
  62. 	SPI_FLASH_Init();
  63.   MX_USART1_UART_Init();
  64. 	printf("\r\n这是一个16M串行flash(W25Q128)实验(QSPI驱动) \r\n");
  65. 	/* 16M串行flash W25Q128初始化 */
  66. 		/* 获取 Flash Device ID */
  67. 	DeviceID = SPI_FLASH_ReadDeviceID();
  68. 	
  69. 	HAL_Delay( 200 );
  70. 	
  71. 	/* 获取 SPI Flash ID */
  72. 	FlashID = SPI_FLASH_ReadID();
  73. 	
  74. 	printf("\r\nFlashID is 0x%X,  Manufacturer Device ID is 0x%X\r\n", FlashID, DeviceID);
  75. 	
  76. 	/* 检验 SPI Flash ID */
  77. 	if (FlashID == sFLASH_ID) 
  78. 	{	
  79. 		printf("\r\n检测到SPI FLASH W25Q128 !\r\n");
  80. 		
  81. 		/* 擦除将要写入的 SPI FLASH 扇区，FLASH写入前要先擦除 */
  82. 		SPI_FLASH_SectorErase(FLASH_SectorToErase);	 	 
  83. 		
  84. 		/* 将发送缓冲区的数据写到flash中 */
  85. 		SPI_FLASH_BufferWrite(Tx_Buffer, FLASH_WriteAddress, BufferSize);
  86. 		printf("\r\n写入的数据为：\r\n%s", Tx_Buffer);
  87. 		
  88. 		/* 将刚刚写入的数据读出来放到接收缓冲区中 */
  89. 		SPI_FLASH_BufferRead(Rx_Buffer, FLASH_ReadAddress, BufferSize);
  90. 		printf("\r\n读出的数据为：\r\n%s", Rx_Buffer);
  91. 		
  92. 		/* 检查写入的数据与读出的数据是否相等 */
  93. 		TransferStatus1 = Buffercmp(Tx_Buffer, Rx_Buffer, BufferSize);
  94. 		if( PASSED == TransferStatus1 )
  95. 		{    
  96. 			LED_ALLON;
  97. 			printf("\r\n16M串行flash(W25Q128)测试成功!\n\r");
  98. 		}
  99. 		else
  100. 		{        
  101. 			LED2_ON;
  102. 			printf("\r\n16M串行flash(W25Q128)测试失败!\n\r");
  103. 		}
  104. 	}// if (FlashID == sFLASH_ID)
  105. 	else
  106. 	{    
  107. 		LED2_ON;
  108. 		printf("\r\n获取不到 W25Q128 ID!\n\r");
  109. 	}
  110. 	
  111. 	SPI_Flash_PowerDown();  
  112.   while (1)
  113.   {
  114.  
  115.   }
  116.  
  117. }
  118.  
  119. TestStatus Buffercmp(uint8_t* pBuffer1, uint8_t* pBuffer2, uint16_t BufferLength)
  120. {
  121.   while(BufferLength--)
  122.   {
  123.     if(*pBuffer1 != *pBuffer2)
  124.     {
  125.       return FAILED;
  126.     }
  127.  
  128.     pBuffer1++;
  129.     pBuffer2++;
  130.   }
  131.   return PASSED;
  132. }
  133.  
  134. /**
  135.   * @brief System Clock Configuration
  136.   * @retval None
  137.   */
  138. void SystemClock_Config(void)
  139. {
  140.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  141.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  142.  
  143.   /** Configure the main internal regulator output voltage
  144.   */
  145.   __HAL_RCC_PWR_CLK_ENABLE();
  146.   __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
  147.   /** Initializes the RCC Oscillators according to the specified parameters
  148.   * in the RCC_OscInitTypeDef structure.
  149.   */
  150.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  151.   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  152.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  153.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  154.   RCC_OscInitStruct.PLL.PLLM = 25;
  155.   RCC_OscInitStruct.PLL.PLLN = 336;
  156.   RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  157.   RCC_OscInitStruct.PLL.PLLQ = 4;
  158.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  159.   {
  160.     Error_Handler();
  161.   }
  162.   /** Initializes the CPU, AHB and APB buses clocks
  163.   */
  164.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
  165.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  166.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  167.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  168.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
  169.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
  170.  
  171.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK)
  172.   {
  173.     Error_Handler();
  174.   }
  175. }
  176.  
  177. /* USER CODE BEGIN 4 */
  178.  
  179. /* USER CODE END 4 */
  180.  
  181. /**
  182.   * @brief  This function is executed in case of error occurrence.
  183.   * @retval None
  184.   */
  185. void Error_Handler(void)
  186. {
  187.   /* USER CODE BEGIN Error_Handler_Debug */
  188.   /* User can add his own implementation to report the HAL error return state */
  189.   __disable_irq();
  190.   while (1)
  191.   {
  192.   }
  193.   /* USER CODE END Error_Handler_Debug */
  194. }
  195.  
  196. #ifdef  USE_FULL_ASSERT
  197. /**
  198.   * @brief  Reports the name of the source file and the source line number
  199.   *         where the assert_param error has occurred.
  200.   * @param  file: pointer to the source file name
  201.   * @param  line: assert_param error line source number
  202.   * @retval None
  203.   */
  204. void assert_failed(uint8_t *file, uint32_t line)
  205. {
  206.   /* USER CODE BEGIN 6 */
  207.   /* User can add his own implementation to report the file name and line number,
  208.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  209.   /* USER CODE END 6 */
  210. }
  211. #endif /* USE_FULL_ASSERT */
  212.  
  213. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

LED和串口UART配置这里就不过多介绍了，感谢大家的阅读！^_^

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

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

  

闽ICP备14008679号