devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

STM32—SPI详解入门（使用SPI通讯读写W25Q128模块）

作者：2023面试高手 | 2024-05-27 08:41:33

赞

踩

w25q128

目录

一、SPI是什么

二、SPI物理架构

三、SPI工作原理

四、SPI工作模式

五、SPI相关寄存器介绍

六、SPI用到的结构体与函数

1.结构体

2.函数

七、W25Q128芯片

1.W25Q128介绍

2.W25Q128存储架构

3.W25Q128常用指令

4.W25Q128状态寄存器

5.W25Q128常见操作流程

八、实验（使用SPI通讯读写W25Q128模块）

1.接线

2.配置

3.代码

1.main.c文件

2.w25q128.c文件（向工程添加w25q128.c文件）

3.w25q128.h文件（向工程添加w25q128.h文件）

4.spi.c文件编写

5.spi.h文件编写

九、STM32工程添加.c和.h文件

一、SPI是什么

        SPI是串行外设接口（Serial Peripheral Interface）的缩写，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便，正是出于这种简单易用的特性，越来越多的芯片集成了这种通信协议，比如 AT91RM9200 。

二、SPI物理架构

        SPI总线包含四条总线：分别为MOSI、MISO、SCK、NSS（CS）。

（1）MISO：主设备输入/从设备输出引脚。该引脚在从模式下发送数据，在主模式下接收数据。

（2）MOSI：主设备输出/从设备输入引脚。该引脚在主模式下发送数据，在从模式下接收数据。

（3）SCK：时钟信号，可以使主从设备同步输入输出。

（4）NSS（CS）： 由主设备控制，用来选择指定的从设备进行通信。（当主设备想要读/写从设备时，首先拉低从设备对应的NSS线）。

三、SPI工作原理

        1.SPI主从模式

         SPI分为主、从两种模式，一个SPI通讯系统需要包含一个（且只能是一个）主设备，一个或多个从设备。提供时钟的为主设备（Master），接收时钟的设备为从设备（Slave），SPI接口的读写操作，都是由主设备发起。当存在多个从设备时，主设备通过从设备各自的片选信号（NSS）来选择从设备。

        2.SPI主、从设备通讯接线

                一个主设备和一个从设备

                 一个主设备和多个从设备        

        3.SPI数据传输

        SPI主设备和从设备都有一个移位寄存器，主机可以通过向它的移位寄存器写入数据来发起一次SPI通讯，主设备的7移到从设备的0上，而从设备的7移到主设备的0上。

1.主设备拉低对应从设备的NSS信号线。（选择从设备进行通信）

2.主设备发送时钟信号，从设备接收时钟信号。（告诉从设备开始进行SPI通讯）

3.数据交换

        主设备(Master)将要发送的数据传输到发送缓存区(Menory)，当从设备收到主设备发送的时钟信号，并且在MOSI引脚上出现第一个数据位时，发送过程开始。余下的位被装进移位寄存器，通过MOSI信号线将字节一位一位的发送给从设备。同时主设备通过MISO引脚将数据一位一位的接收到移位寄存器，当数据接收完成时，将数据传输到接收缓冲区。

        从设备同理，将自己发送缓冲区的数据通过移位寄存器和MISO一位一位发送给主设备，同时通过MOSI引脚将数据一位一位的接收到移位寄存器，当数据接收完成时，将数据传输到接收缓冲区 

        SPI只有主模式和从模式之分，没有读和写的说法，数据的写操作和读操作是同步完成的。

                      i.如果只进行写操作，主机只需忽略接收到的字节。           

                      ii.如果只进行读操作，只需发送一个空字节来获取SPI通讯的一个字节。

四、SPI工作模式

1.时钟极性（CPOL）

        控制在没有数据传输时时钟线的空闲状态电平。       

  • 0：SCK在空闲状态保持低电平。

  • 1：SCK在空闲状态保持高电平。

2.时钟相位（CPHA）

        时钟线在第几个时钟边沿采样数据。

  • 0：SCK的第一个（奇数）边沿进行数据位采样，数据在第一个时钟边沿被锁存。

  • 1：SCK的第二个（偶数）边沿进行数据位采样，数据在第二个时钟边沿被锁存。

3.SPI模式时序图

        模式0（常用）（CPOL = 0，CPHA = 0）

             空闲时SCK时钟为低电平，采样时刻为第一个边沿即上升沿。如图所示，黄线进行采样

         模式1（CPOL = 0，CPHA = 1）

             空闲时SCK时钟为低电平，采样时刻为第二个边沿即下降沿。如图所示，黄线进行采样。

         模式2（CPOL = 1，CPHA = 0）

             空闲时SCK时钟为高电平，采样时刻为第一个边沿即下降沿。如图所示，黄线进行采样。

        模式3（常用）（CPOL = 1，CPHA = 1）

            空闲时SCK时钟为高电平，采样时刻为第二个边沿即上升沿。如图所示，黄线进行采样。

五、SPI相关寄存器介绍

六、SPI用到的结构体与函数

1.结构体

（句柄结构体）SPI_HandleTypeDef

  1. typedef struct __SPI_HandleTypeDef
  2. {
  3.   SPI_TypeDef  *Instance;  /* SPIx */
  4.  
  5.   SPI_InitTypeDef  Init;  /* SPI初始化结构体：通信参数 */
  6.  
  7. } SPI_HandleTypeDef;

