蓝桥杯嵌入式学习笔记¶

HAL_GPIO_WritePin(GPIOF,GPIO_PIN_9,GPIO_PIN_SET);//PF9设置为高电平，GPIO_PIN_RESET代表低电平
HAL_GPIO_ReadPin (GPIOF, GPIO_PIN_5);//读取PF5的引脚状态
HAL_GPIO_TogglePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);//翻转引脚电平
/*GPIO中断回调函数*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
/*逻辑功能写在这里*/
}

void EXTI2_IRQHandler(void)//该函数在stm32xx_it.c文件中
{
 HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_2); //调用中断处理公用函数
}
在 HAL 库中所有的外部中断服务函数都会调用下面的函数
/*需要自己编写的函数，重要*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
/*逻辑功能写在这里*/
}

/*该函数在stm32xx_hal_gpio.c文件中*/
void HAL_GPIO_EXTI_IRQHandler(uint16_t GPIO_Pin)//判断是几号线中断，清除中断标识位，然后调用中断回调函数
{
  if(__HAL_GPIO_EXTI_GET_IT(GPIO_Pin) != RESET)
  {
   __HAL_GPIO_EXTI_CLEAR_IT(GPIO_Pin);
   HAL_GPIO_EXTI_Callback(GPIO_Pin);
  }
}

//设置获取比较值
__HAL_TIM_SetCompare (__HANDLE__, __CHANNEL__, __COMPARE__)
例如：__HAL_TIM_SetCompare(&htim3,TIM_CHANNEL_3,1000);
__HAL_TIM_GetCompare (__HANDLE__, __CHANNEL__)
例如：__HAL_TIM_GetCompare(&htim3,TIM_CHANNEL_3);
//设置获取自动重装值
__HAL_TIM_SetAutoreload (__HANDLE__, __AUTORELOAD__)
例如：__HAL_TIM_SetAutoreload(&htim3,1000);
/*也可以这样：*/htim3.Instance->ARR = 100;//修改定时器3的ARR值
__HAL_TIM_GetAutoreload (__HANDLE__)
例如：__HAL_TIM_GetAutoreload(&htim3);
//设置获取计数值
__HAL_TIM_SetCounter (__HANDLE__,__COUNTER__)
例如：__HAL_TIM_SetCounter(&htim3,1000);
__HAL_TIM_GetCounter (__HANDLE__)
例如：__HAL_TIM_GetCounter(&htim3);

/*枚举型，HAL_OK(成功)、HAL_ERROR（错误）、HAL_BUSY（串口忙碌）、HAL_TIMEOUT（超时）*/
HAL_StatusTypeDef HAL_TIM_Base_Start_IT(TIM_HandleTypeDef *htim);// 使能定时器更新中断和使能定时器
HAL_StatusTypeDef HAL_TIM_Base_Stop_IT(TIM_HandleTypeDef *htim);//关闭定时器和定时器中断
HAL_StatusTypeDef HAL_TIM_Base_Start(TIM_HandleTypeDef *htim);//开启定时器
HAL_StatusTypeDef HAL_TIM_Base_Stop(TIM_HandleTypeDef *htim);//关闭定时器

/*定时器的回调函数*/
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)//更新中断回调函数
void HAL_TIM_OC_DelayElapsedCallback(TIM_HandleTypeDef *htim);//输出比较回调函数
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim);//输入捕获回调函数
void HAL_TIM_TriggerCallback(TIM_HandleTypeDef *htim);//触发中断回调函数

void TIM3_IRQHandler(void);//定时器3的中断服务函数，调用下行函数，在stmxx_hal_it.c中
HAL_TIM_IRQHandler(TIM_HandleTypeDef *htim);//定时器中断共用处理函数，该函数定义在stmxx_hal_tim.c中，并调用了下面的函数

/*需要自己编写的非常重要的函数，不能写错*/
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)//定时器中断回调函数，需要在函数内部区分定时器
{
    if(htim->Instance==TIM3){//定时器中断来源判断
        逻辑语句
    }
    if (htim == &htimx){//定时器中断来源判断
        逻辑语句
    }
}//定时器更新中断

void MX_TIM3_Init(void);//在cubemx配置定时器3，该函数在tim.c中，调用下行函数
HAL_TIM_Base_Init(&htim3)；//初始化定时器3，在stm32xx_hal_tim.c中。调用下两行函数。
HAL_TIM_Base_MspInit(htim);//该函数定义在tim.c中，初始化底层硬件，如开启定时器时钟、设置定时器中断优先级以及开启定时器中断，由CubeMx生成
TIM_Base_SetConfig(htim->Instance, &htim->Init);//在stm32xx_hal_tim.c中，完成对计数模式，时钟分频，自动重装值等设置，配置定时器

