STM32单片机的学习（持续更新中！！！）--HA库版本

小强子！

已于 2024-05-24 12:56:34 修改

阅读量191

点赞数 2

文章标签：单片机 stm32 学习

于 2024-04-08 17:04:18 首次发布

本文链接：https://blog.csdn.net/qq_39855356/article/details/137512840

版权

STM32单片机的学习

一. 基本操作（软件的相关操作）
二. 基本项目
- 2.1 点亮两个led小灯
- 2.2 使用按键控制两个led小灯
三. 复位和时钟控制（RCC）
四. 中断
五. 定时器
六. 串口
七. 看门狗
八. DMA
九. ADC
十. IIC

一. 基本操作（软件的相关操作）

在这里插入图片描述

二. 基本项目

2.1 点亮两个led小灯

先查看原理图：
在这里插入图片描述
可见led1和led2分别对应PB8和PB9端口，且led灯端低电平点亮
设定参数

PB8和PB9使用相同操作

HAL_GPIO_WritePin(GPIOB,GPIO_PIN_8,GPIO_PIN_RESET);//给GPIOB组的第8个引脚低电平，即灯亮
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_9,GPIO_PIN_SET);//给GPIOB组的第9个引脚高电平，即灯灭
HAL_Delay(1000); //延时1000毫秒，即1秒
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_8,GPIO_PIN_SET);//给GPIOB组的第8个引脚高电平，即灯灭
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_9,GPIO_PIN_RESET);//给GPIOB组的第9个引脚低电平，即灯亮
HAL_Delay(1000);//延时1000毫秒，即1秒

2.2 使用按键控制两个led小灯

首先，我们先找到按键所在原理图上的位置
在这里插入图片描述
由原理图可知，当按键被按下时呈现低电平
新建一个工程，操作如上述一样。

三. 复位和时钟控制（RCC）

刚开始先点击：
在这里插入图片描述

输入完72后，点击回车

在这里插入图片描述

四. 中断

4.1 按键点亮led（中断法）

在这里插入图片描述

在这里插入图片描述

下图无需进行更改，在配置32时已经成功配置完毕！！！

代码：

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
	switch(GPIO_Pin)
	{
		case GPIO_PIN_0:
			HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_8);//反转指令！！！
		break;
		case GPIO_PIN_1:
			HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_9);
		break;
	}
}

进阶版：

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
	switch (GPIO_Pin)
	{
		HAL_Delay(50);//软件消抖
		case GPIO_PIN_0:
			if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET)//检测中断源是否来自按键一
			{
				HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_8);//反转！！！
			break;
			}
		case GPIO_PIN_1:
			if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1) == GPIO_PIN_RESET)//检测中断源是否来自按键二
			{
				HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_9);
			break;
			}
	}
}

4.2 振动传感器实战（震动输出低电平）

RCC和SYS设置同上
在这里插入图片描述

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
	//一根中断线上接有多个中断源，判断中断源是否来自PA4
	if(GPIO_Pin == GPIO_PIN_4)
	{
		//若检测到PA4被拉低
		if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_4) == GPIO_PIN_RESET)
		{	//则点亮LED1
			HAL_GPIO_WritePin(GPIOB,GPIO_PIN_8,GPIO_PIN_RESET);
			HAL_Delay(1000);
		}else{
			//若未检测到PA4，则关闭LED1
			HAL_GPIO_WritePin(GPIOB,GPIO_PIN_8,GPIO_PIN_SET);
		}
	}	
}

此处有问题！！！
如果直接在中断服务函数里调用 HAL_Delay 函数，则会造成系统卡死。
原因：程序初始化时默认把滴答定时器的中断优先级设为最低，其它中断源很容易打断它导致卡死。
解决：在 main 函数里使用以下函数提高滴答定时器的中断优先级（提升至0）：HAL_NVIC_SetPriority(SysTick_IRQn,0,0);
或者更改32的配置
在这里插入图片描述

4.3 继电器实战（低电平导通）

PB8—接入继电器 IN
代码直接使用上面振动传感器的就可以

4.4 433M无线发射接收模块实战（按键按下，高电平）

要求：按下遥控器A按键，LED1亮1s；按下遥控器B按键，LED2亮1s

配置相关按键
修改参数及开中断

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
	switch(GPIO_Pin)
	{
		//若检测到PA5被拉高（按键A被按下）
		case GPIO_PIN_5:
			if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_5) == GPIO_PIN_SET)
			{	//则将PB8拉低，点亮LED1亮1s
				HAL_GPIO_WritePin(GPIOB,GPIO_PIN_8,GPIO_PIN_RESET);
				HAL_Delay(1000);
				HAL_GPIO_WritePin(GPIOB,GPIO_PIN_8,GPIO_PIN_SET);
			}else{
				//若未检测到PA5，则关闭LED1
				HAL_GPIO_WritePin(GPIOB,GPIO_PIN_8,GPIO_PIN_SET);
			}
			break;
			
		//若检测到PA6被拉高（按键B被按下）
		case GPIO_PIN_6:
			if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_6) == GPIO_PIN_SET)
			{	//则将PB9拉低，点亮LED1亮1s
				HAL_GPIO_WritePin(GPIOB,GPIO_PIN_9,GPIO_PIN_RESET);
				HAL_Delay(1000);
				HAL_GPIO_WritePin(GPIOB,GPIO_PIN_9,GPIO_PIN_SET);
			}else{
				//若未检测到PA5，则关闭LED1
				HAL_GPIO_WritePin(GPIOB,GPIO_PIN_9,GPIO_PIN_SET);
			}
			break;
	}
}

4.5 电动车报警项目实现

STM32引脚	连接器件
PA4	振动传感器
PA5	433M无线接收模块
PA6	433M无线接收模块
PB7	继电器

//重写中断服务函数，若检测到EXIT中断，则进入该函数
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
	static int mark = J_OFF;
	//若检测到PA4被拉低，并且警报模式打开
	switch(GPIO_Pin)
	{
		case GPIO_PIN_4:
			if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_4) == GPIO_PIN_RESET && mark == J_ON)
			{
				//则将PB7拉低，继电器通电，喇叭一直响
				HAL_GPIO_WritePin(GPIOB,GPIO_PIN_7,GPIO_PIN_RESET);
			}
			break;
		//若检测到PA5被拉高（按键A被按下），设定为开启报警模式
		case GPIO_PIN_5:
			if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_5) == GPIO_PIN_SET)
			{
				//则将PB7拉低（喇叭响）2s，表示进入警报模式
				HAL_GPIO_WritePin(GPIOB,GPIO_PIN_7,GPIO_PIN_RESET);
				HAL_Delay(2000);
				HAL_GPIO_WritePin(GPIOB,GPIO_PIN_7,GPIO_PIN_SET);
				//同时设置标志位为ON
				mark = J_ON;
			}
			break;
		//若检测到PA6被拉高（按键B被按下），设定关闭警报模式
		case GPIO_PIN_6:
			if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_5) == GPIO_PIN_SET)
			{
				//则将PB7拉低（喇叭响）1s，表诉关闭警报模式
				HAL_GPIO_WritePin(GPIOB,GPIO_PIN_7,GPIO_PIN_RESET);
				HAL_Delay(1000);
				HAL_GPIO_WritePin(GPIOB,GPIO_PIN_7,GPIO_PIN_SET);
				//将标志位设置为OFF
				mark = J_OFF;
			}
			break;
	}
}