（初始化结构体）SPI_InitTypeDefSPI

  1. typedef struct
  2. {
  3.   uint32_t Mode;  /* SPI模式（主机模式。从机模式） */
  4.  
  5.   uint32_t Direction;  /* 工作方式（全双工方式、半双工、只读、只写） */
  6.  
  7.   uint32_t DataSize;  /* 数据格式（8bit、16bit） */
  8.  
  9.   uint32_t CLKPolarity;  /* 时钟极性（CPOL） */
  10.  
  11.   uint32_t CLKPhase;  /* 时钟相位（CPHA） */
  12.  
  13.   uint32_t NSS;  /* SS控制方式（软件） */
  14.  
  15.   uint32_t BaudRatePrescaler;  /* SPI波特率预分频值 */
  16.  
  17.   uint32_t FirstBit;  /* 数据传输顺序（MSB、LSB） */
  18.  
  19.   uint32_t TIMode;  /* 数据帧格式（Motorola、TI）*/
  20.  
  21.   uint32_t CRCCalculation;  /* 设置硬件CRC检验 */
  22.  
  23.   uint32_t CRCPolynomial;  /* 设置CRC检验多项式 */
  24.  
  25. } SPI_InitTypeDef;

2.函数

__HAL_RCC_SPI1_CLK_ENABLE()

使能SPI时钟。（使用STM32CubeMX会自动配置）

HAL_SPI_Init()

初始化SPI。（使用STM32CubeMX会自动配置）

HAL_SPI_MspInit()

初始化SPI相关引脚。（使用STM32CubeMX会自动配置）

HAL_SPI_Transmit()  （SPI发送数据）

原型：
HAL_StatusTypeDef HAL_SPI_Transmit(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout)

参数：
SPI_HandleTypeDef *hspi：SPI句柄
uint8_t *pData：发送数据的存储地址
uint16_t Size：发送的数据量大小
uint32_t Timeout：超时时间

实例：
uint8_t uint8_t data = 56;

HAL_SPI_TransmitReceive(&hspi1, &data, 1, 1000)；

HAL_SPI_Receive()  （SPI接收数据）

原型：
HAL_StatusTypeDef HAL_SPI_Receive(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout)

参数：
SPI_HandleTypeDef *hspi：SPI句柄
uint8_t *pData：接收数据的存储地址
uint16_t Size：接收的数据量大小
uint32_t Timeout：超时时间

实例：
uint8_t uint8_t data;

HAL_SPI_TransmitReceive(&hspi1, &data, 1, 1000);

HAL_SPI_TransmitReceive()  （SPI发送接收数据）

原型：
HAL_StatusTypeDef HAL_SPI_TransmitReceive(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size,uint32_t Timeout)

参数：
SPI_HandleTypeDef *hspi：SPI句柄
uint8_t *pTxData：发送数据的存储地址
uint8_t *pRxData：接收数据的存储地址
uint16_t Size：发送和接收的数据量大小
uint32_t Timeout：超时时间

实例：
uint8_t spi1_read_write_byte(uint8_t data)
{
uint8_t rec_data = 0;

HAL_SPI_TransmitReceive(&hspi1, &data, &rec_data, 1, 1000);

return rec_data;
}

__HAL_SPI_ENABLE()   （使能SPI外设）

__HAL_SPI_DISABLE()    （失能SPI外设）

七、W25Q128芯片

1.W25Q128介绍

  • W25Q128是华邦公司推出的一款SPI接口的NOR FIash芯片，其存储空间为128 Mbit，相当于16M字节。

  • Flash 是常用的用于储存数据的半导体器件，它具有容量大，可重复擦写、按”扇区/块”擦除、掉电后数据可继续保存的特性。

  • Flash 是有一个物理特性：只能写0，不能写1，靠擦除来写1。

  • 支持SPI模式1。

  • 数据格式：8bit，MSB。

2.W25Q128存储架构

  • 一个W25Q128 = 256个块 = 256 * 16个扇区 = 256 * 16 *16个页 = 256 * 16 * 16 * 256个字节，即16777216字节，约16M字节，即寻址范围为0x00 ~ 0xFFFFFF。

  • 16777216 -1 = 0xFFFFFF。

  • 对Flash擦除时一般按扇区（4K = 4096字节）来进行擦除。

3.W25Q128常用指令

        W25Q128 全部指令非常多，但常用的如下几个指令：

1.写使能（0x06）

  • 写使能指令将状态寄存器中的WEL位设置为1。

  • 必须在每个页写、扇区擦除、块擦除、芯片擦除和写状态寄存器指令之前进行写使能。

  • 操作：拉低CS片选->发送指令0x06 ->拉高CS片选。

2.读SR1（0x05）

  • 读取状态寄存器指令允许读取8位状态寄存器的值。

  • 操作：拉低CS片选 ->发送指令0x05 ->定义一个uint8_t数据接收SR1的返回值 ->拉高CS片选 

3.读数据（0x03）

  • 读取数据指令允许从存储器顺序读取一个或多个数据字节。

  • 操作：拉低CS片选 -> 发送指令0x03 -> 发送24位地址 -> 读取数据 -> 拉高CS片选

4.页写（0x02）

  • 页写指令允许在指定地址写入小于256字节的指定长度的数据，在非0xFF处写入的数据会失败。

  • 操作：写使能 -> 拉低CS片选 -> 发送指令0x02 -> 发送24位地址 -> 写入数据 -> 拉高CS片选 -> 等待写入结束（即判断状态寄存器的BUSY位是否置0

