基于STM32F103的红外循迹超声波避障小车-Toy模板网

这篇具有很好参考价值的文章主要介绍了基于STM32F103的红外循迹超声波避障小车。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

单片机：stm32f103

传感器：普通红外（我用了4个）

超声波：HC-SR04

舵机：SG90

目标：可以循黑线（十字直行）、并避障

如果硬件配置和我一样以下代码可直接使用，用我配置的引脚即可。

亲测好用。

复制代码的同时请点个赞，多谢！

一、超声波代码

#include "Ultrasonic.h"
#include "stm32f10x.h"
#include "delay.h"
#include "usart.h"
/*记录定时器溢出次数*/
uint overcount=0;

/*设置中断优先级*/
void NVIC_Config(void)
{
    NVIC_InitTypeDef NVIC_InitStructure;//定义中断初始化结构体
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//选择中断分组
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0;//设置 抢占优先级
    NVIC_InitStructure.NVIC_IRQChannelSubPriority=0;//设置子优先级
    NVIC_InitStructure.NVIC_IRQChannel=TIM2_IRQn;//设置子优先级
    NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
    NVIC_Init(&NVIC_InitStructure);//中断初始化
}
/*初始化模块的GPIO以及初始化定时器TIM2*/
void Ultrasonic_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;//中断初始化
    TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;//定义定时器初始化结构体
    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE);//开GPIO 外设时钟 
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);//开Timer外设时钟
    /*TRIG触发信号*/
    GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;//配置输出口速率 
    GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;//配置输出模式为推挽
    GPIO_InitStructure.GPIO_Pin=GPIO_Pin_4;//设置为引脚PA.4 
    GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化PA.4

    /*ECOH回响信号*/
  GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;//配置输入模式 
    GPIO_InitStructure.GPIO_Pin=GPIO_Pin_3;//设置引脚号PA.3 
    GPIO_Init(GPIOA, & GPIO_InitStructure);//初始化PA.3

    /*定时器TIM2初始化*/
    TIM_DeInit(TIM2);
    TIM_TimeBaseInitStructure.TIM_Period=999;//定时周期为1000
    TIM_TimeBaseInitStructure.TIM_Prescaler=71; //分频系数72 
    TIM_TimeBaseInitStructure.TIM_ClockDivision=TIM_CKD_DIV1;//不分频 
    TIM_TimeBaseInitStructure.TIM_CounterMode=TIM_CounterMode_Up;//计 数器向上计数模式 
    TIM_TimeBaseInit(TIM2,&TIM_TimeBaseInitStructure);//初始化Timer2
  TIM_ITConfig(TIM2,TIM_IT_Update,ENABLE);//开启更新中断 
    
  NVIC_Config();//初始化中断分组配置 
    TIM_Cmd(TIM2,DISABLE);//关闭定时器使能

}
float Senor_Using(void)
{
    float length=0,sum=0;
    u16 tim;
    uint i=0;
    /*测5次数据计算一次平均值*/
    while(i!=3)
    {
        PAout(4)=1; //拉高信号，作为触发信号
        delay_us(20); //高电平信号超过10us
        PAout(4)=0;
        /*等待回响信号*/
        while(GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_3)==RESET);
        TIM_Cmd(TIM2,ENABLE);//回响信号到来，开启定时器计数

        i+=1; //每收到一次回响信号+1，收到5次就计算均值
        while(GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_3)==SET);//回响信号消失
        TIM_Cmd(TIM2,DISABLE);//关闭定时器

        tim=TIM_GetCounter(TIM2);//获取计TIM2数寄存器中的计数值，一边计算回响信号时间

        length=(tim+overcount*1000)/58.0;//通过回响信号计算距离

        sum=length+sum;
        TIM2->CNT=0; //将TIM2计数寄存器的计数值清零
        overcount=0; //中断溢出次数清零
        delay_ms(10);
    }
    length=sum/3;
    return length;//距离作为函数返回值
}
void TIM2_IRQHandler(void) //中断，当回响信号很长是，计数值溢出后重复计数，用中断来保存溢出次数
{
    if(TIM_GetITStatus(TIM2,TIM_IT_Update)!=RESET)
     {
    TIM_ClearITPendingBit(TIM2,TIM_IT_Update);//清除中断标志
    overcount++;

     }
}

