STM32HAL库-SPI驱动兼容类比芯片

BSP_LPSPI：软件与硬件SPI驱动切换及类比芯片接口实现,
原创 已于 2025-08-12 00:56:05 修改 · 686 阅读 · 11 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#stm32 #嵌入式硬件 #单片机 #学习

于 2024-01-23 16:29:26 首次发布

前言

  • bsp_lpspi 兼容软件模拟io驱动，32硬件SPI驱动，兼容类比芯片IC驱动。
  • 类比半导体为一家模拟及数模混合芯片和解决方案供应商，公司成立于2018年，由一批来自于国际顶尖半导体公司的本土工程师创建。公司总部位于上海，在上海张江、临港、苏州、深圳、西安、北京分别设有研发和技术支持中心。公司专注于信号链、电源管理、MCU/DSP等领域的芯片设计，产品主要面向工业、通讯、医疗、汽车等市场。类比核心使命是为客户提供高品质芯片，为世界科技化和智能化提供最底层的芯片支持。

一、代码

在这里插入图片描述
通过修改bsp_lpspi.h，宏定义切换软件硬件SPI.

1.bsp_lpspi.c

代码如下（示例）：

#include "bsp_lpspi.h"

#ifdef HardWare_SPI          //Begin of hard_spi
SPI_HandleTypeDef SpiHandle;
void Spi_delay(uint32_t count)
{ 
    volatile uint32_t i = 0;
    for (i = 0; i < count; ++i)
    {
        __asm("NOP"); /* 调用nop空指令 */
         __asm("NOP"); /* 调用nop空指令 */
          __asm("NOP"); /* 调用nop空指令 */
           __asm("NOP"); /* 调用nop空指令 */
            __asm("NOP"); /* 调用nop空指令 */
    }
}
void LPSPI_Init(void)
{
    
    GPIO_InitTypeDef  GPIO_InitStruct;
    /* Enable SPI1 clock */
    SPIx_CLK_ENABLE();
    SPIx_SCK_GPIO_CLK_ENABLE();
    SPIx_MISO_GPIO_CLK_ENABLE();
    SPIx_MOSI_GPIO_CLK_ENABLE();
    SPIx_CS_GPIO_CLK_ENABLE();
    
    /* 初始化GPIO 配置*/
    /*##-1- Configure peripheral GPIO ##########################################*/
    /* SPI SCK GPIO pin configuration  */
    GPIO_InitStruct.Pin       = SPIx_SCK_PIN;
    GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    //GPIO_InitStruct.Pull      = GPIO_PULLDOWN;
    GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    //GPIO_InitStruct.Alternate = SPIx_SCK_AF;
    HAL_GPIO_Init(SPIx_SCK_GPIO_PORT, &GPIO_InitStruct);

    /* SPI MISO GPIO pin configuration  */
    GPIO_InitStruct.Pin = SPIx_MISO_PIN;
	GPIO_InitStruct.Mode      = GPIO_MODE_INPUT;
	GPIO_InitStruct.Pull = GPIO_PULLUP;
    //GPIO_InitStruct.Alternate = SPIx_MISO_AF;
    HAL_GPIO_Init(SPIx_MISO_GPIO_PORT, &GPIO_InitStruct);

    /* SPI MOSI GPIO pin configuration  */
    GPIO_InitStruct.Pin = SPIx_MOSI_PIN;
	GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    //GPIO_InitStruct.Alternate = SPIx_MOSI_AF;
    HAL_GPIO_Init(SPIx_MOSI_GPIO_PORT, &GPIO_InitStruct);
    
   /* SPI CS GPIO pin configuration  */
    GPIO_InitStruct.Pin   = SPIx_CS_PIN;
    GPIO_InitStruct.Mode  = GPIO_MODE_OUTPUT_PP;
    //GPIO_InitStruct.Pull  = GPIO_PULLDOWN;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(SPIx_CS_GPIO_PORT, &GPIO_InitStruct);
    
      /* 初始化SPI 配置*/
     /*##-2- Configure the SPI peripheral #######################################*/
    /* Set the SPI parameters */
    SpiHandle.Instance               = SPIx;
    SpiHandle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
    SpiHandle.Init.Direction         = SPI_DIRECTION_2LINES;
    SpiHandle.Init.CLKPhase          = SPI_PHASE_2EDGE ;
    SpiHandle.Init.CLKPolarity       = SPI_POLARITY_LOW;
    SpiHandle.Init.DataSize          = SPI_DATASIZE_8BIT;
    SpiHandle.Init.FirstBit          = SPI_FIRSTBIT_MSB;
    SpiHandle.Init.TIMode            = SPI_TIMODE_DISABLE;
    SpiHandle.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE;
    SpiHandle.Init.CRCPolynomial     = 7;
    SpiHandle.Init.NSS               = SPI_NSS_SOFT;
    SpiHandle.Init.Mode              = SPI_MODE_MASTER;
    //初始化SPI
    HAL_SPI_Init(&SpiHandle);
	__HAL_SPI_ENABLE(&SpiHandle);
    //默认拉高CS引脚
    HAL_GPIO_WritePin(SPIx_CS_GPIO_PORT,SPIx_CS_PIN,GPIO_PIN_SET);
	
}
void Lpspi_Start(void)
{
	HAL_GPIO_WritePin(SPIx_CS_GPIO_PORT,SPIx_CS_PIN,GPIO_PIN_RESET);
}
void Lpspi_Stop(void)
{
	HAL_GPIO_WritePin(SPIx_CS_GPIO_PORT,SPIx_CS_PIN,GPIO_PIN_SET);
}
void Lpspi_Write(uint8_t datasize,uint8_t *data)
{
  
  //写数据
  HAL_GPIO_WritePin(SPIx_CS_GPIO_PORT,SPIx_CS_PIN,GPIO_PIN_RESET);
  HAL_SPI_Transmit(&SpiHandle,data, datasize, 5000);
  Spi_delay(30);
  HAL_GPIO_WritePin(SPIx_CS_GPIO_PORT,SPIx_CS_PIN,GPIO_PIN_SET);
}
void Lpspi_Read(uint8_t datasize,uint8_t *data,uint8_t *Rxdata)
{
//  读写数据
  HAL_GPIO_WritePin(SPIx_CS_GPIO_PORT,SPIx_CS_PIN,GPIO_PIN_RESET);
  HAL_SPI_TransmitReceive(&SpiHandle,data,Rxdata, datasize, 5000);
  Spi_delay(30);
  HAL_GPIO_WritePin(SPIx_CS_GPIO_PORT,SPIx_CS_PIN,GPIO_PIN_SET);
}
#endif    //end of hard_spi

