🏠 回到主页

蓝桥杯嵌入式学习笔记

个人嵌入式学习笔记，蓝桥杯部分，仅供学习参考，不允许售卖。

提示：本篇相当部分代码及语法解释来自百度文心一言及阿里通义灵码,chatgpt AI生成，并且有相当多的部分摘抄了网络博文和正点原子的HAL库开发手册，本篇笔记由本人在相当长的学习过程中逐渐整理成型，缺少精力对各部分内容来源进行标注，本文档中绝大部分的代码已通过实践验证，如果存在知识点错误或内容有更好的表述形式，欢迎通过邮箱指正 yang92636@qq.com 欢迎您在git代码托管平台上提交Issues，笔者已经参与过了蓝桥杯比赛，本文后续更新幅度和修改范围会非常小，甚至不更新，您可以通过GITEE/GITCODE网址：https://gitee.com/weigo6/MCU_LEARN_LIB 或者 https://gitcode.com/weigo6/MCU_LEARN_LIB 查看最新文档（欢迎来点个Star），希望本份笔记能够为你提供帮助！

跳转本文对应的仓库：与蓝桥杯比赛嵌入式赛道相关的内容整理

一、HAL库常用函数

在写HAL库代码时，所有用户代码放在user code begin和user code end中，否则重新生成代码会被覆盖

1.GPIO

• Output Push Pull：推挽输出，能输出高低电平，且高低电平都有驱动能力。以PB13引脚为例，若需要通过其控制LED灯，则该引脚应配置为“Output Push Pull”模式，对应标准库函数中的“GPIO_Mode_Out_PP”

• Output Open Drain：开漏输出，只能输出低电平，需要借助外部上拉电阻才能输出高电平，对应标准库函数中的“GPIO_Mode_Out_OD”

• Analog mode：模拟输入，ADC采样信号输入引脚的配置模式，对应标准库函数中的“GPIO_Mode_AIN”

• Alternate Function Push Pull：推挽式复用功能，对应标准库函数中的“GPIO_Mode_AF_PP”

• Input mode：输入模式，配合No pull-up/pull-down可形成GPIO_Mpde_IN_FLOATING、GPIO_Mode_IPD、GPIO_Mode_IPU等不同工作模式

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

__HAL_RCC_GPIOF_CLK_ENABLE();//使能GPIOF时钟

__HAL_RCC_USART2_CLK_ENABLE();//使能串口 2 时钟 __HAL_RCC_TIM1_CLK_ENABLE();//使能 TIM1 时钟 __HAL_RCC_DMA1_CLK_ENABLE();//使能 DMA1 时钟

HAL_GPIO_Init();//GPIO初始化

2.NVIC中断

在HAL库中，中断服务函数定义在底层，不需要编写，通常只需要编写中断回调函数，无需清理中断标记位。

• 如果要在中断服务函数中使用 HAL_Delay 函数的话，那么中断的优先级在设置的时候就要注意， 不能设置比 SysTick 的中断优先级比高或者同级，否则中断服务函数一直得不到执行，从而卡死在这里。

第一，如果两个中断的抢占优先级和响应优先级都是一样的话，则看哪个中断先发生就先执行； 第二，高优先级的抢占优先级是可以打断正在进行的低抢占优先级中断的。而抢占优先级相同的中断，高优先级的响应优先级不可以打断低响应优先级的中断。

中断分组表：

中断分组函数在HAL_Init内被调用。

配置 IO 口外部中断的一般步骤：

1. 使能 IO 口时钟。

2. 调用函数 HAL_GPIO_Init 设置 IO 口模式，触发条件，使能 SYSCFG 时钟以及设置 IO 口与中断线的映射关系。

3. 配置中断优先级（NVIC），并使能中断。

4. 在中断服务函数中调用外部中断共用入口函数 HAL_GPIO_EXTI_IRQHandler。

5. 编写外部中断回调函数 HAL_GPIO_EXTI_Callback。

xxxxxxxxxx
16
1
void HAL_NVIC_SetPriorityGrouping(uint32_t PriorityGroup);//这个函数在系统中只需要被调用一次，一旦分组确定就最好不要更改，否则容易造成程序分组混乱。
2
HAL_NVIC_SetPriorityGrouping (NVIC_PriorityGroup_2);//设置系统的中断优先级的分组为2
3
void HAL_NVIC_SetPriority(IRQn_Type IRQn, uint32_t PreemptPriority, uint32_t SubPriority);//设置单个优先级的抢占优先级和响应优先级的值
4
void HAL_NVIC_EnableIRQ(IRQn_Type IRQn);//使能某个中断通道
5
void HAL_NVIC_DisableIRQ(IRQn_Type IRQn);//来清除某个中断使能
6
HAL_NVIC_SetPriority(EXTI0_IRQn,2,1); //使能中断线抢占优先级为 2，子优先级为 1
7
HAL_NVIC_EnableIRQ(EXTI0_IRQn); //使能中断线 0
8

