【STM32】HAL库 SPI DMA UART驱动开发

最新推荐文章于 2025-11-06 14:59:24 发布
原创 最新推荐文章于 2025-11-06 14:59:24 发布 · 2.3k 阅读 · 12 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文分享了一名嵌入式开发者在换岗后面对STM32底层开发的挑战与学习历程，详细介绍了UART、DMA、SPI等外设的初始化配置与使用，以及在新项目中遇到的六轴传感器难题。

零、瞎BB一些

最近真的是.....过得...些许艰难...

从实习到正式入职，在公司的项目组待了3个月左右了，同事、项目、代码、逻辑、架构都熟悉了，毕业后入职1个月的时间里，能给项目组改了几个bug，能接小小的需求写代码，测试，联调，上线功能，正在自我感觉良好一切都渐渐适应，每天干活也开心得飞起的时候，leader通知我换部门....

来了新部门，一切都变了，项目不一样，代码的架构完全变了，之前项目组的代码庞大，是基于rtos的消息通知机制的架构，所以我直接关注到业务逻辑；而新的项目组的代码，没上rtos，是个逻辑代码，业务代码就是HAL库的代码，很底层，就是使用HAL库的spi、dma、tim、usart等等驱动直接些业务代码，而这些我都掌握的不太好，这太底层了。新项目中还用到的六轴传感器，这也是一个大坑，我的新导师都说这个东西很难，我看了几天六轴的相关资料、文档、驱动算法、正点原子的开源飞行器的书籍和代码，真的是...一头雾水....

新部门的人....也不熟悉，我自己又是孤僻的一批.... 感觉也没人爱搭理我...

不过，唯一的好处就是：这些又带来了新的挑战！之前的项目组我惊叹于FreeRTOS系统的魅力，系统架构在RTOS上样子，基于消息通知机制的实时任务系统是这样的结构，并且业务代码也相当的复杂。而现在的项目，更接近底层，我正好能学一学嵌入式的基础，STM32底层的驱动开发，这些太基础了，是一个学生在校期间就英爱学会了，而我是来了公司才接触嵌入式，底层的也就大概的看了看就去看项目代码了，项目代码中将底层的驱动层层封装，根本就没机会看到底层接口，上层接口的业务逻辑就够喝一壶了。

这次这个机会，正好！

 

STM32就是学习各类基础知识，原理啊，通讯协议啊之类的。

各种外设初始化也是走那个流程：使能时钟、配置句柄(xxx_HandleTpyeDef)、配置硬件底层相关（HAL_xxx_MspInit），用HAL库函数初始化句柄（其实就是讲配置好的内容写进寄存器，因为HAL库本来就是对寄存器的上层的封装）。

这里多加一个HAL_xxx_MspDeInit，项目代码里很多DeInit函数，其实就是【失能】掉一个外设的函数，因为初始化的函数相当于要用一个外设就要使能，等不用的时候就要失能。

各类外设要先掌握各原理，什么通信协议，那些总线（原理图）

比如SPI：通讯时就使用3条总线和一条片选信号线：SCK MOSI MISO NSS

UART的话比较简单：就是TX RX 两条通信时的引脚

DMA的话，有很多通道，要去芯片手册中看DMA的哪个通道能连接哪个外设，叫【DMA请求映像表】，DMA没什么引脚要配置，使用时就注意结构体的成员的配置：什么传输方向之类，最后配置完用__HAL_LINKDMA() 将dma句柄和外设句柄连接起来，啧啧啧多形象的函数命令，多好理解。

 

感觉之前学STM走了些弯路，一直用标准外设库去写，没早点用一下HAL库，对HAL库的不熟悉，让我到了新项目组一直学习学习看书看书，没有参与项目。而且师兄说标准外设库都快淘汰了...

代码也粘一下，毕竟都是自己手把手敲的，虽然....都是野火的教程里的代码。

一、UART