#ifndef __Ultrasonic_H
#define    __Ultrasonic_H

#include "stm32f10x.h"
#include "delay.h"

#include "sys.h"
#define uint unsigned int
#define TRIG_Send PAout(4)//定义触发信号TRIG引脚
#define ECHO_Receive PAin(3) //定义回响信号ECHO引脚


void Ultrasonic_Init(void);  //超声波模块相关配置初始化
float Senor_Using(void);  //测距函数，返回值即为距离
void NVIC_Config(void);   //中断配置
#endif

二、舵机控制

#include "SteeringMotor.h" 
#include "delay.h"
//初始化PA2引脚
void Steer_pwm_init(void)
{ 
    GPIO_InitTypeDef GPIO_InitStructure; //声明一个结构体变量，用来初始化GPIO
    TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;//声明一个结构体变量，用来初始化定时器
    TIM_OCInitTypeDef TIM_OCInitStructure;//根据TIM_OCInitStruct中指定的参数初始化外设TIMx
    /* 开启时钟 */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);
    /* 配置GPIO的模式和IO口 */
    GPIO_InitStructure.GPIO_Pin=GPIO_Pin_0;// PB0
    GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP;//复用推挽输出
    GPIO_Init(GPIOB,&GPIO_InitStructure);
    /*TIM2定时器初始化*/
    TIM_TimeBaseInitStructure.TIM_Period = 199; //PWM 频率=72000/(199+1)=36Khz//设置自动重装载寄存器周期的值
    TIM_TimeBaseInitStructure.TIM_Prescaler = 7199;//设置用来作为TIMx时钟频率预分频值
    TIM_TimeBaseInitStructure.TIM_ClockDivision = 0;//设置时钟分割:TDTS= Tck_tim
    TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
    //TIM向上计数模式
    TIM_TimeBaseInit(TIM3, & TIM_TimeBaseInitStructure);
    /*PWM初始化*/ //根据TIM_OCInitStruct中指定的参数初始化外设TIMx
    TIM_OCInitStructure.TIM_OCMode=TIM_OCMode_PWM1;
    TIM_OCInitStructure.TIM_OutputState=TIM_OutputState_Enable;//PWM输出使能
    TIM_OCInitStructure.TIM_OCPolarity=TIM_OCPolarity_High;
    TIM_OC3Init(TIM3,&TIM_OCInitStructure);//Timer2 CH3
    //注意此处初始化时TIM_OC1Init而不是TIM_OCInit，否则会出错。因为固件库的版本不一样。
    TIM_OC3PreloadConfig(TIM3, TIM_OCPreload_Enable);//使能或者失能TIMx在CCR3上的预装载寄存器
    TIM_Cmd(TIM3,ENABLE);//使能或者失能TIMx外设
}
int steeringmotor(void)
{
    delay_init();
//    TIM2_PWM_Init(199,7199);//初始化PWM的周期
//    while(1)
//    {
//        delay_ms(10);
//        TIM_SetCompare3(TIM3,5);//设定占空比，舵机角度为0°中
//        delay_ms(1000);
//        TIM_SetCompare3(TIM3,15);//设定占空比，舵机角度为90°右
//        delay_ms(1000);
//        TIM_SetCompare3(TIM3,25); //设定占空比，舵机角度为180°左
//  }
}

#ifndef __SteeringMotor_H
#define __SteeringMotor_H
#include "sys.h"
#include "stm32f10x.h"
void Steer_pwm_init(void); //舵机pwm初始化
#define   Steer_Right_90    TIM_SetCompare3(TIM3, 9)        //右转90度
#define   Steer_Right_45        TIM_SetCompare3(TIM3, 7)        //右转45度
#define   Steer_Front            TIM_SetCompare3(TIM3, 17)        //舵机摆正
#define   Steer_Left_45          TIM_SetCompare3(TIM3, 23)        //左转45度
#define   Steer_Left_90          TIM_SetCompare3(TIM3, 26 )  //左转90度
#endif

