STM32HAL库笔记

最新推荐文章于 2025-04-14 13:40:34 发布
最新推荐文章于 2025-04-14 13:40:34 发布
阅读量439 收藏 1
点赞数 11
分类专栏： STM32 文章标签： stm32 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2502_90478897/article/details/147191814
版权
使用CubeMX创建工程：

进入CubeMX,先选好芯片，配置时钟源、系统定时、时钟树和其他所需功能，设置工程文件名和保存位置（最好预先新建一个文件夹用来保存工程，最后生成工程

HAL库常用函数：

1.系统与时钟控制

HAL_Init();                  // 初始化HAL库
SystemClock_Config();        // 系统时钟配置（通常由CubeMX生成）
HAL_Delay(uint32_t Delay);   // 毫秒级延时
HAL_GetTick();               // 获取系统时钟滴答数

2.GPIO

GPIO初始化（通常在CubeMX里配置）

GPIO_InitTypeDef GPIO_InitStruct;
GPIO_InitStruct.Pin = GPIO_PIN_5;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

读写GPIO

HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_SET);
GPIO_PinState state = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_5);
HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);（GPIO翻转函数）

3.串口通信

发送与接收：

UART_HandleTypeDef huart1;
HAL_UART_Init(&huart1);                          // 初始化UART
HAL_UART_Transmit(&huart1, data, len, timeout);  // 阻塞式发送
HAL_UART_Receive(&huart1, data, len, timeout);   // 阻塞式接收
HAL_UART_Transmit_IT(&huart1, data, len);        // 中断发送
HAL_UART_Receive_IT(&huart1, data, len);         // 中断接收
HAL_UART_Transmit_DMA(&huart1, data, len);       // 使用DMA发送数据

回调函数：

// UART发送完成回调（中断或DMA模式）
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) 
{
  if (huart->Instance == USART1) 
  {  
     //释放发送缓冲区或触发下一操作
  }
}

// UART接收完成回调（中断或DMA模式）
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) 
{
  if (huart->Instance == USART1) 
  {
    //重新调用 HAL_UART_Receive_IT() 以持续接收
  }
}

// UART错误回调（帧错误、噪声错误等）
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
  if (huart->Instance == USART1)
  {    
     //重新初始化UART或记录错误日志
  }
}

4.定时器（TIM）

PWM输出：

HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1);         // 启动PWM
__HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_1, 50); // 设置占空比

定时器中断：

HAL_TIM_Base_Start_IT(&htim2);   // 启动定时器中断

定时器溢出中断回调：

// 定时器溢出中断回调（周期计数完成）
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) 
{
  if (htim->Instance == TIM2) 
  {
    /* 定时任务处理逻辑 */
    // 例如：执行周期性任务（如LED闪烁）
  }
}

// 输入捕获完成回调（捕获到边沿信号）
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim) 
{
  if (htim->Instance == TIM3) 
  {
    /* 捕获值处理逻辑 */
    uint32_t capture = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);
  }
}

5.ADC和DAC

ADC采样：

HAL_ADC_Start(&hadc1);                           // 启动ADC
HAL_ADC_PollForConversion(&hadc1, timeout);      // 阻塞等待转换完成
uint32_t value = HAL_ADC_GetValue(&hadc1);       // 获取采样值

ADC回调函数：

// ADC转换完成回调（中断或DMA模式）
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc) 
{
  if (hadc->Instance == ADC1)
  {
    /* 采样数据处理逻辑 */
    uint32_t adc_value = HAL_ADC_GetValue(hadc);
  }
}

// ADC转换错误回调（过载、校准错误等）
void HAL_ADC_ErrorCallback(ADC_HandleTypeDef *hadc) 
{
  if (hadc->Instance == ADC1) 
  {
    /* 错误恢复逻辑 */
    HAL_ADC_Start_IT(hadc);  // 尝试重启ADC
  }
}

DAC输出：
 

HAL_DAC_SetValue(&hdac, DAC_CHANNEL_1, DAC_ALIGN_12B_R, 2048);
HAL_DAC_Start(&hdac, DAC_CHANNEL_1);    // 启动DAC

SPI:

阻塞式传输：

