stm32实现单个计时器两个超声波模块

已于 2024-04-24 09:23:45 修改
阅读量158 收藏
点赞数 2
文章标签： stm32 嵌入式硬件 单片机
于 2024-04-23 22:04:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cbl67/article/details/138139756
版权

单个定时器实现不同通道超声波模块测距

/* 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 "dma.h"
#include "i2c.h"
#include "tim.h"
#include "usart.h"
#include "gpio.h"

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

#include "hc-sr04.h"
/* 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 */

/* USER CODE END PM */

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

/* USER CODE BEGIN PV */
char distance[30];
char distance2[30];
/* 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 */


/* 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_DMA_Init();
  MX_USART2_UART_Init();
  MX_USART1_UART_Init();
  MX_TIM4_Init();
  MX_I2C2_Init();
  MX_TIM5_Init();
  MX_TIM1_Init();

//初始化二个超声波模块
  Hcsr04Init( &htim1, TIM_CHANNEL_4);
  Hcsr04Init2( &htim1, TIM_CHANNEL_2);
 //启动超声波模块
  Hcsr04Start();
  /* USER CODE END 2 */
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {   
    
      /* 启动第一个超声波模块 */
      /* 启动第二个超声波模块 */
      Hcsr04Start();
      HAL_Delay(200);//等待回波信号
      sprintf(distance,"distance1:%.1f cm", Hcsr04Read());
      sprintf(distance2,"distance2:%.1f cm", Hcsr04Read2());
     
    }
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */

  /* USER CODE END 3 */
}

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

  /** Configure the main internal regulator output voltage
  */
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

  /** 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.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 4;
  RCC_OscInitStruct.PLL.PLLN = 72;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = 4;
  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 */

void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim) {
    if (htim->Instance == TIM1) {
        if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_4) {
        	Hcsr04TimIcIsr(htim);
        }
        else if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_2) {
        	Hcsr04TimIcIsr2(htim);
        }
    }
}

/**
 * @description: 定时器溢出中 ?????
 * @param {*}
 * @return {*}
 */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef* htim) {

	Hcsr04TimOverflowIsr(htim);

}

/* 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 */


#include "hc-sr04.h"
#include "tim.h"
Hcsr04InfoTypeDef Hcsr04Info;
uint8_t echo_flag = 0;
uint16_t rising_cnt = 0, falling_cnt = 0;
/**
 * @description: ??????????????????
 * @param {TIM_HandleTypeDef} *htim
 * @param {uint32_t} Channel
 * @return {*}
 */
