devbox
算法编织者
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于STM32的智能循迹避障小车实验（超声波部分）_自动循迹避障小车超声波避障模块

作者：算法编织者 | 2024-01-30 11:59:55

赞

踩

自动循迹避障小车超声波避障模块

接上一篇基于STM32的智能循迹避障小车实验（舵机旋转部分）

最后这部分我们实现超声波部分和最后代码的整合

实验所用器件及其介绍

本部分实验采用的是超声波模块HC-SR04，它长这样：

 

买这个的时候最好再买一个支架，可以直接架在舵机上，探查周围的距离。

超声波模块有4个引脚，分别为Vcc、 Trig（控制端）、 Echo（接收端）、 GND；其中VCC、GND接上电源和地， Trig（控制端）控制发出的超声波信号，Echo（接收端）接收反射回来的超声波信号。

控制端的控制原理：通过Trig引脚发一个 10US 以上的高电平,就可以在Echo接收口等待高电平输出；一有输出就可以开定时器计时,当此口变为低电平时就可以读定时器的值,此时就为此次测距的时间,方可算出距离.如此不断的周期测,就可以达到你移动测量的值了。（这个时间最好大于60us，以防检测和发送的声波冲突）。

 

了解了超声波模块的基本工作原理后就可以完成程序设计了。

程序实现

和之前操作一样，我们在之前代码的基础上直接打开CobeMX。

代码实现顺序：先设置触发信号，这里我们使用一个普通的GPIO口输出一个高电平，等待Echo发出脉冲，然后启动定时器，等待Echo变为低电平即为一次定时时间，根据数学公式我们可以将这个时间转化为距离。

CubeMX设置

这里我们还是设置一个普通的GPIO口为输出模式，再使用通用定时器作为测量时间的工具。

这里使用PG11作为GPIO输出口和Trig引脚相连，然后打开TIM4通道1设置为Input Capture direct mode模式，然后再在NVIC中配置主优先级为1次优先级为0，具体配置如图：

 

配置完成后生成代码，

代码实现

