设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › STM32/8 › STM32两轮智能避障小车制作 含keil工程源码、连线图
返回列表 发新帖
查看: 15007|回复: 8
打印 上一主题 下一主题
收起左侧

STM32两轮智能避障小车制作 含keil工程源码、连线图

  [复制链接]
跳转到指定楼层
楼主
ID:495511 发表于 2019-3-21 17:08 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
这个项目最主要研究了基于STM32F103微处理器的智能小车控制系统的设计。整个系统主要包括STM32F103控制器、电机驱动电路、红外检测电路、超声波避障电路。我们采用STM32F103芯片，采用脉冲宽度调制信号（PWM）来完成对电机的控制，循迹模块采用红外探测法进行黑白探测，避障模块进行障碍物检测并躲避，超声波模块用来检测小车与障碍物之间的距离，其他外围电路可用于其他功能的拓展。小车在运行过程中，避障程序优先于循迹程序。

1.介绍
1.1项目介绍
1.2研究目的
1.3设想
1.4研究方法及思路
1.5成果
2.软硬件设计
2.1智能小车介绍
2.2智能小车的组成部分
2.2.1微处理器
2.2.2传感器检测部分
2.2.3超声波检测部分
2.2.4机器人的脚
2.3循迹原理
2.3.1红外探测法
2.3.2循迹方法
2.3.3道路现象分析
2.3.4循迹代码
2.4避障原理
2.4.1HC-SR04工作原理
2.4.2自由避障策略
2.4.3自由避障代码
2.5自动驾驶系统总体结构
3.软硬件调试
3.1软件调试
3.2硬件调试
4.结论

1.介绍1.1项目介绍

本项目是一个自动驾驶系统的项目，该项目能够通过提供自动驾驶、对路况智能处理以及其他为行驶系统设计的新功能，根据场景设定完成自动驾驶。该自动驾驶的设备可以是私家汽车， 货车，也可以是卡车等。

1.2研究目的

设计一个自动驾驶系统，可以在特定地方寻找轨迹，并沿着轨迹行走；可以检测到障碍物的距离并进行躲避。

1.3设想

假设在校方提供提供的样机、红外探测器、超声波检测模块功能正常，电池电量充足，源程序思路代码均正确，场地轨迹明显的情况下，我们的小车可以沿着黑色轨迹线持续行走，遇到障碍物时小车停止，移开障碍物后，小车可继续沿着特定的轨迹行走，直至我们要求其结束。

1.4研究方法及思路

本次实验我们采取模拟法，使用HL-1 智能小车模拟真实的汽车，进行实验。实验过程中，我们模拟不同的路况，例如“T型路”、“十字路”、“断头路”等路况，将小车放在相应的位置，观察其红外探测的指示灯的亮灭状况，并记录下来，分析其对应情况时IO口的输入情况，得出循迹伪代码；避障时，我们通过设置障碍物，分析小车遇到障碍物时应做出的回应，得到相应的伪代码。最终进行整体代码的分析撰写。


1.5成果

循迹：小车在特定场景模式下，按照黑色的轨迹行驶；

避障：循迹模式下，小车遇障碍物停止；自由模式下，小车到障碍物的距离大于20cm时直行，小车到障碍物的距离大于10cm小于20cm时右转；小车到障碍物的距离小于10cm时后退；

文档：提交技术报告、会议纪要、进度计划表、任务书组、项目组成员表等文档

2.软硬件设计2.1智能小车介绍
  • 智能小车是轮式机器人。
  • 它是一个集环境感知、规划决策、自动驾驶等功能于一体的综合系统 。                          
  • 它是集中运用了计算机、传感、信息、通信、导航、人工智能及自动控制等技术的综合体。
图 1 智能小车整体图
2.2智能小车的组成部分2.2.1微处理器
图 2 STM32F103C8主芯片整体图