void Hcsr04Init(TIM_HandleTypeDef *htim, uint32_t Channel)
{
  Hcsr04Info.prescaler = htim->Init.Prescaler; //  72-1
  Hcsr04Info.period = htim->Init.Period;       //  65535

  Hcsr04Info.instance = htim->Instance;
  Hcsr04Info.ic_tim_ch = Channel;
  if(Hcsr04Info.ic_tim_ch == TIM_CHANNEL_1)
  {
    Hcsr04Info.active_channel = HAL_TIM_ACTIVE_CHANNEL_1;             //  TIM_CHANNEL_4
  }
  else if(Hcsr04Info.ic_tim_ch == TIM_CHANNEL_2)
  {
    Hcsr04Info.active_channel = HAL_TIM_ACTIVE_CHANNEL_2;             //  TIM_CHANNEL_4
  }
  else if(Hcsr04Info.ic_tim_ch == TIM_CHANNEL_3)
  {
    Hcsr04Info.active_channel = HAL_TIM_ACTIVE_CHANNEL_3;             //  TIM_CHANNEL_4
  }
  else if(Hcsr04Info.ic_tim_ch == TIM_CHANNEL_4)
  {
    Hcsr04Info.active_channel = HAL_TIM_ACTIVE_CHANNEL_4;             //  TIM_CHANNEL_4
  }
  else if(Hcsr04Info.ic_tim_ch == TIM_CHANNEL_4)
  {
    Hcsr04Info.active_channel = HAL_TIM_ACTIVE_CHANNEL_4;             //  TIM_CHANNEL_4
  }
  /*--------[ Start The ICU Channel ]-------*/
  HAL_TIM_Base_Start_IT(htim);
  HAL_TIM_IC_Start_IT(htim, Channel);
}
void Hcsr04Init2(TIM_HandleTypeDef *htim, uint32_t Channel)
{
  Hcsr04Info.prescaler2 = htim->Init.Prescaler; //  72-1
  Hcsr04Info.period2 = htim->Init.Period;       //  65535

  Hcsr04Info.instance2 = htim->Instance;
  Hcsr04Info.ic_tim_ch2 = Channel;
  if(Hcsr04Info.ic_tim_ch2 == TIM_CHANNEL_1)
  {
    Hcsr04Info.active_channe2 = HAL_TIM_ACTIVE_CHANNEL_1;             //  TIM_CHANNEL_4
  }
  else if(Hcsr04Info.ic_tim_ch2 == TIM_CHANNEL_2)
  {
    Hcsr04Info.active_channe2 = HAL_TIM_ACTIVE_CHANNEL_2;             //  TIM_CHANNEL_4
  }
  else if(Hcsr04Info.ic_tim_ch2 == TIM_CHANNEL_3)
  {
    Hcsr04Info.active_channe2 = HAL_TIM_ACTIVE_CHANNEL_3;             //  TIM_CHANNEL_4
  }
  else if(Hcsr04Info.ic_tim_ch2 == TIM_CHANNEL_4)
  {
    Hcsr04Info.active_channe2 = HAL_TIM_ACTIVE_CHANNEL_4;             //  TIM_CHANNEL_4
  }
  else if(Hcsr04Info.ic_tim_ch2 == TIM_CHANNEL_4)
  {
    Hcsr04Info.active_channe2 = HAL_TIM_ACTIVE_CHANNEL_4;             //  TIM_CHANNEL_4
  }
  /*--------[ Start The ICU Channel ]-------*/
  HAL_TIM_Base_Start_IT(htim);
  HAL_TIM_IC_Start_IT(htim, Channel);
}

/**
 * @description: HC-SR04触发
 * @param {*}
 * @return {*}
 */
void Hcsr04Start()
{
  HAL_GPIO_WritePin(TRIG1_GPIO_Port, TRIG1_Pin, GPIO_PIN_SET);
  HAL_GPIO_WritePin(TRIG2_GPIO_Port, TRIG2_Pin, GPIO_PIN_SET);
  Tims_delay_us(30);   //  10us以上
  HAL_GPIO_WritePin(TRIG1_GPIO_Port, TRIG1_Pin, GPIO_PIN_RESET);
  HAL_GPIO_WritePin(TRIG2_GPIO_Port, TRIG2_Pin, GPIO_PIN_RESET);
}

/**
 * @description: 定时器计数溢出中断处理函数
 * @param {*}    main.c中重定义void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef* htim)
 * @return {*}
 */
void Hcsr04TimOverflowIsr(TIM_HandleTypeDef *htim)
{
  if(htim->Instance == Hcsr04Info.instance)
  {
    Hcsr04Info.tim_overflow_counter++;
    Hcsr04Init(&htim1, TIM_CHANNEL_4);
    Hcsr04Init2(&htim1, TIM_CHANNEL_2);
  }
}
/*void Hcsr04TimOverflowIsr2(TIM_HandleTypeDef *htim)
{
  if(htim->Instance == Hcsr04Info.instance2)
  {
    Hcsr04Info.tim_overflow_counter2++;
    Hcsr04Init(&htim3, TIM_CHANNEL_1);
  }
}
*/
/**
 * @description: 输入捕获计算高电平时间->距离
 * @param {*}    main.c中重定义void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
 * @return {*}
 */