HAL_TIM_Encoder_Start(&htim1, TIM_CHANNEL_ALL);//启动编码器模式
cnt_encoder = __HAL_TIM_GET_COUNTER(&htim1);//通过函数获取TIM1的CNT值
/*获取TIM1 CNT值*/
__HAL_TIM_GET_COUNTER(&htim1);//return 返回uint16_t整数型变量，即当前的计数值

/**设置TIM1的CNT值*/
__HAL_TIM_SET_COUNTER(&htim1, 0);
// 开始捕获
/*上升下降沿捕获在cubemx里可直接配置，通常自动重装寄存器设为最大值*/
__HAL_TIM_SET_CAPTUREPOLARITY(&htim1, TIM_CHANNEL_3, TIM_INPUTCHANNELPOLARITY_RISING);//配置为上升沿捕获
__HAL_TIM_SET_CAPTUREPOLARITY(htim, TIM_CHANNEL_3, TIM_INPUTCHANNELPOLARITY_FALLING);//配置为下降沿捕获

HAL_TIM_IC_Start_IT(&htim1, TIM_CHANNEL_3);//开启TIM1通道3的输入捕获中断
/*重定义输入捕获中断函数*/
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
  if (htim == &htim1 && htim->Channel == HAL_TIM_ACTIVE_CHANNEL_3)//判断捕获通道，注意==ACTIVE==
  {
    逻辑代码
  }//比较麻烦的判断方法，通常不用判断通道
  if(htim == &htim1) //判断输入捕获定时器
    {
         uint32_t  cc1_value = 0;//uint8_t位数过少
        cc1_value = __HAL_TIM_GET_COUNTER(htim);//获取发生捕获时的计数值
        cc1_value=HAL_TIM_ReadCapturedValue(htim,TIM_CHANNEL_1);
      //该代码读取输入捕获ccr寄存器的值，与上行代码可做相互替代，因为输入捕获发生时会把cnt值复制到ccr寄存器里
        __HAL_TIM_SetCounter(htim,0);//清除CNT
        f40 = 1000000/cc1_value;//逻辑代码示意，频率=系统时钟频率/TIM时钟分频/输入捕获ccr计数器的值（单次捕获计算）
    }
}

HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);//启用定时器3的通道一PWM输出
__HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_1, period);//设置PWM的占空比，注意period需要小于设置中的Counter Period（ARR）
__HAL_TIM_GetCompare(&htim3,TIM_CHANNEL_1);//获取比较值
htim3.Instance->ARR = 100;//修改定时器3的ARR值 
//示例
for (int period = 0; period < 100; period++) {
        __HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_1, period);
        HAL_Delay(7);
    }

HAL_StatusTypeDef HAL_ADCEx_Calibration_Start(ADC_HandleTypeDef *hadc,
                                              uint32_t CalibrationMode, uint32_t SingleDiff);
HAL_ADCEx_Calibration_Start(&hadc1, ADC_CALIB_OFFSET,ADC_SINGLE_ENDED);
//ADC校准函数，只有一部分MCU支持这种额外校准模式
/*形参 2 是校准模式选择，有以下两种：
1）ADC_CALIB_OFFSET 表示只运行偏移校准而不运行线性度校准。
2）ADC_CALIB_OFFSET_LINEARITY 表示同时运行偏移校准和线性度校准。
形参 3 是单端或差分模式选择，有以下两种：
1）ADC_SINGLE_ENDED 表示单端输入模式。
2）ADC_DIFFERENTIAL_ENDED 表示差分输入模式。*/
HAL_ADCEx_Calibration_Start(ADC_HandleTypeDef* hadc, uint32_t SingleDiff);//第二个参数是单端输入和差分输入选择
//ADC校准函数 注：STM32F4没有软件ADC校准

HAL_ADC_Init(&hadc1);//初始化ADC，调用下行函数,被MX_ADC1_Init()调用，在stm32xx_hal_adc.c中
HAL_ADC_MspInit(hadc);//ADC的GPIO初始化代码，在adc.c中
HAL_ADC_Start(&hadc1); //启动ADC1

HAL_ADC_ConfigChannel(&hadc1,&sConfig);//ADC通道配置函数
HAL_ADC_Stop(&hadc1);//停止ADC转换