#ifdef Soft_SPI  //begin of soft_spi
SPI_HandleTypeDef SpiHandle;
void Spi_delay(uint32_t count)
{ 
    volatile uint32_t i = 0;
    for (i = 0; i < count; ++i)
    {
        __asm("NOP"); /* 调用nop空指令 */
         __asm("NOP"); /* 调用nop空指令 */
          __asm("NOP"); /* 调用nop空指令 */
           __asm("NOP"); /* 调用nop空指令 */
            __asm("NOP"); /* 调用nop空指令 */
    }
}
void LPSPI_Init(void)
{
    
    GPIO_InitTypeDef  GPIO_InitStruct;
    /* Enable SPI1 clock */
    //SPIx_CLK_ENABLE();
    SPIx_SCK_GPIO_CLK_ENABLE();
    SPIx_MISO_GPIO_CLK_ENABLE();
    SPIx_MOSI_GPIO_CLK_ENABLE();
    SPIx_CS_GPIO_CLK_ENABLE();
    
    /* 初始化GPIO 配置*/
    /*##-1- Configure peripheral GPIO ##########################################*/
    /* SPI SCK GPIO pin configuration  */
    GPIO_InitStruct.Pin       = SPIx_SCK_PIN;
    GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_PP;
    //GPIO_InitStruct.Pull      = GPIO_PULLDOWN;
    GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    //GPIO_InitStruct.Alternate = SPIx_SCK_AF;
    HAL_GPIO_Init(SPIx_SCK_GPIO_PORT, &GPIO_InitStruct);

    /* SPI MISO GPIO pin configuration  */
    GPIO_InitStruct.Pin = SPIx_MISO_PIN;
	GPIO_InitStruct.Mode      = GPIO_MODE_INPUT;
	GPIO_InitStruct.Pull = GPIO_PULLUP;
    //GPIO_InitStruct.Alternate = SPIx_MISO_AF;
    HAL_GPIO_Init(SPIx_MISO_GPIO_PORT, &GPIO_InitStruct);

    /* SPI MOSI GPIO pin configuration  */
    GPIO_InitStruct.Pin = SPIx_MOSI_PIN;
	GPIO_InitStruct.Mode      = GPIO_MODE_OUTPUT_PP;
    //GPIO_InitStruct.Alternate = SPIx_MOSI_AF;
    HAL_GPIO_Init(SPIx_MOSI_GPIO_PORT, &GPIO_InitStruct);
    
   /* SPI CS GPIO pin configuration  */
    GPIO_InitStruct.Pin   = SPIx_CS_PIN;
    GPIO_InitStruct.Mode  = GPIO_MODE_OUTPUT_PP;
    //GPIO_InitStruct.Pull  = GPIO_PULLDOWN;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(SPIx_CS_GPIO_PORT, &GPIO_InitStruct);
  
    //默认拉高CS引脚
    HAL_GPIO_WritePin(SPIx_CS_GPIO_PORT,SPIx_CS_PIN,GPIO_PIN_SET);
	//SCLK空闲拉低
	HAL_GPIO_WritePin(SPIx_SCK_GPIO_PORT,SPIx_SCK_PIN,GPIO_PIN_RESET);
	//SCLK空闲拉高
	//HAL_GPIO_WritePin(SPIx_SCK_GPIO_PORT,SPIx_SCK_PIN,GPIO_PIN_SET);
	
}
void Lpspi_Start(void)
{
	HAL_GPIO_WritePin(SPIx_CS_GPIO_PORT,SPIx_CS_PIN,GPIO_PIN_RESET);
}
void Lpspi_Stop(void)
{
	HAL_GPIO_WritePin(SPIx_CS_GPIO_PORT,SPIx_CS_PIN,GPIO_PIN_SET);
}
void SCLK_H(void)
{
	HAL_GPIO_WritePin(SPIx_SCK_GPIO_PORT,SPIx_SCK_PIN,GPIO_PIN_SET);
}
void SCLK_L(void)
{
	HAL_GPIO_WritePin(SPIx_SCK_GPIO_PORT,SPIx_SCK_PIN,GPIO_PIN_RESET);
}
void SPI_Transmit_Data_mode0(uint8_t *Data ,uint8_t Size)      //SCLK low  first edge
{
	uint8_t i,a=0,data=0;
	for(a=0;a<Size;a++)
	{
		data = Data[a];
		for(i = 0;i < 8;i++)
		{
			SCLK_L();
			if(data&(0x80))//data bit = 1
			{
				HAL_GPIO_WritePin(SPIx_MOSI_GPIO_PORT,SPIx_MOSI_PIN,GPIO_PIN_SET);//MOSI SET 1
			}
			else
			{
				HAL_GPIO_WritePin(SPIx_MOSI_GPIO_PORT,SPIx_MOSI_PIN,GPIO_PIN_RESET);//MOSI SET 0
			}
			SCLK_H();
			data <<=1;
		}
	}
}
void SPI_Receive_Data_mode0( uint8_t *Data,uint8_t *Rxdata ,uint8_t Size)   //SCLK low  first edge
{
	uint8_t i,a,data,rxdata;
	for(a=0;a<Size;a++)
	{
		data = Data[a];
		Rxdata[a]=0;
		for(i = 0;i < 8;i++)
		{
			SCLK_L();
			if(data&(0x80))//data bit = 1
			{
				HAL_GPIO_WritePin(SPIx_MOSI_GPIO_PORT,SPIx_MOSI_PIN,GPIO_PIN_SET);//MOSI SET 1
			}
			else
			{
				HAL_GPIO_WritePin(SPIx_MOSI_GPIO_PORT,SPIx_MOSI_PIN,GPIO_PIN_RESET);//MOSI SET 0
			}
			if(HAL_GPIO_ReadPin(SPIx_MISO_GPIO_PORT,SPIx_MISO_PIN)==1)
			{
				Rxdata[a]|=(0x80 >>i);
			}
			SCLK_H();
			data <<=1;
		}
	}
}
void SPI_Transmit_Data_mode1(uint8_t *Data ,uint8_t Size)   //SCLK low  second edge
{
	uint8_t i,a=0,data=0;
	for(a=0;a<Size;a++)
	{
		data = Data[a];
		for(i = 0;i < 8;i++)
		{
			SCLK_H();
			if(data&(0x80))//data bit = 1
			{
				HAL_GPIO_WritePin(SPIx_MOSI_GPIO_PORT,SPIx_MOSI_PIN,GPIO_PIN_SET);//MOSI SET 1
			}
			else
			{
				HAL_GPIO_WritePin(SPIx_MOSI_GPIO_PORT,SPIx_MOSI_PIN,GPIO_PIN_RESET);//MOSI SET 0
			}
			data <<=1;
			SCLK_L();
		}
	}
}
void SPI_Receive_Data_mode1( uint8_t *Data,uint8_t *Rxdata ,uint8_t Size)   //SCLK low  second edge
{
	uint8_t i,a,data,rxdata;
	
	for(a=0;a<Size;a++)
	{
		data = Data[a];
		Rxdata[a]=0;
		for(i = 0;i < 8;i++)
		{
			SCLK_H();
			if(data&(0x80))//data bit = 1
			{
				HAL_GPIO_WritePin(SPIx_MOSI_GPIO_PORT,SPIx_MOSI_PIN,GPIO_PIN_SET);//MOSI SET 1
			}
			else
			{
				HAL_GPIO_WritePin(SPIx_MOSI_GPIO_PORT,SPIx_MOSI_PIN,GPIO_PIN_RESET);//MOSI SET 0
			}
			data <<=1;
 			SCLK_L();
			if(HAL_GPIO_ReadPin(SPIx_MISO_GPIO_PORT,SPIx_MISO_PIN)==1)
			{
				Rxdata[a]|=(0x80 >>i);
			}
		}
	}
}
void SPI_Transmit_Data_mode2(uint8_t *Data ,uint8_t Size)            //SCLK high  first edge
{
	uint8_t i,a=0,data=0;
	for(a=0;a<Size;a++)
	{
		data = Data[a];
		for(i = 0;i < 8;i++)
		{
			SCLK_H();
			//Spi_delay(1);
			if(data&(0x80))//data bit = 1
			{
				HAL_GPIO_WritePin(SPIx_MOSI_GPIO_PORT,SPIx_MOSI_PIN,GPIO_PIN_SET);//MOSI SET 1
			}
			else
			{
				HAL_GPIO_WritePin(SPIx_MOSI_GPIO_PORT,SPIx_MOSI_PIN,GPIO_PIN_RESET);//MOSI SET 0
			}
			//Spi_delay(1);
			SCLK_L();
			//Spi_delay(1);
			data <<=1;
			SCLK_H();
			//Spi_delay(1);
		}
	}
}
void SPI_Receive_Data_mode2( uint8_t *Data,uint8_t *Rxdata ,uint8_t Size)   //SCLK low  first edge
{
	uint8_t i,a,data,rxdata;
	for(a=0;a<Size;a++)
	{
		data = Data[a];
		Rxdata[a]=0;
		for(i = 0;i < 8;i++)
		{
			SCLK_H();
			//Spi_delay(1);
			if(data&(0x80))//data bit = 1
			{
				HAL_GPIO_WritePin(SPIx_MOSI_GPIO_PORT,SPIx_MOSI_PIN,GPIO_PIN_SET);//MOSI SET 1
			}
			else
			{
				HAL_GPIO_WritePin(SPIx_MOSI_GPIO_PORT,SPIx_MOSI_PIN,GPIO_PIN_RESET);//MOSI SET 0
			}
 			SCLK_L();
			if(HAL_GPIO_ReadPin(SPIx_MISO_GPIO_PORT,SPIx_MISO_PIN)==1)
			{
				Rxdata[a]|=(0x80 >>i);
			}
			data <<=1;
			SCLK_H();
		}			
	}
}
void SPI_Transmit_Data_mode3(uint8_t *Data ,uint8_t Size)     //SCLK high  second edge
{
	uint8_t i,a=0,data=0;
	for(a=0;a<Size;a++)
	{
		data = Data[a];
		for(i = 0;i < 8;i++)
		{
			SCLK_L();
			if(data&(0x80))//data bit = 1
			{
				HAL_GPIO_WritePin(SPIx_MOSI_GPIO_PORT,SPIx_MOSI_PIN,GPIO_PIN_SET);//MOSI SET 1
			}
			else
			{
				HAL_GPIO_WritePin(SPIx_MOSI_GPIO_PORT,SPIx_MOSI_PIN,GPIO_PIN_RESET);//MOSI SET 0
			}
			data <<=1;
			SCLK_H();
		}
	}
}
void SPI_Receive_Data_mode3( uint8_t *Data,uint8_t *Rxdata ,uint8_t Size)   //SCLK low  second edge
{
	uint8_t i,a,data,rxdata;
	for(a=0;a<Size;a++)
	{
		data = Data[a];
		Rxdata[a]=0;
		for(i = 0;i < 8;i++)
		{
			SCLK_L();
			if(data&(0x80))//data bit = 1
			{
				HAL_GPIO_WritePin(SPIx_MOSI_GPIO_PORT,SPIx_MOSI_PIN,GPIO_PIN_SET);//MOSI SET 1
			}
			else
			{
				HAL_GPIO_WritePin(SPIx_MOSI_GPIO_PORT,SPIx_MOSI_PIN,GPIO_PIN_RESET);//MOSI SET 0
			}
			data <<=1;
 			SCLK_H();
			if(HAL_GPIO_ReadPin(SPIx_MISO_GPIO_PORT,SPIx_MISO_PIN)==1)
			{
				Rxdata[a]|=(0x80 >>i);
			}
		}
	}
}
void Lpspi_Write(uint8_t datasize,uint8_t *data)
{
  //写数据
  Lpspi_Start();
  SPI_Transmit_Data_mode1(data,datasize);
  Spi_delay(30);
  Lpspi_Stop();
}
void Lpspi_Read(uint8_t datasize,uint8_t *data,uint8_t *Rxdata)
{
//  读写数据
  Lpspi_Start();
  SPI_Receive_Data_mode1( data,Rxdata ,datasize);
  Spi_delay(30);
  Lpspi_Stop();
}