STM32F103C8主芯片

  •    内核：ARM 32位的Cortex-M3 CPU 工作频率72MHz                           
  •    存储器：64KB闪存程序存储器、20KB的SRAM
  •    电源电压：2.0V~3.6V
  •    数据转换器：2个12位AD转换器（10个输入通道）
  •    调试模式：串行单线调试（SWD）和JTAG接口
2.2.2传感器检测部分
图 3 红外反射传感器整体图

红外反射传感器

  •    检测距离：1mm~8mm
  •    比较器输出数字开关量（0和1）
  •    配多圈可调精密电位器调节灵敏度
  •    工作电压：3.3V~5V

传感器的红外发射二极管不断发射红外线，当发射出的红外线没有被反射回来或被反射回来强度不大时，比较器的输出端为高电平，指示灯熄灭；当红外线被反射回来且强度足够大时，比较器的输出端为低电平，指示灯被点亮。

2.2.3超声波检测部分
图 4 HC-SR04整体图

HC-SR04引脚

  • VCC供5V电源
  • GND为地线
  • TRIG触发控制信号输入
  • ECHO回响信号输出
表 1  HC-SR04电器参数

电气参数

HC-SR04声波模块

工作电压

DC  5V

工作电流

15mA

输入触发信号

10us的TTL脉冲

输出回响

输出TTL电平信号信号，与射程成比例



2.2.4机器人的脚
图 5 LN98N集成电机驱动整体图
  •    机械部分

车轮为三个，前轮是两个主动轮，后轮是一个从动轮

  •    电机部分
  •   两个直流电机
  •   L298N集成电机驱动芯片
  •   工作电压：5V

微控制器产生PWM信号给L298N，通过调节方波的占空比来控制电机的转速。两个电机转速相同时小车前进或后退；转速不同时小车转弯；两个电机反向等速运转时，小车原地转圈。

2.3循迹原理

小车循迹指的是小车在白色地板上循黑线行走，通常采取的方法是红外探测法。

2.3.1红外探测法

利用红外线在不同颜色的物体表面具有不同的反射强度的特点，在小车行驶过程中不断地向地面发射红外光，当红外光遇到白色纸质地板时发生漫反射，反射光被装在小车上的接收管接收；如果遇到黑线则红外光被吸收，小车上的接收管接收不到红外光。单片机就是否收到反射回来的红外光为依据来确定黑线的位置和小车的行走路线。

2.3.2循迹方法

采用与路面颜色有较大差别的线条（白色路面上有条黑色曲线）作引导线，当循迹传感器照到黑线时输出高电平1，照到白色时输出低电平0。

图 6 循迹示意图
2.3.3道路现象分析
路径名称
路径图示
小车操作



循迹直行


寻迹直行，沿着当前黑色路径指示直行

L弯左转

循迹左转90度，沿着当前黑色路径指示直行

L弯右转

循迹右转90度，沿着当前黑色路径指示直行

T型路口按命令转弯

遇到T型路口，根据命令转弯。命令左转，向左转弯；命令右转，向右循迹转弯。

            

              十字路口

遇到十字路口，根据命令行驶。左转，右转直行

断头路

遇到断头路，左转180度调头

图表 1   道路状态模拟

我们采用三路循迹，共8中状态指示，对应状况如下所示

表 2    红外检测状态分析

指示灯A、C、E
代号
回应
000
OUT
掉头（‘u’）
001
R
右转（‘r’）
010
M
执行（‘f’）
011
MR
右转（‘r’）
100
L
左转（‘l’）
101
LR

110
LM
左转（‘l’）
111
LMR
右转（‘r’）

备注：我们设计的线路之间有一定的距离，LR状态不会出现