和之前实现定时器的中断相似的步骤，但是我们这里要实现另外的中断回调函数：

  1. uint8_t TIM4CH1_CAP_STA = 0;                        // 输入捕获状态
  2.  
  3. uint16_t TIM4CH1_CAP_VAL;                           // 输入捕获值
  4.  
  5. // 中断服务函数里面会自动调用这个回调函数，这个是定时器更新中断处理的函数（更新时间回调函数，这里更新溢出的时间）
  6.  
  7. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
  8.  
  9. {
  10.  
  11.     if(htim->Instance == TIM4)       // 判断定时器4是否发生中断
  12.  
  13.     {
  14.  
  15.         if((TIM4CH1_CAP_STA & 0X80) == 0)           // 还未成功捕获
  16.  
  17.         {
  18.  
  19.             if(TIM4CH1_CAP_STA & 0X40)   // 已经捕获到高电平
  20.  
  21.             {         
  22.  
  23.                 if((TIM4CH1_CAP_STA & 0X3F) == 0X3F)// 高电平时间太长了，做溢出处理
  24.  
  25.                 { 
  26.  
  27.                     TIM4CH1_CAP_STA |= 0X80;   // 标记为完成一次捕获
  28.  
  29.                     TIM4CH1_CAP_VAL += 1;       // 计数器值
  30.  
  31.                 }
  32.  
  33.                 else
  34.  
  35.                 {
  36.  
  37.                     TIM4CH1_CAP_STA++;    // 若没有溢出，就只让TIM5CH1_CAP_STA自加
  38.  
  39.                 }               
  40.  
  41.             }  
  42.  
  43.         }
  44.  
  45.     }
  46.  
  47. }
  48.  
  49.  
  50.  
  51. // 定时器输入捕获中断处理回调函数，该函数在 HAL_TIM_IRQHandler(TIM_HandleTypeDef *htim) 中会被调用（通道输入捕获）
  52.  
  53. void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
  54.  
  55. {
  56.  
  57.     if((TIM4CH1_CAP_STA & 0X80) == 0)               // 还未成功捕获
  58.  
  59.     {
  60.  
  61.          if(TIM4CH1_CAP_STA & 0X40)         // 捕获到一个下降沿
  62.  
  63.         {          
  64.  
  65.                      TIM4CH1_CAP_STA |= 0X80;   // 标记成功捕获到一次高电平脉宽
  66.  
  67.                      TIM4CH1_CAP_VAL = HAL_TIM_ReadCapturedValue(&htim4, TIM_CHANNEL_1); // 获取当前的计数器值
  68.  
  69.                      TIM_RESET_CAPTUREPOLARITY(&htim4, TIM_CHANNEL_1);                 // 清除原来的设置        
  70.  
  71.                      TIM_SET_CAPTUREPOLARITY(&htim4,TIM_CHANNEL_1, TIM_ICPOLARITY_RISING);// 设置上升沿捕获
  72.  
  73.               }
  74.  
  75.               else
  76.  
  77.         {
  78.  
  79.                      TIM4CH1_CAP_STA = 0;     // 清空自定义的状态寄存器
  80.  
  81.                      TIM4CH1_CAP_VAL = 0;        // 清空捕获值
  82.  
  83.                      TIM4CH1_CAP_STA |= 0X40;        // 标记捕获到上升沿
  84.  
  85.                      __HAL_TIM_DISABLE(&htim4);    // 关闭定时器
  86.  
  87.                      __HAL_TIM_SET_COUNTER(&htim4, 0);   // 计数器值清零
  88.  
  89.                      TIM_RESET_CAPTUREPOLARITY(&htim4,TIM_CHANNEL_1);  // 一定要先清除原来的设置   ！！              
  90.  
  91.                  TIM_SET_CAPTUREPOLARITY(&htim4,TIM_CHANNEL_1,TIM_ICPOLARITY_FALLING);   // 设置下降沿捕获
  92.  
  93.                      __HAL_TIM_ENABLE(&htim4);         // 使能定时器     
  94.  
  95.               }     
  96.  
  97.        }
  98.  
  99. }

完成中断回调函数之后，就可以在主函数中启动中断了，最后我这里使用了串口输出相关的距离、时间，也可以使用其他的方式输出，因为最后整合代码时不需要串口输出，所以我对串口配置没有说明。