5.扇区擦除时序（0x20）

        写入数据前，检查内存空间是否全部都是 0XFF ，不满足需擦除。

        拉低CS片选 → 发送20H→ 发送24位地址 → 拉高CS片选

6.芯片擦除（0xC7）

  • 芯片擦除指令将W25Q128的所有数据都擦除为0xFF。

  • 操作：写使能 -> 等待空闲（即判断状态寄存器的BUSY位是否置0） -> 拉低CS片选 -> 发送指令0xC7 -> 拉高CS片选 -> 等待芯片擦除完成（即判断状态寄存器的BUSY位是否置0）

7.读取W25Q128的芯片ID（0x90）

  • 读取制造商/设备ID指令。

  • 操作：拉低片选信号 -> 发送24位地址，地址为0xFFFFFF -> 定义一个uint16_t数据接收芯片ID -> 拉高片选信号

4.W25Q128状态寄存器

        W25Q128一共有3个状态寄存器，它们的作用时跟踪芯片的状态。其中，状态寄存器1比较常用。

         1.BUSY位（指示当前的状态）        

        BUSY是状态寄存器中的只读位，当设备执行页程序、四页程序、扇区擦除、块擦除、芯片擦除、写状态寄存器或擦除/程序安全寄存器指令时，将其设置为1状态。 在此期间，器件将忽略除读取状态寄存器和擦除/程序挂起指令之外的其他指令。 当编程、擦除或写入状态/安全寄存器指令完成时，忙位将被清除为0状态，表示设备已准备好接受进一步的指令。

0：空闲

1：忙
        2.WEL位（写使能锁定）

        WEL是状态寄存器(S1)中的只读位，在执行写使能指令后被设置为1。 当设备被禁止写入时，WEL状态位被清除为0。 在上电时或在下列任何指令之后发生写禁用状态：写禁用、页程序、四页程序、扇区擦除、块擦除、芯片擦除、写状态寄存器、擦除安全寄存器和程序安全寄存器。

1：可以操作页、扇区、块

0：禁止写入
 

5.W25Q128常见操作流程

写操作：

八、实验（使用SPI通讯读写W25Q128模块）

1.接线

        W25Q128与STM32F103C8T6板子接线，在STM32F103C8T6的产品手册中找到板子上的SPI1的接口。

        PA4作为SPI1的NSS，PA5作为SPI1的CLK，PA6作为SPI1的DO（MISO），PA7作为SPI1的DI（MOSI）。

2.配置

        1.SYS

        2. RCC

 

         3.SPI1

         4.SUART1

          5.使用MicroLIB库

3.代码