2.3.4循迹代码
图 7   循迹代码截图
2.4避障原理2.4.1HC-SR04工作原理
  • 给超声波模块接入电源和地。
  • 给脉冲触发引脚（trig）输入一个长为20us的高电平方波。
  • 输入方波后，模块会自动发射8个40KHz的声波，与此同时回波引脚（echo）端的电平会由0变为1；（此时应该启动定时器计时）
  • 当超声波返回被模块接收到时，回波引 脚端的电平会由1变为0；（此时应该停止定时器计数），定时器记下的这个时间即为超声波由发射到返回的总时长。
  •   根据声音在空气中的速度为344米/秒，即可计算出所测的距离。
2.4.2自由避障策略
表 3自由避障策略分析
当前距离（curDis）/cm
应答策略/代号
10<curDis <20
掉头（‘u’）
curDis<10
后退（‘b’）
curDis >20
直行（‘f’）

2.4.3自由避障代码
图 8  自由避障程序截图
2.5自动驾驶系统总体结构

图 8  自动驾驶系统总体结构
3.软硬件调试3.1软件调试

系统开发条件：Keil 5.26.2.0

下载工具：J-Link 6.20

3.2硬件调试

小车连线：

·电源

              小车J2 –VCC 接stm32控制板JP2- +5V

              小车J2 –GND接stm32控制板JP2- GN

              小车J2 –VCC接红外控制板VCC

小车J2 –GND接红外控制板GND

·驱动

              小车J3-IN1接stm32控制板JP3-PB10

              小车J3-IN2接stm32控制板JP3-PB11

              小车J3-IN3接stm32控制板JP3-PB12

              小车J3-IN4接stm32控制板JP3-PB13

              小车J3-EN1接stm32控制板JP3-3.3V

              小车J3-EN2接stm32控制板JP3-3.3V

·红外信号输出

              红外控制板D01接stm32控制板J2-PB5

              红外控制板D02接stm32控制板J2-PB6

              红外控制板D03接stm32控制板J2-PB7

·超声波输入输出

              超声波模块接小车J6

              小车J4-P2.0接stm32控制板PA0

              小车J4-P2.1接stm32控制板PA4

4.结论