9
/*stm32 IO口外部中断服务函数*/
10
void EXTI0_IRQHandler();
11
void EXTI1_IRQHandler();
12
void EXTI2_IRQHandler();
13
void EXTI3_IRQHandler();
14
void EXTI4_IRQHandler();
15
void EXTI9_5_IRQHandler();
16
void EXTI15_10_IRQHandler();

GPIO与中断线的映射关系图

中断函数调用示例：

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

中断处理函数定义

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

该函数进行了清除了中断标志位，因此在编写函数过程中只需要写函数HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)控制逻辑。

\(^o^)/~

3.TIM

更新中断就是定时器溢出中断，定时器就是计数器。

与定时器的值有关的函数

xxxxxxxxxx
16
1
//设置获取比较值
2
__HAL_TIM_SetCompare (__HANDLE__, __CHANNEL__, __COMPARE__)
3
例如：__HAL_TIM_SetCompare(&htim3,TIM_CHANNEL_3,1000);
4
__HAL_TIM_GetCompare (__HANDLE__, __CHANNEL__)
5
例如：__HAL_TIM_GetCompare(&htim3,TIM_CHANNEL_3);
6
//设置获取自动重装值
7
__HAL_TIM_SetAutoreload (__HANDLE__, __AUTORELOAD__)
8
例如：__HAL_TIM_SetAutoreload(&htim3,1000);
9
/*也可以这样：*/htim3.Instance->ARR = 100;//修改定时器3的ARR值
10
__HAL_TIM_GetAutoreload (__HANDLE__)
11
例如：__HAL_TIM_GetAutoreload(&htim3);
12
//设置获取计数值
13
__HAL_TIM_SetCounter (__HANDLE__,__COUNTER__)
14
例如：__HAL_TIM_SetCounter(&htim3,1000);
15
__HAL_TIM_GetCounter (__HANDLE__)
16
例如：__HAL_TIM_GetCounter(&htim3);

等价函数

常用函数

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

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

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

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

这里列出单独使能/关闭定时器中断和使能/关闭定时器方法： __HAL_TIM_ENABLE_IT(htim, TIM_IT_UPDATE);//使能句柄指定的定时器更新中断 __HAL_TIM_DISABLE_IT (htim, TIM_IT_UPDATE);//关闭句柄指定的定时器更新中断 __HAL_TIM_ENABLE(htim);//使能句柄 htim 指定的定时器 //似乎不起作用，使用上面的代码 __HAL_TIM_DISABLE(htim);//关闭句柄 htim 指定的定时器

涉及到初始化的一些代码

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

定时器编码器

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

输入捕获

当你设置的捕获开始的时候，cpu会将计数寄存器的值复制到捕获比较寄存器中并开始计数，当再次捕捉到电平变化时，这是计数寄存器中的值减去刚才复制的值就是这段电平的持续时间，你可以设置上升沿捕获、下降沿捕获、或者上升沿下降沿都捕获。 需要开启NVIC中断

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

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

PWM

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

4.ADC

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

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

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

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

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

ADC单通道采集

使用示例：获取 ADC1 通道 ch 的转换结果，先取 times 次,然后取平均

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

5.I2C

I2C代码根据所使用的I2C外设模块，通常由厂商提供。HAL库IIC初始化可同过CubeMX软件图形化完成。

软件模拟iic的一些通用代码

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