#ifndef BSP_USART_H
#define BSP_USART_H
​
#include "stm32f1xx.h"
#include <stdio.h>
​
//串口波特率
#define DEBUG_USART_BAUDRATE                    115200
​
//引脚定义
/*******************************************************/
#define DEBUG_USART                             USART1
#define DEBUG_USART_CLK_ENABLE()                __HAL_RCC_USART1_CLK_ENABLE()
​
#define DEBUG_USART_RX_GPIO_PORT                GPIOA
#define DEBUG_USART_RX_GPIO_CLK_ENABLE()        __HAL_RCC_GPIOA_CLK_ENABLE()
#define DEBUG_USART_RX_PIN                      GPIO_PIN_10
​
#define DEBUG_USART_TX_GPIO_PORT                GPIOA
#define DEBUG_USART_TX_GPIO_CLK_ENABLE()       __HAL_RCC_GPIOA_CLK_ENABLE()
#define DEBUG_USART_TX_PIN                      GPIO_PIN_9
​
#define DEBUG_USART_IRQHandler                  USART1_IRQHandler
#define DEBUG_USART_IRQ                         USART1_IRQn
​
​
void Usart_SendString(uint8_t *str);
void DEBUG_USART_Config(void);
int fputc(int ch, FILE *f);
int fgetc(FILE *f);
extern UART_HandleTypeDef UartHandle;
​
#endif
#include "bsp_usart.h"
​
//                 UartHandle管理串口所有配置
UART_HandleTypeDef UartHandle;
​
//配置与硬件底层无关内容：如串口协议，其中包括波特率，奇偶校验，停止位
void DEBUG_USART_Config()
{
    UartHandle.Instance = DEBUG_USART;
    
    //波特率，8位字长，1停止位，无奇偶校验，无硬件控制，收发模式
    UartHandle.Init.BaudRate = DEBUG_USART_BAUDRATE;
    UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
    UartHandle.Init.StopBits = UART_STOPBITS_1;//stm32f1xx_hal_uart.h
    UartHandle.Init.Parity = UART_PARITY_NONE;
    UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    UartHandle.Init.Mode = UART_MODE_TX_RX;
    
    HAL_UART_Init(&UartHandle);
    
    //使能串口接收中断
    __HAL_UART_ENABLE_IT(&UartHandle,UART_IT_RXNE);  
}
​
​
// mcu 底层硬件相关的配置如引脚、时钟、DMA、中断
//实际被HAL_UART_Init（stm32f1xx_hal_uart.c）该函数调用
void HAL_UART_MspInit(UART_HandleTypeDef *huart)
{
    GPIO_InitTypeDef GPIO_Init;
    
    //串口时钟 GPIO时钟
    DEBUG_USART_CLK_ENABLE();
    DEBUG_USART_RX_GPIO_CLK_ENABLE();
    DEBUG_USART_TX_GPIO_CLK_ENABLE();
    
    //配置引脚复用功能 TX 
    GPIO_Init.Pin = DEBUG_USART_TX_PIN;
    GPIO_Init.Mode = GPIO_MODE_AF_PP;
    GPIO_Init.Pull = GPIO_PULLUP;
    GPIO_Init.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(DEBUG_USART_TX_GPIO_PORT, &GPIO_Init);
    
    //配置Rx
    GPIO_Init.Pin = DEBUG_USART_RX_PIN;
    GPIO_Init.Mode = GPIO_MODE_AF_INPUT;//复用输入模式
    HAL_GPIO_Init(DEBUG_USART_RX_GPIO_PORT, &GPIO_Init); 
    
    HAL_NVIC_SetPriority(DEBUG_USART_IRQ ,0,1); //抢占优先级0，子优先级1
    HAL_NVIC_EnableIRQ(DEBUG_USART_IRQ );           //使能USART1中断通道 
    
}
​
/*****************  发送字符串 **********************/
/*  HAL_UART_Transmit 函数（这是一个阻塞的发送函数，无需重复判断串口是否发送完成）
    发送每个字符，直到遇到
    空字符才停止发送。*/
void Usart_SendString(uint8_t *str)
{
    unsigned int k=0;
  do 
  {
      HAL_UART_Transmit(&UartHandle,(uint8_t *)(str + k) ,1,1000);
      k++;
  } while(*(str + k)!='\0');
  
}
//重定向c库函数printf到串口DEBUG_USART，重定向后可使用printf函数
int fputc(int ch, FILE *f)
{
    /* 发送一个字节数据到串口DEBUG_USART */
    HAL_UART_Transmit(&UartHandle, (uint8_t *)&ch, 1, 1000);    
    
    return (ch);
}
​
//重定向c库函数scanf到串口DEBUG_USART，重写向后可使用scanf、getchar等函数
int fgetc(FILE *f)
{       
    int ch;
    HAL_UART_Receive(&UartHandle, (uint8_t *)&ch, 1, 1000); 
    return (ch);
}
//stm32f1xx_it.c  
//中断函数
​
void DEBUG_USART_IRQHandler(void)
{
    uint8_t ch = 1;
    if (__HAL_UART_GET_FLAG( &UartHandle, UART_FLAG_RXNE ) != RESET) 
    {
        ch=( uint16_t)READ_REG(UartHandle.Instance->DR);
        WRITE_REG ( UartHandle.Instance->DR,ch);
    }
}

 

二、DMA

dma直接读取存储器（RAM）的内容 给 usart，uart的tx接收到dma的数据后，tx是发送端，会将数据发给电脑，上位机可看到日志输出。

#ifndef BSP_DMA_H
#define BSP_DMA_H
​
#include "stm32f1xx.h"
​
//DMA
#define SENDBUFF_SIZE                           1000//发送的数据量
#define DEBUG_USART_DMA_CLK_ENABLE()            __HAL_RCC_DMA1_CLK_ENABLE()
#define DEBUG_USART_DMA_STREAM                  DMA1_Channel4
​
​
void USART_DMA_Config(void);
​
#endif

 