#endif //end of soft_spi

2.bsp_lpspi.h

代码如下（示例）：

/*
  analogysemi
  xutong 2023/10/19
*/
#ifndef __BSP_LPSPI_H
#define __BSP_LPSPI_H

//#include "stm32h7xx_hal.h"
//#include "stm32g0xx_hal.h"
#include "stm32f1xx.h"


//#define HardWare_SPI
#define Soft_SPI

#define SPIx                             SPI1
#define SPIx_CLK_ENABLE()                __HAL_RCC_SPI1_CLK_ENABLE()
#define SPIx_SCK_GPIO_CLK_ENABLE()       __HAL_RCC_GPIOA_CLK_ENABLE()
#define SPIx_MISO_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
#define SPIx_MOSI_GPIO_CLK_ENABLE()      __HAL_RCC_GPIOA_CLK_ENABLE()
 
#define SPIx_CS_GPIO_CLK_ENABLE()        __HAL_RCC_GPIOA_CLK_ENABLE()
/* Definition for SPIx Pins */
#define SPIx_SCK_PIN                     GPIO_PIN_5
#define SPIx_SCK_GPIO_PORT               GPIOA
#define SPIx_SCK_AF                      GPIO_AF5_SPI1
#define SPIx_MISO_PIN                    GPIO_PIN_6
#define SPIx_MISO_GPIO_PORT              GPIOA
#define SPIx_MISO_AF                     GPIO_AF5_SPI1
#define SPIx_MOSI_PIN                    GPIO_PIN_7
#define SPIx_MOSI_GPIO_PORT              GPIOA
#define SPIx_MOSI_AF                     GPIO_AF5_SPI1