7
#ifndef _IIC_H//基础文件定义
8
#define _IIC_H
9
#include"gpio.h"
10
/* IIC-SCL 引脚 定义 */
11
#define IIC_SCL_GPIO_PORT  GPIOA
12
#define IIC_SCL_GPIO_PIN   GPIO_PIN_11
13
/* IIC-SDA 引脚 定义 */
14
#define IIC_SDA_GPIO_PORT GPIOA
15
#define IIC_SDA_GPIO_PIN GPIO_PIN_12
16
/* IO 操作,控制GPIO引脚电平，在这里X为1表示控制为高电平，0为低电平 */
17
#define IIC_SCL(x) do{ x ? \
18
HAL_GPIO_WritePin(IIC_SCL_GPIO_PORT, IIC_SCL_GPIO_PIN, GPIO_PIN_SET) : \
19
HAL_GPIO_WritePin(IIC_SCL_GPIO_PORT, IIC_SCL_GPIO_PIN, GPIO_PIN_RESET); \
20
}while(0) /* SCL */
21
#define IIC_SDA(x) do{ x ? \
22
HAL_GPIO_WritePin(IIC_SDA_GPIO_PORT, IIC_SDA_GPIO_PIN, GPIO_PIN_SET) : \
23
HAL_GPIO_WritePin(IIC_SDA_GPIO_PORT, IIC_SDA_GPIO_PIN, GPIO_PIN_RESET); \
24
}while(0) /* SDA */
25
/* 读取 SDA */
26
#define IIC_READ_SDA HAL_GPIO_ReadPin(IIC_SDA_GPIO_PORT, IIC_SDA_GPIO_PIN)
27

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

38
#endif
39

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

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

53
void iic_stop(void)
54
{
55
 IIC_SDA(0);
56
 iic_delay();
57
 IIC_SCL(1);
58
 iic_delay();
59
 IIC_SDA(1); /* STOP 信号: 当 SCL 为高时, SDA 从低变成高, 表示停止信号 */
60
 iic_delay();
61
}
62

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

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

75
//模拟从机产生应答信号，从机通过将 SDA 拉低来产生应答信号
76
void iic_ack(void)
77
{
78
IIC_SDA(0); /* SCL = 1 时， SDA = 0,表示应答 */
79
iic_delay();
80
IIC_SCL(1);
81
iic_delay();
82
 
83
IIC_SCL(0); /* SCL 1 -> 0 */
84
iic_delay();
85
IIC_SDA(1); /* 主机释放 SDA 线 */
86
iic_delay();
87
}
88

89
//不产生 ACK 应答
90
void iic_nack(void)
91
{
92
 IIC_SDA(1); /* SCL 高电平 时， SDA = 1,表示不应答 */
93
 iic_delay();
94
 IIC_SCL(1);
95
 iic_delay();
96
 IIC_SCL(0); /* SCL 1 -> 0 产生一个时钟 */
97
 iic_delay();
98
}
99

100
//发送一个字节函数，data: 要发送的数据
101
void iic_send_byte(uint8_t data)
102
{
103
uint8_t t;
104
for (t = 0; t < 8; t++)
105
{
106
    IIC_SDA((data & 0x80) >> 7);/* 高位先发送 */
107
    iic_delay();
108
    IIC_SCL(1);
109
    iic_delay();
110
    IIC_SCL(0); /* SCL 1 -> 0 产生一个时钟 */
111
    data <<= 1; /* 左移 1 位,用于下一次发送 */
112
}
113
    IIC_SDA(1); /* 发送完成, 主机释放 SDA 线 */
114
}
115

116
//读取一个字节函数，ack=1 时，发送 ack; ack=0 时，发送 nack
117
uint8_t iic_read_byte(uint8_t ack)
118
{
119
 uint8_t i, receive = 0;
120
 for (i = 0; i < 8; i++ ) /* 接收 1 个字节数据 */
121
 {
122
     receive <<= 1; /* 高位先输出,所以先收到的数据位要左移 */
123
     IIC_SCL(1);
124
     iic_delay();
125
     if (IIC_READ_SDA){receive++;}
126
     IIC_SCL(0);
127
     iic_delay();
128
 }
129
 if (!ack){
130
    iic_nack(); /* 发送 nACK */}
131
 else{
132
    iic_ack(); /* 发送 ACK */
133
 }
134
 return receive;
135
}
136

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

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

148
    while (IIC_READ_SDA) //等待从机下拉   
149
    {
150
        waittime++;
151

152
        if (waittime > 250)
153
        {
154
            iic_stop();//超时停止iic，接收应答失败
155
            rack = 1;
156
            break;
157
        }
158
    }
159

160
    IIC_SCL(0);    
161
    iic_delay();
162
    return rack;
163
}

硬件IIC

硬件IIC通过CubeMX设置，默认开启I2C即可

使用STM32硬件I2C驱动AHT10温湿度传感器的代码

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