#include "bsp_dma.h"
​
//DMA 读取RAM中数据后 ，发送给usart（串口接收到数据打印出来）
​
uint8_t SendBuff[SENDBUFF_SIZE];
​
DMA_HandleTypeDef  DMA_Handle;      //DMA句柄
extern UART_HandleTypeDef UartHandle; //USRT句柄（定义在bsp_usart.c中）
​
void USART_DMA_Config(void)
{
    //1.使能时钟 2.配置句柄 3.HAL库函数初始化句柄 4.连接两个句柄
    __HAL_RCC_DMA1_CLK_ENABLE();
    
    DMA_Handle.Instance = DMA1_Channel4;//通道4（再数据手册中查看DMA的通道请求映像表）
    
    DMA_Handle.Init.Direction = DMA_MEMORY_TO_PERIPH; //存储器到外设
    DMA_Handle.Init.PeriphInc = DMA_PINC_DISABLE;     //外设非增量模式
    DMA_Handle.Init.MemInc = DMA_MINC_ENABLE;         //存储器增量模式
    DMA_Handle.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;    //外设数据长度:8位
    DMA_Handle.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;       //存储器数据长度:8位
    DMA_Handle.Init.Mode = DMA_NORMAL;                            //外设普通模式
    DMA_Handle.Init.Priority = DMA_PRIORITY_MEDIUM;               //中等优先级
    
    HAL_DMA_Init(&DMA_Handle);
    
    //连接DMA句柄
    __HAL_LINKDMA(&UartHandle,hdmatx,DMA_Handle);
​
}

 

三、SPI

spi野火的教程是用来读取Flash，这部分的调试 遇到了一些问题.... 代码调不通，读取不到flash的内容.....

#ifndef BSP_SPI_H
#define BSP_SPI_H
​
#include "stm32f1xx.h"
​
//FLASH相关
#define sFLASH_ID                        0XEF4017     //W25Q64
#define SPI_FLASH_PageSize              256
#define SPI_FLASH_PerWritePageSize      256
​
#define W25X_WriteEnable              0x06 
#define W25X_WriteDisable             0x04 
#define W25X_ReadStatusReg          0x05 
#define W25X_WriteStatusReg         0x01 
#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 WIP_Flag                  0x01  /* Write In Progress (WIP) flag */
#define Dummy_Byte                0xFF
​
​
//spi1参数定义：spi号 和 GPIO等
#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_GPIOC_CLK_ENABLE()
​
//强制或解除APB2外围设备复位
#define     SPIx_FORCE_RESET()      __HAL_RCC_SPI1_FORCE_RESET()
#define     SPIx_RELEASE_RESET()    __HAL_RCC_SPI1_RELEASE_RESET()
​
//SPI1引脚宏定义 SCK MISO  MOSI NSS(CS)
#define SPIx_SCK_PIN                     GPIO_PIN_5
#define SPIx_SCK_GPIO_PORT               GPIOA
​
#define SPIx_MISO_PIN                    GPIO_PIN_6
#define SPIx_MISO_GPIO_PORT              GPIOA
​
#define SPIx_MOSI_PIN                    GPIO_PIN_7
#define SPIx_MOSI_GPIO_PORT              GPIOA
​
#define FLASH_CS_PIN                     GPIO_PIN_0              
#define FLASH_CS_GPIO_PORT               GPIOC 
​
//控制 CS(NSS)引脚输出电平的宏(配置产生起始和停止信号)
#define digitalHi(p,i)              {p->BSRR=i;}              //设置为高电平      
#define digitalLo(p,i)              {p->BSRR=(uint32_t)i << 16;}                //输出低电平
#define SPI_FLASH_CS_LOW()      digitalLo(FLASH_CS_GPIO_PORT,FLASH_CS_PIN )
#define SPI_FLASH_CS_HIGH()     digitalHi(FLASH_CS_GPIO_PORT,FLASH_CS_PIN )
​
/*等待超时时间*/
#define SPIT_FLAG_TIMEOUT         ((uint32_t)0x1000)
#define SPIT_LONG_TIMEOUT         ((uint32_t)(10 * SPIT_FLAG_TIMEOUT))
​
/*信息输出*/
#define FLASH_DEBUG_ON         1
​
#define FLASH_INFO(fmt,arg...)           printf("<<-FLASH-INFO->> "fmt"\n",##arg)
#define FLASH_ERROR(fmt,arg...)          printf("<<-FLASH-ERROR->> "fmt"\n",##arg)
#define FLASH_DEBUG(fmt,arg...)          do{\
                                          if(FLASH_DEBUG_ON)\
                                          printf("<<-FLASH-DEBUG->> [%d]"fmt"\n",__LINE__, ##arg);\
                                          }while(0)
