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

基于STM32芯片的四驱循迹小车_基于stm32的智能小车四轮驱动控制系统设计

作者：从前慢现在也慢 | 2024-03-27 01:25:22

赞

踩

基于stm32的智能小车四轮驱动控制系统设计

循迹小车包括三个基本模块：

1.宏定义模块

2.电机驱动模块

3.红外循迹模块

4.PWM调速模块

我将代码部分分为4个模块进行模块化编程：interface(各个引脚口的宏定义，方便记忆)、motor(电机驱动模块)、timer(定时器模块)、track(红外循迹模块)

一、宏定义模块

.h 各个引脚的宏定义以及实现小车前进后退的引脚使能函数定义(22-40行)

  1. #ifndef __INTERFACE_H_
  2. #define __INTERFACE_H_
  3.  
  4. #include "stm32f10x.h" 
  5. #include "motor.h"
  6. #include "track.h"
  7. #include "timer.h"
  8. #include "speedset.h"
  9.  
  10.  
  11. #define SEARCH_L_PIN         GPIO_Pin_2
  12. #define SEARCH_L_GPIO        GPIOA
  13. #define SEARCH_L_IO          GPIO_ReadInputDataBit(SEARCH_L_GPIO, SEARCH_L_PIN)
  14.  
  15. #define SEARCH_R_PIN         GPIO_Pin_3
  16. #define SEARCH_R_GPIO        GPIOA
  17. #define SEARCH_R_IO          GPIO_ReadInputDataBit(SEARCH_R_GPIO, SEARCH_R_PIN)
  18.  
  19. #define BLACK_AREA 1       
  20. #define WHITE_AREA 0       
  21.  
  22. #define FRONT_LEFT_F_PIN          GPIO_Pin_7
  23. #define FRONT_LEFT_F_GPIO         GPIOA
  24. #define FRONT_LEFT_F_SET          GPIO_SetBits(FRONT_LEFT_F_GPIO , FRONT_LEFT_F_PIN)
  25. #define FRONT_LEFT_F_RESET        GPIO_ResetBits(FRONT_LEFT_F_GPIO , FRONT_LEFT_F_PIN)
  26.  
  27. #define FRONT_LEFT_B_PIN          GPIO_Pin_6
  28. #define FRONT_LEFT_B_GPIO         GPIOA
  29. #define FRONT_LEFT_B_SET          GPIO_SetBits(FRONT_LEFT_B_GPIO , FRONT_LEFT_B_PIN)
  30. #define FRONT_LEFT_B_RESET        GPIO_ResetBits(FRONT_LEFT_B_GPIO , FRONT_LEFT_B_PIN)
  31.  
  32. #define FRONT_RIGHT_F_PIN         GPIO_Pin_4
  33. #define FRONT_RIGHT_F_GPIO        GPIOA
  34. #define FRONT_RIGHT_F_SET         GPIO_SetBits(FRONT_RIGHT_F_GPIO , FRONT_RIGHT_F_PIN)
  35. #define FRONT_RIGHT_F_RESET       GPIO_ResetBits(FRONT_RIGHT_F_GPIO , FRONT_RIGHT_F_PIN)
  36.  
  37. #define FRONT_RIGHT_B_PIN         GPIO_Pin_5
  38. #define FRONT_RIGHT_B_GPIO        GPIOA
  39. #define FRONT_RIGHT_B_SET         GPIO_SetBits(FRONT_RIGHT_B_GPIO , FRONT_RIGHT_B_PIN)
  40. #define FRONT_RIGHT_B_RESET       GPIO_ResetBits(FRONT_RIGHT_B_GPIO , FRONT_RIGHT_B_PIN)
  41.  
  42. #define FRONT_LEFT_GO    FRONT_LEFT_F_SET; FRONT_LEFT_B_RESET    
  43. #define FRONT_LEFT_BACK  FRONT_LEFT_F_RESET; FRONT_LEFT_B_SET  
  44. #define FRONT_LEFT_STOP  FRONT_LEFT_F_RESET; FRONT_LEFT_B_RESET
  45.  
  46.  
  47. #define FRONT_RIGHT_GO     FRONT_RIGHT_F_SET;  FRONT_RIGHT_B_RESET  
  48. #define FRONT_RIGHT_BACK   FRONT_RIGHT_F_RESET;FRONT_RIGHT_B_SET  
  49. #define FRONT_RIGHT_STOP   FRONT_RIGHT_F_RESET;FRONT_RIGHT_B_RESET
  50.  
  51.  
  52.  
  53. void GPIOCLK_Init(void);
  54. void all_init(void);
  55.  
  56. #endif