/*等待 ADC 常规组转换完成函数*/
HAL_StatusTypeDef HAL_ADC_PollForConversion(ADC_HandleTypeDef *hadc,uint32_t Timeout);
HAL_ADC_PollForConversion(&hadc1, 10); /* 轮询转换 */;
//一般先调用 HAL_ADC_Start 函数启动转换，再调用该函数等待转换完成，然后再调用
//形参 2 是等待转换的等待时间，单位是毫秒（ms）。

HAL_ADC_GetValue(&hadc1);//获取当前转换值

uint32_t adc_get_result_average(uint32_t ch, uint8_t times){
    uint32_t temp_val = 0;uint8_t t;
    //HAL_ADCEx_Calibration_Start(&hadc1, ADC_CALIB_OFFSET,ADC_SINGLE_ENDED);
    //ADC 校准，如果MCU支持额外的校准
    /* 等待共模校准完成 */
    //while (HAL_ADCEx_Calibration_GetState(&hadc) != HAL_ADC_CALIBRATION_STATE_COMPLETED);
    //等待共模校准完成
    HAL_ADCEx_Calibration_Start(&hadc1,ADC_SINGLE_ENDED);//单端校准ADC
    HAL_ADC_Start(&hadc1); /* 启动 ADC */
    HAL_ADC_PollForConversion(&hadc1, 10); /* 轮询转换，设置转换10次*/;
    for (t = 0; t < times; t++) {/* 获取 times 次数 */
        temp_val += HAL_ADC_GetValue(&hadc1);
        HAL_Delay(5);
    }/* 获取转换结果，并将每次转换结果进行相加 */
    return temp_val / times; /* 返回转换后的平均值*/
}

/*以下代码GPIO配置开漏输出上拉电阻，如果配置SDA线推挽输出，则需要考虑SDA输出输入方向*/
 /*类似这样*/#define SDA_IN() {GPIOB->MODER&=~(3<<(9*2));GPIOB->MODER|=0<<9*2;}
            //PB9 输入模式
            #define SDA_OUT() {GPIOB->MODER&=~(3<<(9*2));GPIOB->MODER|=1<<9*2;} 
            //PB9 输出模式

#ifndef _IIC_H//基础文件定义
#define _IIC_H
#include"gpio.h"
/* IIC-SCL 引脚 定义 */
#define IIC_SCL_GPIO_PORT  GPIOA
#define IIC_SCL_GPIO_PIN   GPIO_PIN_11
/* IIC-SDA 引脚 定义 */
#define IIC_SDA_GPIO_PORT GPIOA
#define IIC_SDA_GPIO_PIN GPIO_PIN_12
/* IO 操作,控制GPIO引脚电平，在这里X为1表示控制为高电平，0为低电平 */
#define IIC_SCL(x) do{ x ? \
HAL_GPIO_WritePin(IIC_SCL_GPIO_PORT, IIC_SCL_GPIO_PIN, GPIO_PIN_SET) : \
HAL_GPIO_WritePin(IIC_SCL_GPIO_PORT, IIC_SCL_GPIO_PIN, GPIO_PIN_RESET); \
}while(0) /* SCL */
#define IIC_SDA(x) do{ x ? \
HAL_GPIO_WritePin(IIC_SDA_GPIO_PORT, IIC_SDA_GPIO_PIN, GPIO_PIN_SET) : \
HAL_GPIO_WritePin(IIC_SDA_GPIO_PORT, IIC_SDA_GPIO_PIN, GPIO_PIN_RESET); \
}while(0) /* SDA */
/* 读取 SDA */
#define IIC_READ_SDA HAL_GPIO_ReadPin(IIC_SDA_GPIO_PORT, IIC_SDA_GPIO_PIN)

/* IIC 所有操作函数 */
void iic_init(void); /* 初始化 IIC 的 IO 口 */
void iic_start(void); /* 发送 IIC 开始信号 */
void iic_stop(void); /* 发送 IIC 停止信号 */
void iic_ack(void); /* IIC 发送 ACK 信号 */
void iic_nack(void); /* IIC 不发送 ACK 信号 */
uint8_t iic_wait_ack(void); /* IIC 等待 ACK 信号 */
void iic_send_byte(uint8_t txd); /* IIC 发送一个字节 */
uint8_t iic_read_byte(unsigned char ack); /* IIC 读取一个字节 */

#endif

void iic_init(void)
{
 /* SDA 引脚模式设置,开漏输出,上拉, 这样就不用再设置 IO 方向了, 开漏输出的时候(=1), 
也可以读取外部信号的高低电平 */
 MX_GPIO_Init(); /* 初始化 PA11 和 PA12，配置为开漏输出、上拉、高速模式 */
 iic_stop(); /* 停止总线上所有设备 */
}