15
void AHT10_Read(float *temperature,float *humidity){
16
    uint8_t sendBuffer[3]={0xAC,0x33,0x00};//传感器测量参数
17
    uint8_t readBuffer[6];
18
    HAL_I2C_Master_Transmit(&hi2c1,AHT10_ADDRESS,sendBuffer,3,HAL_MAX_DELAY);//调用的指针，从机地址，发送变量存储地址，发送多少位数据，超时时间
19
    HAL_Delay(75);
20
    HAL_I2C_Master_Receive(&hi2c1,AHT10_ADDRESS,readBuffer,6,HAL_MAX_DELAY);
21
    
22
    if((readBuffer[0] & 0x80)==0){//确实读取到了数据
23
        uint32_t data=0;
24
        data = (((uint32_t)readBuffer[3]>>4) +((uint32_t)readBuffer[2]<<4 )+((uint32_t)readBuffer[1]<<12)); 
25
        *humidity = data * 100.0f/(1<<20);//根据公式得到湿度
26
        data = (((uint32_t)readBuffer[3] & 0x0F)<<16) +((uint32_t)readBuffer[4]<<8 )+((uint32_t)readBuffer[5]); 
27
        *temperature = data * 200.f/(1<<20) - 50;//根据公式得到温度
28
    }
29
}
30
//头文件
31
#ifndef _AHT10_H//基础文件定义
32
#define _AHT10_H
33
#include "i2c.h"
34

35
void AHT10_Read(float *temperature,float *humidity);
36
void aht10_init(void);
37

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

6.UART串口通信

初始化、发送接收和中断回调函数

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

12
void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)//在stm32xx_it.c中，被对应的USART1_IRQHandler()调用
13
//该函数调用回调函数，该函数和回调函数定义在stm32xx_hal_uart.c中，使用CubeMX只需编写回调函数
14
/* 数据完全发送完成后调用 */
15
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
16
/* 一半数据发送完成时调用 */
17
void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart)
18
/* 数据完全接受完成后调用 */
19
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
20
/* 一半数据接收完成时调用，配合HAL_UART_Receive_IT/DMA使用 */
21
void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart)
22
/* 传输出现错误时调用 */
23
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
24
/* UART 中止完成时调用 */
25
void HAL_UART_AbortCpltCallback(UART_HandleTypeDef *huart)
26
/* UART 中止完成回调函数 */
27
void HAL_UART_AbortTransmitCpltCallback(UART_HandleTypeDef *huart)
28
/* UART 中止接收完整的回调函数 */
29
void HAL_UART_AbortReceiveCpltCallback(UART_HandleTypeDef *huart)

传输中断函数

xxxxxxxxxx
13
1
/*一些中止正在进行的发送/接收传输函数（中断模式和阻塞模式）。*/
2
/* 中止正在进行的传输(阻塞模式) */
3
HAL_StatusTypeDef HAL_UART_Abort(UART_HandleTypeDef *huart);
4
/* 中止正在进行的传输传输(阻塞模式) */ 
5
HAL_StatusTypeDef HAL_UART_AbortTransmit(UART_HandleTypeDef *huart);
6
/* 中止正在进行的接收传输(阻塞模式) */ 
7
HAL_StatusTypeDef HAL_UART_AbortReceive(UART_HandleTypeDef *huart);
8
/* 中止正在进行的传输(中断模式) */ 
9
HAL_StatusTypeDef HAL_UART_Abort_IT(UART_HandleTypeDef *huart);
10
/* 中止正在进行的传输(中断模式) */ 
11
HAL_StatusTypeDef HAL_UART_AbortTransmit_IT(UART_HandleTypeDef *huart);
12
/* 中止正在进行的接收传输(中断模式) */
13
HAL_StatusTypeDef HAL_UART_AbortReceive_IT(UART_HandleTypeDef *huart); 

串口DMA传输

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

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

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

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

空闲中断

如果要实现数据不定长收发，需要开启串口空闲中断

使用串口DMA实现不定长数据接收（串口和DMA均由CubeMX配置，无需另外代码）

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

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

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

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

使用示例

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

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

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

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

DMA

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

RTC

RTC使用示例（串口定时打印当前时间）

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

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

SysTick函数

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

关于uwTick

HAL_IncTick() 是 STM32 HAL（硬件抽象层）库中的一个函数，用于在 SysTick 中断服务例程（ISR）内部递增一个名为 uwTick 的全局变量的值。这个全局变量用作系统的滴答计数器（tick counter），通常以毫秒为单位递增。HAL_IncTick() 函数的主要目的是提供一个简单而通用的机制，用来追踪自系统启动以来经过的时间，以及实现基于时间的操作，比如延时。

具体来说，HAL_IncTick() 函数的工作机制如下：

• 滴答计数器 (uwTick): 这是一个无符号的全局变量，通常在 HAL 库的源代码中定义。每次调用 HAL_IncTick() 时，此变量的值会增加1。其时基（时间间隔）通常由 SysTick 定时器的配置决定，标准配置下为1毫秒。