// 全双工阻塞式传输（发送并接收数据）
HAL_StatusTypeDef HAL_SPI_TransmitReceive(
  SPI_HandleTypeDef *hspi,      // SPI句柄（如&hspi1）
  uint8_t *pTxData,             // 发送数据缓冲区
  uint8_t *pRxData,             // 接收数据缓冲区
  uint16_t Size,                // 数据长度（字节数）
  uint32_t Timeout              // 超时时间（毫秒）
);

// 仅发送数据（阻塞式）
HAL_StatusTypeDef HAL_SPI_Transmit(
  SPI_HandleTypeDef *hspi,
  uint8_t *pData,
  uint16_t Size,
  uint32_t Timeout
);

// 仅接收数据（阻塞式）
HAL_StatusTypeDef HAL_SPI_Receive(
  SPI_HandleTypeDef *hspi,
  uint8_t *pData,
  uint16_t Size,
  uint32_t Timeout
);

中断非阻塞传输：

// 启动全双工中断传输
HAL_StatusTypeDef HAL_SPI_TransmitReceive_IT(
  SPI_HandleTypeDef *hspi,
  uint8_t *pTxData,
  uint8_t *pRxData,
  uint16_t Size
);

// 启动仅发送中断传输
HAL_StatusTypeDef HAL_SPI_Transmit_IT(
  SPI_HandleTypeDef *hspi,
  uint8_t *pData,
  uint16_t Size
);

// 启动仅接收中断传输
HAL_StatusTypeDef HAL_SPI_Receive_IT(
  SPI_HandleTypeDef *hspi,
  uint8_t *pData,
  uint16_t Size
);

DMA传输：

// 启动全双工DMA传输
HAL_StatusTypeDef HAL_SPI_TransmitReceive_DMA(
  SPI_HandleTypeDef *hspi,
  uint8_t *pTxData,
  uint8_t *pRxData,
  uint16_t Size
);

// 启动仅发送DMA传输
HAL_StatusTypeDef HAL_SPI_Transmit_DMA(
  SPI_HandleTypeDef *hspi,
  uint8_t *pData,
  uint16_t Size
);

// 启动仅接收DMA传输
HAL_StatusTypeDef HAL_SPI_Receive_DMA(
  SPI_HandleTypeDef *hspi,
  uint8_t *pData,
  uint16_t Size
);

回调函数：

// SPI传输完成回调（中断或DMA模式）
void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi) 
{
  if (hspi->Instance == SPI1) 
  {  // 判断SPI实例
     /* 处理接收数据 */
     // 示例：将接收数据存入全局变量
     memcpy(rx_buffer, spi_rx_data, sizeof(spi_rx_data));
  }
}

// SPI发送完成回调
void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi) 
{
  /* 发送完成后的逻辑 */
  // 例如：释放发送缓冲区
}

// SPI接收完成回调
void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef *hspi) 
{
  /* 接收完成后的逻辑 */
}

// SPI错误回调（模式错误、CRC错误等）
void HAL_SPI_ErrorCallback(SPI_HandleTypeDef *hspi) 
{
  if (hspi->Instance == SPI1) 
  {
    /* 错误处理 */
    // 例如：重新初始化SPI
       HAL_SPI_DeInit(hspi);
       HAL_SPI_Init(hspi);
  }
}

I2C：

主模式：

// 主模式阻塞式发送数据
HAL_StatusTypeDef HAL_I2C_Master_Transmit(
  I2C_HandleTypeDef *hi2c,      // I2C句柄（如&hi2c1）
  uint16_t DevAddress,          // 从设备地址（7位或10位）
  uint8_t *pData,               // 发送数据缓冲区
  uint16_t Size,                // 数据长度
  uint32_t Timeout              // 超时时间
);

// 主模式阻塞式接收数据
HAL_StatusTypeDef HAL_I2C_Master_Receive(
  I2C_HandleTypeDef *hi2c,
  uint16_t DevAddress,
  uint8_t *pData,
  uint16_t Size,
  uint32_t Timeout
);

// 主模式中断发送
HAL_StatusTypeDef HAL_I2C_Master_Transmit_IT(
  I2C_HandleTypeDef *hi2c,
  uint16_t DevAddress,
  uint8_t *pData,
  uint16_t Size
);

// 主模式中断接收
HAL_StatusTypeDef HAL_I2C_Master_Receive_IT(
  I2C_HandleTypeDef *hi2c,
  uint16_t DevAddress,
  uint8_t *pData,
  uint16_t Size
);

从模式：