五. 定时器

定时器工作原理：
使用精准的时基，通过硬件的方式，实现定时功能。定时器核心就是计数器。
在这里插入图片描述
定时器计数模式：

定时器溢出时间计算公式：

参数	说明
Tout	想要设定的时间
PSC	预分频系数
ARR	自动重装载值

例如，要定时500ms，则：PSC=7199，ARR=4999，Tclk=72M

5.1 使用定时器中断点亮LED灯

需求：使用定时器中断方法，每500ms翻转一次LED1（PB8）灯状态

5.1.1 RCC配置

在这里插入图片描述

5.1.2. LED1灯配置

在这里插入图片描述

5.1.3 时钟数配置

在这里插入图片描述

5.1.4 重写更新中断回调函数

在这里插入图片描述

虚函数（中断函数）重写

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(htim->Instance == TIM2){
		HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_8);
	}
}

5.1.5 启动定时器

在main.c中，在定时器初始化命令之后加入以下代码：

HAL_TIM_Base_Start_IT(&htim2);

在这里插入图片描述

5.2 PWM

PWM模式1：在向上计数时，一旦 CNT < CCRx 时输出为有效电平（非高电平、低电平（具体看自己设置）），否则为无效电平；在向下计数时，一旦 CNT > CCRx 时输出为无效电平，否则为有效电平。
PWM模式2：在向上计数时，一旦 CNT < CCRx 时输出为无效电平，否则为有效电平；在向下计数时，一旦 CNT > CCRx 时输出为有效电平，否则为无效电平。
在这里插入图片描述

PWM周期与频率：

在这里插入图片描述
PWM占空比：由TIMx_CCRx寄存器决定。

5.2.1 PWM波实验

需求：使用PWM点亮LED1实现呼吸灯效果。
如何计算周期/频率？
假如频率为 2kHz ，则：PSC=71，ARR=499
LED1连接到哪个定时器的哪一路？
在这里插入图片描述
通道三
相关配置：

uint16_t pwmVal = 0;//调整占空比参数
uint16_t dir = 1;//改变方向 1:越来越亮 0：越来越暗

HAL_TIM_PWM_Start(&htim4,TIM_CHANNEL_3);//开启PWM波

  while (1)
  {
    /* USER CODE END WHILE */
		HAL_Delay(1);
		
		if(dir){
			pwmVal++;
		}else{
			pwmVal--;
		}
		
		if(pwmVal > 500){
			dir = 0;
		}else if(pwmVal == 0){
			dir = 1;
		}
		
		__HAL_TIM_SetCompare(&htim4,TIM_CHANNEL_3,pwmVal);//修改占空比
    /* USER CODE BEGIN 3 */
  }

5.3 感应开关盖垃圾桶

在这里插入图片描述

项目需求：
检测靠近时，垃圾桶自动开盖并伴随滴一声，2秒后关盖
发生震动时，垃圾桶自动开盖并伴随滴一声，2秒后关盖
按下按键时，垃圾桶自动开盖并伴随滴一声，2秒后关盖

5.3.1 sg90舵机（使用PWM波）

需求：每隔1s，转动一个角度：0度 --> 45度 --> 90度 --> 135度 --> 180度 --> 0度
确定周期/频率
在这里插入图片描述
如果周期为20ms，则 PSC=7199，ARR=199

角度控制：

1.0ms------------45度； 5.0% 对应函数中CCRx为10
1.5ms------------90度； 7.5% 对应函数中CCRx为15
2.0ms-----------135度； 10.0% 对应函数中CCRx为20
2.5ms-----------180度； 12.5% 对应函数中CCRx为25
相关配置：

	HAL_TIM_PWM_Start(&htim4,TIM_CHANNEL_3);//开启PWM波
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */
		HAL_Delay(1000);
		__HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_3, 5);//0度
		HAL_Delay(1000);
		__HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_3, 10);//45度
		HAL_Delay(1000);
		__HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_3, 15);//90度
		HAL_Delay(1000);
		__HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_3, 20);//135度
		HAL_Delay(1000);
		__HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_3, 25);//180度
			/* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

5.3.2 超声波传感器

怎么让它发送波
Trig ，给Trig端口至少10us的高电平
怎么知道它开始发了
Echo信号，由低电平跳转到高电平，表示开始发送波
怎么知道接收了返回波
Echo，由高电平跳转回低电平，表示波回来了
怎么算时间
Echo引脚维持高电平的时间！
波发出去的那一下，开始启动定时器
波回来的拿一下，我们开始停止定时器，计算出中间经过多少时间
怎么算距离
距离 = 速度（340m/s）* 时间/2

需求：
使用超声波测距，当手离传感器距离小于5cm时，LED1点亮，否则保持不亮状态。
接线：
Trig — PB6
Echo — PB7
LED1 — PB8
定时器配置：
使用 TIM2 ，只用作计数功能，不用作定时。
将 PSC 配置为71，则计数 1 次代表 1us 。

int cnt = 0;
float distance = 0;

while (1)
{
  /* USER CODE END WHILE */
	//1. Trig ，给Trig端口至少10us的高电平
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_6,GPIO_PIN_SET);
	TIM2_Delay_us(20);
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_6,GPIO_PIN_RESET);
	
	//2. echo由低电平跳转到高电平，表示开始发送波
	//波发出去的那一下，开始启动定时器
	while(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_7) == GPIO_PIN_RESET);
	HAL_TIM_Base_Start(&htim2);//开启计数器
	__HAL_TIM_SetCounter(&htim2,0);//从0开始计数
			
	//3. 由高电平跳转回低电平，表示波回来了
	//波回来的那一下，我们开始停止定时器
	while(HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_7) == GPIO_PIN_SET);
	HAL_TIM_Base_Stop(&htim2);//关闭计数器
	
	//4. 计算出中间经过多少时间
	cnt = __HAL_TIM_GetCounter(&htim2);//获取计数次数
	//5. 距离 = 速度 （340m/s）* 时间/2（计数1次表示1us）
	//340m/s = 34000cm/s = 34000cm/1000ms = 34000cm/1000000us = 34cm/1000us
	distance = cnt*340/2*0.000001*100;//单位：cm
	if(distance < 5){
		HAL_GPIO_WritePin(GPIOB,GPIO_PIN_8,GPIO_PIN_RESET);
	}else{
		HAL_GPIO_WritePin(GPIOB,GPIO_PIN_8,GPIO_PIN_SET);
	}
	//每500毫秒测试一次距离
	HAL_Delay(500);
   /* USER CODE BEGIN 3 */
}