• SysTick 中断服务例程 (ISR): 在一个标准的STM32项目中，SysTick 定时器配置为每隔固定的时间间隔（例如1毫秒）产生一次中断。每当 SysTick 中断发生时，都会执行 SysTick 的中断服务例程。在这个例程中，调用 HAL_IncTick() 来递增滴答计数器。

• 时间管理功能: 通过这种机制，HAL 库提供了一系列基于时间的函数，如 HAL_GetTick()（获取当前的滴答计数器值），HAL_Delay()（实现延时）。这些功能依赖于 uwTick 的值，因此 HAL_IncTick() 的正确调用对于时间管理功能的正常工作至关重要。

在实际应用中，开发者通常不需要直接调用 HAL_IncTick()，因为这个函数已经在 HAL 库的 SysTick 中断服务例程模板中被调用。开发者需要确保 SysTick 定时器正确配置，以及对应的中断服务例程已经包含了对 HAL_IncTick() 的调用。这样，开发者就可以利用 HAL_GetTick() 和 HAL_Delay() 等函数实现时间相关的功能，而无需关心背后的细节。

实际开发中，一些延迟应用并不需要开启定时器，可以使用SysTick 中断服务（不需要手动配置，只需要配置好系统时钟就可以）。

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

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

微秒级延迟函数（根据系统主频不同需要修改）

开启相应的定时器，把函数放在tim.c中

xxxxxxxxxx
23
1
void delay_us(uint16_t us)//72Mhz下使用
2
{
3
uint16_t differ = 0xffff-us-5;
4
__HAL_TIM_SET_COUNTER(&htim7,differ); //设定TIM7计数器起始值
5
HAL_TIM_Base_Start(&htim7); //启动定时器
6
while(differ < 0xffff-5)
7
{ //判断
8
differ = __HAL_TIM_GET_COUNTER(&htim7); //查询计数器的计数值
9
}
10
HAL_TIM_Base_Stop(&htim7);
11
}
12

13
void delay_us(uint32_t us) {//168Mhz下使用，时钟分频为41，向上计数
14
  HAL_TIM_Base_Start(&htim7);
15
  uint32_t start = HAL_TIM_ReadCapturedValue(&htim7, TIM_CHANNEL_1);
16
  while (1) {
17
    uint32_t current = HAL_TIM_ReadCapturedValue(&htim7, TIM_CHANNEL_1);
18
    if ((current - start) >= us) {
19
      break;
20
    }
21
    HAL_TIM_Base_Stop(&htim7);
22
  }
23
}

软件重启函数，复位，使能/关闭全局中断

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

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

NVIC_SystemReset();软件复位函数

在软件复位过程中，程序仍然可以响应中断，为避免软重启失败。通常会在软重启前关闭所有中断。

二、c语言语法

1、sprintf函数

sprintf 是一个在 C 语言中常用的函数，用于将格式化的数据写入字符串中。它的函数原型如下：