// 从模式中断接收数据
HAL_StatusTypeDef HAL_I2C_Slave_Receive_IT(
  I2C_HandleTypeDef *hi2c,
  uint8_t *pData,
  uint16_t Size
);

// 从模式中断发送数据
HAL_StatusTypeDef HAL_I2C_Slave_Transmit_IT(
  I2C_HandleTypeDef *hi2c,
  uint8_t *pData,
  uint16_t Size
);

回调函数：

// 主模式发送完成回调
void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *hi2c) 
{
  if (hi2c->Instance == I2C1) 
  {
    /* 发送完成后的逻辑 */
    // 示例：触发数据接收
    HAL_I2C_Master_Receive_IT(hi2c, DEV_ADDR, rx_data, RX_SIZE);
  }
}

// 主模式接收完成回调
void HAL_I2C_MasterRxCpltCallback(I2C_HandleTypeDef *hi2c) 
{
  /* 处理接收数据 */
  // 示例：解析传感器数据
  sensor_value = (rx_data[0] << 8) | rx_data[1];
}

// 从模式发送完成回调
void HAL_I2C_SlaveTxCpltCallback(I2C_HandleTypeDef *hi2c) 
{
  /* 从设备发送完成处理 */
}

// 从模式接收完成回调
void HAL_I2C_SlaveRxCpltCallback(I2C_HandleTypeDef *hi2c) 
{
  /* 处理主设备发送的数据 */
}

// I2C错误回调（仲裁丢失、总线错误等）
void HAL_I2C_ErrorCallback(I2C_HandleTypeDef *hi2c) 
{
  if (hi2c->Instance == I2C1) 
  {
    /* 错误恢复 */
    // 示例：重新初始化I2C
    HAL_I2C_DeInit(hi2c);
    HAL_I2C_Init(hi2c);
  }
}

7.中断回调函数

// 外部中断通用回调函数（需用户实现）
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) 
{
  switch (GPIO_Pin) 
  {
    case GPIO_PIN_0:  
      // 处理PA0/PB0等引脚的中断
      /* 例如：按键按下触发LED翻转 */
      HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);
      break;
    case GPIO_PIN_1:  
      // 处理PA1/PB1等引脚的中断
      /* 例如：传感器信号触发数据采集 */
      Start_Sensor_Read();
      break;
    // ... 其他引脚处理
  }
}

下面是常用函数的应用(都需要在CubeMX里提前配置硬件和移植各外设驱动程序)：

1.实现LED闪烁

main.c 在主函数的while循环里

  while (1)
  {
     HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);
	 HAL_Delay(500);
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }

2.简易呼吸灯

 while (1)
  {
		for(Time=0; Time<10; Time++)
		{
			for(delay=0; delay<10;delay++)
			{
				HAL_GPIO_WritePin(LED_GPIO_Port, LED_Pin, GPIO_PIN_RESET);
				HAL_Delay(Time);
				HAL_GPIO_WritePin(LED_GPIO_Port, LED_Pin, GPIO_PIN_SET);
				HAL_Delay(10-Time);
			}
		}
		for(Time=10; Time>0; Time--)
		{
			for(delay=0; delay<10;delay++)
			{
				HAL_GPIO_WritePin(LED_GPIO_Port, LED_Pin, GPIO_PIN_RESET);
				HAL_Delay(Time);
				HAL_GPIO_WritePin(LED_GPIO_Port, LED_Pin, GPIO_PIN_SET);
				HAL_Delay(10-Time);
			}
		}

3.按键控制LED


#define K1 HAL_GPIO_ReadPin(K1_GPIO_Port, K1_Pin)

 while (1)
 {
	if(K1 == 0)
	{
		HAL_Delay(10);//消抖
		if(K1 == 0)
	    {
		 while(K1 == 0);//当按键按下并被释放时改变LED电平状态
		 HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);
		}
	}
 }

4.定时器软件呼吸灯

/* USER CODE BEGIN PD */
#define LED(a) HAL_GPIO_WritePin(LED_GPIO_Port, LED_Pin, (GPIO_PinState)a)
/* USER CODE END PD */

/* USER CODE BEGIN PV */
uint8_t PWM_Period;
uint8_t light;
uint8_t Flag;
uint16_t time_10us, time_10ms;
/* USER CODE END PV */