5.3 垃圾桶项目

在这里插入图片描述

main

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2024 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "tim.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
#define OPEN 1
#define CLOSE 0
/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */
char flag = CLOSE;
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
//使用TIM2来做us级延时函数
void TIM2_Delay_us(uint16_t n_us)
{
	/* 使能定时器2计数 */
	__HAL_TIM_ENABLE(&htim2);
	__HAL_TIM_SetCounter(&htim2, 0);
	while(__HAL_TIM_GetCounter(&htim2) < ((1 * n_us)-1) );
	/* 关闭定时器2计数 */
	__HAL_TIM_DISABLE(&htim2);
}

double get_distance()
{
	int cnt = 0;
	
	//1. Trig ，给Trig端口至少10us的高电平
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_SET);//拉高
	TIM2_Delay_us(20);
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_RESET);//拉低
	//2. echo由低电平跳转到高电平，表示开始发送波
	//波发出去的那一下，开始启动定时器
	while(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_7) == GPIO_PIN_RESET);//等待输入电平拉高
	HAL_TIM_Base_Start(&htim2);
	__HAL_TIM_SetCounter(&htim2,0);
	//3. 由高电平跳转回低电平，表示波回来了
	while(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_7) == GPIO_PIN_SET);//等待输入电平变低
	//波回来的那一下，我们开始停止定时器
	HAL_TIM_Base_Stop(&htim2);
	//4. 计算出中间经过多少时间
	cnt = __HAL_TIM_GetCounter(&htim2);
	//5. 距离 = 速度 （340m/s）* 时间/2（计数1次表示1us）
	return (cnt*340/2*0.000001*100); //单位：cm
}

void openStatusLight()
{
	//点亮LED1
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_8,GPIO_PIN_RESET);
}

void closeStatusLight()
{
	//熄灭LED1
	HAL_GPIO_WritePin(GPIOB,GPIO_PIN_8,GPIO_PIN_SET);
}

void initSG90_0()
{
	HAL_TIM_PWM_Start(&htim4,TIM_CHANNEL_4);//启动定时器4
	__HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_4, 5);//将舵机置为0°
}

void openDusbin()
{
	if(flag == CLOSE){
		flag = OPEN;
		__HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_4, 15);//将舵机置为90°
		HAL_GPIO_WritePin(GPIOB,GPIO_PIN_4,GPIO_PIN_RESET);
		HAL_Delay(100);
		HAL_GPIO_WritePin(GPIOB,GPIO_PIN_4,GPIO_PIN_SET);
	}
	HAL_Delay(2000);
}

void closeDusbin()
{
	__HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_4, 5);//将舵机置为90°
	flag = CLOSE;
	HAL_Delay(150);
}

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
	if(GPIO_Pin == GPIO_PIN_0 || GPIO_Pin == GPIO_PIN_5){
		if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET ||//按键
			HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_5) == GPIO_PIN_RESET)		//震动传感器
		{
			openDusbin();
			openStatusLight();
		}
	}
		
}

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_TIM2_Init();
  MX_TIM4_Init();
  /* USER CODE BEGIN 2 */
	initSG90_0();
	HAL_NVIC_SetPriority(SysTick_IRQn,0,0);//在 main 函数里使用以下函数提高滴答定时器的中断优先级（提升至0）
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
		float distance;
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
		//超声波测距
		distance = get_distance();
		if(distance < 10){
			//点亮LED1
			openStatusLight();
			//开盖
			openDusbin();
		}else{
			//熄灭LED1
			closeStatusLight();
			//关盖
			closeDusbin();
		}
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

六. 串口

常用函数：串口发送/接收函数：

HAL_UART_Transmit(); 串口发送数据，使用超时管理机制
HAL_UART_Receive(); 串口接收数据，使用超时管理机制
HAL_UART_Transmit_IT(); 串口中断模式发送  
HAL_UART_Receive_IT(); 串口中断模式接收

串口中断回调函数：

HAL_UART_IRQHandler(UART_HandleTypeDef *huart); //串口中断处理函数
HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart); //发送中断回调函数
HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart); //接收中断回调函数

状态标记变量：

USART_RX_STA

从0开始，串口中断接收到一个数据（一个字节）就自增1。当数据读取全部OK时候（回车和换行符号来的时
候），那么 USART_RX_STA的最高位置1，表示串口数据接收全部完毕了，然后main函数里面可以处理数据
了。
在这里插入图片描述

6.1 串口实验（非中断）

需求：接受串口工具发送的字符串，并将其发送回串口工具。
串口配置：

选定串口

通过阻塞方式发送，每回点击32上的复位都显示字符
那么我们接下来来使用阻塞的方式来接收串口数据并发送

为了避免总是频繁的发送，那么只需对ch清空

接下来，我们采用printf函数，对串口数据进行传输
首先先改写printf()内部的代码

int fputc(int ch,FILE *f)
{
  unsigned char temp[1] = {ch};
	HAL_UART_Transmit(&huart1,temp,1,0xffff);
	return ch;
}

在while(1)里面

HAL_UART_Receive(&huart1,ch,19,100);
//HAL_UART_Transmit(&huart1,ch,strlen(ch),100);
printf(ch);
memset(ch,0,strlen(ch));

但是一定要注意！！！
在这里插入图片描述
一定一定一定要这个打开（重要的事情讲三遍！！！）

发送成功！！！

6.2 串口实验（中断）

在这里插入图片描述
串口中断调用的虚函数—进行重写

// 接收完成回调函数，收到一个数据后，在这里处理
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	// 判断中断是由哪个串口触发的
	if(huart->Instance == USART1)
	{
		// 判断接收是否完成（UART1_RX_STA bit15 位是否为1）
		if((UART1_RX_STA & 0x8000) == 0)
		{
			// 如果已经收到了 0x0d （回车），
			if(UART1_RX_STA & 0x4000)
			{
				// 则接着判断是否收到 0x0a （换行）
				if(buf == 0x0a)
					// 如果 0x0a 和 0x0d 都收到，则将 bit15 位置为1
					UART1_RX_STA |= 0x8000;
				else
					// 否则认为接收错误，重新开始
					UART1_RX_STA = 0;
			}
			else	// 如果没有收到了 0x0d （回车）
			{
				//则先判断收到的这个字符是否是 0x0d （回车）
				if(buf == 0x0d)
				{
					// 是的话则将 bit14 位置为1
					UART1_RX_STA |= 0x4000;
				}
				else
				{
					// 否则将接收到的数据保存在缓存数组里
					UART1_RX_Buffer[UART1_RX_STA & 0X3FFF] = buf;
					UART1_RX_STA++;
					
					// 如果接收数据大于UART1_REC_LEN（200字节），则重新开始接收
					if(UART1_RX_STA > UART1_REC_LEN - 1)
						UART1_RX_STA = 0;
				}
			}
		}
		// 重新开启中断
		HAL_UART_Receive_IT(&huart1, &buf, 1);
	}
}