1.main.c文件

  1. /* USER CODE BEGIN Header */
  2. /**
  3.   ******************************************************************************
  4.   * @file           : main.c
  5.   * @brief          : Main program body
  6.   ******************************************************************************
  7.   * @attention
  8.   *
  9.   * Copyright (c) 2023 STMicroelectronics.
  10.   * All rights reserved.
  11.   *
  12.   * This software is licensed under terms that can be found in the LICENSE file
  13.   * in the root directory of this software component.
  14.   * If no LICENSE file comes with this software, it is provided AS-IS.
  15.   *
  16.   ******************************************************************************
  17.   */
  18. /* USER CODE END Header */
  19. /* Includes ------------------------------------------------------------------*/
  20. #include "main.h"
  21. #include "spi.h"
  22. #include "usart.h"
  23. #include "gpio.h"
  24.  
  25. /* Private includes ----------------------------------------------------------*/
  26. /* USER CODE BEGIN Includes */
  27.  
  28. #include "stdio.h"
  29. #include "string.h"
  30. #include "w25q128.h"
  31.  
  32. /* USER CODE END Includes */
  33.  
  34. /* Private typedef -----------------------------------------------------------*/
  35. /* USER CODE BEGIN PTD */
  36.  
  37. /* USER CODE END PTD */
  38.  
  39. /* Private define ------------------------------------------------------------*/
  40. /* USER CODE BEGIN PD */
  41.  
  42. #define TEXT_SIZE 16
  43. #define  FLASH_WriteAddress     0x000000  //数据写入w25q128的地址，地址范围为0x000000 ~ 0xFFFFFF
  44. #define  FLASH_ReadAddress      FLASH_WriteAddress
  45.  
  46. /* USER CODE END PD */
  47.  
  48. /* Private macro -------------------------------------------------------------*/
  49. /* USER CODE BEGIN PM */
  50.  
  51. /* USER CODE END PM */
  52.  
  53. /* Private variables ---------------------------------------------------------*/
  54.  
  55. /* USER CODE BEGIN PV */
  56.  
  57. /* USER CODE END PV */
  58.  
  59. /* Private function prototypes -----------------------------------------------*/
  60. void SystemClock_Config(void);
  61. /* USER CODE BEGIN PFP */
  62.  
  63. /* USER CODE END PFP */
  64.  
  65. /* Private user code ---------------------------------------------------------*/
  66. /* USER CODE BEGIN 0 */
  67.  
  68.  
  69. //重写stdio.h文件中的prinft()里的fputc()函数
  70. int fputc(int my_data,FILE *p)
  71. {
  72.     unsigned char temp = my_data;
  73.     //改写后，使用printf()函数会将数据通过串口一发送出去
  74.     HAL_UART_Transmit(&huart1,&temp,1,0xffff);  //0xfffff为最大超时时间
  75.     return my_data;
  76. }
  77.  
  78.  
  79. /* USER CODE END 0 */
  80.  
  81. /**
  82.   * @brief  The application entry point.
  83.   * @retval int
  84.   */
  85. int main(void)
  86. {
  87.   /* USER CODE BEGIN 1 */
  88.  
  89.     uint8_t datatemp[TEXT_SIZE];
  90.     
  91.   /* USER CODE END 1 */
  92.  
  93.   /* MCU Configuration--------------------------------------------------------*/
  94.  
  95.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  96.   HAL_Init();
  97.  
  98.   /* USER CODE BEGIN Init */
  99.  
  100.   /* USER CODE END Init */
  101.  
  102.   /* Configure the system clock */
  103.   SystemClock_Config();
  104.  
  105.   /* USER CODE BEGIN SysInit */
  106.  
  107.   /* USER CODE END SysInit */
  108.  
  109.   /* Initialize all configured peripherals */
  110.   MX_GPIO_Init();
  111.   MX_USART1_UART_Init();
  112.   MX_SPI1_Init();
  113.   /* USER CODE BEGIN 2 */
  114.  
  115.     /* w25q128初始化 */
  116.     w25q128_init();
  117.     
  118.     /* 写入测试数据 */
  119.     sprintf((char *)datatemp, "hello jiangxiao");
  120.     w25q128_write(datatemp, FLASH_WriteAddress, TEXT_SIZE);
  121.     printf("数据写入完成！\r\n");
  122.     
  123.     /* 读出测试数据 */
  124.     memset(datatemp, 0, TEXT_SIZE);
  125.     w25q128_read(datatemp, FLASH_ReadAddress, TEXT_SIZE);
  126.     printf("读出数据：%s\r\n", datatemp);
  127.  
  128.   /* USER CODE END 2 */
  129.  
  130.   /* Infinite loop */
  131.   /* USER CODE BEGIN WHILE */
  132.   while (1)
  133.   {
  134.     /* USER CODE END WHILE */
  135.  
  136.     /* USER CODE BEGIN 3 */
  137.   }
  138.   /* USER CODE END 3 */
  139. }
  140.  
  141. /**
  142.   * @brief System Clock Configuration
  143.   * @retval None
  144.   */
  145. void SystemClock_Config(void)
  146. {
  147.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  148.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  149.  
  150.   /** Initializes the RCC Oscillators according to the specified parameters
  151.   * in the RCC_OscInitTypeDef structure.
  152.   */
  153.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  154.   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  155.   RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  156.   RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  157.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  158.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  159.   RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  160.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  161.   {
  162.     Error_Handler();
  163.   }
  164.  
  165.   /** Initializes the CPU, AHB and APB buses clocks
  166.   */
  167.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
  168.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  169.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  170.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  171.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  172.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
  173.  
  174.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  175.   {
  176.     Error_Handler();
  177.   }
  178. }
  179.  
  180. /* USER CODE BEGIN 4 */
  181.  
  182. /* USER CODE END 4 */
  183.  
  184. /**
  185.   * @brief  This function is executed in case of error occurrence.
  186.   * @retval None
  187.   */
  188. void Error_Handler(void)
  189. {
  190.   /* USER CODE BEGIN Error_Handler_Debug */
  191.   /* User can add his own implementation to report the HAL error return state */
  192.   __disable_irq();
  193.   while (1)
  194.   {
  195.   }
  196.   /* USER CODE END Error_Handler_Debug */
  197. }
  198.  
  199. #ifdef  USE_FULL_ASSERT
  200. /**
  201.   * @brief  Reports the name of the source file and the source line number
  202.   *         where the assert_param error has occurred.
  203.   * @param  file: pointer to the source file name
  204.   * @param  line: assert_param error line source number
  205.   * @retval None
  206.   */
  207. void assert_failed(uint8_t *file, uint32_t line)
  208. {
  209.   /* USER CODE BEGIN 6 */
  210.   /* User can add his own implementation to report the file name and line number,
  211.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  212.   /* USER CODE END 6 */
  213. }
  214. #endif /* USE_FULL_ASSERT */