//改变占空比
void PWM_LED(void)
{
	if(Flag == 0) //从暗到亮
	{
		if(light < 100)
		{
			light++;
			if(light >= 100)
			Flag = 1;
		}
	}
	else          //从亮到暗
	{
		if(light > 0)
		{
			light--;
			if(light == 0)
			Flag = 0;
		}
	}
}

int main()
{

 /* USER CODE BEGIN 2 */
	HAL_TIM_Base_Start_IT(&htim1);
  /* USER CODE END 2 */

  while (1)
  {
		if(time_10ms == 1)//每10ms改变一次占空比
		{
			time_10ms = 0;
			PWM_LED();
		}
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }

}

/* USER CODE BEGIN 4 */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(htim->Instance == htim1.Instance) //10us中断一次
	{
		time_10us++;
		if(time_10us >= 1000)    //10*1000 = 10000us = 10ms
		{
			time_10us = 0;
			time_10ms = 1;
		}
		
		PWM_Period++;
		if(PWM_Period >= 100)	//1ms 设置PWM周期
			PWM_Period = 0;
		
		if(PWM_Period < light)	//输出比较 OC
			LED(0);
		else
			LED(1);
	}
}
/* USER CODE END 4 */

5.硬件PWM呼吸灯

/* USER CODE BEGIN PV */
uint8_t Flag;
uint16_t light;
uint8_t time_1ms, time_10ms;
/* USER CODE END PV */

int main(void)
{
   /* USER CODE BEGIN 2 */
	HAL_TIM_Base_Start_IT(&htim1);
	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_3);
  /* USER CODE END 2 */
  

  while (1)
  {
		if(time_10ms == 1)//每10ms改变一次占空比
		{
			time_10ms = 0;
			
			if(Flag == 0)
			{
				light+=10;
				if(light >= 999)
				Flag = 1;
			}
			else
			{
				light-=10;
				if(light == 0)
				Flag = 0;
			}
			
		   __HAL_TIM_SET_COMPARE(&htim2, TIM_CHANNEL_3, light);	
			
		}

}

/* USER CODE BEGIN 4 */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if(htim->Instance == htim1.Instance)     //定时器1触发中断
    {
			time_1ms++;
			if(time_1ms >= 10)
			{
				time_1ms = 0;
				time_10ms = 1;
			}
    }
}
/* USER CODE END 4 */

6.舵机控制

/* USER CODE BEGIN PD */
#define K1 HAL_GPIO_ReadPin(K1_GPIO_Port, K1_Pin)
#define K2 HAL_GPIO_ReadPin(K2_GPIO_Port, K2_Pin)
/* USER CODE END PD */


/* USER CODE BEGIN PV */
uint8_t SG90;
/* USER CODE END PV */

/* USER CODE BEGIN 0 */
//标准的PWM信号周期为20ms，脉宽在0.5ms至2.5ms之间变化，对应0到180度的旋转角度
void SG90Angle_Set(uint8_t Angle)
{
	__HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_4, Angle/180.0*2000+500);	
}
/* USER CODE END 0 */


int main(void)
{ 
    /* USER CODE BEGIN 2 */
	HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_4);
    /* USER CODE END 2 */


  while (1)
  {
		
			if(K1 == 0)
			{
				if(SG90 < 180)
				SG90++;
			}
			if(K2 == 0)
			{
				if(SG90 > 0)
				SG90--;
			}
			
			SG90Angle_Set(SG90);

         }
   } 
 

}

7.烟雾传感器ADC采集

/* USER CODE BEGIN PD */
#define MQ HAL_GPIO_ReadPin(MQ_GPIO_Port, MQ_Pin)//DO
/* USER CODE END PD */

/* USER CODE BEGIN PV */
float MQ_Value;
/* USER CODE END PV */


int main(void)
{

  /* USER CODE BEGIN 2 */
	OLED_Init();
  /* USER CODE END 2 */

while (1)
  {    
        //ADC采集的值为0-4095，对应引脚电压的0-3.3v
		HAL_ADC_Start(&hadc1);//开启ADC1采集
		if(HAL_ADC_PollForConversion(&hadc1, 999) == HAL_OK)//999为等待时间
		MQ_Value = HAL_ADC_GetValue(&hadc1)/4095.0*3.3;//把采集到的值赋给MQ_Value
		HAL_ADC_Stop(&hadc1);//关闭ADC1采集
		
		OLED_ShowString(0, 0, "气体浓度：", OLED_8X16);
		OLED_ShowFloatNum(80, 0, MQ_Value, 1, 1, OLED_8X16);
		
		OLED_ShowString(0, 16, "触发：", OLED_8X16);
		if(MQ == 0)
			OLED_ShowString(48, 16, "是", OLED_8X16);
		else
			OLED_ShowString(48, 16, "否", OLED_8X16);
		OLED_Update();
    
  }
   

 }