static void iic_delay(void)
{
 delay_us(2); /* 2us 的延时, 读写速度在 250Khz 以内 */
}

void iic_stop(void)
{
 IIC_SDA(0);
 iic_delay();
 IIC_SCL(1);
 iic_delay();
 IIC_SDA(1); /* STOP 信号: 当 SCL 为高时, SDA 从低变成高, 表示停止信号 */
 iic_delay();
}

void iic_start(void)
{
IIC_SDA(1);
IIC_SCL(1);
iic_delay();
IIC_SDA(0); /* START 信号: 当 SCL 为高时, SDA 从高变成低, 表示起始信号 */

iic_delay();
IIC_SCL(0); /* 钳住 I2C 总线，准备发送或接收数据 */
iic_delay();
}

//模拟从机产生应答信号，从机通过将 SDA 拉低来产生应答信号
void iic_ack(void)
{
IIC_SDA(0); /* SCL = 1 时， SDA = 0,表示应答 */
iic_delay();
IIC_SCL(1);
iic_delay();

IIC_SCL(0); /* SCL 1 -> 0 */
iic_delay();
IIC_SDA(1); /* 主机释放 SDA 线 */
iic_delay();
}

//不产生 ACK 应答
void iic_nack(void)
{
 IIC_SDA(1); /* SCL 高电平 时， SDA = 1,表示不应答 */
 iic_delay();
 IIC_SCL(1);
 iic_delay();
 IIC_SCL(0); /* SCL 1 -> 0 产生一个时钟 */
 iic_delay();
}

//发送一个字节函数，data: 要发送的数据
void iic_send_byte(uint8_t data)
{
uint8_t t;
for (t = 0; t < 8; t++)
{
    IIC_SDA((data & 0x80) >> 7);/* 高位先发送 */
    iic_delay();
    IIC_SCL(1);
    iic_delay();
    IIC_SCL(0); /* SCL 1 -> 0 产生一个时钟 */
    data <<= 1; /* 左移 1 位,用于下一次发送 */
}
    IIC_SDA(1); /* 发送完成, 主机释放 SDA 线 */
}

//读取一个字节函数，ack=1 时，发送 ack; ack=0 时，发送 nack
uint8_t iic_read_byte(uint8_t ack)
{
 uint8_t i, receive = 0;
 for (i = 0; i < 8; i++ ) /* 接收 1 个字节数据 */
 {
     receive <<= 1; /* 高位先输出,所以先收到的数据位要左移 */
     IIC_SCL(1);
     iic_delay();
     if (IIC_READ_SDA){receive++;}
     IIC_SCL(0);
     iic_delay();
 }
 if (!ack){
    iic_nack(); /* 发送 nACK */}
 else{
    iic_ack(); /* 发送 ACK */
 }
 return receive;
}

//iic等待ACK函数，reak返回0接收应答成功，返回1接收应答失败
uint8_t iic_wait_ack(void)
{
    uint8_t waittime = 0;
    uint8_t rack = 0;

    IIC_SDA(1);  //数据线设置为高，等待从机下拉
    iic_delay();
    IIC_SCL(1);   
    iic_delay();

    while (IIC_READ_SDA) //等待从机下拉   
    {
        waittime++;

        if (waittime > 250)
        {
            iic_stop();//超时停止iic，接收应答失败
            rack = 1;
            break;
        }
    }

    IIC_SCL(0);    
    iic_delay();
    return rack;
}

#include "aht10.h"
#define AHT10_ADDRESS 0x70
//HAL库硬件IIC
//AHT10的地址是0x38（7位），从机左移一位（末尾补零）变为8位即为0x70，如果主机发起通信的目的是为了从从机读取数据末位改为1（此位会由HAL库有关函数自动更改）
void aht10_init(void){
    uint8_t  readBuffer;
    HAL_Delay(40);
    HAL_I2C_Master_Receive(&hi2c1,AHT10_ADDRESS,&readBuffer,1,HAL_MAX_DELAY);//调用的指针，从机地址，读取变量存储地址，读取多少位数据，超时时间
    if((readBuffer & 0x08) == 0x00){//从机返回值不为1
        uint8_t send_Buffer[3] = {0xE1,0x08,0x00};//初始化传感器参数
        HAL_I2C_Master_Transmit(&hi2c1,AHT10_ADDRESS,send_Buffer,3,HAL_MAX_DELAY);//调用的指针，从机地址，发送变量存储地址，发送多少位数据，超时时间
    }
}