2.w25q128.c文件（向工程添加w25q128.c文件）

  1. #include "w25q128.h"
  2. #include "spi.h"
  3. #include "stdio.h"
  4.  
  5.  
  6.  
  7. //w25q128初始化
  8. void w25q128_init(void)
  9. {
  10. 		uint16_t flash_type;
  11.     spi1_read_write_byte(0xFF); /* 清除DR（数据寄存器）,写入一个0xFF */
  12.     W25Q128_CS(1);  //拉高片选信号不进行SPI通信
  13. 		flash_type = w25q128_read_id();   /* 读取FLASH ID. */
  14. 		if (flash_type == W25Q128){
  15. 			printf("检测到W25Q128芯片\r\n");
  16. 		}
  17. }
  18.  
  19.  
  20.  
  21. //等待W25Q128空闲
  22. static void w25q128_wait_busy(void)
  23. {
  24.     while ((w25q128_rd_sr1() & 0x01) == 1);   /* 等待状态寄存器的BUSY位清空 */
  25. }
  26.  
  27.  
  28.  
  29. //读取状态寄存器的值
  30. uint8_t w25q128_rd_sr1(void)
  31. {
  32.     uint8_t rec_data = 0;
  33.     
  34.     W25Q128_CS(0);
  35. 		spi1_read_write_byte(FLASH_ReadStatusReg1);     // 写入指令0x05：读状态寄存器1
  36.     rec_data = spi1_read_write_byte(0xFF);  //获取状态寄存器1的值
  37.     W25Q128_CS(1);
  38.     
  39.     return rec_data;
  40. }
  41.  
  42.  
  43.  
  44. //W25Q128写使能,即置位WEL为1
  45. void w25q128_write_enable(void)
  46. {
  47.     W25Q128_CS(0);
  48.     spi1_read_write_byte(FLASH_WriteEnable);   /* 发送指令0x06：写使能 */
  49.     W25Q128_CS(1);
  50. }
  51.  
  52.  
  53.  
  54. //发送24位地址
  55. static void w25q128_send_address(uint32_t address)  /*address：地址范围0~16777215字节，即寻址范围为0x00 ~ 0xFFFFFF */
  56. {
  57.     spi1_read_write_byte((uint8_t)((address)>>16));     /* 发送 bit23 ~ bit16 地址 */
  58.     spi1_read_write_byte((uint8_t)((address)>>8));      /* 发送 bit15 ~ bit8  地址 */
  59.     spi1_read_write_byte((uint8_t)address);             /* 发送 bit7  ~ bit0  地址 */
  60. }
  61.  
  62.  
  63.  
  64. //擦除整个芯片
  65. void w25q128_erase_chip(void)
  66. {
  67.     w25q128_write_enable();    /* 写使能 */
  68.     w25q128_wait_busy();       /* 等待空闲 */
  69.     W25Q128_CS(0);
  70.     spi1_read_write_byte(FLASH_ChipErase);  /* 发送指令0xC7：擦除整个芯片 */ 
  71.     W25Q128_CS(1);
  72.     w25q128_wait_busy();       /* 等待芯片擦除结束 */
  73. }
  74.  
  75.  
  76.  
  77. //擦除一个扇区
  78. void w25q128_erase_sector(uint32_t saddr)  /* saddr：该参数是第几个扇区 */
  79. {
  80.     saddr *= 4096;  /* 一个扇区大小为4096字节 */
  81.     w25q128_write_enable();        /* 写使能 */
  82.     w25q128_wait_busy();           /* 等待空闲 */
  83.     W25Q128_CS(0);
  84.     spi1_read_write_byte(FLASH_SectorErase);    /* 发送指令0x20：擦除指定扇区 */
  85.     w25q128_send_address(saddr);   /* 发送擦除的扇区地址 */
  86.     W25Q128_CS(1);
  87.     w25q128_wait_busy();           /* 等待扇区擦除完成 */
  88. }
  89.  
  90.  
  91.  
  92. //读取w25q128芯片ID
  93. uint16_t w25q128_read_id(void)
  94. {
  95.     uint16_t deviceid;
  96.  
  97.     W25Q128_CS(0);  //拉低片选信号进行SPI通信
  98.     spi1_read_write_byte(FLASH_ManufactDeviceID);   /* 发送读取 ID 命令 */
  99. 		/* 发送3个0 */
  100. 		/*
  101.     spi1_read_write_byte(0);    
  102.     spi1_read_write_byte(0);
  103.     spi1_read_write_byte(0);
  104. 		*/
  105. 	
  106. 		w25q128_send_address(0x000000);
  107. 	
  108.     deviceid = spi1_read_write_byte(0xFF) << 8;     /* 读取高8位字节 */
  109.     deviceid |= spi1_read_write_byte(0xFF);         /* 读取低8位字节 */
  110.     W25Q128_CS(1);
  111.  
  112.     return deviceid;
  113. }
  114.  
  115. /*
  116. 读取W25Q128的FLASH，在指定地址开始读取指定长度的数据
  117. pubf：需要读取的数据
  118. addr：指定的地址
  119. datalen：指定的数据大小
  120. */
  121. void w25q128_read(uint8_t *pbuf, uint32_t addr, uint16_t datalen)
  122. {
  123.     uint16_t i;
  124.  
  125.     W25Q128_CS(0);
  126.     spi1_read_write_byte(FLASH_ReadData);       /* 发送指令0x03：读取数据 */
  127.     w25q128_send_address(addr);                /* 发送需要读取的数据地址 */
  128.     
  129.     for(i=0;i<datalen;i++)
  130.     {
  131.         pbuf[i] = spi1_read_write_byte(0XFF);   /* 循环读取 */
  132.     }
  133.     
  134.     W25Q128_CS(1);
  135. }
  136.  
  137.  
  138.  
  139. /*
  140. 单页写，在指定地址写入小于256字节的指定长度的数据，在非0xFF处写入的数据会失败
  141. pubf：需要写入的数据
  142. addr：指定的地址
  143. datalen：指定的数据大小
  144. */
  145. static void w25q128_write_page(uint8_t *pbuf, uint32_t addr, uint16_t datalen)
  146. {
  147.     uint16_t i;
  148.  
  149.     w25q128_write_enable();    /* 写使能 */
  150.  
  151.     W25Q128_CS(0);
  152.     spi1_read_write_byte(FLASH_PageProgram);    /* 发送命令0x02：页写 */
  153.     w25q128_send_address(addr);                /* 发送写入的页地址 */
  154.  
  155.     for(i=0;i<datalen;i++)
  156.     {
  157.         spi1_read_write_byte(pbuf[i]);          /* 循环写入 */
  158.     }
  159.     
  160.     W25Q128_CS(1);
  161.     w25q128_wait_busy();       /* 等待写入结束 */
  162. }
  163.  
  164.  
  165.  
  166. /*
  167. 多页写，在指定地址写入指定长度的数据，在非0xFF处写入的数据会失败
  168. pubf：需要写入的数据
  169. addr：指定的地址
  170. datalen：指定的数据大小
  171. */
  172. static void w25q128_write_nocheck(uint8_t *pbuf, uint32_t addr, uint16_t datalen)
  173. {
  174.     uint16_t pageremain;
  175.     pageremain = 256 - addr % 256;  /* 获取指定地址那页的剩余字节数 */
  176.  
  177.     if (datalen <= pageremain)      /* 指定地址那页的剩余字节数能装下指定数据大小 */
  178.     {
  179.         pageremain = datalen;  
  180.     }
  181.  
  182.     while (1)
  183.     { 
  184. 			/* 当指定地址那页的剩余字节数能装下指定数据大小时,一次性写完 */
  185.             
  186. 			/* 当指定数据大小比指定地址那页的剩余字节数要大时, 先写完指定地址那页的剩余字节, 然后根据剩余数据大小进行不同处理 */
  187.         w25q128_write_page(pbuf, addr, pageremain);  //页写
  188.  
  189.         if (datalen == pageremain)   /* 写入结束了 */
  190.         {
  191.             break;  
  192.         }
  193.         else     /* datalen > pageremain */
  194.         {
  195.             pbuf += pageremain;         /* pbuf指针地址偏移,前面已经写了pageremain字节 */
  196.             addr += pageremain;         /* 写地址偏移,前面已经写了pageremain字节 */
  197.             datalen -= pageremain;      /* 写入总长度减去已经写入了的字节数 */
  198.  
  199.             if (datalen > 256)          /* 剩余数据大小还大于一页 */
  200.             {
  201.                 pageremain= 256;       /* 一次写入256个字节，即一次写一页 */
  202.             }
  203.             else     /* 剩余数据大小小于一页  */
  204.             {
  205.                 pageremain= datalen;   /* 一次性写完 */
  206.             }
  207.         }
  208.     }
  209. }
  210.  
  211.  
  212. /*
  213. //写入W25Q128的FLASH，在指定地址开写入取指定长度的数据
  214. pubf：需要写入的数据
  215. addr：指定的地址
  216. datalen：指定的数据大小
  217. */
  218. uint8_t g_w25q128_buf[4096];   /* 扇区缓存 */
  219.  
  220. void w25q128_write(uint8_t *pbuf, uint32_t addr, uint16_t datalen)
  221. {
  222.     uint32_t secpos;
  223.     uint16_t secoff;
  224.     uint16_t secremain;
  225.     uint16_t i;
  226.     uint8_t *w25q128_buf;
  227.  
  228.     w25q128_buf = g_w25q128_buf;
  229.     secpos = addr / 4096;       /* 获取指定地址在哪片扇区 */
  230.     secoff = addr % 4096;       /* 指定数据在在扇区内的偏移数据大小 */
  231.     secremain = 4096 - secoff;  /* 扇区剩余字节数 */
  232.  
  233.     if (datalen <= secremain)  /* 指定地址那片扇区的剩余字节数能装下指定数据大小 */
  234.     {
  235.         secremain = datalen;    
  236.     }
  237.  
  238.     while (1)
  239.     {
  240.         w25q128_read(w25q128_buf, secpos * 4096, 4096);   /* 读出指定地址那片扇区的全部内容 */
  241.  
  242.         for (i = 0; i < secremain; i++)   /* 校验数据，防止数据出现非0xFF */
  243.         {
  244.             if (w25q128_buf[secoff + i] != 0xFF)  //扇区数据有一个数据不是0xFF
  245.             {
  246.                 break;      /* 需要擦除, 直接退出for循环 */
  247.             }
  248.         }
  249.  
  250.         if (i < secremain)   /* 需要擦除 */
  251.         {
  252.             w25q128_erase_sector(secpos);  /* 擦除这个扇区 */
  253.  
  254.             for (i = 0; i < secremain; i++)   /* 复制 */
  255.             {
  256.                 w25q128_buf[i + secoff] = pbuf[i];
  257.             }
  258.  
  259.             w25q128_write_nocheck(w25q128_buf, secpos * 4096, 4096);  /* 写入整个扇区 */
  260.         }
  261.         else        /* 写已经擦除了的,直接写入扇区剩余区间. */
  262.         {
  263.             w25q128_write_nocheck(pbuf, addr, secremain);  /* 直接写扇区 */
  264.         }
  265.  
  266.         if (datalen == secremain)
  267.         {
  268.             break;  /* 写入结束了 */
  269.         }
  270.         else        /* 写入未结束 */
  271.         {
  272.             secpos++;               /* 扇区地址增1，新的一个扇区 */
  273.             secoff = 0;             /* 偏移位置为0 */
  274.  
  275.             pbuf += secremain;      /* 指针偏移 */
  276.             addr += secremain;      /* 写地址偏移 */
  277.             datalen -= secremain;   /* 字节数递减 */
  278.  
  279.             if (datalen > 4096)
  280.             {
  281.                 secremain = 4096;   /* 一次写入一个扇区 */
  282.             }
  283.             else
  284.             {
  285.                 secremain = datalen;/* 一次性写完 */
  286.             }
  287.         }
  288.     }
  289. }