while(1)内部程序

  /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
		//判断判断串口是否接收完成
		if(UART1_RX_STA & 0x8000)
		{
			printf("收到数据：");
			// 将收到的数据发送到串口
			HAL_UART_Transmit(&huart1, UART1_RX_Buffer, UART1_RX_STA & 0x3fff, 0xffff);
			// 等待发送完成
			while(huart1.gState != HAL_UART_STATE_READY);
			printf("\r\n");
			// 重新开始下一次接收
			UART1_RX_STA = 0;
		}
		printf("hello qiang\r\n");
		HAL_Delay(1000);

在这里插入图片描述

6.3 蓝牙插座_风扇 _灯（非中断）

在这里插入图片描述

HAL_UART_Transmit(&huart1, (uint8_t *)"hello world\n", strlen("hello world\n"), 100);
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
		HAL_UART_Receive(&huart1, ch, 19, 100);
		//HAL_UART_Transmit(&huart1, ch, strlen(ch), 100);
		//printf(ch);
		printf("%s", ch);
		if(!strcmp((const char *)ch, "open"))
		{
			HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_RESET);
			if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_8) == GPIO_PIN_RESET)
				printf("LED1已经打开\r\n");
		}
		else if (!strcmp((const char *)ch, "close"))
		{
			HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_SET);
			if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_8) == GPIO_PIN_SET)
				printf("LED1已经关闭\r\n");
		}
		else
		{
			if(ch[0] != '\0')
				printf("指令发送错误：%s\r\n", ch);
		}
		memset(ch, 0, strlen((const char *)ch));
  }

在这里插入图片描述

6.4 蓝牙插座_风扇 _灯（中断）

 while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
		//判断判断串口是否接收完成
		if(UART1_RX_STA & 0x8000)
		{
			printf("收到数据：");
			if(!strcmp((const char *)UART1_RX_Buffer, "open"))
		{
			HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_RESET);
			if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_8) == GPIO_PIN_RESET)
				printf("LED1已经打开\r\n");
		}
		else if (!strcmp((const char *)UART1_RX_Buffer, "close"))
		{
			HAL_GPIO_WritePin(GPIOB, GPIO_PIN_8, GPIO_PIN_SET);
			if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_8) == GPIO_PIN_SET)
				printf("LED1已经关闭\r\n");
		}
		else
		{
			if(UART1_RX_Buffer[0] != '\0')
				printf("指令发送错误：%s\r\n", UART1_RX_Buffer);
		}
			printf("\r\n");
			// 重新开始下一次接收
			UART1_RX_STA = 0;
		}
		//printf("hello qiang\r\n");
		HAL_Delay(40);

  }

6.5 ESP工作为AP路由模式并当成服务器

在这里插入图片描述

main.c函数中全部代码

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2022 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "usart.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <stdio.h>
#include <string.h>
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
//串口接收缓存（1字节）
uint8_t buf=0;

//定义最大接收字节数 200，可根据需求调整
#define UART1_REC_LEN 200

// 接收缓冲, 串口接收到的数据放在这个数组里，最大UART1_REC_LEN个字节
uint8_t UART1_RX_Buffer[UART1_REC_LEN];

//  接收状态
//  bit15，      接收完成标志
//  bit14，      接收到0x0d
//  bit13~0，    接收到的有效字节数目
uint16_t UART1_RX_STA=0;

char LJWL[]  = "AT+CWJAP=\"TP-LINK_3E30\",\"18650711783\"\r\n"; //入网指令
char LJFWQ[] = "AT+CIPSTART=\"TCP\",\"192.168.0.113\",8880\r\n"; //连接服务器指令
char TCMS[]  = "AT+CIPMODE=1\r\n";  //透传指令
char SJCS[]  = "AT+CIPSEND\r\n";	//数据传输开始指令
char QCMK[] = "AT+RST\r\n";		//重启模块指令
char AT_OK_Flag = 0;				//OK返回值的标志位
char AT_Connect_Net_Flag = 0;		//WIFI GOT IP返回值的标志位
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
// 接收完成回调函数，收到一个数据后，在这里处理
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	// 判断中断是由哪个串口触发的
	if(huart->Instance == USART1)
	{
		// 判断接收是否完成（UART1_RX_STA bit15 位是否为1）
		if((UART1_RX_STA & 0x8000) == 0)
		{
			// 如果已经收到了 0x0d （回车），
			if(UART1_RX_STA & 0x4000)
			{
				// 则接着判断是否收到 0x0a （换行）
				if(buf == 0x0a){
					// 如果 0x0a 和 0x0d 都收到，则将 bit15 位置为1
					UART1_RX_STA |= 0x8000;
					//查看是都收到WIFI GOT IP
					if(!strcmp(UART1_RX_Buffer,"WIFI GOT IP"))
						AT_Connect_Net_Flag = 1;
						
					//查看是否收到 OK
					if(!strcmp(UART1_RX_Buffer,"OK"))
						AT_OK_Flag = 1;
					
					//查看是否收到FAIL
					if(!strcmp(UART1_RX_Buffer,"FAIL")){
						int i = 0;
						for(i=0;i<5;i++){
							HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_8);
							HAL_Delay(1000);
						}
						printf(QCMK);
					}
					
					//灯控指令
					if(!strcmp(UART1_RX_Buffer,"L-1"))
						HAL_GPIO_WritePin(GPIOB,GPIO_PIN_8,GPIO_PIN_RESET);
					if(!strcmp(UART1_RX_Buffer,"L-0"))
						HAL_GPIO_WritePin(GPIOB,GPIO_PIN_8,GPIO_PIN_SET);
					
					memset(UART1_RX_Buffer,0,UART1_REC_LEN);
					UART1_RX_STA = 0;
				}else
					// 否则认为接收错误，重新开始
					UART1_RX_STA = 0;
			}
			else	// 如果没有收到了 0x0d （回车）
			{
				//则先判断收到的这个字符是否是 0x0d （回车）
				if(buf == 0x0d)
				{
					// 是的话则将 bit14 位置为1
					UART1_RX_STA |= 0x4000;
				}
				else
				{
					// 否则将接收到的数据保存在缓存数组里
					UART1_RX_Buffer[UART1_RX_STA & 0X3FFF] = buf;
					UART1_RX_STA++;
					
					// 如果接收数据大于UART1_REC_LEN（200字节），则重新开始接收
					if(UART1_RX_STA > UART1_REC_LEN - 1)
						UART1_RX_STA = 0;
				}
			}
		}
		// 重新开启中断
		HAL_UART_Receive_IT(&huart1, &buf, 1);
	}
}