void AHT10_Read(float *temperature,float *humidity){
    uint8_t sendBuffer[3]={0xAC,0x33,0x00};//传感器测量参数
    uint8_t readBuffer[6];
    HAL_I2C_Master_Transmit(&hi2c1,AHT10_ADDRESS,sendBuffer,3,HAL_MAX_DELAY);//调用的指针，从机地址，发送变量存储地址，发送多少位数据，超时时间
    HAL_Delay(75);
    HAL_I2C_Master_Receive(&hi2c1,AHT10_ADDRESS,readBuffer,6,HAL_MAX_DELAY);

    if((readBuffer[0] & 0x80)==0){//确实读取到了数据
        uint32_t data=0;
        data = (((uint32_t)readBuffer[3]>>4) +((uint32_t)readBuffer[2]<<4 )+((uint32_t)readBuffer[1]<<12)); 
        *humidity = data * 100.0f/(1<<20);//根据公式得到湿度
        data = (((uint32_t)readBuffer[3] & 0x0F)<<16) +((uint32_t)readBuffer[4]<<8 )+((uint32_t)readBuffer[5]); 
        *temperature = data * 200.f/(1<<20) - 50;//根据公式得到温度
    }
}
//头文件
#ifndef _AHT10_H//基础文件定义
#define _AHT10_H
#include "i2c.h"

void AHT10_Read(float *temperature,float *humidity);
void aht10_init(void);

#endif
//在main.c的主函数中执行以下函数，实现串口发送采集的数据
MX_I2C1_Init();//HAL库生成
aht10_init();
AHT10_Read(&temperature,&humidity);
sprintf(message,"温度.2lf,湿度%.2lf%%\r\n",temperature,humidity);
HAL_UART_Transmit(&huart1,(uint8_t*)message,strlen(message),HAL_MAX_DELAY);
HAL_Delay(1000);

HAL_UART_Init(UART_HandleTypeDef *huart)//初始化

//参数1：使用的串口，2：要发送的数据，3：数据大小，4：发送的超时时间
HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t
                                    *pData, uint16_t Size, uint32_t Timeout) /*串口轮询模式发送，使用超时管理机*/
HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t
                                   *pData, uint16_t Size, uint32_t Timeout) /*串口轮询模式接收，使用超时管理机*/
//参数1：使用的串口，2：要发送的数据，3：数据大小(字节)    
HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t*pData, uint16_t Size) /*串口中断模式发*/
HAL_StatusTypeDef HAL_UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t*pData, uint16_t Size) /*串口中断模式接收*/

void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)//在stm32xx_it.c中，被对应的USART1_IRQHandler()调用
//该函数调用回调函数，该函数和回调函数定义在stm32xx_hal_uart.c中，使用CubeMX只需编写回调函数
/* 数据完全发送完成后调用 */
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
/* 一半数据发送完成时调用 */
void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart)
/* 数据完全接受完成后调用 */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
/* 一半数据接收完成时调用，配合HAL_UART_Receive_IT/DMA使用 */
void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart)
/* 传输出现错误时调用 */
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
/* UART 中止完成时调用 */
void HAL_UART_AbortCpltCallback(UART_HandleTypeDef *huart)
/* UART 中止完成回调函数 */
void HAL_UART_AbortTransmitCpltCallback(UART_HandleTypeDef *huart)
/* UART 中止接收完整的回调函数 */
void HAL_UART_AbortReceiveCpltCallback(UART_HandleTypeDef *huart)

/*一些中止正在进行的发送/接收传输函数（中断模式和阻塞模式）。*/
/* 中止正在进行的传输(阻塞模式) */
HAL_StatusTypeDef HAL_UART_Abort(UART_HandleTypeDef *huart);
/* 中止正在进行的传输传输(阻塞模式) */ 
HAL_StatusTypeDef HAL_UART_AbortTransmit(UART_HandleTypeDef *huart);
/* 中止正在进行的接收传输(阻塞模式) */ 
HAL_StatusTypeDef HAL_UART_AbortReceive(UART_HandleTypeDef *huart);
/* 中止正在进行的传输(中断模式) */ 
HAL_StatusTypeDef HAL_UART_Abort_IT(UART_HandleTypeDef *huart);
/* 中止正在进行的传输(中断模式) */ 
HAL_StatusTypeDef HAL_UART_AbortTransmit_IT(UART_HandleTypeDef *huart);
/* 中止正在进行的接收传输(中断模式) */
HAL_StatusTypeDef HAL_UART_AbortReceive_IT(UART_HandleTypeDef *huart); 