主函数部分

  1. int main(void)
  2.  
  3. {
  4.  
  5.   /* USER CODE BEGIN 1 */
  6.  
  7. //    uint8_t i = 0;
  8.  
  9.       
  10.  
  11.        uint8_t length_res[10];  // 定义一个数组存放前方的距离
  12.  
  13. //    uint8_t Car_Command= 4;
  14.  
  15.   /* USER CODE END 1 */
  16.  
  17.  
  18.  
  19.   /* MCU Configuration--------------------------------------------------------*/
  20.  
  21.  
  22.  
  23.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  24.  
  25.   HAL_Init();
  26.  
  27.  
  28.  
  29.   /* USER CODE BEGIN Init */
  30.  
  31.  
  32.  
  33.   /* USER CODE END Init */
  34.  
  35.  
  36.  
  37.   /* Configure the system clock */
  38.  
  39.   SystemClock_Config();
  40.  
  41.  
  42.  
  43.   /* USER CODE BEGIN SysInit */
  44.  
  45.  
  46.  
  47.   /* USER CODE END SysInit */
  48.  
  49.  
  50.  
  51.   /* Initialize all configured peripherals */
  52.  
  53.   MX_GPIO_Init();
  54.  
  55.   MX_TIM2_Init();
  56.  
  57.   MX_USART1_UART_Init();
  58.  
  59.   MX_TIM3_Init();
  60.  
  61.   MX_TIM4_Init();
  62.  
  63.   /* USER CODE BEGIN 2 */
  64.  
  65.       
  66.  
  67.        printf("这是智能小车方向控制测试程序");
  68.  
  69.        HAL_TIM_Base_Start_IT(&htim3);  // 这个中断是之前的舵机中断
  70.  
  71.        HAL_TIM_PWM_Start_IT(&htim3, TIM_CHANNEL_1);
  72.  
  73.        HAL_TIM_IC_Start_IT(&htim4,TIM_CHANNEL_1);  // 一定要开启TIM4通道1的捕获中断，这个是超声波中断
  74.  
  75.   __HAL_TIM_ENABLE_IT(&htim4,TIM_IT_UPDATE);  // 一定要开启TIM4的更新中断
  76.  
  77.   printf("This is TIM_CAP test...\n");   
  78.  
  79.   /* USER CODE END 2 */
  80.  
  81.  
  82.  
  83.   /* Infinite loop */
  84.  
  85.   /* USER CODE BEGIN WHILE */
  86.  
  87.   while (1)
  88.  
  89.   {
  90.  
  91.               HAL_GPIO_WritePin(GPIOG, GPIO_PIN_12, GPIO_PIN_SET);
  92.  
  93.               HAL_Delay(1);
  94.  
  95.               HAL_GPIO_WritePin(GPIOG, GPIO_PIN_12, GPIO_PIN_RESET);
  96.  
  97.              
  98.  
  99.               HAL_Delay(500);
  100.  
  101.    if(TIM4CH1_CAP_STA & 0X80)    // 完成一次高电平捕获
  102.  
  103.    {
  104.  
  105.      temp = TIM4CH1_CAP_STA & 0X3F;
  106.  
  107.       temp *= 1000;            // 溢出总时间
  108.  
  109.      temp = (temp+TIM4CH1_CAP_VAL)/58.0; // temp+TIM4CH1_CAP_VAL是总的时间，除以58是距离
  110.  
  111.       printf("High level duration:%lld cm\r\n",temp);  // 输出每次测出的距离，单位是cm
  112.  
  113.       TIM4CH1_CAP_STA = 0;             // 准备下一次捕获
  114.  
  115.        }
  116.  
  117.              
  118.  
  119.     /* USER CODE END WHILE */
  120.  
  121.              
  122.  
  123.     /* USER CODE BEGIN 3 */
  124.  
  125.   }
  126.  
  127.                     
  128.  
  129.   /* USER CODE END 3 */
  130.  
  131. }

这样就完成了超声波部分的测试，最后我们将代码整合，就可以完成小车自动识别障碍物然后前进

代码整合