int fputc(int ch, FILE *f)
{      
	unsigned char temp[1]={ch};
	HAL_UART_Transmit(&huart1,temp,1,0xffff);  
	return ch;
}
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART1_UART_Init();
  MX_USART2_UART_Init();
  /* USER CODE BEGIN 2 */
	HAL_NVIC_SetPriority(SysTick_IRQn,0,0);
	// 开启接收中断
	HAL_UART_Receive_IT(&huart1, &buf, 1);
	HAL_UART_Transmit(&huart2,"Let's go\r\n",strlen("Let's go\r\n"),100);
	printf(LJWL);
	//while(!AT_Connect_Net_Flag);
	while(!AT_OK_Flag) HAL_Delay(50);
	HAL_UART_Transmit(&huart2,"333\r\n",strlen("333\r\n"),100);
	AT_OK_Flag = 0;
	//发送连服务器指令并等待成功
	printf(LJFWQ);
	while(!AT_OK_Flag) HAL_Delay(50);
	AT_OK_Flag = 0;
	//发送透传模式指令并等待成功
	printf(TCMS);
	while(!AT_OK_Flag) HAL_Delay(50);
	AT_OK_Flag = 0;
	//发送数据传输指令并等待成功
	printf(SJCS);
	while(!AT_OK_Flag) HAL_Delay(50);
	
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
		HAL_UART_Transmit(&huart2,"hello qiang\r\n",strlen("hello qiang\r\n"),100);
		HAL_Delay(3000);

  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

6.6 板子当作路由和服务器模式控制

main主函数内部代码

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2022 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "usart.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <stdio.h>
#include <string.h>
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
//串口接收缓存（1字节）
uint8_t buf=0;

//定义最大接收字节数 200，可根据需求调整
#define UART1_REC_LEN 200

// 接收缓冲, 串口接收到的数据放在这个数组里，最大UART1_REC_LEN个字节
uint8_t UART1_RX_Buffer[UART1_REC_LEN];

//  接收状态
//  bit15，      接收完成标志
//  bit14，      接收到0x0d
//  bit13~0，    接收到的有效字节数目
uint16_t UART1_RX_STA=0;

//1 工作在路由模式
char LYMO[] = "AT+CWMODE=2\r\n";
//2 使能多链接
char DLJ[] = "AT+CIPMUX=1\r\n"; 
//3 建立TCPServer
char JLFW[] = "AT+CIPSERVER=1\r\n"; // default port = 333 

//发送数据
char FSSJ[] = "AT+CIPSEND=0,5\r\n";

char AT_OK_Flag = 0;				//OK返回值的标志位
char AT_Connect_Net_Flag = 0;		//WIFI GOT IP返回值的标志位
char Client_Connect_Flag = 0;

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
// 接收完成回调函数，收到一个数据后，在这里处理
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	// 判断中断是由哪个串口触发的
	if(huart->Instance == USART1)
	{
		// 判断接收是否完成（UART1_RX_STA bit15 位是否为1）
		if((UART1_RX_STA & 0x8000) == 0)
		{
			// 如果已经收到了 0x0d （回车），
			if(UART1_RX_STA & 0x4000)
			{
				// 则接着判断是否收到 0x0a （换行）
				if(buf == 0x0a){
					// 如果 0x0a 和 0x0d 都收到，则将 bit15 位置为1
					UART1_RX_STA |= 0x8000;
					//查看是都收到WIFI GOT IP
					if(!strcmp(UART1_RX_Buffer,"WIFI GOT IP"))
						AT_Connect_Net_Flag = 1;
						
					//查看是否收到 OK
					if(!strcmp(UART1_RX_Buffer,"OK"))
						AT_OK_Flag = 1;
					
					//查看是否收到FAIL
					if(!strcmp(UART1_RX_Buffer,"0,CONNECT"))
						Client_Connect_Flag	= 1;
						
					
					//灯控指令
					if(!strcmp(UART1_RX_Buffer,"L-1"))
						HAL_GPIO_WritePin(GPIOB,GPIO_PIN_8,GPIO_PIN_RESET);
					if(!strcmp(UART1_RX_Buffer,"L-0"))
						HAL_GPIO_WritePin(GPIOB,GPIO_PIN_8,GPIO_PIN_SET);
					
					memset(UART1_RX_Buffer,0,UART1_REC_LEN);
					UART1_RX_STA = 0;
				}else
					// 否则认为接收错误，重新开始
					UART1_RX_STA = 0;
			}
			else	// 如果没有收到了 0x0d （回车）
			{
				//则先判断收到的这个字符是否是 0x0d （回车）
				if(buf == 0x0d)
				{
					// 是的话则将 bit14 位置为1
					UART1_RX_STA |= 0x4000;
				}
				else
				{
					// 否则将接收到的数据保存在缓存数组里
					UART1_RX_Buffer[UART1_RX_STA & 0X3FFF] = buf;
					UART1_RX_STA++;
					
					// 如果接收数据大于UART1_REC_LEN（200字节），则重新开始接收
					if(UART1_RX_STA > UART1_REC_LEN - 1)
						UART1_RX_STA = 0;
				}
			}
		}
		// 重新开启中断
		HAL_UART_Receive_IT(&huart1, &buf, 1);
	}
}

int fputc(int ch, FILE *f)
{      
	unsigned char temp[1]={ch};
	HAL_UART_Transmit(&huart1,temp,1,0xffff);  
	return ch;
}
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART1_UART_Init();
  MX_USART2_UART_Init();
  /* USER CODE BEGIN 2 */
	HAL_NVIC_SetPriority(SysTick_IRQn,0,0);
	// 开启接收中断
	HAL_UART_Receive_IT(&huart1, &buf, 1);
	HAL_UART_Transmit(&huart2,"Let's go\r\n",strlen("Let's go\r\n"),100);
	
	
	printf(LYMO);
	while(!AT_OK_Flag) HAL_Delay(50);
	AT_OK_Flag = 0;
	printf(DLJ);
	while(!AT_OK_Flag) HAL_Delay(50);
	AT_OK_Flag = 0;
	printf(JLFW);

	while(!Client_Connect_Flag) HAL_Delay(50);
	AT_OK_Flag = 0;	
	if(Client_Connect_Flag){
		HAL_GPIO_WritePin(GPIOB,GPIO_PIN_8,GPIO_PIN_RESET);
		HAL_GPIO_WritePin(GPIOB,GPIO_PIN_9,GPIO_PIN_RESET);
	}
	
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
		
		//4 发送数据
		printf(FSSJ);
		HAL_Delay(2000);
		printf("Hello");
		HAL_Delay(2000);

  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

6.7 4G遥控插座_风扇_灯

加粗样式
main.c主函数

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2022 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "usart.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <stdio.h>
#include <string.h>
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
//串口接收缓存（1字节）
uint8_t buf=0;

//定义最大接收字节数 200，可根据需求调整
#define UART1_REC_LEN 200

// 接收缓冲, 串口接收到的数据放在这个数组里，最大UART1_REC_LEN个字节
uint8_t UART1_RX_Buffer[UART1_REC_LEN];