void Hcsr04TimIcIsr(TIM_HandleTypeDef* htim)
{
  if((htim->Instance == Hcsr04Info.instance) && (htim->Channel == Hcsr04Info.active_channel))
  {
    if(Hcsr04Info.edge_state == 0)      //  捕获上升沿
    {
      // 得到上升沿开始时间T1，并更改输入捕获为下降沿
      Hcsr04Info.t1 = HAL_TIM_ReadCapturedValue(htim, Hcsr04Info.ic_tim_ch);
      __HAL_TIM_SET_CAPTUREPOLARITY(htim, Hcsr04Info.ic_tim_ch, TIM_INPUTCHANNELPOLARITY_FALLING);
      Hcsr04Info.tim_overflow_counter = 0;  //  定时器溢出计数器清零
      Hcsr04Info.edge_state = 1;        //  上升沿、下降沿捕获标志位
    }
    else if(Hcsr04Info.edge_state == 1) //  捕获下降沿
    {
      // 捕获下降沿时间T2，并计算高电平时间
      Hcsr04Info.t2 = HAL_TIM_ReadCapturedValue(htim, Hcsr04Info.ic_tim_ch);
      Hcsr04Info.t2 += Hcsr04Info.tim_overflow_counter * Hcsr04Info.period; //  需要考虑定时器溢出中断
      Hcsr04Info.high_level_us = Hcsr04Info.t2 - Hcsr04Info.t1; //  高电平持续时间 = 下降沿时间点 - 上升沿时间点
      // 计算距离
      Hcsr04Info.distance = (Hcsr04Info.high_level_us / 1000000.0) * 340.0 / 2.0 * 100.0;
      // 重新开启上升沿捕获
      Hcsr04Info.edge_state = 0;  //  一次采集完毕，清零
      __HAL_TIM_SET_CAPTUREPOLARITY(htim, Hcsr04Info.ic_tim_ch, TIM_INPUTCHANNELPOLARITY_RISING);
    }
  }
}
void Hcsr04TimIcIsr2(TIM_HandleTypeDef* htim)
{
  if((htim->Instance == Hcsr04Info.instance2) && (htim->Channel == Hcsr04Info.active_channe2))
  {
    if(Hcsr04Info.edge_state2 == 0)      //  捕获上升沿
    {
      // 得到上升沿开始时间T1，并更改输入捕获为下降沿
      Hcsr04Info.t12 = HAL_TIM_ReadCapturedValue(htim, Hcsr04Info.ic_tim_ch2);
      __HAL_TIM_SET_CAPTUREPOLARITY(htim, Hcsr04Info.ic_tim_ch2, TIM_INPUTCHANNELPOLARITY_FALLING);
      Hcsr04Info.tim_overflow_counter2 = 0;  //  定时器溢出计数器清零
      Hcsr04Info.edge_state2 = 1;        //  上升沿、下降沿捕获标志位
    }
    else if(Hcsr04Info.edge_state2 == 1) //  捕获下降沿
    {
      // 捕获下降沿时间T2，并计算高电平时间
      Hcsr04Info.t22 = HAL_TIM_ReadCapturedValue(htim, Hcsr04Info.ic_tim_ch2);
      Hcsr04Info.t22 += Hcsr04Info.tim_overflow_counter2 * Hcsr04Info.period2; //  需要考虑定时器溢出中断
      Hcsr04Info.high_level_us2 = Hcsr04Info.t22 - Hcsr04Info.t12; //  高电平持续时间 = 下降沿时间点 - 上升沿时间点
      // 计算距离
      Hcsr04Info.distance2 = (Hcsr04Info.high_level_us2 / 1000000.0) * 340.0 / 2.0 * 100.0;
      // 重新开启上升沿捕获
      Hcsr04Info.edge_state2 = 0;  //  一次采集完毕，清零
      __HAL_TIM_SET_CAPTUREPOLARITY(htim, Hcsr04Info.ic_tim_ch2, TIM_INPUTCHANNELPOLARITY_RISING);
    }
  }
}

/**
 * @description: 读取距离
 * @param {*}
 * @return {*}
 */