3.w25q128.h文件（向工程添加w25q128.h文件）

  1. #include "stdint.h"
  2.  
  3. /* W25Q128片选引脚定义 */
  4. #define W25Q128_CS_GPIO_PORT           GPIOA
  5. #define W25Q128_CS_GPIO_PIN            GPIO_PIN_4
  6.  
  7. /* W25Q128片选信号 */
  8. #define W25Q128_CS(x)      do{ x ? \
  9.                                   HAL_GPIO_WritePin(W25Q128_CS_GPIO_PORT, W25Q128_CS_GPIO_PIN, GPIO_PIN_SET) : \
  10.                                   HAL_GPIO_WritePin(W25Q128_CS_GPIO_PORT, W25Q128_CS_GPIO_PIN, GPIO_PIN_RESET); \
  11.                             }while(0)
  12.  
  13. /* FLASH芯片列表 */
  14. #define W25Q128     0XEF17          /* W25Q128  芯片ID */
  15.  
  16. /* 指令表 */
  17. #define FLASH_WriteEnable                        0x06 
  18. #define FLASH_ReadStatusReg1                0x05 
  19. #define FLASH_ReadData                            0x03 
  20. #define FLASH_PageProgram                        0x02 
  21. #define FLASH_SectorErase                        0x20 
  22. #define FLASH_ChipErase                            0xC7 
  23. #define FLASH_ManufactDeviceID            0x90 
  24.  
  25. /* 静态函数 */
  26. static void w25q128_wait_busy(void);                                                                                                //等待W25Q128空闲       
  27. static void w25q128_send_address(uint32_t address);                                                                      //发送24位地址
  28. static void w25q128_write_page(uint8_t *pbuf, uint32_t addr, uint16_t datalen);         //单页写，在指定地址写入小于256字节的指定长度的数据，在非0xFF处写入的数据会失败
  29. static void w25q128_write_nocheck(uint8_t *pbuf, uint32_t addr, uint16_t datalen);        //多页写，在指定地址写入指定长度的数据，在非0xFF处写入的数据会失败
  30.  
  31. /* 普通函数 */
  32. void w25q128_init(void);                            //w25q128初始化  
  33. uint16_t w25q128_read_id(void);       //读取w25q128芯片ID   
  34. void w25q128_write_enable(void);      //W25Q128写使能,即置位WEL为1    
  35. uint8_t w25q128_rd_sr1(void);                 //读取状态寄存器的值        
  36.  
  37. void w25q128_erase_chip(void);               //擦除整个芯片      
  38. void w25q128_erase_sector(uint32_t saddr);   //擦除一个扇区
  39. void w25q128_read(uint8_t *pbuf, uint32_t addr, uint16_t datalen);     //读取W25Q128的FLASH，在指定地址开始读取指定长度的数据
  40. void w25q128_write(uint8_t *pbuf, uint32_t addr, uint16_t datalen);    //写入W25Q128的FLASH，在指定地址开写入取指定长度的数据
  41.  
  42.  
  43.