//串口的DMA发送函数
HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart,uint8_t *pData, uint16_t Size)
//参数1：使用的串口，2：要发送的数据，3：数据大小（字节）

//串口DMA停止暂停恢复函数
HAL_StatusTypeDef HAL_UART_DMAStop(UART_HandleTypeDef *huart); /* 停止 */
HAL_StatusTypeDef HAL_UART_DMAPause(UART_HandleTypeDef *huart); /* 暂停 */
HAL_StatusTypeDef HAL_UART_DMAResume(UART_HandleTypeDef *huart);/* 恢复 */

//串口DMA的接收函数
HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef *huart, uint8_t*pData, uint16_t Size)
//参数1：使用的串口，2：要接收的数据地址，3：要接收的数据大小（字节）

DMA 传输完成回调函数 UART_DMAReceiveCplt 会调用HAL_UART_RxCpltCallback 函数

/* 在设定模式下接收一定数量的数据，直到接收到预期数量的数据或发生空闲事件，
第三个参数为最大数据接收长度，一般为数组长度(字节) */ 
HAL_UARTEx_ReceiveToIdle_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);//DMA模式
HAL_UARTEx_ReceiveToIdle(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);//普通阻塞模式
HAL_UARTEx_ReceiveToIdle_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);//中断模式

/* 以DMA模式发送大量数据 */
HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart, const uint8_t *pData, uint16_t Size);

/* 接待事件回调(使用高级接待服务后调用的Rx事件通知) ，适用于接收不定长数据的回调函数HAL_UART_RxCpltCallback*/
void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size);//回调函数，第三个参数为最大数据接收长度

//通过DMA接收串口发来的数据，并且利用串口空闲中断在将这些数据发送至串口助手的示意代码
char pData[255];
 void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
{//Size为接收到的数据大小
    if(huart->Instance == USART1)
    {  
        HAL_UART_DMAStop(&huart1);//关闭是为了重新设置发送多少数据，不关闭会造成数据错误      
        HAL_UART_Transmit_DMA(&huart1, (uint8_t *)pData, Size);//设置DMA发送多少数据        
        HAL_UARTEx_ReceiveToIdle_DMA(&huart1,(uint8_t *)pData, 255);//继续开启空闲中断DMA接收，在主程序需要加这句
       __HAL_DMA_DISABLE_IT(&hdma_usart1_rx,DMA_IT_HT);//关闭DMA传输过半中断，在主程序需要加这句，其余模式不需要
       /* extern DMA_HandleTypeDef hdma_usart1_rx;需要先添加此行*/
 //HAL_UARTEx_ReceiveToIdle_IT(&huart1,(uint8_t *)pData, 255);//继续开启空闲中断模式接收，在主程序需要加这句*
 //HAL_UARTEx_ReceiveToIdle(&huart1,(uint8_t *)pData, 255);//继续开启空闲中断普通接收，在主程序需要加这句*
 //中断与普通写法形同DMA
    }
}//DMA传输过半中断同样能触发 HAL_UARTEx_RxEventCallback，因此需要手动关闭

HAL_UART_Transmit(&huart1,(uint8_t *)"hi",sizeof("hi"),50);//阻塞模式发送hi

//中断模式发送示例
char text[30];
sprintf(text,"helloworld");
HAL_UART_Transmit_IT(&huart1,(uint8_t *)text,sizeof(text));
HAL_Delay(10);//多句发送函数在一起需要有延迟等待串口不被占用，sizeof和strlen等价
HAL_UART_Transmit_IT(&huart1,(uint8_t *)"ha",strlen("ha"));

//DMA串口发送
HAL_UART_Transmit_DMA(&huart1,(uint8_t *)"234567\r\n", 10);

//将串口中断接收到的数据发送出去
uint8_t Rx_Data[1];//此代码只能对定长数据进行接收转发，接收的数据只能是接收中断函数中定义的值
HAL_UART_Receive_IT(&huart1,Rx_Data,1);//接收中断值设置为1字节时可以进行任意长度接收转发
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)//串口发送会对串口中断接收产生阻塞影响
{
    if(huart->Instance == USART1)
    {
        HAL_UART_Transmit(&huart1,Rx_Data,sizeof(Rx_Data),100);
        HAL_UART_Receive_IT(&huart1,Rx_Data,1);  //接收结束后需要重新调用该函数，不然只能接收一次
    }
}