.c 使能时钟和各模块的总初始化

  1. #include "interface.h"
  2.  
  3. void GPIOCLK_Init(void)
  4. {
  5.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA , ENABLE);
  6.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB , ENABLE);
  7.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC , ENABLE);
  8. }
  9.  
  10. void all_init(void)
  11. {
  12.      GPIOCLK_Init();                                  
  13.      motor_init();                               
  14.    tracking_init();            
  15.    TIM2_Init();       
  16.  
  17. }

二、电机模块

这是商家给的原理图，理念是两个电机驱动模块控制四个电机，也就是一个电机驱动模块控制两个电机。所以在电机模块我们要做的就是初始化PA4 PA5 PA6 PA7，再编写小车的前后左右移动函数。因为是四驱车，所以小车的转向是通过两边车轮反向运动实现的。

.c 下面内容中的个别变量(speed_count、Time_10us_motor、front_left_speed_duty、front_left_speed_duty)与定时器有关将在下一模块讲解

  1. #include "motor.h"    
  2. #include "stm32f10x.h" 
  3. #include "speedset.h"
  4.  
  5. unsigned int speed_count=0;
  6. unsigned char Time_10us_motor = 0;   
  7. int front_left_speed_duty=0;  
  8. int front_right_speed_duty=0;
  9.  
  10. void MotorGPIO_Configuration(void)
  11. {
  12.     GPIO_InitTypeDef GPIO_InitStructure;
  13.     
  14.     GPIO_InitStructure.GPIO_Pin = FRONT_LEFT_F_PIN;
  15.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  16.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;     
  17.     GPIO_Init(FRONT_LEFT_F_GPIO, &GPIO_InitStructure);    
  18.     
  19.     GPIO_InitStructure.GPIO_Pin = FRONT_LEFT_B_PIN;    
  20.     GPIO_Init(FRONT_LEFT_B_GPIO, &GPIO_InitStructure); 
  21.     
  22.     GPIO_InitStructure.GPIO_Pin = FRONT_RIGHT_F_PIN;    
  23.     GPIO_Init(FRONT_RIGHT_F_GPIO, &GPIO_InitStructure); 
  24.     
  25.     GPIO_InitStructure.GPIO_Pin = FRONT_RIGHT_B_PIN;    
  26.     GPIO_Init(FRONT_RIGHT_B_GPIO, &GPIO_InitStructure); 
  27.     
  28. }
  29.  
  30. void CarMove(void)
  31. {   
  32.     
  33.     if(front_left_speed_duty > 0)
  34.     {
  35.         if(speed_count < front_left_speed_duty)
  36.         {
  37.             FRONT_LEFT_GO;
  38.         }else
  39.         {
  40.             FRONT_LEFT_STOP;
  41.         }
  42.     }
  43.     else if(front_left_speed_duty < 0)
  44.     {
  45.         if(speed_count < (-1)*front_left_speed_duty)
  46.         {
  47.             FRONT_LEFT_BACK;
  48.         }else
  49.         {
  50.             FRONT_LEFT_STOP;
  51.         }
  52.     }
  53.     else                
  54.     {
  55.         FRONT_LEFT_STOP;
  56.     }
  57.     
  58.  
  59.     if(front_right_speed_duty > 0)
  60.     {
  61.         if(speed_count < front_right_speed_duty)
  62.         {
  63.             FRONT_RIGHT_GO;
  64.         }else                
  65.         {
  66.             FRONT_RIGHT_STOP;        }
  67.     }
  68.     else if(front_right_speed_duty < 0)
  69.     {
  70.         if(speed_count < (-1)*front_right_speed_duty)
  71.         {
  72.             FRONT_RIGHT_BACK;
  73.         }else               
  74.         {
  75.             FRONT_RIGHT_STOP; 
  76.         }
  77.     }
  78.     else               
  79.     {
  80.         FRONT_RIGHT_STOP; 
  81.     }
  82.     
  83.  
  84. }
  85. void CarGo(void)
  86. {
  87.     front_left_speed_duty= sudu;
  88.     front_right_speed_duty=sudu;
  89.  
  90. }
  91.  
  92. void CarBack(void)
  93. {
  94.     front_left_speed_duty=-sudu;
  95.     front_right_speed_duty=-sudu;
  96.  
  97. }
  98.  
  99.  
  100. void CarLeft(void) {
  101.     front_left_speed_duty=sudu;
  102.     front_right_speed_duty=-sudu-10;
  103.  
  104. }
  105.  
  106.  
  107. void CarRight(void)
  108. {
  109.     front_left_speed_duty=-sudu-10;
  110.     front_right_speed_duty=sudu;
  111.  
  112. }
  113.  
  114.  
  115. void CarStop(void)
  116. {
  117.     front_left_speed_duty=0;
  118.     front_right_speed_duty=0;
  119.  
  120. }
  121.  
  122.  
  123. void CarBack_Trailing(void)
  124. {
  125.     front_left_speed_duty=-sudu;
  126.     front_right_speed_duty=-sudu;
  127.  
  128. }
  129.  
  130. void CarLeft_Trailing(void)
  131. {
  132.     front_left_speed_duty=90;
  133.     front_right_speed_duty=-90;
  134.  
  135. }
  136.  
  137. void CarRight_Trailing(void)
  138. {
  139.     front_left_speed_duty=-90;
  140.     front_right_speed_duty=90;
  141.  
  142. }
  143.  
  144. void motor_init(void)
  145. {
  146.     MotorGPIO_Configuration();     
  147.     CarStop();                    
  148. }