//  接收状态
//  bit15，      接收完成标志
//  bit14，      接收到0x0d
//  bit13~0，    接收到的有效字节数目
uint16_t UART1_RX_STA=0;

#define SIZE 12

char buffer[SIZE];

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
// 接收完成回调函数，收到一个数据后，在这里处理
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	// 判断中断是由哪个串口触发的
	if(huart->Instance == USART1)
	{
		// 判断接收是否完成（UART1_RX_STA bit15 位是否为1）
		if((UART1_RX_STA & 0x8000) == 0)
		{
			// 如果已经收到了 0x0d （回车），
			if(UART1_RX_STA & 0x4000)
			{
				// 则接着判断是否收到 0x0a （换行）
				if(buf == 0x0a){
					// 如果 0x0a 和 0x0d 都收到，则将 bit15 位置为1
					UART1_RX_STA |= 0x8000;
					
					//灯控指令
					if(!strcmp(UART1_RX_Buffer,"L-1"))
						HAL_GPIO_WritePin(GPIOB,GPIO_PIN_8,GPIO_PIN_RESET);
					if(!strcmp(UART1_RX_Buffer,"L-0"))
						HAL_GPIO_WritePin(GPIOB,GPIO_PIN_8,GPIO_PIN_SET);
					
					memset(UART1_RX_Buffer,0,UART1_REC_LEN);
					UART1_RX_STA = 0;
				}else
					// 否则认为接收错误，重新开始
					UART1_RX_STA = 0;
			}
			else	// 如果没有收到了 0x0d （回车）
			{
				//则先判断收到的这个字符是否是 0x0d （回车）
				if(buf == 0x0d)
				{
					// 是的话则将 bit14 位置为1
					UART1_RX_STA |= 0x4000;
				}
				else
				{
					// 否则将接收到的数据保存在缓存数组里
					UART1_RX_Buffer[UART1_RX_STA & 0X3FFF] = buf;
					UART1_RX_STA++;
					
					// 如果接收数据大于UART1_REC_LEN（200字节），则重新开始接收
					if(UART1_RX_STA > UART1_REC_LEN - 1)
						UART1_RX_STA = 0;
				}
			}
		}
		// 重新开启中断
		HAL_UART_Receive_IT(&huart1, &buf, 1);
	}
}

int fputc(int ch, FILE *f)
{      
	unsigned char temp[1]={ch};
	HAL_UART_Transmit(&huart1,temp,1,0xffff);  
	return ch;
}
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART1_UART_Init();
  MX_USART2_UART_Init();
  /* USER CODE BEGIN 2 */
	HAL_NVIC_SetPriority(SysTick_IRQn,0,0);
	// 开启接收中断
	HAL_UART_Receive_IT(&huart1, &buf, 1);
	HAL_UART_Transmit(&huart2,"Let's go\r\n",strlen("Let's go\r\n"),100);
	
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
		
		//4 发送数据
		HAL_Delay(2000);

  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

七. 看门狗

在由单片机构成的微型计算机系统中，由于单片机的工作常常会受到来自外界电磁场的干扰，造成程序的跑飞，而陷入死循环，程序的正常运行被打断，由单片机控制的系统无法继续工作，会造成整个系统的陷入停滞状态，发生不可预料的后果，所以出于对单片机运行状态进行实时监测的考虑，便产生了一种专门用于监测单片机程序运行状态的模块或者芯片，俗称“看门狗”(watchdog) 。
独立看门狗工作在主程序之外，能够完全独立工作，它的时钟是专用的低速时钟（LSI），由 VDD 电压供电，在停止模式和待机模式下仍能工作。

7.1 独立看门狗本质

本质是一个 12 位的递减计数器，当计数器的值从某个值一直减到0的时候，系统就会产生一个复位信号，即IWDG_RESET 。
如果在计数没减到0之前，刷新了计数器的值的话，那么就不会产生复位信号，这个动作就是我们经常说的喂狗。

7.2 独立看门狗框图

在这里插入图片描述

7.3 独立看门狗时钟

独立看门狗的时钟由独立的RC振荡器LSI提供，即使主时钟发生故障它仍然有效，非常独立。启用IWDG后，LSI时钟会自动开启。LSI时钟频率并不精确，F1用40kHz。
LSI经过一个8位的预分频器得到计数器时钟。
在这里插入图片描述
分频系数算法：

重装载寄存器
重装载寄存器是一个12位的寄存器，用于存放重装载值，低12位有效，即最大值为4096，这个值的大小决定着独立看门狗的溢出时间。

键寄存器
键寄存器IWDG_KR可以说是独立看门狗的一个控制寄存器，主要有三种控制方式，往这个寄存器写入下面三个不同的值有不同的效果。
在这里插入图片描述
溢出时间计算公式

7.4 独立看门狗实验 IWDG

开启独立看门狗，溢出时间为1秒，使用按键1进行喂狗
溢出时间计算： PSC为固定值，上面的预分频寄存器(IWDG_PR)，有8种可能性
PSC=64，RLR=625 fiwdg = 40KHZ

打开看门狗
打开串口

编程：

当我们未进行喂狗时，32会一直重启，每隔1s重启一次！

那么我们设置喂狗

if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET)
	HAL_IWDG_Refresh(&hiwdg);//喂狗函数
HAL_Delay(50);

当一直按按键1 则不会打印信息

7.5 窗口看门狗WWDG

7.5.1 简介

窗口看门狗用于监测单片机程序运行时效是否精准，主要检测软件异常，一般用于需要精准检测程序运行时间的场合。
独立看门狗检测硬件异常
窗口看门狗的本质是一个能产生系统复位信号和提前唤醒中断的6位计数器。
产生复位条件：

当递减计数器值从 0x40 减到 0x3F 时复位（即T6位跳变到0）
计数器的值大于 W[6:0] 值时喂狗会复位。

产生中断条件：

当递减计数器等于 0x40 时可产生提前唤醒中断 (EWI)。

窗口看门狗工作原理
在这里插入图片描述
WWDG框图

控制寄存器

配置寄存器

状态寄存器

超时时间计算

Tout是WWDG超时时间（没喂狗）
Fwwdg是WWDG的时钟源频率（最大36M）
4096是WWDG固定的预分频系数
2^WDGTB是WWDG_CFR寄存器设置的预分频系数值
T[5:0]是WWDG计数器低6位，最多63

7.5.2 实验

开启窗口看门狗，计数器值设置为 0X7F ，窗口值设置为 0X5F ，预分频系数为 8 。程序启动时点亮 LED1 ，300ms 后熄灭。在提前唤醒中断服务函数进行喂狗，同时翻转 LED2 状态。
在这里插入图片描述

八. DMA

8.1 DMA 简介