​
/*************************************************************************************************************/
​
​
//初始化
void SPI_FLASH_Init(void);
​
//
void SPI_FLASH_SectorErase(uint32_t SectorAddr);
void SPI_FLASH_BulkErase(void);
void SPI_FLASH_PageWrite(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite);
void SPI_FLASH_BufferWrite(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite);
void SPI_FLASH_BufferRead(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead);
uint32_t SPI_FLASH_ReadID(void);
uint32_t SPI_FLASH_ReadDeviceID(void);
void SPI_FLASH_StartReadSequence(uint32_t ReadAddr);
void SPI_Flash_PowerDown(void);
void SPI_Flash_WAKEUP(void);
​
uint8_t SPI_FLASH_ReadByte(void);
uint8_t SPI_FLASH_SendByte(uint8_t byte);
uint16_t SPI_FLASH_SendHalfWord(uint16_t HalfWord);
void SPI_FLASH_WriteEnable(void);
void SPI_FLASH_WaitForWriteEnd(void);
​
#endif
#include "bsp_spi.h"
​
/*
初始化:  
    GPIO 结构体
    SPI 结构体
​
写应用接口：
    读flash 写flash 擦除...
*/
​
//SPI句柄结构体
SPI_HandleTypeDef HandleSPI;
​
static __IO uint32_t  SPITimeout = SPIT_LONG_TIMEOUT;
​
static uint16_t SPI_TIMEOUT_UserCallback(uint8_t errorCode);
​
​
​
//配置硬件资源
//初始化SPI GPIO部分引脚  GPIO 引脚模式初始化 复用功能(用户定义强函数)
void HAL_SPI_MspInit(SPI_HandleTypeDef* hspi) 
{
    GPIO_InitTypeDef  GPIO_InitStruct;
    
    //使能GPIO 和SPI 时钟
    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_GPIOC_CLK_ENABLE();
    __HAL_RCC_SPI1_CLK_ENABLE();
    
    //配置4个GPIO引脚 SCK MOSI MISO NSS
    GPIO_InitStruct.Pin       = SPIx_SCK_PIN;
    GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull      = GPIO_PULLUP;
    GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(SPIx_SCK_GPIO_PORT, &GPIO_InitStruct);
    
    GPIO_InitStruct.Pin = SPIx_MISO_PIN;
    HAL_GPIO_Init(SPIx_MISO_GPIO_PORT, &GPIO_InitStruct);
    
    GPIO_InitStruct.Pin = SPIx_MOSI_PIN;
    HAL_GPIO_Init(SPIx_MOSI_GPIO_PORT, &GPIO_InitStruct);
    
    GPIO_InitStruct.Pin = FLASH_CS_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    HAL_GPIO_Init(SPIx_MOSI_GPIO_PORT, &GPIO_InitStruct);//向寄存器写入参数（完成GPIO初始化）
    
}
​
//初始化SPI模式：
void SPI_FLASH_Init(void)
{
    HandleSPI.Instance = SPI1;
    // SPI 外设配置为主机端，双线全双工模式，数据帧长度为 8位，使用 SPI 模式 3(CLKPolarity =1，CLKPhase =1)，NSS 引脚由软件控制以及 MSB 先行模式
    HandleSPI.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
    HandleSPI.Init.Direction = SPI_DIRECTION_2LINES;
    HandleSPI.Init.CLKPhase = SPI_PHASE_2EDGE;
    HandleSPI.Init.CLKPolarity = SPI_POLARITY_HIGH;
    HandleSPI.Init.CRCPolynomial = 7;
    HandleSPI.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    HandleSPI.Init.DataSize = SPI_DATASIZE_8BIT;
    HandleSPI.Init.FirstBit = SPI_FIRSTBIT_MSB;
    HandleSPI.Init.NSS = SPI_NSS_SOFT;
    HandleSPI.Init.TIMode = SPI_TIMODE_DISABLE;
    HandleSPI.Init.Mode = SPI_MODE_MASTER;//主模式
    
    //配置写进寄存器、使能SPI
    HAL_SPI_Init(&HandleSPI);
    __HAL_SPI_ENABLE(&HandleSPI);
}
​
​
​
​
/**
  * @brief  使用SPI发送一个字节的数据
  * @param  byte：要发送的数据
  * @retval 返回接收到的数据
  */