8.DHT11温湿度传感器

/* USER CODE BEGIN PV */
uint16_t time_1ms, time_500ms;
//uint16_t temp, humi;
/* USER CODE END PV */

/* USER CODE BEGIN 0 */
void Sensor_Function()
{
	DHT11_Read_Data(&temp, &humi);
	
}

void Display_Function()
{
    OLED_ShowHumi(0, 16, humi);
	OLED_ShowFloatNum(0, 0, temp, 2, 1, OLED_8X16);
	
}
/* USER CODE END 0 */



int main(void)
{
   /* USER CODE BEGIN 2 */
	HAL_TIM_Base_Start_IT(&htim1);  //定时器中断开始初始化
	OLED_Init();
	DHT11_Init();
  /* USER CODE END 2 */

  while (1)
  {
		if(time_500ms == 1)//每500ms采集一次
		{
			time_500ms = 0;
			Sensor_Function();
			Display_Function();
		}
  }



}

/* USER CODE BEGIN 4 */
//定时器中断回调函数
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(htim->Instance == htim1.Instance)        //定时器1触发中断
	{
		time_1ms++;
		if(time_1ms >= 500)
		{
				time_1ms= 0;
				time_500ms = 1;
		}
	}
}
/* USER CODE END 4 */

9.串口通信

/* USER CODE BEGIN PD */
uint8_t USART2_TX_BUF[200];
#define u2_printf(...)  HAL_UART_Transmit(&huart2,USART2_TX_BUF,sprintf((char *)USART2_TX_BUF,__VA_ARGS__),0xffff)
/* USER CODE END PD */

/* USER CODE BEGIN PV */
//串口2的数据获取
uint8_t uart2_value;      //串口传的单个数据
//串口的储存数组，串口的接收时间，串口存值的数量
uint8_t uart2_buf[36],uart2_time,uart2_num;
uint8_t uart2_rx_flag;//串口的获取值的标志位
uint8_t dis_buf[36];
/* USER CODE END PV */

int main(void)
{
     /* USER CODE BEGIN 2 */
	HAL_TIM_Base_Start_IT(&htim1);  //定时器中断开始初始化
	HAL_UART_Receive_IT(&huart2, &uart2_value, 1);
	OLED_Init();
    /* USER CODE END 2 */


while (1)
  {
		if(uart2_rx_flag == 1)//当接收完一帧数据
		{
			uart2_rx_flag = 0;
			
			memcpy(dis_buf, uart2_buf, sizeof(dis_buf));//把存储接收数据数组赋给定义的数组
			memset(uart2_buf, '\0', sizeof(uart2_buf));//清空存储接收数据的数组
			OLED_Clear();//清屏
		}
		
		u2_printf("Hello!");//串口发送
		OLED_ShowString(0, 0, (char *)dis_buf, OLED_8X16);//在OLED上显示接收的数据
		OLED_Update();
		HAL_Delay(1000);
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
    /* USER CODE END 3 */
}

/* USER CODE BEGIN 4 */
//定时器中断回调函数
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	if(htim->Instance == htim1.Instance)        //定时器1触发中断
	{
		//定时器中串口处理过程
		if(uart2_num != 0) //串口接收到数据传来
		{
			uart2_time++;       //计时开始
			if(uart2_time >= 10)//如果接收完数据后的时间大于等于10代表一帧数据接受完成
			{
				uart2_time = 0;   
				uart2_num = 0;
				uart2_rx_flag = 1;//把接收数据标志位设为1
			}
		}
	}
}

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	if(huart->Instance == huart2.Instance)//串口2触发中断
	{
		//获取串口2的数据，uart2_value
		HAL_UART_Receive_IT(&huart2, &uart2_value, 1);
		//将数据一个一个存储到uart2_buf中
		uart2_buf[uart2_num++] = uart2_value;		
		uart2_time = 0;//每接收存储完一个数据就开始计时
	}
}
/* USER CODE END 4 */

10.串口DMA通信