本次项目设计了中央处理模块、电机驱动模块、避障模块和循迹模块。其中中央处理模块的芯片是stm32f103，电机驱动模块的主要芯片是LM293D，避障模块的主要器件是HC-SR04，循迹模块的主要器件是五个红外探测器（IR）。通过各模块之间的配合以及软件和硬件设计的结合，使得最终设计出的小车具有循迹功能和避障功能，即能沿轨迹黑线前进，不会偏出轨迹，并且当探测到障碍物时可停止前进，且探测距离大于10cm。最终完成了该项目的设想预期。



  1. #include <stdio.h>

  3. extern void CarInit(void);
  4. extern void DebugInit(void);
  5. extern void TimerInit(void);
  6. extern void CheckTimer(void);

  8. int main()
  9. {
  10.   TimerInit();    // 系统任务定时器初始化
  11.   CarInit();      // 小车各模块初始化
  12.   DebugInit();

  14.   while(1)
  15.   {
  16.     CheckTimer(); // 开始执行定时任务
  17.   }
  18. }
  19. timer.c
  20. #include "stm32f10x.h"

  22. void TimerInit()
  23. {
  24.               RCC->APB2ENR |= 1 << 11;

  26.               TIM1->PSC = 36000 - 1;
  27.               TIM1->ARR = 65535;
  28.               TIM1->CR1 = 0x81;
  29. }

  31. static unsigned short TimeGet()
  32. {
  33.   return TIM1->CNT;
  34. }


  37. struct timer
  38. {
  39.   void (*proc)(void);
  40.   int reload;
  41.   unsigned short begin;
  42.   unsigned short duration;
  43. };

  45. #define TIMER_CNT_MAX 8
  46. static struct timer tmr[TIMER_CNT_MAX];
  47. static int tmr_cnt=0;

  49. int SetTimer(unsigned short duration, void (*proc)(void) , int reload)
  50. {
  51.   if (tmr_cnt >= TIMER_CNT_MAX)
  52.   {
  53.     return 0;
  54.   }
  55.   tmr[tmr_cnt].begin = TimeGet();
  56.   tmr[tmr_cnt].duration = duration;
  57.   tmr[tmr_cnt].proc = proc;
  58.   tmr[tmr_cnt].reload = reload;
  59.   tmr_cnt++;
  60.   return 1;
  61. }

  63. // CheckTimer为主程序循环调用函数，执行定时事务
  64. void CheckTimer()
  65. {
  66.   int tmr_idx=0;
  67.   int i=0;
  68.   unsigned short now = TimeGet();

  70.   while (tmr_idx < tmr_cnt)
  71.   {
  72.     if ((unsigned short)(now - tmr[tmr_idx].begin) >= tmr[tmr_idx].duration)
  73.     {
  74.       if (tmr[tmr_idx].proc)
  75.         (*tmr[tmr_idx].proc)();
  76.       if (tmr[tmr_idx].reload)
  77.       {
  78.         tmr[tmr_idx].begin = now;
  79.         tmr_idx++;
  80.       }
  81.       else
  82.       {
  83.         for (i=tmr_idx; i<tmr_cnt-1; i++)
  84.           tmr[i] = tmr[i+1];
  85.         tmr_cnt--;
  86.       }
  87.     }
  88.     else
  89.       tmr_idx++;
  90.   }
  91. }

  93. 3.motor.c

  95. #include "stm32f10x.h"

  97. struct motor
  98. {
  99.   enum {STOP, FORWARD, BACKWARD} state;
  100.   int forward_opcode;
  101.   int backward_opcode;
  102. };

  104. static struct motor left_motor, right_motor;

  106. void MotorInit()
  107. {
  108.   RCC->APB2ENR |= 1 << 3;
  109.   GPIOB->CRH &= 0xff0000ff;
  110.   GPIOB->CRH |= 0x00333300; //PB10              左后退 , PB11              左前进, PB12              右前进, PB13  右后退
  111.   GPIOB->BSRR = ((1 << 10) | (1 << 11) | (1 << 12) | (1 << 13)) << 16;
  112.             
  113.   left_motor.state = STOP;
  114.   left_motor.forward_opcode = 1 << 11;
  115.   left_motor.backward_opcode = 1 << 10;

  117.   right_motor.state = STOP;
  118.   right_motor.forward_opcode = 1 << 12;
  119.   right_motor.backward_opcode = 1 << 13;            
  120. }

  122. //对某电机施加前转驱动电平
  123. static void MotorRotateForward(struct motor *pmotor)
  124. {
  125.               if (pmotor->state != FORWARD)
  126.               {
  127.                 GPIOB->BSRR = (pmotor->backward_opcode << 16) | pmotor->forward_opcode;
  128.                 pmotor->state = FORWARD;
  129.               }
  130. }

  132. //对某电机施加后转驱动电平
  133. static void MotorRotateBackward(struct motor *pmotor)
  134. {
  135.               if(pmotor->state != BACKWARD)
  136.               {
  137.                 GPIOB->BSRR = (pmotor->forward_opcode << 16) | pmotor->backward_opcode;
  138.                 pmotor->state = BACKWARD;
  139.               }
  140. }

  142. //对某电机停止驱动电平
  143. static void MotorStop(struct motor *pmotor)
  144. {
  145.               if (pmotor->state != STOP)
  146.               {
  147.                 GPIOB->BSRR = (pmotor->forward_opcode | pmotor->backward_opcode) << 16;
  148.                 pmotor->state = STOP;
  149.               }
  150. }

  152. //电机控制函数
  153. //输入参数：电机标识字符'r'或’l'（右或左）   操作代码字符'f'、'b'或's'（正转、反转或静止）
  154. void MotorControl(char motor, char op_cmd)
  155. {
  156.   struct motor *pmotor;

  158.   if (motor == 'r')
  159.     pmotor = &right_motor;
  160.   else if (motor == 'l')
  161.     pmotor = &left_motor;
  162.   else
  163.     return;
  164.   if (op_cmd == 'f')
  165.     MotorRotateForward(pmotor);
  166.   if (op_cmd == 'b')
  167.     MotorRotateBackward(pmotor);
  168.   if (op_cmd == 's')
  169.     MotorStop(pmotor);
  170. }
  171. wheel.c
  172. #include "stm32f10x.h"

  174. extern void MotorInit(void);
  175. static void WheelDrive(void);
  176. extern void MotorControl(char motor, char op_cmd);
  177. extern int SetTimer(unsigned short duration, void (*proc)(void) , int reload);

  179. struct wheel
  180. {
  181.   unsigned short period;
  182.   unsigned short duty;
  183.   unsigned short current;
  184.   unsigned char motor;
  185.   unsigned char dir;
  186. };

  188. static struct wheel wheel_left, wheel_right;
  189. static enum{STOP, FORWARD, BACKWARD, LEFT, RIGHT, U_TURN} state;

  191. // WheelInit是对小车的车轮要的外部接口进行初始化。
  192. void WheelInit()
  193. {
  194.               MotorInit();

  196.               wheel_left.period = 50;
  197.               wheel_left.duty = 15;
  198.               wheel_left.current = wheel_left.period;
  199.               wheel_left.dir = 's';
  200.               wheel_left.motor = 'l';
  201.             
  202.               wheel_right.period = 50;
  203.               wheel_right.duty = 15;
  204.               wheel_right.current = wheel_right.period;
  205.               wheel_right.dir = 's';
  206.               wheel_right.motor = 'r';

  208.               state = STOP;
  209.             
  210.               SetTimer(2, WheelDrive, 1); // 每1ms执行一次
  211. }

  213. static void WheelRun(struct wheel *pwheel, char dir)
  214. {
  215.               if((dir != 'f') && (dir != 'b'))
  216.     return;
  217.               pwheel->dir = dir;
  218.               pwheel->current++;
  219.               if (pwheel->current >= pwheel->period)
  220.     pwheel->current = 0;
  221.               if (pwheel->current < pwheel->duty)
  222.     MotorControl(pwheel->motor, pwheel->dir);
  223.               if(pwheel->current >= pwheel->duty)
  224.     MotorControl(pwheel->motor, 's');
  225. }

  227. static void WheelStop (struct wheel *pwheel)
  228. {
  229.               if(pwheel->dir == 's')
  230.   return;
  231.               pwheel->dir = 's';
  232.               pwheel->current = pwheel->period;
  233.               MotorControl(pwheel->motor, 's');
  234. }

  236. // WheelDrive是根据工作状态来设定小车的前进、后退、左转、右转及停止，
  237. // 主要是操控WheelRun和WheelStop两个函数实现所需要的功能。
  238. static void WheelDrive()
  239. {
  240.   switch(state)
  241.   {
  242.                 case FORWARD:
  243.       WheelRun(&wheel_right, 'f');
  244.       WheelRun(&wheel_left, 'f');
  245.     break;
  246.                
  247.     case BACKWARD:
  248.       WheelRun(&wheel_right, 'b');
  249.       WheelRun(&wheel_left, 'b');
  250.     break;

  252.                 case LEFT:
  253.                   WheelRun(&wheel_right, 'f');
  254.       WheelStop(&wheel_left);
  255.     break;

  257.                 case RIGHT:
  258.       WheelStop(&wheel_right);
  259.       WheelRun(&wheel_left, 'f');
  260.     break;

  262.                 case STOP:
  263.       WheelStop(&wheel_right);
  264.       WheelStop(&wheel_left);
  265.     break;

  267.     case U_TURN:
  268.       WheelRun(&wheel_right, 'b');
  269.       WheelRun(&wheel_left, 'f');
  270.     break;
  271.   }
  272. }
  273. // WheelControl外部采用命令方式改变车的工作状态
  274. void WheelControl(char cmd)
  275. {
  276.   switch(cmd)
  277.   {
  278.                 case 'f':
  279.       state = FORWARD;
  280.     break;

  282.                 case 'b':
  283.       state = BACKWARD;
  284.     break;

  286.                 case 'l':
  287.       state = LEFT;
  288.     break;

  290.                 case 'r':
  291.       state = RIGHT;
  292.     break;

  294.                 case 's':
  295.       state = STOP;
  296.     break;

  298.     case 'u':
  299.       state = U_TURN;
  300.     break;
  301.   }            
  302. }

  304. void SpeedChange(unsigned char mode)
  305. {
  306.   if (mode)
  307.   {
  308.     wheel_left.duty = 35;
  309.     wheel_right.duty = 35;
  310.   }
  311.   else
  312.   {
  313.     wheel_left.duty = 15;
  314.     wheel_right.duty = 15;
  315.   }
  316. }
  317. detection.c

  319. #include "stm32f10x.h"
  320. #include <stdio.h>

  322. static void UpdateDistance(void);
  323. extern void SpeedChange(unsigned char mode);
  324. extern int  SetTimer(unsigned short duration, void (*proc)(void) ,int reload);

  326. static unsigned char TIM2CaptureFlag; // 输入捕获状态
  327. unsigned int curDis = 0xffff;         // 当前距离
  328. unsigned char SYSTEM_MODE = 0;        // 模式选择 0--循迹避障，1--自由避障
  329. char InfraredState;

  331. void DetectionInit()
  332. {
  333.   GPIO_InitTypeDef        GPIO_InitStructure;
  334.   NVIC_InitTypeDef        NVIC_InitStructure;
  335.   TIM_ICInitTypeDef       TIM_ICInitStruct;
  336.   TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;

  338.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC, ENABLE);
  339.   RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);

  341.   // HC-SR04 Echo PA0 (TIM2_CH1的IC1)
  342.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
  343.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
  344.   GPIO_Init(GPIOA, &GPIO_InitStructure);
  345.   GPIO_ResetBits(GPIOA, GPIO_Pin_0);

  347.   // HC-SR04 Trig PA4
  348.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
  349.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  350.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  351.   GPIO_Init(GPIOA, &GPIO_InitStructure);
  352.   GPIO_ResetBits(GPIOA, GPIO_Pin_4);

  354.   // LED
  355.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
  356.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  357.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  358.   GPIO_Init(GPIOC, &GPIO_InitStructure);
  359.   GPIO_ResetBits(GPIOC, GPIO_Pin_13);

  361.   // 左红外 PB5，中红外 PB6，右红外 PB7
  362.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
  363.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  364.   GPIO_Init(GPIOB, &GPIO_InitStructure);

  366.   // 功能选择 PB8
  367.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
  368.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
  369.   GPIO_Init(GPIOB, &GPIO_InitStructure);
  370.   GPIO_ResetBits(GPIOB, GPIO_Pin_8);

  372.   // TIM2
  373.   TIM_TimeBaseStructure.TIM_Period = 0xffff;                  // 重载计数值最大
  374.   TIM_TimeBaseStructure.TIM_Prescaler = 72 - 1;               // 计数周期1us
  375.   TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;     // 不分频
  376.   TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; // 向上计数
  377.   TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);

  379.   //TIM2_CH1输入捕获初始化
  380.   TIM_ICInitStruct.TIM_Channel = TIM_Channel_1;               // 使用通道1
  381.   TIM_ICInitStruct.TIM_ICFilter = 0x02;                       // 不滤波
  382.   TIM_ICInitStruct.TIM_ICPrescaler = TIM_ICPSC_DIV1;          // 不分频
  383.   TIM_ICInitStruct.TIM_ICSelection = TIM_ICSelection_DirectTI;// 直接映射到IC1
  384.   TIM_ICInit(TIM2, &TIM_ICInitStruct);

  386.   // TIM2 NVIC配置
  387.   NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
  388.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  389.   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  390.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  391.   NVIC_Init(&NVIC_InitStructure);

  393.   TIM_ITConfig(TIM2, TIM_IT_CC1, ENABLE);
  394.   TIM_Cmd(TIM2, ENABLE);

  396.   // 100ms更新一次距离
  397.   SetTimer(200, UpdateDistance, 1);
  398. }

  400. char DetectionGet()
  401. {
  402.   InfraredState = (GPIOB->IDR >> 5) & 0x7; // 低三位分别为PB5、PB6、PB7的值
  403.   return InfraredState;
  404. }

  406. void TIM2_IRQHandler(void)
  407. {
  408.   if((TIM2CaptureFlag & 0x10) == 0)                       // 是否是新的一次捕获
  409.   {
  410.     TIM2CaptureFlag |= 0x10;                              // 捕获到一次上升沿
  411.     TIM_SetCounter(TIM2, 0);
  412.     TIM_OC1PolarityConfig(TIM2, TIM_ICPolarity_Falling);  // 设置为下降沿捕获
  413.   }
  414.   else
  415.     curDis = 0.017 * TIM_GetCapture1(TIM2);
  416.   TIM_ClearITPendingBit(TIM2, TIM_IT_CC1);                // 清除中断标志位
  417. }

  419. static void Delay20Us()
  420. {
  421.   int i = 0;
  422.   for (; i <= 231; i++);
  423. }

  425. static void UpdateDistance()
  426. {
  427.   TIM2CaptureFlag = 0;
  428.   TIM_OC1PolarityConfig(TIM2, TIM_ICPolarity_Rising);

  430.   // Trig
  431.   GPIO_SetBits(GPIOA, GPIO_Pin_4);
  432.   Delay20Us();
  433.   GPIO_ResetBits(GPIOA, GPIO_Pin_4);

  435.   // 系统模式选择
  436.   if (GPIOB->IDR & 0x100)
  437.     SYSTEM_MODE = 1;
  438.   else
  439.     SYSTEM_MODE = 0;
  440.   SpeedChange(SYSTEM_MODE);
  441. }
  442. track.c
  443. #include "stm32f10x.h"
  444. #include <stdio.h>

  446. extern void WheelControl(char cmd);

  448. enum {OUT, R, M, MR, L, LR, LM, LMR};
  449. extern unsigned int curDis; // 当前测距结果
  450. static char lastDetect = M; // 上一次的红外探测结果
  451. static char uTurnFLag = 0;  // 大转弯标记

  453. void TrackRun(char detection)
  454. {
  455.   if (curDis <= 15)
  456.     GPIO_SetBits(GPIOC, GPIO_Pin_13);
  457.   else
  458.     GPIO_ResetBits(GPIOC, GPIO_Pin_13);

  460.   // 当前距离小于15cm，停车
  461.   if (curDis <= 15)
  462.   {
  463.     WheelControl('s');
  464.     return;
  465.   }

  467.   if (detection != OUT)
  468.     uTurnFLag = 0;

  470.   // 直行的case
  471.   if (detection == M)
  472.     WheelControl('f');

  474.   // 右转的case
  475.   if (detection == R || detection == MR || detection == LMR)
  476.     WheelControl('r');

  478.   // 左转的case
  479.   if (detection == L)
  480.     WheelControl('l');

  482.   // 大转弯
  483.   if (uTurnFLag)
  484.     WheelControl('u');

  486.   // other cases
  487.   if (detection == OUT)
  488.     switch (lastDetect)
  489.     {
  490.       case R:
  491.         WheelControl('r');
  492.       break;

  494.       case M:
  495.         uTurnFLag = 1;
  496.       break;

  498.       case MR:
  499.         WheelControl('r');
  500.       break;

  502.       case L:
  503.         WheelControl('l');
  504.       break;

  506.       case LM:
  507.         WheelControl('l');
  508.       break;
  509.     }

  511.   if (detection != OUT)
  512.     lastDetect = detection;
  513. }
  514. avoid.c
  515. #include "stm32f10x.h"

  517. extern void WheelControl(char cmd);

  519. extern unsigned int curDis;

  521. void ObstacleAvoid()
  522. {
  523.   if (curDis <= 20)
  524.     GPIO_SetBits(GPIOC, GPIO_Pin_13);
  525.   else
  526.     GPIO_ResetBits(GPIOC, GPIO_Pin_13);

  528.   if (curDis >= 10 && curDis <= 20) // 满足 10cm <= dist <= 20cm
  529.     WheelControl('u');              // 则右转

  531.   if (curDis < 10)                  // 满足 dist < 10cm
  532.     WheelControl('b');              // 则后退

  534.   if (curDis > 20)
  535.     WheelControl('f');              // 其他case则直行
  536. }
  537. car.c
  538. #include "stm32f10x.h"
  539. #include <stdio.h>

  541. static void CarRun (void);
  542. extern void WheelInit(void);
  543. extern char DetectionGet(void);
  544. extern void DetectionInit(void);
  545. extern void ObstacleAvoid(void);
  546. extern void TrackRun(char detection);
  547. extern int  SetTimer(unsigned short duration, void (*proc)(void) , int reload);

  549. extern unsigned char SYSTEM_MODE;

  551. void CarInit()
  552. {
  553.   WheelInit();               // 车轮初始化
  554.   DetectionInit();           // 传感器初始化（红外和超声波）
  555.   SetTimer(2, CarRun, 1);    // 每1ms执行一次CarRun
  556. }

  558. static void CarRun()
  559. {
  560.   char det = DetectionGet();
  561.   if (SYSTEM_MODE)
  562.     ObstacleAvoid();
  563.   else
  564.     TrackRun(det);
  565. }