HAL_StatusTypeDef HAL_DMA_Init(DMA_HandleTypeDef *hdma);//DMA初始化
与串口有关的DMA见上文
HAL_StatusTypeDef HAL_DMA_Start_IT(DMA_HandleTypeDef *hdma, uint32_tSrcAddress, uint32_t DstAddress, uint32_t DataLength)//DMA中断方式启动函数，参数1：使用的dma,参数2：源内存缓冲区地址，参数3：目标内存缓冲区地址；参数4：数据长度
/*DMA 传输完成后，会执行对应的 DMA 中断服务函数，对应的 DMA 中断服务函数会调用
DMA 中断请求函数 HAL_DMA_IRQHandler*/
HAL_StatusTypeDef HAL_DMA_Start(DMA_HandleTypeDef *hdma, uint32_tSrcAddress, uint32_t DstAddress, uint32_t DataLength)//DMA启动函数  

RTC_DateTypeDef GetDate;  //获取日期结构体，需要预先在cubemx中配置日期时间
RTC_TimeTypeDef GetTime;   //获取时间结构体

/* Get the RTC current Time */
HAL_RTC_GetTime(&hrtc, &GetTime, RTC_FORMAT_BIN);
 /* Get the RTC current Date */
HAL_RTC_GetDate(&hrtc, &GetDate, RTC_FORMAT_BIN);
/* Display date Format : yy/mm/dd */
printf("%02d/%02d/%02d\r\n",2000 + GetDate.Year, GetDate.Month, GetDate.Date);
/* Display time Format : hh:mm:ss */
printf("%02d:%02d:%02d\r\n",GetTime.Hours, GetTime.Minutes, GetTime.Seconds);
printf("\r\n");
HAL_Delay(1000);
//if(GetData.WeekDay==1){printf("星期一\r\n");判断星期
这里需要注意：不管你需要读取时间日期还是只想要读取时间，读取日期的函数不能够丢。

HAL_GetTick(void);
//该函数的作用就是返回uwTick，一个用于获取当前系统时间的函数，其主要实现基于SysTick中断

extern uint16_t syscount[];//默认情况下，1ms触发一次中断，该函数定义在stm32xx_it.c中，由CubeMX生成
void SysTick_Handler(void)
{
    if(syscount[0] < 5000){//5s
        syscount[0]++;
    }
    if(syscount[1] < 100){//0.1s
        syscount[1]++;
    }
  HAL_IncTick();
}

if (syscount[0] >= 5000){逻辑代码;syscount[0] = 0}//一种使用示例

void delay_us(uint16_t us)//72Mhz下使用
{
uint16_t differ = 0xffff-us-5;
__HAL_TIM_SET_COUNTER(&htim7,differ); //设定TIM7计数器起始值
HAL_TIM_Base_Start(&htim7); //启动定时器
while(differ < 0xffff-5)
{ //判断
differ = __HAL_TIM_GET_COUNTER(&htim7); //查询计数器的计数值
}
HAL_TIM_Base_Stop(&htim7);
}

void delay_us(uint32_t us) {//168Mhz下使用，时钟分频为41，向上计数
  HAL_TIM_Base_Start(&htim7);
  uint32_t start = HAL_TIM_ReadCapturedValue(&htim7, TIM_CHANNEL_1);
  while (1) {
    uint32_t current = HAL_TIM_ReadCapturedValue(&htim7, TIM_CHANNEL_1);
    if ((current - start) >= us) {
      break;
    }
    HAL_TIM_Base_Stop(&htim7);
  }
}

/*软件重启函数*/
__set_FAULTMASK(1);//关闭所有中断
NVIC_SystemReset();//复位函数

__set_FAULTMASK(0); //使能全局中断

#include <stdio.h>  

int main() {  
    char buffer[100];  
    int a = 10;  
    float b = 3.14;  
    char c = 'd';  
    sprintf(buffer, "整数：%d, 浮点数：%f, 字符：%c", a, b, c);  
    printf("%s\n", buffer);  
    return 0;  
}

整数：10, 浮点数：3.140000, 字符：d

LCD_DisplayStringLine(u8 Line, u8 *ptr)

      char text[30];
      unsigned int i=5;
      sprintf(text,"CNDR:%d%%   ",i);

      LCD_DisplayStringLine(Line9,(unsigned char*)text);

#include <stdbool.h>  

bool a = true;  
bool b = false;

struct Student {  
  int id;  
  char name[50];  
  int age;  
};
struct Student stu1;  
stu1.id = 1;  
stu1.name = "John Doe";  
stu1.age = 20;