4.spi.c文件编写

  1. /* USER CODE BEGIN Header */
  2. /**
  3.   ******************************************************************************
  4.   * @file    spi.c
  5.   * @brief   This file provides code for the configuration
  6.   *          of the SPI instances.
  7.   ******************************************************************************
  8.   * @attention
  9.   *
  10.   * Copyright (c) 2023 STMicroelectronics.
  11.   * All rights reserved.
  12.   *
  13.   * This software is licensed under terms that can be found in the LICENSE file
  14.   * in the root directory of this software component.
  15.   * If no LICENSE file comes with this software, it is provided AS-IS.
  16.   *
  17.   ******************************************************************************
  18.   */
  19. /* USER CODE END Header */
  20. /* Includes ------------------------------------------------------------------*/
  21. #include "spi.h"
  22.  
  23. /* USER CODE BEGIN 0 */
  24.  
  25. /* USER CODE END 0 */
  26.  
  27. SPI_HandleTypeDef hspi1;  /* SPI句柄 */
  28.  
  29. /* SPI1 init function */
  30. void MX_SPI1_Init(void)
  31. {
  32.  
  33.   /* USER CODE BEGIN SPI1_Init 0 */
  34.  
  35.   /* USER CODE END SPI1_Init 0 */
  36.  
  37.   /* USER CODE BEGIN SPI1_Init 1 */
  38.  
  39.   /* USER CODE END SPI1_Init 1 */
  40.   hspi1.Instance = SPI1;
  41.   hspi1.Init.Mode = SPI_MODE_MASTER;  /* 设置SPI模式主机模式 */
  42.   hspi1.Init.Direction = SPI_DIRECTION_2LINES;  /* 设置SPI工作方式：全双工 */
  43.   hspi1.Init.DataSize = SPI_DATASIZE_8BIT;  /* 设置数据格式：8bit */
  44.     
  45.     /* SPI模式1 */
  46.   hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;  /* 设置时钟极性：CPOL = 0 */
  47.   hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;  /* 设置时钟相位：CPHA = 1 */
  48.   
  49.     hspi1.Init.NSS = SPI_NSS_SOFT;  /* 设置片选方式：软件NSS */
  50.   hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;  /* 设置SPI时钟波特率分频：256分频 */
  51.   hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;  /* 设置数据大小端：MSB */
  52.   hspi1.Init.TIMode = SPI_TIMODE_DISABLE;  /* 设置数据帧格式：Motolora */
  53.   hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;  /* 设置CRC校验：关闭CRC检验 */
  54.   hspi1.Init.CRCPolynomial = 10;  /* 设置CRC校验多项式：1~65535 */
  55.   if (HAL_SPI_Init(&hspi1) != HAL_OK)
  56.   {
  57.     Error_Handler();
  58.   }
  59.   /* USER CODE BEGIN SPI1_Init 2 */
  60.  
  61.   /* USER CODE END SPI1_Init 2 */
  62.  
  63. }
  64.  
  65. void HAL_SPI_MspInit(SPI_HandleTypeDef* spiHandle)
  66. {
  67.  
  68.   GPIO_InitTypeDef GPIO_InitStruct = {0};
  69.   if(spiHandle->Instance==SPI1)
  70.   {
  71.   /* USER CODE BEGIN SPI1_MspInit 0 */
  72.  
  73.   /* USER CODE END SPI1_MspInit 0 */
  74.     /* SPI1 clock enable */
  75.     __HAL_RCC_SPI1_CLK_ENABLE();
  76.  
  77.     __HAL_RCC_GPIOA_CLK_ENABLE();
  78.     /**SPI1 GPIO Configuration
  79.     PA5     ------> SPI1_SCK
  80.     PA6     ------> SPI1_MISO
  81.     PA7     ------> SPI1_MOSI
  82.     */
  83.     GPIO_InitStruct.Pin = GPIO_PIN_5|GPIO_PIN_7;
  84.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  85.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  86.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  87.  
  88.     GPIO_InitStruct.Pin = GPIO_PIN_6;
  89.     GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  90.     GPIO_InitStruct.Pull = GPIO_NOPULL;
  91.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  92.  
  93.   /* USER CODE BEGIN SPI1_MspInit 1 */
  94.  
  95.   /* USER CODE END SPI1_MspInit 1 */
  96.   }
  97. }
  98.  
  99. void HAL_SPI_MspDeInit(SPI_HandleTypeDef* spiHandle)
  100. {
  101.  
  102.   if(spiHandle->Instance==SPI1)
  103.   {
  104.   /* USER CODE BEGIN SPI1_MspDeInit 0 */
  105.  
  106.   /* USER CODE END SPI1_MspDeInit 0 */
  107.     /* Peripheral clock disable */
  108.     __HAL_RCC_SPI1_CLK_DISABLE();
  109.  
  110.     /**SPI1 GPIO Configuration
  111.     PA5     ------> SPI1_SCK
  112.     PA6     ------> SPI1_MISO
  113.     PA7     ------> SPI1_MOSI
  114.     */
  115.     HAL_GPIO_DeInit(GPIOA, GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7);
  116.  
  117.   /* USER CODE BEGIN SPI1_MspDeInit 1 */
  118.  
  119.   /* USER CODE END SPI1_MspDeInit 1 */
  120.   }
  121. }
  122.  
  123. /* USER CODE BEGIN 1 */
  124.  
  125. /*通过SPI1同时读写一个字节数据
  126. 主机只向从机进行写操作，调用此函数时忽略返回值
  127. 主机只向从机进行读操作，调用此函数时随便传入一个字符，尽量是0xFF
  128. */
  129. uint8_t spi1_read_write_byte(uint8_t data)  
  130. {
  131.     uint8_t rec_data = 0;
  132.     
  133.     HAL_SPI_TransmitReceive(&hspi1, &data, &rec_data, 1, 1000);  //spi读写数据函数，参数2存放用来发送的数据，参数3存放用来接收的数据
  134.    
  135.     return rec_data;  
  136. }
  137.  
  138. /* USER CODE END 1 */