三、红外循迹代码

#include "sensor.h"
void xunji_config(void)    
{
  GPIO_InitTypeDef GPIO_InitStructure;    
  RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE); // 使能PC端口时钟
  RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOC, ENABLE); // 使能PC端口时钟
  GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_12 | GPIO_Pin_13  | GPIO_Pin_14 | GPIO_Pin_15;    //选择对应的引脚
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;//配置GPIO模式,输入上拉       
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOB, &GPIO_InitStructure);  //初始化PB端口

   GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_3;
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;//配置GPIO模式,输入上拉       
   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   GPIO_Init(GPIOC, &GPIO_InitStructure);  //初始化PC端口
}
void Read_xunji_Date(void)
{
 xunji_1;
 xunji_2;
 xunji_3;
 xunji_4;
 xunji_5;
}

#ifndef __sensor_H
#define    __sensor_H
#include "stm32f10x.h"
#define xunji_1 GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_12)
#define xunji_2 GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_13)
#define xunji_3 GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_14)
#define xunji_4 GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_15)
#define xunji_5 GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_3)
void xunji_config(void);
void Read_xunji_Date(void);  //读循迹模块返回的值
#endif

四、PWM控制小黄电机

#include "motor.h"//1右前 2右后  3左前 4左后
#include "delay.h"
void CarGo(void)
{
  TIM_SetCompare1(TIM4 , 975);  //数值越大速度越慢
  TIM_SetCompare2(TIM4 , 1199);//后
  TIM_SetCompare3(TIM4 , 975);  
  TIM_SetCompare4(TIM4 , 1199);    //后
}
void CarGo2(void)
{
  TIM_SetCompare1(TIM4 , 920);  //数值越大速度越慢
  TIM_SetCompare2(TIM4 , 1199);//后
  TIM_SetCompare3(TIM4 , 920);  
  TIM_SetCompare4(TIM4 , 1199);    //后
}

void CarStop(void)
{
  TIM_SetCompare1(TIM4 , 1199);
  TIM_SetCompare2(TIM4 , 1199);
  TIM_SetCompare3(TIM4 , 1199);    
  TIM_SetCompare4(TIM4 , 1199);
}

void CarBack(void)
{
  TIM_SetCompare1(TIM4 , 1199);
  TIM_SetCompare2(TIM4 , 900);
  TIM_SetCompare3(TIM4 , 1199);    
  TIM_SetCompare4(TIM4 , 900);
}

void CarRight(void)
{
  TIM_SetCompare1(TIM4 , 900);
  TIM_SetCompare2(TIM4 , 1199);//右后
  TIM_SetCompare3(TIM4 , 790);//前左
  TIM_SetCompare4(TIM4 , 1199);//后
}

void CarBigRight(void)
{
  TIM_SetCompare1(TIM4 , 1199);
  TIM_SetCompare2(TIM4 , 975);//450
  TIM_SetCompare3(TIM4 , 740);
  TIM_SetCompare4(TIM4 , 1199);
}
void CarBigRight2(void)
{
  TIM_SetCompare1(TIM4 , 1199);
  TIM_SetCompare2(TIM4 , 850);//450
  TIM_SetCompare3(TIM4 , 740);
  TIM_SetCompare4(TIM4 , 1199);
}
void CaryuandiRight(void)
{
  TIM_SetCompare1(TIM4 , 1199);
  TIM_SetCompare2(TIM4 , 1199);
  TIM_SetCompare3(TIM4 , 450);
  TIM_SetCompare4(TIM4 , 1199);
}

void CarLeft(void)
{
  TIM_SetCompare1(TIM4 , 790);//右前
  TIM_SetCompare2(TIM4 , 1199);
  TIM_SetCompare3(TIM4 , 900);
  TIM_SetCompare4(TIM4 , 1199);//左  后
}