.h 

  1. #ifndef __MOTOR_H_
  2. #define __MOTOR_H_
  3.  
  4. #include "interface.h"
  5.  
  6. extern int front_left_speed_duty;     
  7. extern int front_right_speed_duty;   
  8. extern unsigned char Time_10us_motor;
  9. extern unsigned int speed_count;     
  10. void motor_init(void);
  11.  
  12.  
  13. void CarMove(void);             
  14. void CarGo(void);                
  15. void CarBack(void);            
  16. void CarLeft(void);           
  17. void CarRight(void);          
  18. void CarStop(void);         
  19. void motor_init(void);      
  20. void CarBack_Trailing(void);              
  21. void CarLeft_Trailing(void);               
  22. void CarRight_Trailing(void);             
  23.  
  24. #endif

三、定时器模块

循迹小车在控制速度方面一般使用的是PWM定时器，通过调节占空比来调节小车的转速，寻常的有通过硬件来实现此功能，即改变CCR和ARR的值来改变固定周期内高电平的时间来调节占空比，吸收了店家的参考代码，这次我通过软件来实现占空比的改变,通过定时器中断不断实现变量自加来设置周期。

他是这样想的，周期设置为100份(下文简称100)，我让小车前30向前，后70停止，就是占空比30%

实现途径就是一个一个计数：0，1，2，...，直到30以前都让小车向前，一旦数到31，那么就让小车停止。

因为定时器中断中的speed_count在不断改变，而小车的运动与否是由speed_count与xxxx_xxx_speed_duty的大小关系决定的，所以通过改变xxxx_xxx_speed_duty的大小就可以改变小车运动时间的大小也就是常说的占空比，而上面的程序里也写了xxxx_xxx_speed_duty的大小=sudu，所以我们最终改变sudu这个变量的大小就能改变占空比也就能改变小车的速度

  1. #include "timer.h"
  2.  
  3. unsigned char Time_10us_sum = 0;       
  4. unsigned char Time_1ms = 0;           
  5. static void NVIC_TIM2Configuration(void)//中断初始化
  6. { 
  7.     NVIC_InitTypeDef NVIC_InitStructure;
  8.     NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
  9.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  10.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  11.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  12.  
  13.     NVIC_Init(&NVIC_InitStructure);
  14. }
  15.  
  16. void TIM2_Init(void)//定时器初始化
  17. {
  18.     TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
  19.  
  20.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
  21.     TIM_TimeBaseStructure.TIM_Period = (10- 1);
  22.     TIM_TimeBaseStructure.TIM_Prescaler = (72 - 1);
  23.     TIM_TimeBaseStructure.TIM_ClockDivision = 0;
  24.     TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
  25.     TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);
  26.     TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
  27.     TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);
  28.     TIM_Cmd(TIM2, ENABLE);  
  29.     NVIC_TIM2Configuration();
  30. }
  31.  
  32. void TIM2_IRQHandler(void)//定时器执行函数
  33. {
  34.  
  35.     if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET)
  36.         
  37.     {
  38.         TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
  39.         
  40.             
  41.                     Time_10us_sum++;  
  42.                 Time_10us_motor++;    //变量自加
  43.                 
  44.                             
  45.         if(Time_10us_sum >= 100)//1ms
  46.         {
  47.             Time_10us_sum = 0;         
  48.             Time_1ms++;                
  49.             
  50.                          
  51.         }
  52.         
  53.         if(Time_10us_motor >= 10)//0.1ms
  54.         {
  55.                    
  56.                     Time_10us_motor = 0;
  57.             
  58.                     speed_count++;  
  59.                     
  60.                     if(speed_count >= 100)
  61.                     {
  62.                         speed_count = 0;
  63.                     }
  64.                         
  65.                  CarMove();  
  66.      
  67.                 }
  68.         
  69.              
  70.     }
  71. }
  72.