5.spi.h文件编写

  1. /* USER CODE BEGIN Header */
  2. /**
  3.   ******************************************************************************
  4.   * @file    spi.h
  5.   * @brief   This file contains all the function prototypes for
  6.   *          the spi.c file
  7.   ******************************************************************************
  8.   * @attention
  9.   *
  10.   * Copyright (c) 2023 STMicroelectronics.
  11.   * All rights reserved.
  12.   *
  13.   * This software is licensed under terms that can be found in the LICENSE file
  14.   * in the root directory of this software component.
  15.   * If no LICENSE file comes with this software, it is provided AS-IS.
  16.   *
  17.   ******************************************************************************
  18.   */
  19. /* USER CODE END Header */
  20. /* Define to prevent recursive inclusion -------------------------------------*/
  21. #ifndef __SPI_H__
  22. #define __SPI_H__
  23.  
  24. #ifdef __cplusplus
  25. extern "C" {
  26. #endif
  27.  
  28. /* Includes ------------------------------------------------------------------*/
  29. #include "main.h"
  30.  
  31. /* USER CODE BEGIN Includes */
  32.  
  33. /* USER CODE END Includes */
  34.  
  35. extern SPI_HandleTypeDef hspi1;
  36.  
  37. /* USER CODE BEGIN Private defines */
  38.  
  39. /* USER CODE END Private defines */
  40.  
  41. void MX_SPI1_Init(void);
  42.  
  43. /* USER CODE BEGIN Prototypes */
  44.  
  45. uint8_t spi1_read_write_byte(uint8_t data);
  46.  
  47. /* USER CODE END Prototypes */
  48.  
  49. #ifdef __cplusplus
  50. }
  51. #endif
  52.  
  53. #endif /* __SPI_H__ */

九、STM32工程添加.c和.h文件

        1.在创建好的STM32工程中找到Core的文件夹

         2.向文件夹里添加新的xxx.c文件或xxx.h文件

        3.在keil5中导入工程后，将这两个文件添加到工程列表中

 

        4.添加头文件

        只需在需要添加头文件的c文件中写上需添加的头文件再编译就能自动添加

        例如下图

 

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

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

  

闽ICP备14008679号