typedef struct {  
    // 成员变量定义  
    // ...  
} 结构体别名;

typedef struct StructName {  
    // 成员变量定义  
    // ...  
} StructName;

/*下面举一个例子*/

#include <stdio.h>  

typedef struct {  
    char name[50];  
    int age;  
} Person;  

int main() {  
    Person p1;  // 使用别名声明结构体实例  
    p1.age = 25;  
    printf("Name: %s\n", p1.name);  
    printf("Age: %d\n", p1.age);  
    return 0;  
}

// 在头文件中声明弱变量  
extern int global_var;  

// 在源文件1.c中定义弱变量  
int global_var = 10;

// 在源文件2.c中引用弱变量  
extern int global_var;  

void func() {  
  printf("The value of global_var is %d\n", global_var);  
}

__IO uint32_t* register_address = (uint32_t*)0x40000000;

#include <stdio.h>  

#define FEATURE_A  

int main() {  
    #ifdef FEATURE_A  
        printf("Feature A is enabled.\n");  
    #else  
        printf("Feature A is not enabled.\n");  
    #endif  
    return 0;  
}

//加入以下代码,支持 printf 函数,而不需要选择 use MicroLIB 标准库版本
#if 1
#pragma import(__use_no_semihosting) 
//标准库需要的支持函数 
struct __FILE 
{ 
int handle; 
}; 
FILE __stdout; 
//定义_sys_exit()以避免使用半主机模式
_sys _exit(int x) 
{ 
x = x; 
} 
//重定义 fputc 函数
int fputc(int ch, FILE *f)
{ 
while(USART_GetFlagStatus(USART1,USART_FLAG_TC)==RESET); 
 USART_SendData(USART1,(uint8_t)ch); 
return ch;
}
#endif

//HAL库版本
#include <stdio.h>//添加头文件
int fputc(int ch, FILE *f)//在串口文件中添加这段
{
  HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xffff);
  return ch;
}

switch (expression) {  
   case constant1:  
      // 代码块1  
      break;  
   case constant2:  
      // 代码块2  
      break;  
   ...  
   default:  
      // 默认代码块  
}

#include <stdio.h>  

int main() {  
    int i;  

    for (i = 0; i < 10; i++) {  
        printf("%d ", i);  
        if (i == 5) {  
            goto end_of_loop;  //goto语句
        }  
    }  

    end_of_loop:  //标签语法
        printf("End of loop\n");  

        return 0;  
}

int sscanf(const char *str, const char *format, ...);

#include <stdio.h>  
int main() {  
    const char *input = "42 3.14 Hello";  
    int integer;  
    float floating;  
    char str[20];  

    // 从input字符串中读取一个整数，一个浮点数和一个字符串  
    int itemsRead = sscanf(input, "%d %f %19s", &integer, &floating, str);  

    // 打印读取到的值和读取的项数  
    printf("Read %d items:\n", itemsRead);  
    printf("Integer: %d\n", integer);  
    printf("Floating: %f\n", floating);  
    printf("String: %s\n", str);  

    return 0;  
}

int strcmp(const char *str1, const char *str2);

#include <stdio.h>
#include <string.h>

int main() {
    char str1[] = "hello";
    char str2[] = "world";
    int result = strcmp(str1, str2);
    if (result == 0) {
        printf("两个字符串相等\n");
    }
    else if (result < 0) {
        printf("第一个字符串小于第二个字符串\n");
    }
    else {
        printf("第一个字符串大于第二个字符串\n");
    }
    return 0;
}

#include <string.h>
size_t strlen(const char *str);

#include <stdio.h>
#include <string.h>
int main() {
    const char *str = "Hello, World!";
    size_t length = strlen(str);
    printf("Length of the string is: %zu\n", length);
    return 0;
}

size_t size = sizeof(object_or_type);

#include <stdio.h>
int main() {
    int arr[10];
    size_t sizeInBytes = sizeof(arr);
    printf("Size of the array is: %zu bytes\n", sizeInBytes);
    return 0;
}
//%zu 是一个格式说明符，用于 printf 或 scanf 等格式化输入输出函数中。它用来匹配 size_t 类型的数据。使用 %zu 格式说明符可以确保无论 size_t 是多大，都能正确地打印其值，而不会发生整型溢出或类型不匹配的问题。

void *memset(void *ptr, int value, size_t num);

int arr[10];
memset(arr, 0, sizeof(arr));
char rx[20];
memset(rx,0,strlen(rx));

#include <string.h>
char *strtok(char *str, const char *delim);