void CarBigLeft(void)
{
  TIM_SetCompare1(TIM4 , 715);
  TIM_SetCompare2(TIM4 , 1199);
  TIM_SetCompare3(TIM4 , 1199);
  TIM_SetCompare4(TIM4 , 890);
}
void CarBigLeft2(void)
{
  TIM_SetCompare1(TIM4 , 590);
  TIM_SetCompare2(TIM4 , 1199);
  TIM_SetCompare3(TIM4 , 1199);
  TIM_SetCompare4(TIM4 , 620);
}
void CarSpecialGo(void)
{
    TIM_SetCompare1(TIM4 , 900);  //数值越大速度越慢
  TIM_SetCompare2(TIM4 , 1199);//后
  TIM_SetCompare3(TIM4 , 1000);  
  TIM_SetCompare4(TIM4 , 1199);    //后
}
void CarSpecialPlusGo(void)
{
    TIM_SetCompare1(TIM4 , 880);  //数值越大速度越慢
  TIM_SetCompare2(TIM4 , 1199);//后
  TIM_SetCompare3(TIM4 , 1000);  
  TIM_SetCompare4(TIM4 , 1199);    //后
}
void CarSpecialLeft(void)
{
  TIM_SetCompare1(TIM4 , 700);//右前
  TIM_SetCompare2(TIM4 , 1199);//右后
  TIM_SetCompare3(TIM4 , 1199);//左前
  TIM_SetCompare4(TIM4 , 900);//左后
}
void CarSpecialRight(void)
{
  TIM_SetCompare1(TIM4 , 1199);//右前
  TIM_SetCompare2(TIM4 , 900);//右后
  TIM_SetCompare3(TIM4 , 750);//左前
  TIM_SetCompare4(TIM4 , 1199);//左后
}

void TIM4_PWM_Init(void)  //TIM4的pwm设置和相应的引脚设置
{
  GPIO_InitTypeDef GPIO_InitStructure;

  TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
  TIM_OCInitTypeDef TIM_OCInitStructure; 
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4 , ENABLE);
  RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB | RCC_APB2Periph_AFIO, ENABLE);
  
  
  TIM_TimeBaseStructure.TIM_Period = 1199;
  TIM_TimeBaseStructure.TIM_Prescaler = 1999;
  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseStructure.TIM_ClockDivision = 0;
  TIM_TimeBaseInit(TIM4 , &TIM_TimeBaseStructure);
  
  //端口复用
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;   //初始化要用的B6/B7口
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;     
  GPIO_Init(GPIOB, &GPIO_InitStructure);   
  
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9;   //初始化要用的口
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;     
  GPIO_Init(GPIOB, &GPIO_InitStructure);   
    
    
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 ;          //PB.10端口配置
    GPIO_Init(GPIOB, &GPIO_InitStructure);          //根据设定参数初始化GPIOB.10 
    GPIO_ResetBits(GPIOB,GPIO_Pin_10);                         
    
    
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;           //PB.11端口配置
    GPIO_Init(GPIOB, &GPIO_InitStructure);          //根据设定参数初始化GPIOB.11 
    GPIO_ResetBits(GPIOB,GPIO_Pin_11);        
        
  
  //PWM通道1
  TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2;
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
  TIM_OCInitStructure.TIM_Pulse = 0;
  TIM_OC1Init(TIM4 , &TIM_OCInitStructure);
  TIM_OC1PreloadConfig(TIM4 , TIM_OCPreload_Enable);
  
  //PWM通道2
  TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2;
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
  TIM_OCInitStructure.TIM_Pulse =0;
  TIM_OC2Init(TIM4 , &TIM_OCInitStructure);
  TIM_OC2PreloadConfig(TIM4 , TIM_OCPreload_Enable);
  
  //PWM通道3
  TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2;
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
  TIM_OCInitStructure.TIM_Pulse = 0;
  TIM_OC3Init(TIM4 , &TIM_OCInitStructure);
  TIM_OC3PreloadConfig(TIM4 , TIM_OCPreload_Enable);
  
  //PWM通道4
  TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM2;
  TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
  TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
  TIM_OCInitStructure.TIM_Pulse = 0;
  TIM_OC4Init(TIM4 , &TIM_OCInitStructure);
  TIM_OC4PreloadConfig(TIM4 , TIM_OCPreload_Enable);
  TIM_Cmd(TIM4 , ENABLE);
}