四、红外循迹模块

实现小车循迹需要用到两个红外循迹模块，在循迹模块被黑线遮挡时，对应引脚电平发生变化，通过读取引脚电平来判断是否要转弯(转弯时一边会先接触黑线，如果没接触黑线就直行)，因为赛道转弯变化多端，所以在循迹方面的代码设置上加入了sudu这一个变量来调速，sudu大小可以在实际调试中改变，同时循迹模块的灵敏度也可以调节，通过改变小车的速度和循迹模块的灵敏度可以让小车在赛道上更稳定的运行。

注意：这里的GPIO输出模式设置为上拉输入，让小车在没有检测到黑线时IO口保持高电平

.c 

  1. #include "track.h"  
  2.     
  3. void tracking_init(void)// 引脚初始化
  4.  {
  5.      
  6.     GPIO_InitTypeDef  GPIO_InitStructure;
  7.         
  8.     GPIO_InitStructure.GPIO_Pin = SEARCH_R_PIN;
  9.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
  10.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  11.     GPIO_Init(SEARCH_R_GPIO , &GPIO_InitStructure); 
  12.     
  13.     GPIO_InitStructure.GPIO_Pin = SEARCH_L_PIN;
  14.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
  15.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  16.     GPIO_Init(SEARCH_L_GPIO , &GPIO_InitStructure); 
  17.     
  18.  }
  19.  
  20.  void tracking_detector()  //循迹函数
  21. {
  22.     
  23.      if(SEARCH_L_IO == WHITE_AREA && SEARCH_R_IO == WHITE_AREA)
  24.      {
  25.         CarGo();  
  26.          
  27.      }
  28.      
  29.     
  30.     
  31.         
  32.      if(SEARCH_L_IO == BLACK_AREA&&SEARCH_R_IO == WHITE_AREA)
  33.     {
  34.         CarLeft_Trailing();  
  35.         
  36.     }
  37.     
  38.     
  39.      if (SEARCH_R_IO == BLACK_AREA&&SEARCH_L_IO == WHITE_AREA)
  40.          
  41.     {
  42.         CarRight_Trailing(); 
  43.         
  44.     }
  45.     
  46.     
  47.     
  48.      if (SEARCH_R_IO == BLACK_AREA&&SEARCH_L_IO == BLACK_AREA)
  49.     {
  50.         CarStop();  
  51.     }
  52. }
  53.  
  54. void tracking_display_execute(void)  
  55. {
  56.                  sudu=22; //循迹平稳运行速度（可调，但速度快了红外灵敏度可能跟不上）
  57.            tracking_detector();         
  58.  }

.h

  1. #ifndef __TRACK_H_
  2. #define __TRACK_H_
  3.  
  4. #include "interface.h"
  5.  
  6. void tracking_detector(void);             
  7. void tracking_init(void);                 
  8. void tracking_display_execute(void);
  9.     
  10. #endif

最后，在main.c进行所有模块的初始化，再一直执行tracking_display_execute()函数就可以实现循迹的功能。

  1. #include "interface.h" 
  2.  
  3.  int main(void)
  4.  {      
  5.      all_init();
  6.      
  7.      while(1){
  8.          tracking_display_execute();
  9.      }
  10.  }
  11.

五、困难与解决

因为是第一次进行stm32项目，难免遇到小问题，我将把个人遇到的问题与解决方法向大家分享。

keil的使用

keil软件是一款不断更新的软件，我的电脑因为重装(不要使用中文用户名！！！)后下载的是最新版本的keil，在编译后出现了几个莫名的报错，这个问题在不断尝试后通过使用更低版本的keil得到了解决，新版本的keil可能因为刚出版与部分代码不兼容，建议大家先使用稳定下来的老版本。

St-link的使用

我的stilink是在买正点原子学习板的时候一起买的，而stlink的接口与我的核心板的接口不一样，这个时候就需要向你的客服索要stilink对应端口的图片，并用杜邦线将对应的端口连接起来

总结

本文记录的是基于stm32c8t6芯片的循迹小车，属于我的学习分享，如果有不正确的地方欢迎大家指出，并且我将在循迹小车的功能上继续编写红外避障的功能，拓宽小车功能，大家一起共勉！

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

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

  

闽ICP备14008679号