#define SPIx_CS_PIN                      GPIO_PIN_4
#define SPIx_CS_GPIO_PORT                GPIOA



void Spi_delay(uint32_t count);
void LPSPI_Init(void);
void Lpspi_Start(void);
void Lpspi_Stop(void);
void Lpspi_Write(uint8_t datasize,uint8_t *data);
void Lpspi_Read(uint8_t datasize,uint8_t *data,uint8_t *Rxdata);
void SCLK_H(void);
void SCLK_L(void);
void SPI_Receive_Data( uint8_t *Data,uint8_t *Rxdata ,uint8_t Size);
void SPI_Transmit_Data(uint8_t *Data ,uint8_t Size);
#endif /* __BSP_LPSPI_H */

总结

类比芯片 bsp_lpspi 兼容 软件控制io驱动,硬件驱动，通过修改头文件宏定义切换硬件软件驱动

【STM32 CubeMX】SPI HAL库编程
m0_62599305的博客
02-17 3068
STM32 CubeMX 是一款由 STMicroelectronics 提供的图形化配置工具，用于生成 STM32 微控制器的初始化代码和项目框架。在 STM32 开发中，使用 CubeMX 可以大大简化初始化过程，并帮助开发者快速构建应用程序。其中，SPI（串行外设接口）是一种常用的通信协议，它在连接外部设备时非常有用。本文将介绍如何使用 CubeMX 结合 SPI HAL 库进行 STM32 SPI 的初始化和编程。
FPGA学习笔记（九）SPI学习总结及stm32的HAL库下SPI配置
贾saisai的博客
12-06 3515
一、FPGA学习笔记（一）入门背景、软件及时钟约束二、FPGA学习笔记（二）Verilog语法初步学习(语法篇1)三、FPGA学习笔记（三） 流水灯入门FPGA设计流程四、FPGA学习笔记（四）通过数码管学习顶层模块和例化的编写五、FPGA学习笔记（五）Testbench（测试平台）文件编写进行Modelsim仿真六、FPGA学习笔记（六）Modelsim单独仿真和Quartus联合仿真七、FPGA学习笔记（七）verilog的深入学习之任务与函数（语法篇3）八、FPGA学习笔记（八）同步/异步信号的打拍分
STM32LL库使用——SPI通信
junfoot的博客
04-20 1万+
我们使用的芯片为STM32G431RBT6 查阅其参考手册得到SPI相关寄存器： 相关代码 static int spi_transmit_receive(uint16_t data_in, uint16_t *data_out, uint32_t timeout_ms){ int state = 0; *data_out = 0; uint32_t timeout_cnt; static const uint32_t timeout_cnt_num = 10000; /* W..
STM32——hal_SPI_(介绍)
qq_59527512的博客
06-05 2384
SPI（串行外围设备接口）是一种高速的、全双工、同步的通信协议，通常用于短距离通信，尤其是在嵌入式系统中与各种外围设备进行通信。SPI接口由摩托罗拉公司推出，由于其简单和灵活的特性，它被广泛用于多种应用中，包括传感器、显示屏、存储器等。
SPI的HAL库配置
qq_44386182的博客
09-13 252
【经典案例】使用HAL库配置STM32F407的SPI外设
gygkhd的博客
06-07 2134
本文详细介绍了如何使用STM32CubeMX和HAL库配置STM32F407的SPI外设，并提供了一个简单的发送和接收数据的示例。通过这些步骤，开发者可以快速上手使用STM32F407的SPI功能，实现各种SPI通信应用。
STM32HAL库下SPI驱动与类比芯片兼容性实现
资源摘要信息: "STM32HAL库-SPI驱动兼容类比芯片" 知识点1：STM32微控制器简介 STM32是一系列基于ARM Cortex-M处理器的32位微控制器，由STMicroelectronics（意法半导体）生产。STM32系列微控制器广泛应用于嵌入式...
STM32之CubeL4（一）---HAL详解与CubeMX使用（GPIO + EXIT示例）
热门推荐
流云
08-30 1万+
一、HAL库与STD库对比 之前使用STM32系列芯片都是基于STD（Standard Peripheral Libraries）标准外设库，标准外设库将相关寄存器以结构体的形式组织起来，使用库函数操作外设有点轻度面向对象编程的感觉，比寄存器操作方便不少。但在不同芯片上使用标准外设库开发的程序可移植性比较差，换个芯片常需要重新做大量的开发工作，为了解决这个问题，ST推出了全新的HAL（Hardwa...
类比半导体驱动程序基本SPI驱动
03-21
STM32的SPI驱动使用HAL库或LL库，开发者可以灵活配置SPI引脚复用、中断优先级、数据帧格式等。STM32的SPI支持硬件CRC校验，增强了数据传输的可靠性。通过HAL_SPI_Transmit/Receive函数，可以实现主设备的数据发送和...
【STM32 HAL库中的数据传输秘技】：避免数据粘包现象的三大法则
本文针对STM32 HAL库中的数据传输问题，介绍了数据传输的基础知识、核心问题及避免粘包的三大法则，并展示了具体的实现方法。同时，文中还探讨了数据传输的进阶应用，包括多缓冲机制、RTOS环境下的数据传输以及低...
HAL库版本，硬件SPI驱动74HC595
06-30
HAL库版本，硬件SPI驱动74HC595,函数斜的很清楚，已经实现
STM32F1x HAL库学习笔记（12）硬件 SPI 的配置
白杨木屋
01-29 3949
本文开发环境： MCU型号：STM32F103C8T6 IDE环境： MDK 5.27 代码生成工具：STM32CubeMx 5.6.1 HAL库版本：STM32Cube_FW_F1_V1.8.3 本文内容： STM32CubeMx 配置 硬件 SPI 主机 文章目录一、硬件 SPI 的使用二、SPI 的配置1. CubeMx 配置基础配置SPI 配置生成工程三. HAL 库中 SPI 的 API 函数四、其他 一、硬件 SPI 的使用 SPI 比 I2C 速度更快，通常可以设置为9M或1.
【STM32】HAL库中的实现（九）：SPI（串行外设接口）
最新发布
猫猫的小茶馆
08-21 2237
SPI（Serial Peripheral Interface）是一种全双工主从通信协议，采用4线制（SCK时钟、MOSI主发从收、MISO主收从发、CS片选），支持多从机连接。W25Qxx系列SPI Flash存储器（如W25Q64）具有大容量、长寿命特性。本文通过STM32 HAL库实现了SPI驱动W25Qxx的完整方案。
仅需一个 HAL 库函数：轻松实现 STM32 的 SPI 编程（以 Flash 25Q128 为例）
jmlinux的博客
02-22 3177
 主要介绍如何用HAL_SPI_TransmitReceive()函数实现对W25Q128 Flash存储器ID的读取。先介绍SPI是一种高速且简单的同步串行接口技术，由四根线(（MOSI、MISO、SCLK和SS/CS）)组成。接着介绍Flash ,它是串行闪存芯片，能提供更大存储容量。还提到STM32 HAL库简化了SPI编程，以正点原子精英V2开发板为例，给出开发环境及函数原型和参数。最后展示读取ID的代码示例，通过发送命令、接收数据并判断状态来获取ID。 
HAL库实现SPI读写FLASH（W25Q32）
何物爱惜雨的博客
03-18 1728
SPI，Flash相关知识点，HAL库实现SPI读写FLASH（W25Q32）
HAL库STM32常用外设教程（八）—— SPI （读写W25Q128）
That_Assassin的博客
03-28 1万+
串行外设接口（Serial Peripheral Interface,SPI）是一种传输速率比较高的串行接口，一些ADC芯片、Flash存储器芯片采用SPI接口，MCU通过SPI接口与这些外围器件通信。通过本文讲解了SPI通信，其中涉及了SPI的原理、HAL库的相关驱动函数，其中涉及了SPI轮询、中断、DMA三种方式。然后又通过Flash芯片W25Q128作为示例来讲解SPI通信，讲解了W25Q128的部分指令，轮询方式读写W25Q128，其中涉及的SPI的CubeMx配置应当熟悉掌握。
【STM32L496】使用HAL库实现SPI写入/读取数据（AD5421）
kiro_1023的博客
09-09 4985
通过AD5421实现SPI通信
STM32·HAL库开发（十七）SPI通信——案例：W25Q128读写
ZZQ的博客
09-04 752
STM32开发之SPI通信：案例：SPI读写W25Q128存储芯片
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

咕咕鸟bird

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值