float Hcsr04Read()
{
  // 测距结果限幅
  if(Hcsr04Info.distance >= 1000)
  {
    Hcsr04Info.distance = 1000;        //元器件资料说是600cm最高距离，这里保守一点
  }
  return Hcsr04Info.distance;
}
float Hcsr04Read2()
{
  // 测距结果限幅
  if(Hcsr04Info.distance2 >= 1000)
  {
    Hcsr04Info.distance2 = 1000;        //元器件资料说是600cm最高距离，这里保守一点
  }
  return Hcsr04Info.distance2;
}


/**
  * @brief  ?????us,Prescaler -> 32-1
  * @param  us: <= 65535
  * @retval None
  */
void Tims_delay_us(uint16_t nus)
{
	__HAL_TIM_SET_COUNTER(DLY_TIM_Handle, 0);
	__HAL_TIM_ENABLE(DLY_TIM_Handle);
	while (__HAL_TIM_GET_COUNTER(DLY_TIM_Handle) < nus)
	{
	}
	__HAL_TIM_DISABLE(DLY_TIM_Handle);
}


/*
 * hc-sr04.h
 *
 *  Created on: Mar 6, 2024
 *      Author: c'b'l
 */

#ifndef INC_HC_SR04_H_
#define INC_HC_SR04_H_
#include "main.h"


#define DLY_TIM_Handle (&htim1)

typedef struct
{
	uint8_t  edge_state;
	uint16_t tim_overflow_counter;
	uint32_t prescaler;
	uint32_t period;
	uint32_t t1;	//	?????
	uint32_t t2;	//	?????
	uint32_t high_level_us;	//	???????
	float    distance;
	TIM_TypeDef* instance;
    uint32_t ic_tim_ch;
	HAL_TIM_ActiveChannel active_channel;
	uint8_t  edge_state2;
	uint16_t tim_overflow_counter2;
	uint32_t prescaler2;
	uint32_t period2;
	uint32_t t12;	//	?????
	uint32_t t22;	//	?????
	uint32_t high_level_us2;	//	???????
	float    distance2;
	TIM_TypeDef* instance2;
	uint32_t ic_tim_ch2;
	HAL_TIM_ActiveChannel active_channe2;
}Hcsr04InfoTypeDef;

extern Hcsr04InfoTypeDef Hcsr04Info;

/**
 * @description: ??????????????????
 * @param {TIM_HandleTypeDef} *htim
 * @param {uint32_t} Channel
 * @return {*}
 */
void Hcsr04Init(TIM_HandleTypeDef *htim, uint32_t Channel);
void Hcsr04Init2(TIM_HandleTypeDef *htim, uint32_t Channel);

/**
 * @description: HC-SR04??
 * @param {*}
 * @return {*}
 */
void Hcsr04Start();

/**
 * @description: ?????????????
 * @param {*}    main.c????void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef* htim)
 * @return {*}
 */
void Hcsr04TimOverflowIsr(TIM_HandleTypeDef *htim);
void Hcsr04TimOverflowIsr2(TIM_HandleTypeDef *htim);

/**
 * @description: ???????????->??
 * @param {*}    main.c????void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
 * @return {*}
 */
void Hcsr04TimIcIsr(TIM_HandleTypeDef* htim);
void Hcsr04TimIcIsr2(TIM_HandleTypeDef* htim);

/**
 * @description: ????
 * @param {*}
 * @return {*}
 */
float Hcsr04Read();
float Hcsr04Read2();
void Tims_delay_us(uint16_t nus);

#endif /* INC_HC_SR04_H_ */

芯片型号
在这里插入图片描述
定时器设置
在这里插入图片描述
部分引脚备注
在这里插入图片描述