/* USER CODE BEGIN PV */
// 串口接收缓冲区
uint8_t rx_data[256] = {0};
/* USER CODE END PV */

int main(void)
{
    /* USER CODE BEGIN 2 */
	// 使用Ex函数，接收不定长数据
	HAL_UARTEx_ReceiveToIdle_DMA(&huart2, rx_data, sizeof(rx_data));
	// 关闭DMA传输过半中断（HAL库默认开启，但我们只需要接收完成中断）
	__HAL_DMA_DISABLE_IT(huart2.hdmarx, DMA_IT_HT);
	OLED_Init();
  /* USER CODE END 2 */



}

/* USER CODE BEGIN 4 */
// 不定长数据接收完成回调函数
void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size)
{
		if (huart->Instance == USART2)
		{
				// 使用DMA将接收到的数据发送回去
				HAL_UART_Transmit_DMA(&huart2, rx_data, Size);
			
				if(rx_data[0] == 0xAA && rx_data[2] == 0xBB)
				{
					if(rx_data[1] == 0x01)
						HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);
					if(rx_data[1] == 0x02)
						HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET);
				}
			
				// 重新启动接收，使用Ex函数，接收不定长数据
				HAL_UARTEx_ReceiveToIdle_DMA(&huart2, rx_data, sizeof(rx_data));
				// 关闭DMA传输过半中断（HAL库默认开启，但我们只需要接收完成中断）
				__HAL_DMA_DISABLE_IT(huart2.hdmarx, DMA_IT_HT);
		}
}
/* USER CODE END 4 */

11.ADC的DMA采集


/* USER CODE BEGIN PV */
uint16_t AD_Value[2];
/* USER CODE END PV */

int main(void)
{
     /* USER CODE BEGIN 2 */
	HAL_TIM_Base_Start_IT(&htim1);
	HAL_ADCEx_Calibration_Start(&hadc1);     //校准ADC
	HAL_ADC_Start_DMA(&hadc1, (uint32_t *)AD_Value, 2); //开启ADC1DMA采集   
	OLED_Init();
    /* USER CODE END 2 */

  while (1)
  {
		OLED_ShowNum(0, 0, AD_Value[0]/4095.0*100, 4, OLED_8X16);
		OLED_ShowNum(0, 32,AD_Value[1]/4095.0*100, 4, OLED_8X16);
		OLED_Update();
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */

}


/* USER CODE BEGIN 4 */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if(htim->Instance == htim1.Instance)        //定时器1触发中断
    {
			static uint16_t time;
			
			time++;
			if(time >= 100)
			{
				HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);
				time = 0;
			}
    }
}
/* USER CODE END 4 */

12.外部中断（测试红外传感器触发次数）


/* USER CODE BEGIN PV */
uint16_t IR_num;
uint8_t Flag_IR;
uint8_t Flag_delay, delay_time;
/* USER CODE END PV */

int main(void)
{
    /* USER CODE BEGIN 2 */
	HAL_TIM_Base_Start_IT(&htim1);
	OLED_Init();
    /* USER CODE END 2 */

 while (1)
  {
		OLED_ShowNum(0, 32, IR_num, 3, OLED_8X16);
		OLED_Update();
		HAL_Delay(3000);
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
    /* USER CODE END 3 */
}

/* USER CODE BEGIN 4 */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if(htim->Instance == htim1.Instance)   //定时器1触发中断
    {

			
			if(Flag_delay)//标志位为1时开始计时
			{
				delay_time++;
				if(delay_time >= 20)//达到指定计时条件再把标志位设为0
				Flag_delay = 0;
			}
			else
				delay_time = 0;//标志位为0就不计时
    }
}

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)//GPIO中断回调函数
{
  if(GPIO_Pin == IR_Pin)//如果是红外传感器引脚引起GPIO中断
    {
	    if(HAL_GPIO_ReadPin(IR_GPIO_Port, IR_Pin) && Flag_delay == 0)
	    {
          IR_num++;
	      Flag_delay = 1;//当红外传感器触发1次把标志位设为1避免触发一次导致IR_num一直增加
		}
    }
}
/* USER CODE END 4 */


 