sprintf函数会将传递给它的可变参数按照指定的格式进行格式化，并将结果写入str` 指向的字符串中。返回值是写入字符串的字符数（不包括字符串末尾的空字符）。

sprintf 函数在 C 语言中是标准库函数，它定义在 stdio.h 头文件中。

xxxxxxxxxx
11
1
#include <stdio.h>  
2
  
3
int main() {  
4
    char buffer[100];  
5
    int a = 10;  
6
    float b = 3.14;  
7
    char c = 'd';  
8
    sprintf(buffer, "整数：%d, 浮点数：%f, 字符：%c", a, b, c);  
9
    printf("%s\n", buffer);  
10
    return 0;  
11
}

输出结果

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

sprintf所写入的字符串为char类型。而蓝桥杯屏幕显示函数所需的参量类型为uint8_t。建议强制类型转换以避免warning。不过实测该warning不影响程序运行。

xxxxxxxxxx
1
1
LCD_DisplayStringLine(u8 Line, u8 *ptr)

一种规范的写法：

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

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

2、bool布尔类型

在C语言中，布尔类型是一种基本的数据类型，用于表示逻辑值true和false。 在C99标准及其之后的标准中，C语言在<stdbool.h>头文件中提供了内置的布尔类型支持。当你包含这个头文件时，你可以使用bool关键字来声明布尔变量，使用true和false来表示布尔值。例如：

xxxxxxxxxx
4
1
#include <stdbool.h>  
2
  
3
bool a = true;  
4
bool b = false;

请注意，true和false在C99中是关键字，它们的值分别是1和0。同时，bool实际上是一个宏，通常被定义为_Bool或者int。

3、结构体struct与typedef struct

struct和typedef struct都是用来定义结构体的关键字

xxxxxxxxxx
9
1
struct Student {  
2
  int id;  
3
  char name[50];  
4
  int age;  
5
};
6
struct Student stu1;  
7
stu1.id = 1;  
8
stu1.name = "John Doe";  
9
stu1.age = 20;

在这个例子中，我们定义了一个名为Student的结构体，它包含三个成员：id，name，和age。其中，id是一个整数，name是一个字符数组（可以存储一个长度为50的字符串），age也是一个整数，创建了一个名为stu1的Student结构体实例，并为其成员赋值。

在C语言中，使用typedef和struct来定义结构体类型的语法如下：

xxxxxxxxxx
26
1
typedef struct {  
2
    // 成员变量定义  
3
    // ...  
4
} 结构体别名;
5

6
typedef struct StructName {  
7
    // 成员变量定义  
8
    // ...  
9
} StructName;
10

11
/*下面举一个例子*/
12

13
#include <stdio.h>  
14
  
15
typedef struct {  
16
    char name[50];  
17
    int age;  
18
} Person;  
19
  
20
int main() {  
21
    Person p1;  // 使用别名声明结构体实例  
22
    p1.age = 25;  
23
    printf("Name: %s\n", p1.name);  
24
    printf("Age: %d\n", p1.age);  
25
    return 0;  
26
}

在上述示例中，我们定义了一个名为Person的结构体类型，并使用别名Person来声明结构体实例p1。然后，我们可以使用点号.来访问结构体成员变量，例如p1.name和p1.age。

结构体指针成员变量引用方法是通过“->”符号实现，比如要访问 usart3 结构体指针指向的结 构体的成员变量 BaudRate,方法是：Usart3->BaudRate;

4、弱定义extern,__weak

在C语言中，弱定义是一种允许同一个符号（变量或函数）在多个源文件中被定义，但在链接时只有一个定义会被保留的定义方式。弱定义使用extern关键字来声明变量或函数，并且在声明后面不跟任何分号。

下面是一个使用弱定义的示例：

假设我们有一个全局变量global_var，需要在多个源文件中共享。我们可以将其声明为弱变量，并在其中一个源文件中定义它：

xxxxxxxxxx
5
1
// 在头文件中声明弱变量  
2
extern int global_var;  
3
  
4
// 在源文件1.c中定义弱变量  
5
int global_var = 10;

在其他源文件中，我们可以使用extern关键字来引用global_var变量，例如：

xxxxxxxxxx
6
1
// 在源文件2.c中引用弱变量  
2
extern int global_var;  
3
  
4
void func() {  
5
  printf("The value of global_var is %d\n", global_var);  
6
}

在链接时，链接器会选择其中一个定义作为最终的定义，其他定义将被忽略。因此，在最终的可执行程序中，只有一个global_var变量会被定义，并且可以被所有源文件访问。

需要注意的是，弱定义只能用于变量或函数，不能用于函数参数、结构体、枚举等其他类型。此外，弱定义必须保证只有一个强定义（使用static关键字定义的变量或函数），否则会导致链接错误。

__weak关键字用于修饰函数或变量，表示该函数或变量是弱定义的。

大部分中断回调函数都被__weak关键字修饰

具体来说，当你在代码中声明一个弱定义的函数或变量时，如果你没有在其它地方定义这个函数或变量，编译器会报错。

而使用__weak关键字可以告诉编译器，这个函数或变量是弱定义的，如果在其它地方没有定义，则使用这个弱定义的函数或变量。

__weak关键字通常用于在不同的模块之间共享函数或变量，特别是在嵌入式系统中，不同的模块可能会使用相同的函数或变量名，为了避免冲突，使用弱定义是一种有效的解决方法。

需要注意的是，__weak关键字并不是C语言的标准化关键字，而是特定编译器或环境提供的扩展。

5、__IO定义

__IO是一个在嵌入式C语言中常见的关键字，特别是在与硬件相关的编程中。__IO通常用于指定一个变量或地址空间为输入输出(IO)空间。

在大多数处理器架构中，内存被划分为几个不同的空间，例如：RAM、ROM、IO空间等。__IO关键字用于告诉编译器，某个变量或指针引用的地址位于IO空间，而不是常规的RAM或ROM空间。

例如，当您在与硬件寄存器交互时，这些寄存器通常位于特殊的IO地址空间。在这种情况下，您可能会使用__IO关键字来定义一个指向这些寄存器的指针：

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

在这个例子中，register_address是一个指向地址0x40000000的指针，并且这个地址被指定为IO空间。这样编译器就知道，当访问这个指针时，需要生成适用于访问IO空间的机器代码。

__IO并不是C语言的标准关键字，而是特定于某些编译器和架构的扩展。

6、 ifdef 条件编译

在C语言中，#ifdef是一个预处理指令，它用于进行条件编译。#ifdef后面跟着一个宏名称，如果这个宏被定义了，那么#ifdef后面的代码就会被编译进去，否则这部分代码会被忽略。

下面是一个简单的例子：

xxxxxxxxxx
12
1
#include <stdio.h>  
2
  
3
#define FEATURE_A  
4
  
5
int main() {  
6
    #ifdef FEATURE_A  
7
        printf("Feature A is enabled.\n");  
8
    #else  
9
        printf("Feature A is not enabled.\n");  
10
    #endif  
11
    return 0;  
12
}

在这个例子中，如果宏FEATURE_A被定义了，那么程序会输出"Feature A is enabled."。如果宏FEATURE_A没有被定义，那么程序会输出"Feature A is not enabled."。

在实际开发中，我们通常会使用#ifdef来检查某些编译选项或者平台特性是否被定义，然后根据这些条件来选择性地编译代码。

7、printf串口重定向

这段 printf 函数支持的代码在初始化串口后使用，这段代码加入之后便可以通 过 printf 函数向串口发送我们需要的内容。

xxxxxxxxxx
30
1
//加入以下代码,支持 printf 函数,而不需要选择 use MicroLIB 标准库版本
2
#if 1
3
#pragma import(__use_no_semihosting) 
4
//标准库需要的支持函数 
5
struct __FILE 
6
{ 
7
int handle; 
8
}; 
9
FILE __stdout; 
10
//定义_sys_exit()以避免使用半主机模式
11
_sys _exit(int x) 
12
{ 
13
x = x; 
14
} 
15
//重定义 fputc 函数
16
int fputc(int ch, FILE *f)
17
{ 
18
while(USART_GetFlagStatus(USART1,USART_FLAG_TC)==RESET); 
19
 USART_SendData(USART1,(uint8_t)ch); 
20
return ch;
21
}
22
#endif
23

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

8、switch case多路分支语法

switch语句是一种多路选择结构，可以根据不同的条件选择不同的执行路径。

xxxxxxxxxx
11
1
switch (expression) {  
2
   case constant1:  
3
      // 代码块1  
4
      break;  
5
   case constant2:  
6
      // 代码块2  
7
      break;  
8
   ...  
9
   default:  
10
      // 默认代码块  
11
}

这是最简单和最常用的switch语句结构。这里，expression是要评估的表达式，constant1、constant2等是可能的值。如果expression的值等于某个case后面的常量，则执行相应的代码块。break语句用于退出switch语句。如果没有break，程序将继续执行下一个case。

9、goto语句与标签

goto语句用于无条件地转移到程序中的另一部分。它通常用于跳出循环或提前退出函数。然而，使用goto语句需要谨慎，因为过度使用它可能会导致代码难以理解和维护。

标签（Label）是一个代码标识符，后面跟一个冒号，它标识一个语句的位置。标签可以与goto语句一起使用，使程序跳转到该标签所在的语句。

xxxxxxxxxx
17
1
#include <stdio.h>  
2
  
3
int main() {  
4
    int i;  
5
  
6
    for (i = 0; i < 10; i++) {  
7
        printf("%d ", i);  
8
        if (i == 5) {  
9
            goto end_of_loop;  //goto语句
10
        }  
11
    }  
12
  
13
    end_of_loop:  //标签语法
14
        printf("End of loop\n");  
15
  
16
        return 0;  
17
}

标签可以被多次引用，这意味着可以在代码中定义相同的标签多次。但是，一个标签只能被一个语句块内的 goto 语句引用，也就是说，goto语句只能跳转到最近的被引用的标签所在的位置。这个规则是为了确保代码的可读性和可维护性。如果一个标签被多个goto语句引用，就会导致代码的流程变得不清晰，而且也不容易理解。因此，一个标签只能被一个语句块内的goto语句引用，这样可以保证代码的流程更加清晰和易于理解。

10、sscanf函数

sscanf 是一个标准C库函数，用于从字符串中读取格式化输入。它的名字代表“string scan”，意即从字符串中扫描格式化的数据。sscanf 的工作方式与 scanf 类似，但它不是从标准输入（通常是键盘）读取数据，而是从一个给定的字符串中读取。

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

• str：指向要读取的字符串的指针。

• format：一个格式字符串，指定了要读取的数据的类型和格式。

• ...：表示可变数量的指针，这些指针指向将要存储读取数据的变量。

sscanf 函数的返回值是成功读取并赋值的输入项数，如果输入结束或发生输入失败，则可能小于提供的指针数量。

下面是一个简单的 sscanf 示例：

xxxxxxxxxx
18
1
#include <stdio.h>  
2
int main() {  
3
    const char *input = "42 3.14 Hello";  
4
    int integer;  
5
    float floating;  
6
    char str[20];  
7
  
8
    // 从input字符串中读取一个整数，一个浮点数和一个字符串  
9
    int itemsRead = sscanf(input, "%d %f %19s", &integer, &floating, str);  
10
  
11
    // 打印读取到的值和读取的项数  
12
    printf("Read %d items:\n", itemsRead);  
13
    printf("Integer: %d\n", integer);  
14
    printf("Floating: %f\n", floating);  
15
    printf("String: %s\n", str);  
16
  
17
    return 0;  
18
}

在这个例子中，sscanf 函数尝试从 input 字符串中读取一个整数、一个浮点数和一个字符串，并将这些值存储在相应的变量中。格式字符串 "%d %f %19s" 指定了要读取的数据类型和格式：一个整数（%d）、一个浮点数（%f）和一个最多包含19个字符的字符串（%19s）。注意，字符串的读取长度被限制为19个字符，以避免缓冲区溢出。

11、左移右移操作符<< >>

1. 左移运算符 (<<)

   • 将左操作数的所有位向左移动指定的位数，右侧空出的位用0填充。

   • 有一个8位的二进制数 00001010 (十进制中的10)。如果我们将其左移1位，结果为 00010100 (十进制中的20)。

   • 左移操作相当于乘以2的某个幂。例如，左移1位相当于乘以2，左移2位相当于乘以4，以此类推。

2. 右移运算符 (>>)

   • 将左操作数的所有位向右移动指定的位数。

   • 对于无符号整数，右侧溢出的位被丢弃，左侧空出的位用0填充。

   • 对于有符号整数，右移的处理方式依赖于具体的编译器或机器。在许多环境中，算术右移会保留符号位（即最左边的位），这意味着负数的右移会在左侧填充1，而正数或0的右移会在左侧填充0。但在某些环境中，也可能采用逻辑右移，即无论符号如何，都在左侧填充0。

   • 有一个8位的二进制数 00001010 (十进制中的10)。如果我们将其右移1位，结果为 00000101 (十进制中的5)。

   • 右移操作可以被视为整除2的某个幂。例如，右移1位相当于除以2，右移2位相当于除以4（忽略余数），以此类推。

12、strcmp函数

strcmp 函数是 C 语言标准库中 <string.h> 头文件提供的一个函数，用于比较两个字符串，其语法如下：

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

• str1：要比较的第一个字符串。指向第一个要比较的 null 结尾字符串的指针。

• str2：要比较的第二个字符串。指向第二个要比较的 null 结尾字符串的指针。

strcmp函数会比较两个字符串str1和str2，如果两个字符串相等，则返回0；

如果str1小于str2，则返回一个负数；

如果str1大于str2，则返回一个正数。

以下是一个简单的示例代码，演示如何使用strcmp函数：

xxxxxxxxxx
18
1
#include <stdio.h>
2
#include <string.h>
3

4
int main() {
5
    char str1[] = "hello";
6
    char str2[] = "world";
7
    int result = strcmp(str1, str2);
8
    if (result == 0) {
9
        printf("两个字符串相等\n");
10
    }
11
    else if (result < 0) {
12
        printf("第一个字符串小于第二个字符串\n");
13
    }
14
    else {
15
        printf("第一个字符串大于第二个字符串\n");
16
    }
17
    return 0;
18
}

在上面的示例代码中，我们比较了两个字符串str1和str2，并根据strcmp函数的返回值输出不同的结果。

13、strlen/sizeof函数

在C语言中，strlen 和 sizeof 是两个不同的操作，它们用于不同的目的。

1. strlen 函数用于计算字符串的长度，不包括 null 终止字符 '\0'。strlen 是 C 标准库中 <string.h> 头文件提供的函数。下面是它的语法：

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

函数参数：

• str: 指向以 null 结尾的字符串的指针。

返回值：

• 返回 str 所指向的字符串的长度，不包括 null 终止字符。

用法示例：

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