DMA(Direct Memory Access，直接存储器访问) 提供在外设与内存、存储器和存储器、外设与外设之间的高速数据传输使用。它允许不同速度的硬件装置来沟通，而不需要依赖于CPU，在这个时间中，CPU对于内存的工作来说就无法使用。
DMA的意义
代替 CPU 搬运数据，为 CPU 减负。

数据搬运的工作比较耗时间；
数据搬运工作时效要求高（有数据来就要搬走）；
没啥技术含量（CPU 节约出来的时间可以处理更重要的事）。

搬运什么数据：存储器、外设
三种搬运方式：

存储器→存储器（例如：复制某特别大的数据buf）
存储器→外设（例如：将某数据buf写入串口TDR寄存器）
外设→存储器（例如：将串口RDR寄存器写入某数据buf）

存储器→存储器
在这里插入图片描述
存储器→外设

外设→存储器

DMA 控制器
STM32F103有2个 DMA 控制器，DMA1有7个通道，DMA2有5个通道。
一个通道每次只能搬运一个外设的数据！！ 如果同时有多个外设的 DMA 请求，则按照优先级进行响应。
DMA1有7个通道：
在这里插入图片描述
DMA2有5个通道

DMA及通道的优先级
优先级管理采用软件+硬件：

软件：每个通道的优先级可以在DMA_CCRx寄存器中设置，有4个等级
最高级>高级>中级>低级
硬件：如果2个请求，它们的软件优先级相同，则较低编号的通道比较高编号的通道有较高的优先权。
比如：如果软件优先级相同，通道2优先于通道4

DMA传输方式

DMA_Mode_Normal（正常模式）
一次DMA数据传输完后，停止DMA传送，也就是只传输一次
DMA_Mode_Circular（循环传输模式）
当传输结束时，硬件自动会将传输数据量寄存器进行重装，进行下一轮的数据传输。也就是多次传输模

指针递增模式
外设和存储器指针在每次传输后可以自动向后递增或保持常量。当设置为增量模式时，下一个要传输的地址将是前一个地址加上增量值。
在这里插入图片描述
地址只有一个（串口）下图所示

上面是两种方式！！！

8.2 实验一、内存到内存搬运

在这里插入图片描述

使用DMA的方式将数组A的内容复制到数组B中，搬运完之后将数组B的内容打印到屏幕
用到的库函数

1. HAL_DMA_Start----开DMA
HAL_StatusTypeDef HAL_DMA_Start(DMA_HandleTypeDef *hdma, 
								uint32_t SrcAddress,
								uint32_t DstAddress, 
								uint32_t DataLength)
参数一：DMA_HandleTypeDef *hdma，DMA通道句柄
参数二：uint32_t SrcAddress，源内存地址
参数三：uint32_t DstAddress，目标内存地址
参数四：uint32_t DataLength，传输数据长度。注意：需要乘以sizeof(uint32_t)
返回值：HAL_StatusTypeDef，HAL状态（OK，busy，ERROR，TIMEOUT）

2. __HAL_DMA_GET_FLAG---标志
#define __HAL_DMA_GET_FLAG(__HANDLE__, __FLAG__)
参数一：HANDLE，DMA通道句柄
参数二：FLAG，数据传输标志。==DMA_FLAG_TCx==表示数据传输完成标志
返回值：FLAG的值（SET/RESET）完成返回SET 未返回RESET

代码实现：

开启数据传输
等待数据传输完成
打印数组内容

在这里插入图片描述
打开串口

在这里插入图片描述

//源数组
uint32_t srcBuf[BUF_SIZE]={
	0x00000000,0x11111111,0x22222222,0x33333333,
	0x44444444,0x55555555,0x66666666,0x77777777,
	0x88888888,0x99999999,0xAAAAAAAA,0xBBBBBBBB,
	0xCCCCCCCC,0xDDDDDDDD,0xEEEEEEEE,0xFFFFFFFF
};
//目录数组
uint32_t desBuf[BUF_SIZE];

int fputc(int ch,FILE *f)
{
	unsigned char temp[1] = {ch};
	HAL_UART_Transmit(&huart1,temp,1,0xffff);
	return ch;
}

//1.开启数据传输
/*
HAL_StatusTypeDef HAL_DMA_Start(DMA_HandleTypeDef *hdma, 
								uint32_t SrcAddress,
								uint32_t DstAddress, 
								uint32_t DataLength)
参数一：DMA_HandleTypeDef *hdma，DMA通道句柄
参数二：uint32_t SrcAddress，源内存地址
参数三：uint32_t DstAddress，目标内存地址
参数四：uint32_t DataLength，传输数据长度。注意：需要乘以sizeof(uint32_t)
返回值：HAL_StatusTypeDef，HAL状态（OK，busy，ERROR，TIMEOUT）
*/
HAL_DMA_Start(&hdma_memtomem_dma1_channel1,(uint32_t)srcBuf,(uint32_t)desBuf,BUF_SIZE*sizeof(uint32_t));
//2.等待数据完成
while(__HAL_DMA_GET_FLAG(&hdma_memtomem_dma1_channel1,DMA_FLAG_TC1) == RESET);
//打印数组内容
for(i=0;i<BUF_SIZE;i++){
	printf("Buf[%d] = %X\r\n",i,desBuf);
}

8.2 实验二、内存到外设搬运

在这里插入图片描述

使用DMA的方式将内存数据搬运到串口1发送寄存器，同时闪烁LED1。
用到的库函数

HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart, 
										uint8_t *pData,
										uint16_t Size)
参数一：UART_HandleTypeDef *huart，串口句柄
参数二：uint8_t *pData，待发送数据首地址
参数三：uint16_t Size，待发送数据长度
返回值：HAL_StatusTypeDef，HAL状态（OK，busy，ERROR，TIMEOUT）

代码实现：

准备数据
将数据通过串口DMA发送

在这里插入图片描述

//待发送数据
unsigned char sendBuf[BUF_SIZE] = {0};

for(i=0;i<BUF_SIZE;i++){
	sendBuf[i] = 'A';
}
	
//将数据通过串口DMA发送
/*
HAL_StatusTypeDef HAL_UART_Transmit_DMA(UART_HandleTypeDef *huart, 
										uint8_t *pData,
										uint16_t Size)
参数一：UART_HandleTypeDef *huart，串口句柄
参数二：uint8_t *pData，待发送数据首地址
参数三：uint16_t Size，待发送数据长度
返回值：HAL_StatusTypeDef，HAL状态（OK，busy，ERROR，TIMEOUT）
*/
HAL_UART_Transmit_DMA(&huart1,sendBuf,BUF_SIZE);

//main.c
HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_8);
HAL_Delay(100);

在这里插入图片描述
小灯一直在翻转，数据也在一直发送直到BUF_SIZE大小全部发送完，说明不占用CPU时间

小灯一直闪，数据一直发送

8.3 实验三、外设到内存搬运

在这里插入图片描述
实验要求
使用DMA的方式将串口接收缓存寄存器的值搬运到内存中，同时闪烁LED1。