Stm32Hal库RTC模块学习笔记
HTxinghai的博客
12-22 2451
也要结合根据实际工程做相应的配置调整。若按上述操作后还会出现等待RTC时钟同步超时的问题，在排除硬件问题后，一般还是RTC时钟配置有问题，这是因为访问RTC模块的寄存器需要。
stm32 HAL库 UART 笔记
best_xo的博客
07-10 1601
USART也叫通用同步/异步串行接收/发送器。USART是一个全双工通用同步/异步串行收发模块，该接口是一个高度灵活的串行通信设备。和UART（通用异步收发器）一样也是一种通用串行接口。而。
stm32 HAL库 笔记 定时器（1） 中断实验
best_xo的博客
07-12 1745
单片机中的定时器主要用于控制时间，比如延时、定时等等。而计数器则主要用于统计事件或的数量。通过控制定时器和计数器的中断、清零等操作，我们可以完成各种复杂的定时、计数等操作，实现更加的。单片机的定时器一般由计数器、、基准时钟等部分组成。在使用定时器之前需要对定时器进行初始化设置，通常包括预分频、计数器值、启动定时器等步骤。在运行时，单片机通过定时器的计数达到一定值后触发中断，并执行相应的程序。
stm32 HAL库 定时器笔记之PWM
best_xo的博客
07-12 1748
脉宽调制（Pulse-Width Modulation，PWM）是利用微处理器的数字输出，来对模拟电路进行控制的一种非常有效的技术，通过对一系列脉冲的宽度进行调制，来等效的获得所需要的波形（含形状和幅值），即通过改变导通时间占总时间的比例，也就是占空比，达到调整电压和频率的目的。广泛应用在从测量、通信到功率控制与变换的许多领域中，用于调压调频，最突出的是针对各种类型的电机应用。
stm32HAL库，标准库全套代码和资料笔记
2301_79858368的博客
11-01 187
链接：https://pan.baidu.com/s/15yR5yAGUhjt-CTgOgyK4Qg。
STM32 HAL库开发笔记
AndrewPerfect的博客
10-22 128
右移时：无符号直接前边补0；有符号数 最开始为1时，前边补1异或：两个值不相同则为1，两个值相同则为0。p_buf++ //是地址++所以最后p_buf[0]=3。
STM32HAL库笔记一：点亮LED灯
m0_56231854的博客
07-09 434
最近在看江协科技的STM32入门课程，因为这是基于标准库函数的，特学习利用CubeMx的hal库，当个笔记。
stm32 HAL库 笔记———使用通用定时器输出pwm
qq_40932099的博客
07-07 2141
首先配置RCC时钟，使用外部晶振 然后配置时钟树，我的是stm32f429 最高支持180MHZ，我使用的是TIM5，TIM5挂载在APB1总线上定时器频率为90MHZ 启用内部时钟，选择通道输出PWM 通道模式分别是： 输入捕获模式 输出比较不输出模式 输出比较模式 PWM不输出模式 PWM输出模式 还有最下面的 Forced Output ，强制输出模式 分频配置 899+1分频，可根据需要修改 因为我的TIM5在APB1总线上，对应频率是90MHZ，那么分频后就是90MHZ/900=100KHZ
stm32 HAL库 笔记——HAL_UARTEx_ReceiveToIdle_IT
热门推荐
qq_40932099的博客
07-02 1万+
如果用hal库一次性接收大量数据，如果通过判断RXNE标志位，每次只接受一个字节会消耗大量mcu资源去频繁处理中断,如果一次性接收多个字节可能会导致数据无法对齐，如果一次接收大量字节，中断回调函数无法执行， HAL_UART_Receive_IT(&huart1,&ch,1); 像这样一次接收一个字节，如果数据量大，会频繁进入中断 HAL_UART_Receive_IT(&huart1,&ch,10); 这样一次接收多个字节会导致接收数据错误 HAL_U
STM32HAL库学习笔记六——串口通信
weixin_44762233的博客
04-25 5108
系列文章目录 文章目录系列文章目录通信的相关基本概念串口通信基本知识定时器与串口的综合应用一、实验目的二、cubemx配置三、代码编写 通信的相关基本概念 编码困难：1.字节长度与数据类型长度搞不清， 2.形参指针数组取地址搞不清 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 串口通信基本知识 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 定时器与串口的综合应用 一、实验目的 实现如
【嵌入式-stm32电位器控制以及旋转编码器控制LED亮暗】
weixin_43251807的博客
04-04 1067
本文主要介绍利用stm32f103C8T6实现电位器和旋转编码器控制PWM的占空比大小来改变LED亮暗程度，按键实现使用定时器非阻塞式，其中一个按键切换3个LED的控制状态，另一个按键是重置当前的LED为熄灭状态。
STM32自学进阶指南：从入门到精通的成长路径 | 零基础入门STM32第九十九步
i萌依的博客
04-13 1262
自学STM32单片机时，应优先通过ISP下载方式苦练基本功，避免过度依赖仿真调试。同时，了解HAL库和标准库的优缺点，以标准库作为入门教学更合适。此外，需掌握定时器、中断的复杂功能及USB从设备接口等知识。通过数据手册和搜索引擎查找资料，独立解决问题以积累经验和提升能力。自学过程中应保持敬畏之心，不断总结未知领域，持续进步。
蓝桥杯嵌入式十五届模拟二（串口DMA，占空比的另一种测量方式）
2202_75840803的博客
04-08 1676
先配置LED的八个引脚为GPIO_OutPut，锁存器PD2也是，然后都设置为起始高电平，生成代码时还要去解决引脚冲突问题按键配置，由原理图按键所对引脚要GPIO_Input生成代码，在文件夹中添加code文件夹，code中添加fun.c、fun.h、headfile.h文件，去资源包中把lcd.c、lcd.h、fonts.h添加到code中，然后去写按键控制灯亮灭的程序，看是否有问题按键控制led没有问题后写lcd显示代码，显示没问题后，解决lcd与led引脚冲突问题，方法在我的其他文章中。
STM32&STM8芯片擦除与读保护
fanzhipeng7000的博客
04-10 244
文件选HEX在选择Verify进行下载。连接STM单片机与断开单片机连接，
STM32 HAL库 OLED驱动实现
m0_75187370的博客
04-13 972
OLED（Organic Light - Emitting Diode）即有机发光二极管，与传统的 LCD 显示屏相比，OLED 具有自发光、视角广、响应速度快、对比度高、功耗低等优点。在嵌入式系统中，OLED 显示屏常被用于显示系统状态信息、图形界面等。通过本文的介绍，你可以基于 STM32F407 HAL 库实现 OLED 显示屏的 8080 接口和 IIC 接口驱动。8080 接口适合对通信速度要求较高的场景，而 IIC 接口则更适合引脚资源有限的情况。
STM32 HAL库 ADC+TIM+DMA 3路 1S采样一次电压
最新发布
m0_75187370的博客
04-14 524
通过结合 STM32F407 的 ADC、TIM 和 DMA 外设，我们可以高效、稳定地实现 3 路模拟信号的周期性采样。定时器用于控制采样频率，DMA 用于数据传输，提高了系统的效率。在实际应用中，可以根据需要对采样频率、通道数量等参数进行调整。
STM32 HAL库之GPIO示例代码
星仔的博客
04-09 553
STM32 HAL库之GPIO示例代码
STM32 BOOT设置，bootloader，死锁使用方法
leoFY123的博客
04-14 233
bootloader程序烧录时，需要 B00T0=1 BOOT1=0 上电时第四个时钟周期检测。Bootloader程序烧写完，B00T0=X BOOT1=0就可以通过ISP模式烧写程序了。需要 B00T0=1 BOOT1=0时重新烧写程序，可以使用flymcu，需要可以联系我。system memory 启动地址：0x1FFF0000。flash memory 启动地址：0x08000000。一般下载程序都放在这里，重启也从这里开始。SRAM 启动地址：0x20000000。
STM32HAL笔记
03-10
STM32HAL笔记是一种用于学习和开发STM32微控制器的文档或笔记。STM32HAL是STMicroelectronics提供的一套硬件抽象层（Hardware Abstraction Layer），它提供了一组API和函数，用于简化STM32微控制器的编程和驱动开发。 在STM32HAL笔记中，通常包含以下内容： 1. STM32HAL库的概述：介绍STM32HAL库的特点、功能和优势。 2. STM32微控制器的基本知识：包括STM32微控制器的架构、寄存器配置和时钟设置等基础知识。 3. STM32HAL库的安装和配置：介绍如何安装和配置STM32HAL库，并与开发环境（如Keil、IAR等）进行集成。 4. STM32HAL库的使用方法：详细介绍STM32HAL库提供的各种API和函数的使用方法，包括GPIO控制、定时器配置、串口通信等。 5. 示例代码和实验：提供一些实际应用场景下的示例代码和实验，帮助读者理解和应用STM32HAL库。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值