在整合之前，我们需要修改之前的代码，现在我们要实现的目的是：超声波模块测量前面的距离，如果距离大于30cm，就让小车直走，距离小于30cm，停车，测量左侧和右侧45°的距离，然后比较这两个数，向距离大的一侧前进。

  1. // 小车停止代码
  2.  
  3. void Car_Stop(void)
  4.  
  5. {
  6.  
  7.        HAL_GPIO_WritePin(IN1_GPIO_Port, IN1_Pin, GPIO_PIN_RESET);
  8.  
  9.        HAL_GPIO_WritePin(IN3_GPIO_Port, IN3_Pin, GPIO_PIN_RESET);
  10.  
  11.  
  12.  
  13. }
  14.  
  15. Uint8_t a;
  16.  
  17. // 上节中我们有个关于舵机旋转方向的表格，在这里我们定义90°为正前方
  18.  
  19. // 右转45°
  20.  
  21. void SG90_Right_45(void)
  22.  
  23. {
  24.  
  25.        a = 1;
  26.  
  27. }
  28.  
  29. // 舵机转向前方
  30.  
  31. void SG90_Front(void)
  32.  
  33. {
  34.  
  35.        a = 2;
  36.  
  37. }
  38.  
  39. // 左转45°
  40.  
  41. void SG90_Left_45(void)
  42.  
  43. {
  44.  
  45.        a = 3;
  46.  
  47. }
  48.  
  49. // 这里我们之前的回调函数也得重新实现，以保证我们可以调整想要的角度
  50.  
  51. /* TIM3 init function */
  52.  
  53. void HAL_TIM_PWM_PulseFinishedCallback(TIM_HandleTypeDef *htim)
  54.  
  55. {
  56.  
  57.        // 舵机的回调函数，使舵机转向
  58.  
  59.        if(htim->Instance == TIM3)  // 判断是否是定时器3引起的中断
  60.  
  61.        {
  62.  
  63.               if(a == 1)  // 判断是具体是哪个转向
  64.  
  65.               {
  66.  
  67.                      __HAL_TIM_SET_COMPARE(&htim3,TIM_CHANNEL_1,10);
  68.  
  69.               }
  70.  
  71.               if(a == 2)
  72.  
  73.               {
  74.  
  75.                      __HAL_TIM_SET_COMPARE(&htim3,TIM_CHANNEL_1,15);
  76.  
  77.               }
  78.  
  79.               if(a == 3)
  80.  
  81.               {
  82.  
  83.                      __HAL_TIM_SET_COMPARE(&htim3,TIM_CHANNEL_1,20);
  84.  
  85.               }
  86.  
  87.        }
  88.  
  89. }
  90.  
  91. 剩下的就是主函数部分的重新实现：
  92.  
  93. int main(void)
  94.  
  95. {
  96.  
  97.   /* USER CODE BEGIN 1 */
  98.  
  99. //    uint8_t i = 0;
  100.  
  101.       
  102.  
  103.        uint8_t length_res[10];  // 定义一个数组存放前方的距离
  104.  
  105. //    uint8_t Car_Command= 4;
  106.  
  107.   /* USER CODE END 1 */
  108.  
  109.  
  110.  
  111.   /* MCU Configuration--------------------------------------------------------*/
  112.  
  113.  
  114.  
  115.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  116.  
  117.   HAL_Init();
  118.  
  119.  
  120.  
  121.   /* USER CODE BEGIN Init */
  122.  
  123.  
  124.  
  125.   /* USER CODE END Init */
  126.  
  127.  
  128.  
  129.   /* Configure the system clock */
  130.  
  131.   SystemClock_Config();
  132.  
  133.  
  134.  
  135.   /* USER CODE BEGIN SysInit */
  136.  
  137.  
  138.  
  139.   /* USER CODE END SysInit */
  140.  
  141.  
  142.  
  143.   /* Initialize all configured peripherals */
  144.  
  145.   MX_GPIO_Init();
  146.  
  147.   MX_TIM2_Init();
  148.  
  149.   MX_USART1_UART_Init();
  150.  
  151.   MX_TIM3_Init();
  152.  
  153.   MX_TIM4_Init();
  154.  
  155.   /* USER CODE BEGIN 2 */
  156.  
  157.       
  158.  
  159.        printf("这是智能小车方向控制测试程序");
  160.  
  161.        HAL_TIM_Base_Start_IT(&htim3);
  162.  
  163.        HAL_TIM_PWM_Start_IT(&htim3, TIM_CHANNEL_1);
  164.  
  165. //    Car_Dir_Com(Car_Command);            
  166.  
  167. //    Car_Go();
  168.  
  169.        HAL_TIM_IC_Start_IT(&htim4,TIM_CHANNEL_1);  // 一定要开启TIM4通道1的捕获中断
  170.  
  171.   __HAL_TIM_ENABLE_IT(&htim4,TIM_IT_UPDATE);  // 一定要开启TIM4的更新中断
  172.  
  173.   printf("This is TIM_CAP test...\n");
  174.  
  175.              
  176.  
  177.   /* USER CODE END 2 */
  178.  
  179.  
  180.  
  181.   /* Infinite loop */
  182.  
  183.   /* USER CODE BEGIN WHILE */
  184.  
  185.   while (1)
  186.  
  187.   {
  188.  
  189.               SG90_Front();   //舵机摆正
  190.  
  191.               HAL_Delay(100);
  192.  
  193.               length_res[0] =Senor_Using();  //测前方距离放在数组里
  194.  
  195.               HAL_Delay(100);
  196.  
  197.               if(length_res[0]>30.00)       //如果前方距离大于30cm  前进
  198.  
  199.               {
  200.  
  201.                      Car_Go();
  202.  
  203.               }     
  204.  
  205.                            
  206.  
  207.               if(length_res[0]<30.00)     //如果前方距离小于30厘米  停车测左右距离
  208.  
  209.               {
  210.  
  211.                      Car_Stop(); 
  212.  
  213.                      SG90_Left_45();      //舵机左转45度测距
  214.  
  215.                      HAL_Delay(700);       
  216.  
  217.                      length_res[1] =Senor_Using();    //把测量结果放进数组
  218.  
  219.                     
  220.  
  221.                      SG90_Right_45();     //舵机右转45度测距
  222.  
  223.                      HAL_Delay(700);
  224.  
  225.                      length_res[4] =Senor_Using();     //把测量结果放进数组                    
  226.  
  227.                            
  228.  
  229.                      SG90_Front();           //舵机摆正
  230.  
  231.                      HAL_Delay(100);
  232.  
  233.                      if(length_res[1]>length_res[4])    //如果左边的距离大于右边的距离
  234.  
  235.                      {
  236.  
  237.                             do                        //舵机摆正
  238.  
  239.                             {
  240.  
  241.                             SG90_Front();
  242.  
  243.                             HAL_Delay(10);
  244.  
  245.                             length_res[0] =Senor_Using(); //重复测前方的距离同时左转
  246.  
  247.                             HAL_Delay(10);                                     
  248.  
  249.                             Car_Left();
  250.  
  251.                             }
  252.  
  253.                             while(length_res[0]<30.00);           //一直转到前方距离大于30cm             
  254.  
  255.                      }
  256.  
  257.                      if(length_res[1]<length_res[4])    //如果右边的距离大于左边的距离
  258.  
  259.                      {
  260.  
  261.                             do
  262.  
  263.                             {
  264.  
  265.                             SG90_Front();
  266.  
  267.                             HAL_Delay(10);
  268.  
  269.                             length_res[0] =Senor_Using();  //重复测前方的距离同时右转
  270.  
  271.                             HAL_Delay(10);                                     
  272.  
  273.                             Car_Right();
  274.  
  275.                             }
  276.  
  277.                             while(length_res[0]<30.00);           //一直转到前方距离大于30cm
  278.  
  279.                      }
  280.  
  281.                            
  282.  
  283.               }
  284.  
  285. // 这部分函数是之前测试超声波的函数，现在不需要
  286.  
  287. //           HAL_GPIO_WritePin(GPIOG, GPIO_PIN_12, GPIO_PIN_SET);
  288.  
  289. //           HAL_Delay(1);
  290.  
  291. //           HAL_GPIO_WritePin(GPIOG, GPIO_PIN_12, GPIO_PIN_RESET);
  292.  
  293. //          
  294.  
  295. //           HAL_Delay(500);
  296.  
  297. //    if(TIM4CH1_CAP_STA & 0X80)    // 完成一次高电平捕获
  298.  
  299. //    {
  300.  
  301. //      temp = TIM4CH1_CAP_STA & 0X3F;
  302.  
  303. //      temp *= 1000;            // 溢出总时间
  304.  
  305. //      temp = (temp+TIM4CH1_CAP_VAL)/58.0;  // 总的高电平时间
  306.  
  307. //      printf("High level duration:%lld cm\r\n",temp);
  308.  
  309. //      TIM4CH1_CAP_STA = 0;          // 准备下一次捕获
  310.  
  311. //           }
  312.  
  313.              
  314.  
  315.     /* USER CODE END WHILE */
  316.  
  317.              
  318.  
  319.     /* USER CODE BEGIN 3 */
  320.  
  321.   }
  322.  
  323.                     
  324.  
  325.   /* USER CODE END 3 */
  326.  
  327. }

这样就完成了整个项目的书写，最后附上整个项目的HAL库源码：

百度网盘 请输入提取码

提取码：1234

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/46290
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号