用到的库函数

1. __HAL_UART_ENABLE
__HAL_UART_ENABLE_IT(__HANDLE__, __INTERRUPT__)
参数一：HANDLE，串口句柄
参数二：INTERRUPT，需要使能的中断
返回值：无

2. HAL_UART_Receive_DMA
HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef *huart, 
										uint8_t *pData,
										uint16_t Size)
参数一：UART_HandleTypeDef *huart，串口句柄
参数二：uint8_t *pData，接收缓存首地址
参数三：uint16_t Size，接收缓存长度
返回值：HAL_StatusTypeDef，HAL状态（OK，busy，ERROR，TIMEOUT）

3. __HAL_UART_GET_FLAG
__HAL_UART_GET_FLAG(__HANDLE__, __FLAG__)
参数一：HANDLE，串口句柄
参数二：FLAG，需要查看的FLAG
返回值：FLAG的值

4. __HAL_UART_CLEAR_IDLEFLAG
__HAL_UART_CLEAR_IDLEFLAG(__HANDLE__)
参数一：HANDLE，串口句柄
返回值：无

5. HAL_UART_DMAStop
HAL_StatusTypeDef HAL_UART_DMAStop(UART_HandleTypeDef *huart)
参数一：UART_HandleTypeDef *huart，串口句柄
返回值：HAL_StatusTypeDef，HAL状态（OK，busy，ERROR，TIMEOUT）

6. __HAL_DMA_GET_COUNTER
__HAL_DMA_GET_COUNTER(__HANDLE__)
参数一：HANDLE，串口句柄
返回值：未传输数据大小

代码实现
如何判断串口接收是否完成？如何知道串口收到数据的长度？
使用串口空闲中断（IDLE）！

串口空闲时，触发空闲中断；
空闲中断标志位由硬件置1，软件清零

利用串口空闲中断，可以用如下流程实现DMA控制的任意长数据接收：

使能IDLE空闲中断；
使能DMA接收中断；
收到串口接收中断，DMA不断传输数据到缓冲区；
一帧数据接收完毕，串口暂时空闲，触发串口空闲中断；
在中断服务函数中，清除中断标志位，关闭DMA传输（防止干扰）；
计算刚才收到了多少个字节的数据。
处理缓冲区数据，开启DMA传输，开始下一帧接收。

在这里插入图片描述

九. ADC

9.1 ADC是什么？

在这里插入图片描述

9.2 ADC的性能指标

量程：能测量的电压范围
分辨率：ADC能辨别的最小模拟量，通常以输出二进制数的位数表示，比如：8、10、12、16位等；位数越多，分辨率越高，一般来说分辨率越高，转化时间越长
转化时间：从转换开始到获得稳定的数字量输出所需要的时间称为转换时间

9.3 ADC特性

12位精度下转换速度可高达1MHZ
供电电压：V SSA ：0V，V DDA ：2.4V~3.6V
ADC输入范围：VREF- ≤ VIN ≤ VREF+ 0~3.3V
采样时间可配置，采样时间越长, 转换结果相对越准确, 但是转换速度就越慢
ADC 的结果可以左对齐或右对齐方式存储在 16 位数据寄存器中

9.4 ADC通道

总共2个ADC（ADC1，ADC2），每个ADC有18个转换通道: 16个外部通道、 2个内部通道（温度传感器、内部参考电压）。
在这里插入图片描述
外部的16个通道在转换时又分为规则通道和注入通道，其中规则通道最多有16路，注入通道最多有4路。
规则组：正常排队的人；
注入组：有特权的人（军人、孕妇）

9.5 ADC转换顺序

每个ADC只有一个数据寄存器，16个通道一起共用这个寄存器，所以需要指定规则转换通道的转换顺序。
规则通道中的转换顺序由三个寄存器控制：SQR1、SQR2、SQR3，它们都是32位寄存器。SQR寄存器控制着转换通道的数目和转换顺序，只要在对应的寄存器位SQx中写入相应的通道，这个通道就是第x个转换。
在这里插入图片描述
和规则通道转换顺序的控制一样，注入通道的转换也是通过注入寄存器来控制，只不过只有一个JSQR寄存器来控制，控制关系如下：

9.6 ADC触发方式

在这里插入图片描述

9.7 ADC转化时间

在这里插入图片描述

9.7 实验：使用ADC读取烟雾传感器的值

在这里插入图片描述

#include "stdio.h"

int fputc(int ch,FILE *f)
{
    unsigned char temp[1] = {ch};
    HAL_UART_Transmit(&huart1,temp,1,0xffff);
    return ch;
}

  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
      HAL_ADC_Start(&hadc1);//启动ADC1转换
      HAL_ADC_PollForConversion(&hadc1,50);//等待ADC转换完成
      smoke_value = HAL_ADC_GetValue(&hadc1);
      printf("some_value = %f\r\n",3.3/4096 *smoke_value);
      //printf("some_value = %d\r\n",smoke_value);
      HAL_Delay(500);
      
  }

十. IIC

HAL_StatusTypeDef HAL_I2C_Mem_Write(I2C_HandleTypeDef *hi2c,
									uint16_t DevAddress,
									uint16_t MemAddress,
									uint16_t MemAddSize,
									uint8_t *pData,
									uint16_t Size,
									uint32_t Timeout)
参数一：I2C_HandleTypeDef *hi2c，I2C设备句柄
参数二：uint16_t DevAddress，目标器件的地址，七位地址必须左对齐
参数三：uint16_t MemAddress，目标器件的目标寄存器地址
参数四：uint16_t MemAddSize，目标器件内部寄存器地址数据长度
参数五：uint8_t *pData，待写的数据首地址
参数六：uint16_t Size，待写的数据长度
参数七：uint32_t Timeout，超时时间
返回值：HAL_StatusTypeDef，HAL状态（OK，busy，ERROR，TIMEOUT）

向OLED写命令的封装：
void Oled_Write_Cmd(uint8_t dataCmd)
{
	HAL_I2C_Mem_Write(&hi2c1, 0x78, 0x00, I2C_MEMADD_SIZE_8BIT,
	&dataCmd, 1, 0xff);
}

向OLED写数据的封装：

void Oled_Write_Data(uint8_t dataData)
{
	HAL_I2C_Mem_Write(&hi2c1, 0x78, 0x40, I2C_MEMADD_SIZE_8BIT,
	&dataData, 1, 0xff);
}

在这里插入图片描述

void Oled_Write_Cmd(uint8_t dataCmd)
{
    HAL_I2C_Mem_Write(&hi2c1,0x78,0x00,I2C_MEMADD_SIZE_8BIT,
                        &dataCmd,1,0xff);
}

void Oled_Write_Data(uint8_t dataData)
{
    HAL_I2C_Mem_Write(&hi2c1,0x78,0x40,I2C_MEMADD_SIZE_8BIT,
                        &dataData,1,0xff);
}