复制代码

底板网上购得，技术文档、源码在附件中
全部资料51hei下载地址：
Smart_Car_Lib_Ver.7z (191.29 KB, 下载次数: 203)
技术报告.docx (1.09 MB, 下载次数: 123)
小车连线new.pdf (855.94 KB, 下载次数: 147)



评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏8 分享淘帖 顶顶1 踩踩
回复

使用道具 举报

沙发
ID:266092 发表于 2019-3-29 10:47 | 只看该作者
程序质量很好，学习学习
回复

使用道具 举报

板凳
ID:505045 发表于 2019-5-18 18:20 | 只看该作者
楼主可以发给我邮箱吗？17382569964@163.COM
回复

使用道具 举报

地板
ID:591784 发表于 2019-7-28 22:08 | 只看该作者
RocWang 发表于 2019-5-18 18:20
楼主可以发给我邮箱吗？

你有吗？能不能也发我一份。992163846@qq.com
回复

使用道具 举报

5#
ID:588361 发表于 2019-7-29 10:21 | 只看该作者
谢谢楼主分享
回复

使用道具 举报

6#
ID:657560 发表于 2019-12-6 14:45 | 只看该作者
RocWang 发表于 2019-5-18 18:20
楼主可以发给我邮箱吗？

你有吗？能不能也发我一份。1610077438@qq.com    谢谢啦
回复

使用道具 举报

7#
ID:826937 发表于 2020-10-8 19:52 | 只看该作者
包含proteus的仿真文件么
回复

使用道具 举报

8#
ID:818895 发表于 2020-10-21 20:48 | 只看该作者
这么好的案例，要好好学习STM32.
回复

使用道具 举报

9#
ID:889199 发表于 2021-4-15 16:41 | 只看该作者
Kvn梦元儿 发表于 2020-10-8 19:52
包含proteus的仿真文件么

不包含proteus文件。——来自已经下载人的评论
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表