cbl67
关注
STM32读取两路超声波模块
06-16
在这个项目中，我们利用STM32读取两路超声波模块，目的是实现对水位的实时监测，并在水位过低时通过蜂鸣器发出报警。 超声波模块通常包括一个超声波发射器和接收器，工作原理是发送一个高频脉冲，然后测量这个脉冲...
CubeMX中超声波HC-SR04的使用【HAL库】
yanyu1002的博客
03-21 295
Hcsr04Init() int main() { Hcsr04Init(&htim2,TIM_CHANNEL_1); //初始化TIM2定时器通道1作为超声波传输数据通道 } Hcsr04Start() int main() { while(1) { Hcsr04Start(); //触发超声波模块，发出信号 } } HAL_TIM_PeriodElapsedCallback() Hcsr04TimOverflowIsr()
STM32驱动多个超声波模块（只用一个定时器）
ApexYuan
03-11 9882
用STM32单片机成功驱动一个超声波模块后，接下来便有了疑问如何用stm32单片机驱动多个超声波模块呢？（驱动一个超声波模块可以参考：stm32驱动超声波模块测距） 超声波模块型号为HC-SR04，模块驱动方式选择利用外部中断的方式驱动（具体细节可参见上面链接）。 经过一个下午的思考实验发现了两种驱动多个超声波模块的方法： 分时测量 同时测量 1.分时测量： 通过类似于实现流水灯的方法，多个超...
stm32+超声波测距+短距蜂鸣器报警
07-06
在本项目"stm32+超声波测距+短距蜂鸣器报警"中，我们将深入探讨如何使用STM32F103系列开发板，结合超声波传感器HC-SR04以及无源蜂鸣器，实现距离检测和短距报警功能。 首先，超声波测距是利用超声波发射和接收之间...
基于STM32的秒表计时器（课设）.zip
02-09
STM32秒表计时器项目是一个典型的嵌入式系统应用，主要利用STM32微控制器的特性来实现计时功能。在这个项目中，我们将会深入探讨STM32的USART（通用同步异步收发传输器）、TIMER（定时器）、EXTI（外部中断）等模块...
超声波模块程序_STM32F103ZET6.zip
01-20
STM32F103ZET6是一款基于ARM Cortex-M3内核的微控制器...通过以上步骤，我们可以使用正点原子精英开发板上的STM32F103ZET6微控制器实现超声波测距功能，结合实际项目需求进行适当的调整和优化，以满足不同的应用场景。
STM32单片机 关于超声波模块的学习（1）
01-06
分享一篇我刚刚弄完的一个超声波模块的学习 超声波模块的介绍： 1.单片机的一个IO口发送高电平的信号给Trig，信号时间要大于10us ...先随便定义两个IO口，连接Trig的IO口配置要推挽输出，连接Echo的IO
OpenMV与STM32通信全面指南
weidl001的博客
09-28 1562
OpenMV是一款开源的微型机器视觉模块，基于ARM Cortex-M7微控制器，运行MicroPython脚本。它支持多种图像处理功能，如颜色识别、形状检测、条形码识别等，适用于教育、快速原型开发和小型嵌入式视觉应用。OpenMV的主要特点：使用MicroPython，降低了开发门槛。模块尺寸小，适合嵌入式应用。支持多种图像处理算法。提供UART、SPI、I2C、USB等通信接口。STM32是STMicroelectronics公司推出的基于ARM Cortex内核的32位微控制器系列。
STM32的ADC技术详解
u012698191的博客
09-30 1116
ADC（Analog-to-Digital Converter，模数转换器） 是将连续的模拟信号转换为离散的数字信号的关键组件。在STM32系列微控制器中，ADC广泛应用于传感器数据采集、信号处理和控制系统等领域。本文将详细介绍STM32的ADC技术，包括其基本概念、架构、配置方法、使用技巧及实际应用示例。
STM32原理知识查询表
weixin_54210362的博客
09-27 608
2024.09.27 单片机的两种看门狗原理解析
嵌入式项目：STM32平衡车详解 (基础知识篇) (基于STM32F103C8T6)
boldht的博客
09-26 1569
嵌入式单片机平衡车项目，基于STM32F103C8T6芯片，系统讲解涉及到的基础知识、各模块、代码
STM32F103C8----3-3 蜂鸣器（跟着江科大学STM32）
oopxiajun博客专栏
09-29 445
面包板的的使用请参考：《
STM32-HAL库驱动DHT11温湿度传感器 --2024.9.28
qq_45784265的博客
09-28 1059
本教程用通俗易懂的语言和详细的操作过程截图，为开发者清除DHT11这只拦路虎，本教程还提供可以快速使用DHT11的驱动代码，只要跟着本教程操作，都可以正确读取到温湿度信息。
蓝桥杯—STM32G431RBT6(RTC时钟获取时间和日期)
JK03820的博客
09-29 1793
在LCD函数中获取值 注意，两个都要获取一下，不然容易出毛病 在LCD中显示 四、开源代码 通过网盘分享的文件：19-TEST9-RTC实时时钟.zip 链接: https://pan.baidu.com/s/150G8rln1ZEBG1QCZBqrMAQ?pwd=0820 提取码: 0820
舵机驱动详解（模拟/数字 STM32）
最新发布
qq_44016222的博客
10-06 638
舵机(Servo)是在程序的控制下，在一定范围内连续改变输出轴角度并保持的电机系统。即舵机只支持在一定角度内转动，无法像普通直流电机按圈转；其主要控制物体的转动并保持（机器人关节、转向机构）。适用于位置角度经常变化的场合。可以作为理想的电机驱动器件。以下MG90S舵机模块的参数：型号MG90S/MG90使用电压4.8V反应速度0.11s4.8V转动角度180度左90，右90)使用温度0~55℃工作扭矩2.0kg产品重量13.6g。
STM32（四）LED闪烁、流水灯及蜂鸣器操作
m0_73597306的博客
10-01 536
小节任务：在对GPIO函数初始化操作及配置好输入或输出模式后，使用GPIO的输入输出函数控制LED闪烁、流水灯及蜂鸣器操作，本小节先使用GPIO的四个输出函数SetBits函数将指定端口设置为高电平ResetBits函数将指定端口设置为低电平WriteBit根据第三个参数的值来设置指定的端口Write函数可以同时对16个端口进行同时写入操作输出模式笔记：推挽输出高低电平均有驱动能力，开漏输出高电平相当于高阻态，没有驱动能力，低电平有驱动能力。一般输出用推挽模式，特殊地方采用开漏输出。
STM32三种启动模式：【详细讲解】
weixin_66299220的博客
09-25 1974
BOOT 引脚的值在时被锁定。在重置后,由用户决定是如何设置 BOOT1 和 BOOT0 引脚,来选择需要的启动模式。
STM32的DMA技术介绍
u012698191的博客
09-30 1085
DMA（Direct Memory Access，直接内存访问） 是一种允许外设直接与系统内存进行数据传输，而无需经过CPU的技术。在STM32微控制器中，DMA技术极大地提高了数据传输效率，降低了CPU的负担，从而提升系统整体性能。
STM32引脚PB3、PB4、PA15作为输入输出的特殊配置
weixin_48867130的博客
09-29 896
一般都只禁用JTAG了，但是在 Asynchronous trace mode（异步跟踪调试模式），PB3还是TRACESWO，TRACESWO if async trace is enabled PB3，所以，作为输入还需要禁用async trace，寄存器版的那两句话就是禁用async trace的之后，输入就没问题了。调试过程：在撰写代码过程中，又发现新的问题，Enter按键无法控制屏幕数值，反复检查了原理图，以及引脚配置均没有问题，通过万用表也检查了引脚的电压，引脚的电压与理论值3V基本一致。
STM32驱动HC-SR04超声波模块实战
"STM32通过编程控制超声波传感器HC-SR04的实现方法" 在本文中，我们将深入探讨如何使用STM32微控制器控制超声波传感器HC-SR04来测量距离，并根据测量结果控制GPIO引脚的状态。STM32是一款基于ARM Cortex-M内核的微...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值