uint8_t SPI_FLASH_SendByte(uint8_t byte)
{
    SPITimeout = SPIT_FLAG_TIMEOUT;
    
    //等待发送缓冲区为空 txe事件(Tx buff empty)
    while(RESET ==  __HAL_SPI_GET_FLAG(&HandleSPI,SPI_FLAG_TXE))
    {
        if ((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(0);
    }
    
    //写入数据寄存器，把要写入的数据写入发送缓冲区
    WRITE_REG(HandleSPI.Instance->DR,byte);
    
    SPITimeout = SPIT_FLAG_TIMEOUT;
    
    //等待接收缓冲区非空 RXNE事件(Rx buffer empty flag)
    while(RESET == __HAL_SPI_GET_FLAG(&HandleSPI,SPI_FLAG_RXNE))
    {
        if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(1);
    }
    
    //读取数据寄存区 获取接收缓冲区数据
    return READ_REG(HandleSPI.Instance->DR);
}
​
/**
  * @brief  使用SPI读取一个字节的数据
  * @param  无
  * @retval 返回接收到的数据
  */
uint8_t SPI_FLASH_ReadByte(void)
{
    return (SPI_FLASH_SendByte(Dummy_Byte));
}
​
 /**
  * @brief  读取FLASH Device ID
  * @param  无
  * @retval FLASH Device ID
  */
uint32_t SPI_FLASH_ReadDeviceID(void)
{
  uint32_t Temp = 0;
​
  /* Select the FLASH: Chip Select low */
  SPI_FLASH_CS_LOW();
​
  /* Send "RDID " instruction */
  SPI_FLASH_SendByte(W25X_DeviceID);
  printf("recv1 = %x\n",SPI_FLASH_SendByte(Dummy_Byte));
  printf("recv2 = %x\n",SPI_FLASH_SendByte(Dummy_Byte));
  printf("recv3 = %x\n",SPI_FLASH_SendByte(Dummy_Byte));
  
  /* Read a byte from the FLASH */
  Temp = SPI_FLASH_SendByte(Dummy_Byte);
    printf("recv4 = %x\n",Temp);
  /* Deselect the FLASH: Chip Select high */
  SPI_FLASH_CS_HIGH();
​
  return Temp;
}
​
/**
 * @brief 读取FLASH ID
 * @retval FLASH ID
*/
uint32_t SPI_FLASH_ReadID(void)
{
    uint32_t temp = 0,temp1 = 0,temp0 = 0,temp2 = 0;
    
    //开始通讯：CS低电平
    SPI_FLASH_CS_LOW();
    
    //发送JEDEC指令
    SPI_FLASH_SendByte(W25X_JedecDeviceID);
    
    //读取数据（结果）
    temp0 = SPI_FLASH_SendByte(Dummy_Byte);
    temp1 = SPI_FLASH_SendByte(Dummy_Byte);
    temp2 = SPI_FLASH_SendByte(Dummy_Byte);
    
    //停止通讯：CS高电平
    SPI_FLASH_CS_HIGH();
    
    //数据组合起来 返回
    temp = (temp0 << 16) | (temp1 << 8) | temp2;
    return temp;    
}
​
//发送 “写使能”给flash(之后可以对flash芯片存储矩阵写入数据)
void SPI_FLASH_WriteEnable()
{
    SPI_FLASH_CS_LOW();                     //开始通讯：CS低电平
    SPI_FLASH_SendByte(W25X_WriteEnable);   //发送xxx指令
    SPI_FLASH_CS_HIGH();                    //停止通讯：CS高电平
}
​
//WIP(busy)标志 flash内粗正在写入
#define WIP_Flag 0x01
/*
 *@brief 读取状态寄存器等待FLASH芯片空闲
 *
*/
void SPI_FLASH_WaitForWriteEnd(void)
{
    uint8_t FLASH_Status = 0;
    SPI_FLASH_CS_LOW();  
    SPI_FLASH_SendByte(W25X_ReadStatusReg);
    
    do //若flash忙 则等待
    {
        FLASH_Status = SPI_FLASH_SendByte(Dummy_Byte);
    }while(SET == (FLASH_Status & WIP_Flag));
    
    SPI_FLASH_CS_HIGH();  
}
​
 /**
  * @brief  擦除FLASH扇区
  * @param  SectorAddr：要擦除的扇区地址
  * @retval 无
  */
void SPI_FLASH_SectorErase(uint32_t SectorAddr)
{
  /* 发送FLASH写使能命令 */
  SPI_FLASH_WriteEnable();
  SPI_FLASH_WaitForWriteEnd();
  /* 擦除扇区 */
  /* 选择FLASH: CS低电平 */
  SPI_FLASH_CS_LOW();
  /* 发送扇区擦除指令*/
  SPI_FLASH_SendByte(W25X_SectorErase);
  /*发送擦除扇区地址的高位*/
  SPI_FLASH_SendByte((SectorAddr & 0xFF0000) >> 16);
  /* 发送擦除扇区地址的中位 */
  SPI_FLASH_SendByte((SectorAddr & 0xFF00) >> 8);
  /* 发送擦除扇区地址的低位 */
  SPI_FLASH_SendByte(SectorAddr & 0xFF);
  /* 停止信号 FLASH: CS 高电平 */
  SPI_FLASH_CS_HIGH();
  /* 等待擦除完毕*/
  SPI_FLASH_WaitForWriteEnd();
}
​
 /**
  * @brief  擦除FLASH扇区，整片擦除
  * @param  无
  * @retval 无
  */
void SPI_FLASH_BulkErase(void)
{
  /* 发送FLASH写使能命令 */
  SPI_FLASH_WriteEnable();
​
  /* 整块 Erase */
  /* 选择FLASH: CS低电平 */
  SPI_FLASH_CS_LOW();
  /* 发送整块擦除指令*/
  SPI_FLASH_SendByte(W25X_ChipErase);
  /* 停止信号 FLASH: CS 高电平 */
  SPI_FLASH_CS_HIGH();
​
  /* 等待擦除完毕*/
  SPI_FLASH_WaitForWriteEnd();
}
​
/**
  * @brief  对FLASH按页写入数据，调用本函数写入数据前需要先擦除扇区
  * @param  pBuffer，要写入数据的指针
  * @param WriteAddr，写入地址
  * @param  NumByteToWrite，写入数据长度，必须小于等于SPI_FLASH_PerWritePageSize
  * @retval 无
  */
void SPI_FLASH_PageWrite(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
{
  /* 发送FLASH写使能命令 */
  SPI_FLASH_WriteEnable();
​
  /* 选择FLASH: CS低电平 */
  SPI_FLASH_CS_LOW();
  /* 写页写指令*/
  SPI_FLASH_SendByte(W25X_PageProgram);
  /*发送写地址的高位*/
  SPI_FLASH_SendByte((WriteAddr & 0xFF0000) >> 16);
  /*发送写地址的中位*/
  SPI_FLASH_SendByte((WriteAddr & 0xFF00) >> 8);
  /*发送写地址的低位*/
  SPI_FLASH_SendByte(WriteAddr & 0xFF);
​
  if(NumByteToWrite > SPI_FLASH_PerWritePageSize)
  {
     NumByteToWrite = SPI_FLASH_PerWritePageSize;
     FLASH_ERROR("SPI_FLASH_PageWrite too large!");
  }
​
  /* 写入数据*/
  while (NumByteToWrite--)
  {
    /* 发送当前要写入的字节数据 */
    SPI_FLASH_SendByte(*pBuffer);
    /* 指向下一字节数据 */
    pBuffer++;
  }
​
  /* 停止信号 FLASH: CS 高电平 */
  SPI_FLASH_CS_HIGH();
​
  /* 等待写入完毕*/
  SPI_FLASH_WaitForWriteEnd();
}
​
/**
  * @brief  对FLASH写入数据，调用本函数写入数据前需要先擦除扇区
  * @param  pBuffer，要写入数据的指针
  * @param  WriteAddr，写入地址
  * @param  NumByteToWrite，写入数据长度
  * @retval 无
  */
void SPI_FLASH_BufferWrite(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
{
  uint8_t NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
    
    /*mod运算求余，若writeAddr是SPI_FLASH_PageSize整数倍，运算结果Addr值为0*/
  Addr = WriteAddr % SPI_FLASH_PageSize;
    
    /*差count个数据值，刚好可以对齐到页地址*/
  count = SPI_FLASH_PageSize - Addr;    
    /*计算出要写多少整数页*/
  NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
    /*mod运算求余，计算出剩余不满一页的字节数*/
  NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
​
     /* Addr=0,则WriteAddr 刚好按页对齐 aligned  */
  if (Addr == 0) 
  {
        /* NumByteToWrite < SPI_FLASH_PageSize */
    if (NumOfPage == 0) 
    {
      SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
    }
    else /* NumByteToWrite > SPI_FLASH_PageSize */
    {
            /*先把整数页都写了*/
      while (NumOfPage--)
      {
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
        WriteAddr +=  SPI_FLASH_PageSize;
        pBuffer += SPI_FLASH_PageSize;
      }
            
            /*若有多余的不满一页的数据，把它写完*/
      SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
    }
  }
    /* 若地址与 SPI_FLASH_PageSize 不对齐  */
  else 
  {
        /* NumByteToWrite < SPI_FLASH_PageSize */
    if (NumOfPage == 0) 
    {
            /*当前页剩余的count个位置比NumOfSingle小，写不完*/
      if (NumOfSingle > count) 
      {
        temp = NumOfSingle - count;
                
                /*先写满当前页*/
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
        WriteAddr +=  count;
        pBuffer += count;
                
                /*再写剩余的数据*/
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, temp);
      }
      else /*当前页剩余的count个位置能写完NumOfSingle个数据*/
      {             
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
      }
    }
    else /* NumByteToWrite > SPI_FLASH_PageSize */
    {
            /*地址不对齐多出的count分开处理，不加入这个运算*/
      NumByteToWrite -= count;
      NumOfPage =  NumByteToWrite / SPI_FLASH_PageSize;
      NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
​
      SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
      WriteAddr +=  count;
      pBuffer += count;
            
            /*把整数页都写了*/
      while (NumOfPage--)
      {
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
        WriteAddr +=  SPI_FLASH_PageSize;
        pBuffer += SPI_FLASH_PageSize;
      }
            /*若有多余的不满一页的数据，把它写完*/
      if (NumOfSingle != 0)
      {
        SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
      }
    }
  }
}
​
/**
  * @brief  读取FLASH数据
  * @param  pBuffer，存储读出数据的指针
  * @param   ReadAddr，读取地址
  * @param   NumByteToRead，读取数据长度
  * @retval 无
  */
void SPI_FLASH_BufferRead(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead)
{
  /* 选择FLASH: CS低电平 */
  SPI_FLASH_CS_LOW();
​
  /* 发送 读 指令 */
  SPI_FLASH_SendByte(W25X_ReadData);
​
  /* 发送 读 地址高位 */
  SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
  /* 发送 读 地址中位 */
  SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
  /* 发送 读 地址低位 */
  SPI_FLASH_SendByte(ReadAddr & 0xFF);
  
    /* 读取数据 */
  while (NumByteToRead--)
  {
    /* 读取一个字节*/
    *pBuffer = SPI_FLASH_SendByte(Dummy_Byte);
    /* 指向下一个字节缓冲区 */
    pBuffer++;
  }
​
  /* 停止信号 FLASH: CS 高电平 */
  SPI_FLASH_CS_HIGH();
}
​
​
​
/*******************************************************************************
* Function Name  : SPI_FLASH_StartReadSequence
* Description    : Initiates a read data byte (READ) sequence from the Flash.
*                  This is done by driving the /CS line low to select the device,
*                  then the READ instruction is transmitted followed by 3 bytes
*                  address. This function exit and keep the /CS line low, so the
*                  Flash still being selected. With this technique the whole
*                  content of the Flash is read with a single READ instruction.
* Input          : - ReadAddr : FLASH's internal address to read from.
* Output         : None
* Return         : None
*******************************************************************************/
void SPI_FLASH_StartReadSequence(uint32_t ReadAddr)
{
  /* Select the FLASH: Chip Select low */
  SPI_FLASH_CS_LOW();
​
  /* Send "Read from Memory " instruction */
  SPI_FLASH_SendByte(W25X_ReadData);
​
  /* Send the 24-bit address of the address to read from -----------------------*/
  /* Send ReadAddr high nibble address byte */
  SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
  /* Send ReadAddr medium nibble address byte */
  SPI_FLASH_SendByte((ReadAddr& 0xFF00) >> 8);
  /* Send ReadAddr low nibble address byte */
  SPI_FLASH_SendByte(ReadAddr & 0xFF);
}
/*******************************************************************************
* Function Name  : SPI_FLASH_SendHalfWord
* Description    : Sends a Half Word through the SPI interface and return the
*                  Half Word received from the SPI bus.
* Input          : Half Word : Half Word to send.
* Output         : None
* Return         : The value of the received Half Word.
*******************************************************************************/
uint16_t SPI_FLASH_SendHalfWord(uint16_t HalfWord)
{
  
  SPITimeout = SPIT_FLAG_TIMEOUT;
​
  /* Loop while DR register in not emplty */
  while (__HAL_SPI_GET_FLAG( &HandleSPI,  SPI_FLAG_TXE ) == RESET)
  {
    if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(2);
   }
​
  /* Send Half Word through the SPIx peripheral */
  WRITE_REG(HandleSPI.Instance->DR, HalfWord);
​
  SPITimeout = SPIT_FLAG_TIMEOUT;
​
  /* Wait to receive a Half Word */
  while (__HAL_SPI_GET_FLAG( &HandleSPI, SPI_FLAG_RXNE ) == RESET)
   {
    if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(3);
   }
  /* Return the Half Word read from the SPI bus */
  return READ_REG(HandleSPI.Instance->DR);
}
​
​
//进入掉电模式
void SPI_Flash_PowerDown(void)   
{ 
  /* 选择 FLASH: CS 低 */
  SPI_FLASH_CS_LOW();
​
  /* 发送 掉电 命令 */
  SPI_FLASH_SendByte(W25X_PowerDown);
​
  /* 停止信号  FLASH: CS 高 */
  SPI_FLASH_CS_HIGH();
}   
​
//唤醒
void SPI_Flash_WAKEUP(void)   
{
  /*选择 FLASH: CS 低 */
  SPI_FLASH_CS_LOW();
​
  /* 发上 上电 命令 */
  SPI_FLASH_SendByte(W25X_ReleasePowerDown);
​
  /* 停止信号 FLASH: CS 高 */
  SPI_FLASH_CS_HIGH();                   //等待TRES1
} 
​
/**
  * @brief  等待超时回调函数
  * @param  None.
  * @retval None.
  */
static uint16_t SPI_TIMEOUT_UserCallback(uint8_t errorCode)
{
  /* 等待超时后的处理,输出错误信息 */
  FLASH_ERROR("SPI 等待超时!errorCode = %d",errorCode);
  return 0;
}
​

 

##

HAL库 STM32运用DMA与IDLE中断实现高效串口通信 (附代码)
m0_73816319的博客
01-17 2923
我们的接收数据采用DMA接收方式，使用DMA+IDE空闲中断，这样的好处时，当接收到一串数据时，串口不会发生中断，而是将接收到的数据通过DMA存到缓存区中，当数据传输完成后，IDE产生中断标志位，进而产生一次中断，我们就可以在这次中断中做一些我们想要实现的功能，这种DMA+IDE接收的方式，很符合数据传输通讯的形式，代码如下。第一步，设置时钟源，在未设置的情况下，我们的单片机默认的系统时钟是8MHz，如下图所示。第二步，在SYS里面的Debug选择 Serial write，重定向printf函数。
__HAL_LINKDMA是什么具体解释他的作用和用法
2301_76192086的博客
03-25 781
是STM32 HAL库中的一个宏，用于将外设（如SPI、UART、ADC等）与其对应的DMA句柄关联起来。它的作用是建立外设与DMA通道之间的连接，确保外设在进行DMA传输时能够正确使用指定的DMA资源。当外设需要利用DMA进行数据传输时，必须明确指定使用哪个DMA通道或流。通过将外设句柄中的DMA相关字段指向具体的DMA句柄，实现两者的绑定。对于支持双向传输的外设（如UART的发送和接收），可以分别关联发送和接收的DMA句柄，确保发送和接收使用独立的DMA通道。HAL库的DMA传输函数（如。
STM32 SPI DMA 的使用
08-03
一是想总结一下SPI总线的特点与注意点，二是总结一下SPI DMA的使用。
__HAL_LINKDMA详解(简单粗暴)
最新发布
z8178919的博客
11-06 386
该摘要解释了HAL_LINKDMA宏的功能及其参数含义。宏的作用是将DMA句柄与外设(如ADC)关联起来：第一个参数是目标外设句柄，第二个参数是外设结构体中的DMA句柄成员，第三个参数是DMA控制器句柄。通过这个宏，可以将预先配置的DMA参数值(如图1)传递到ADC模块(如图2)的DMA句柄中，完成DMA通道与外设的绑定。
使用STM32 CUBE IDE配置STM32F7 用DMA传输多通道ADC数据
qq_30993593的博客
02-09 4318
配置好之后，只需三行代码即可。以及使用DMA传输，数据没有更新的原因和解决办法。
STM32HAL库+SPI+DMA驱动SW2812
qq_43175613的博客
01-22 2842
STM32利用硬件SPI 最小内存方式驱动SW2812
stm32之hal库spi驱动封装(实现阻塞,中断,dma三种方式)
scl8295的博客
05-04 1827
此版本的驱动，并没有做相关宏定义的显示，所以可以直接通过参数配置来进行切换，如果需要限定的话，可以根据以上代码进行调整。这里只添加了spi1，如果需要其他的spi,需要添加spi硬件部分io,dma配置部分，spi中断部分即可，整体的spi逻辑框架无需修改。
STM32 HAL库串口+DMA空闲中断接收不定长数据
11-04
STM32 HAL库是STMicroelectronics为STM32微控制器系列提供的一种高级抽象层库，它简化了硬件访问，使得开发者能更专注于应用程序的逻辑，而不是底层硬件操作。在这个特定的场景中，我们关注的是使用HAL库来实现串口...
精选资源
stm32的HAL库硬件SPI驱动AD7606全速SPI 硬件开发 - 单片机.zip
09-28
HAL库为开发者提供了丰富的函数集，这些函数对STM32的各个外设进行了封装，包括GPIO、SPI、I2C、UART等。使用HAL库的优点在于代码可移植性强，降低了不同STM32系列间移植的复杂性，同时提高了开发效率。 2. SPI...
精选资源
《STM32 HAL 库开发实战指南—基于F103霸道_V2》_hal库_stm32开发指南_V2_STM32HAL库开发实战指
10-01
《STM32 HAL库开发实战指南—基于F103霸道_V2》是一本专注于STM32微控制器的开发教程，特别关注了STM32F103系列，并且使用了STM32的HAL（Hardware Abstraction Layer）库。HAL库是意法半导体官方推出的一种全新的、...
STM32F407 基于HAl库实现串口空闲中断的接收，与DMA接收发送数据
07-28
STM32F407结合HAL库实现的串口空闲中断接收和DMA接收发送数据的技术，是现代嵌入式系统开发中一项非常实用的技术，它在提升系统性能、简化代码实现、降低CPU负载等方面都具有显著的优势。开发者通过掌握这一技术，...
STM32的使用之SPI通信DMA模式
08-03
MCU:STM32F303VC，在SPI通信中，可以同时开启发送和接收DMA请求，自动数据的发送和接收，完成数据的交换。
精选资源
STM32HAL库MPU6050
04-04
开发过程中，开发者需要理解STM32的HAL库结构，了解如何配置I2C接口，设置中断和DMA，以及如何使用虚拟串口进行数据传输。同时，理解MPU6050的数据输出格式和校准方法也是必不可少的。通过这个项目，可以学习到...
【STM32】HAL库中的SPI传输（可利用中断或DMA进行连续传输）
热门推荐
Mike Zhou的博客
11-30 2万+
【STM32】HAL库中的SPI传输（可利用中断或DMA进行连续传输）
笔记之STM32F0芯片SPI_DMA的使用（HAL库）
自由的天空
10-02 1万+
在调用HAL_SPI_TransmitReceive_DMA()函数前，拉低NSS，在DMA的传输完成中断进行拉高NSS，然后测试，效果是可以的，数据传输完后就立刻拉高了，就是NSS拉低到数据传输的时间较长，那么都可以在中断里拉高NSS了，那么在开启DMA传输前，拉低NSS不也是可以的吗。现在数据传输是在NSS拉低范围内了，但是NSS拉低到数据传输有9.96us，数据传输完到NSS拉高也有11.312us，字节间距倒是减少了不少，至少证明SPI+DMA这条路应该是没问题的，可以减少数据传输的时间。
STM32CubeMX配置HAL库实现SPI-DMA的递归调用
Shirjay的博客
02-09 5895
HAL库实现SPI-DMA的递归调用，思路可拓展至其他协议与DMA的应用场景
STM32F407 HAL库 SPI DMA 使用详解及优缺点分析
04-24 2810
一、STM32F407 SPI 控制器简介STM32F407 包含 3个SPI控制器（SPI1/2/3），支持：全双工/半双工通信主/从模式切换时钟频率高达 42 MHz（SPI1）硬件 CRC 校验（可选）通过DMA可实现高效数据流传输，适用于高速、大容量数据场景（如显示屏刷新、高速ADC采集）。
【STM32】硬件SPI+DMA驱动WS2812灯珠，基于HAL库
我的博客
01-27 1万+
STM32F103单片机配合Cubemx软件，基于HAL库，利用SPI和DMA驱动ws2812灯珠，实现幻彩流水灯。 笔者使用的WS2812是淘宝买的灯环，如下图所示留出来四个接口，分别是根据描述我们使用到的仅为DIN，VCC，GND5VPA7。
STM32F407HAL库使用SPI+DMA驱动LVGL刷屏
qq_47736089的博客
09-26 5638
这里有一个SPI回调函数需要自己写，HAL_SPI_TxCpltCallback函数表示SPI发送完成的回调函数，只在SPI的中断发送完成或DMA发送完成后调用，因此可以将LVGL的刷新函数lv_disp_flush_ready放在此处调用，以保证刷新的实时性。DMA发送数据的类型有字节、半字、字三种类型，应当选取与SPI配置的相同类型，例如这里SPI配置的为字节，所以对应的DMA也应该配置为字节；至此SPI+DMA配置完毕；因为SPI要和DMA连接到一起，所以内存的地址要自增，但外设的地址不允许自增；
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值