#ifndef __MOTER_H
#define    __MOTER_H


#include "stm32f10x.h"
#define ENA PBout(11)  
#define ENB PBout(10)

void TIM4_PWM_Init(void);
void CarGo(void);
void CarGo2(void);
void CarStop(void);
void CarBack(void);
void CarLeft(void);
void CaryuandiRight(void);
void CarBigLeft(void);  //大左转
void CarBigLeft2(void); 
void CarRight(void);
void CarBigRight(void);   //大右转
void CarBigRight2(void);
void CarSpecialLeft(void);
void CarSpecialGo(void);
void CarSpecialPlusGo(void);
void CarSpecialRight(void);
    #endif

五、main函数

1、解释

我的主函数有些啰嗦，以前写的，懒得改了。

大意就是：

分为两部分

第一部分代码表示循迹的时候可以避障

第一部分代码表示仅仅循迹

逻辑部分仅供参考！建议按自己的逻辑改改！！

已知：仅仅在直行的时候遇到一次障碍物

所以：我的避障在直行判断里面

if（b==0）（此为第一部分代码。b是标志位，目的是只执行一次避障）

{

if（直行判断）

{

直行

if（距离<30）（请按照实际情况修改参数）

{

避障逻辑（请按照实际情况修改逻辑）

b++；

}

if（其他判断）

{左、右转弯等等

}

if（b==1）（此为第二部分代码。b是标志位，目的是只执行一次避障）

{

正常循迹判断

}

2、代码

#include "led.h"
#include "delay.h"
#include "sys.h"
#include "Ultrasonic.h"
#include "motor.h"
#include "sensor.h"
#include "SteeringMotor.h" 


 int main(void)
{
//    float  length_res[5]={0};  //用来存放测距结果
    int a=0,b=0,c=0,d=0;
    char str[20];//用来存放浮点数字符
    SystemInit();    // 配置系统时钟为72M 
  delay_init();    //延时初始化        
    xunji_config();   //循迹初始化
  Ultrasonic_Init();
    TIM4_PWM_Init();
  Steer_pwm_init();
    while(1)
    {
         Read_xunji_Date(); //读循迹线值
                 //车前4个循迹模块从右到左分别是xunji_4，xunji_3，xunji_2，xunji_1
                //xunji_x=1白亮      x 2 3 x
if(b==0)
        {
            if(xunji_1==1&&xunji_2==0&&xunji_3==1&&xunji_4==1)//0100
                {
                CarRight(); //如果第二个读取到黑线，右转
                continue;
                }
                if(xunji_1==0&&xunji_2==1&&xunji_3==1&&xunji_4==1)//1000
                {
                CarBigRight();  //如果第一个读取到黑线，大右转
                continue;
                }
             if(xunji_1==1&&xunji_2==1&&xunji_3==0&&xunji_4==1)//0010
                {                  
                 CarLeft();//如果第三个读取到黑线，左转
                 continue; 
                }
                
                if(xunji_1==1&&xunji_2==1&&xunji_3==1&&xunji_4==0)//0001
                {
                CarBigLeft();   //如果第四个读取到黑线，大左转
                continue;                
                }
                
             if(xunji_1==1&&xunji_2==1&&xunji_3==1&&xunji_4==1)//0001
                {
                CarGo();    //如果都读取到白线，直走
                 if(Senor_Using()<30.00)//大 不撞
                    {
                        a++;
                        if(a==1)
                        {
                                        Steer_Front;
                                        delay_ms(700);    
                                        CarStop();
                                        delay_ms(700);        
                                        Steer_Right_90 ;
                                        delay_ms(700);
                                        CarSpecialLeft();
                                        delay_ms(530);                
                                        do
                                    {
                                        CarSpecialPlusGo();
                                        delay_ms(700);
                                    }while(Senor_Using()<50.00);
                                     CarStop();
                                     delay_ms(700);
                                     CarSpecialRight();
                                     delay_ms(670);
                                        do
                                    {
                                        CarSpecialPlusGo();
                                        delay_ms(1000);
                                    }while(Senor_Using()<50.00);
                                     CarStop();
                                     delay_ms(700);
                                     CarSpecialRight();   
                                     delay_ms(650);
                                    do
                                    {
                                        CarSpecialGo();
                                        delay_ms(100);
                                    }while(xunji_1== 1&&xunji_2==1&&xunji_3==1&&xunji_4==1&&xunji_5==0);
                                     CarStop();
                                    delay_ms(1000);
                                    Steer_Front;    
                                    delay_ms(700);         
                                     CarSpecialLeft();
                                     delay_ms(500);
                                    b++;
                        }
                    }
                }
                if(xunji_1==0&&xunji_2==0&&xunji_3==1&&xunji_4==1)
                {
                    CarBigRight();    //如果右侧都黑且左侧都白，大右
                    continue;
                }    
                    if(xunji_3==0&&xunji_4==0&&xunji_1==1&&xunji_2==1)
                    {
                            CarBigLeft();//如果左侧都黑且右侧都白，大左
                        continue;
                    }
                    if(xunji_3==0&&xunji_4==0&&xunji_1==1&&xunji_2==0)
                    {
                            CarBigLeft();//如果左侧都黑且右侧都白，大左
                        continue;
                    }
                    if(xunji_1==0&&xunji_2==0&&xunji_3==0&&xunji_4==1)
                {
                    CarBigRight();    //如果右侧都黑且左侧都白，大右
                    continue;
                }    

             if(xunji_1==0&&xunji_4==0&&xunji_3==1&&xunji_2==1)
             {
                        CarGo();
                }
              if(xunji_1==1&&xunji_4==1&&xunji_3==0&&xunji_2==0)
             {
                        CarGo();
                }
         }
if(b==1)
            {
                if(xunji_1==1&&xunji_2==0&&xunji_3==1&&xunji_4==1)//0100
                {
                CarRight(); //如果第二个读取到黑线，右转
                continue;
                }
                if(xunji_1==0&&xunji_2==1&&xunji_3==1&&xunji_4==1)//1000
                {
              CarBigRight2(); //如果第一个读取到黑线，大右转
                delay_ms(10);
                }
             if(xunji_1==1&&xunji_2==1&&xunji_3==0&&xunji_4==1)//0010
                {                  
                 CarLeft();//如果第三个读取到黑线，左转
                 continue; 
                }
                
                if(xunji_1==1&&xunji_2==1&&xunji_3==1&&xunji_4==0)//0001
                {
               CarBigLeft2();   //如果第四个读取到黑线，大左转
                    delay_ms(10);                
                }
                
             if(xunji_1==1&&xunji_2==1&&xunji_3==1&&xunji_4==1)//0001
                {
                CarGo2();    //如果都读取到白线，直走
                }
                if(xunji_1==0&&xunji_2==0&&xunji_3==1&&xunji_4==1)
                {
                    CarBigRight2();    //如果右侧都黑且左侧都白，大右
                        delay_ms(10);
                }    
                    if(xunji_3==0&&xunji_4==0&&xunji_1==1&&xunji_2==1)
                    {
                            CarBigLeft2();//如果左侧都黑且右侧都白，大左
                            delay_ms(10);
                    }
                    if(xunji_3==0&&xunji_4==0&&xunji_1==1&&xunji_2==0)
                    {
                            CarBigLeft2();//如果左侧都黑且右侧都白，大左
                            delay_ms(10);
                    }
                    if(xunji_1==0&&xunji_2==0&&xunji_3==0&&xunji_4==1)
                {
                    CarBigRight2();    //如果右侧都黑且左侧都白，大右
                        delay_ms(10);
                }    

             if(xunji_1==0&&xunji_4==0&&xunji_3==1&&xunji_2==1)
             {
                        CarGo2();
                }
              if(xunji_1==1&&xunji_4==1&&xunji_3==0&&xunji_2==0)
             {
                        CarGo2();
                }
        }
  }

}

.文章来源地址https://www.toymoban.com/news/detail-454164.html

到了这里，关于基于STM32F103的红外循迹超声波避障小车的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！