第四章 小车寻路的那些骚操作

最新推荐文章于 2023-05-15 23:10:42 发布
最新推荐文章于 2023-05-15 23:10:42 发布
阅读量759 收藏 13
点赞数 2
原文链接：http://www.cnblogs.com/StringSir/p/8443340.html
版权

 

在这一章，我来带领大家学习机器人巡线。首先请大家按照要求拼装好小车。我们巡线采用的是安装7个探头来精准巡线。

测量光度值

在学习小车寻路之前，我们必须要学习一下模拟探头。什么是模拟探头？模拟探头的原理是：根据探测地面光的大小转换成不同的值给小车。大家都知道黑色吸光，白色反光，这样模拟探头探测到黑色区域或白色区域所转换的值就不一样了，我们探头可以通过不停的检测前方的光度值，来判断小车目前所在黑线的位置，进而使用程序智能地调整小车的位置。我们可以在小车巡线之前，先要多次测量黑线的值和白线的值，以两者的均值作为中间值，当超过中间值我们就认为是黑线，小于中间值我们就认为是白线。

因为天气和环境的变化原因，我们每天实验都需要测量光值，下面是我写的一套智能测量灰度值的程序：

#include <LNDZ.h>
int ll, l, m, r, rr, hr, hl;
int ll2, l2, m2, r2, rr2, hr2, hl2;
lc lcd;
ir ykq;
der jst;
void init()
{
  //B_start();
  ykq.start();
  lcd.begin(16, 2);
  lcd.bg(1);
  ll2 = l2 = m2 = r2 = rr2 = hr2 = hl2 = 0;
}
void repeat()
{
  ll = AR(4); //请注意这里传感器与模拟输入口编号的对应
  l = AR(2);
  m = AR(1);
  r = AR(3);
  rr = AR(5);
  hr = AR(6);//中间左边探头接6号模拟端口
  hl = AR(7); //中间右边探头接7号模拟端口

  lcd.setCursor(0, 1);
  lcd.print(hl);
  lcd.setCursor(4, 1);
  lcd.print(ll);
  lcd.setCursor(3, 0);
  lcd.print(l);
  lcd.setCursor(7, 0);
  lcd.print(m);
  lcd.setCursor(11, 0);
  lcd.print(r);
  lcd.setCursor(9, 1);
  lcd.print(rr);
  lcd.setCursor(13, 1);
  lcd.print(hr);
  delay(200);
  lcd.clear();

  if (ykq.decode(&jst)) {
    switch (jst.value)
    {
      case one: {
          ll2 += ll;
          l2 += l;
          m2 += m;
          r2 += r;
          rr2 += rr;
          beep(500);
        } break;
      case two: {
          hr2 += hr;
          hl2 += hl;
          beep(500);
        } break;
      case three: {
          lcd.setCursor(0, 1);
          lcd.print(hl2/2);
          lcd.setCursor(4, 1);
          lcd.print(ll2/2);
          lcd.setCursor(3, 0);
          lcd.print(l2/2);
          lcd.setCursor(7, 0);
          lcd.print(m2/2);
          lcd.setCursor(11, 0);
          lcd.print(r2/2);
          lcd.setCursor(9, 1);
          lcd.print(rr2/2);
          lcd.setCursor(13, 1);
          lcd.print(hr2/2);
          beep(500);
          while (1);
        } break;
      default:  break;
    }
    ykq.next();
  }
}

 

聪明的同学查看了代码就会明白这个意思：遥控按下1机器人会记录前方5个探头的光值，按下2机器人会记录中间2个探头的光值。我们需要按两下1和2分别测量前5个探头的黑色值白色值和后2个探头的黑色值白色值。(小车鸣叫了500ms证明成功取到值)然后按下3按钮小车会自动计算出中间值打印到屏幕上。

顺序如下：

42135分别是前5个探头光值从左向右排，左下和右下分别是后面两个探头。

 

自动寻轨

在学习了寻路的原理，我们就来实现一次圆形轨道寻路吧！

在实验之前我们先学习motor(40,40);这个函数，这个函数第一个参数代表左轮速度，第二个则代表的是右轮速度。（范围-100~100）下面正式列出代码：

 

#include <LNDZ.h>
bool dx = true;
bool l, m, r, ll, rr;
int data[5] = {210 , 245 , 220 , 256 , 259};//这个值每次实验都要测量的

void init()
{
  B_start();
}
void repeat()
{
  lookUpLine();//基本寻线
}

void lookUpLine()
{
  readFrontData();//反复地读数据
  if (m) motor(35, 35);//如果中间探头碰到黑线前进
  if (l) motor(0, 30);//如果中间左边探头碰到黑线小幅度左转
  if (r) motor(30, 0);
  if (ll)motor(-30, 30); //如果最左边探头碰到黑线大幅度左转
  if (rr)motor(30, -30);
}

void readFrontData()
{
  //从每个端口读数据,并判断是否大于中间值，大于则是黑线存为1，小于则是白线存为0
  ll = AR(4) > data[0];
  l = AR(2) > data[1];
  m = AR(1) > data[2];
  r = AR(3) > data[3];
  rr = AR(5) > data[4];
}

 

复杂路口处理

硬件上

     首先，为了提高在复杂路口转弯的精确性，我们放弃了传统的五探头寻线，我们自己研制出了一套“七眼”寻线的方法，并对前五个探头的位置进行了适当调整，而且在小车底部的中间增加了两个探头。我的探头布置如下：（如图用字母表示探头）

 

用前五个探头中间的R、M、L探头进行基本寻轨，前面的RR、LL个探头和底部中间的HR、HL探头进行复杂路口细节处理。考虑到和传统的五探头寻线相比机器效率会有所降低，开销上会有些上升。所以我们设计了相应的程序算法来提高效率，减少开销。

程序上

   我们在程序上做了大量改进和优化。研制了一套适用于这种小车寻轨的智能算法。

在对“七眼”寻轨提升效率和减小开销上，在基本寻轨时用R、M、L三个探头判断，旁边的RR和LL用于对路口的判断。在处理复杂或特殊路口时，我们才会用到HR、HL探头。

整体我们采用分治的思想，将每一个复杂的路口拆分成若干个相对简单小步骤来处理。我通过大量的实验和思考，设计出了能处理绝大部分复杂路口的小步骤的代码和使用框架，并用宏定义了这些小步骤，采用这些用宏定义的小步骤，进行创造性的组合能够精准的通过复杂路口。

我们在处理这些小步骤的，我们利用RR、LL、M、HR、HL探头进行“卡位”。下面给出一个复杂路口的示例：

 

路口示例图

#include <LNDZ.h>

/*黑白线转换的变量（黑线寻轨true,白线寻轨false）*/
bool b_w = true;
bool l, m, r, ll, rr, hl, hr;
/*4,2,1,3,5,7,6探头（LL,L,M,R,RR,HL,HR）的光值*/
int data[7] = {338 , 328 , 268 , 289 , 245, 400 , 350};

/*宏命名规则
LEFT和RINGHT是转弯的方向，LINGHT_L、LEFT_LINGHT_M和LINGHT_R是用哪个哪个灯进行判断分别对应（ll,m,rr）；
LEFT_TURN和RINGHT_TURN是分别靠ll和rr探头进行判断和转弯；
FORWARD_L、FORWARD_R和FORWARD_M前进直到（hl,hr,hl || hr)到达过了黑线才结束（用hl,hr去做判断），通常用于小车精确探出半个车身，利于转弯；
_WHILE_START_(x)和_WEND_; 每新的路口进入新的循环(每个循环对不同的路口进行处理）
STOP_LOOK；小车停留一段时间，通常用于多个动作组合中防止小车打滑；
*/
#define LEFT_LINGHT_L;   readFrontData(); while(ll == 0){readFrontData();motor(-40, 40);}
#define LEFT_LINGHT_M;   readFrontData(); while(m  == 0){readFrontData();motor(-40, 40);}
#define RINGHT_LINGHT_R; readFrontData(); while(rr == 0){readFrontData();motor(40, -40);}
#define RINGHT_LINGHT_M; readFrontData(); while(m == 0) {readFrontData();motor(40, -40);}
#define LEFT_TURN;       readFrontData(); while(ll == 0){readFrontData();motor(-40, 40);} while (m  == 0){readFrontData();motor(-40, 40);}
#define RINGHT_TURN;     readFrontData(); while(rr == 0){readFrontData();motor(40, -40);} while (m  == 0){readFrontData();motor(40, -40);}
#define FORWARD_L;       readBackData();  while(hl == 0){readBackData();motor(40, 40);}   while(hl == 1){readBackData();motor(40, 40);}
#define FORWARD_R;       readBackData();  while(hr == 0){readBackData();motor(40, 40);}   while(hr == 1){readBackData();motor(40, 40);}
#define FORWARD_M;       readBackData();  while(hr == 0 || hl == 0){readBackData();motor(40, 40);}   while(hr == 1 || hl == 1){readBackData();motor(40, 40);}
#define _WHILE_START_(x)   while (true) { lookUpLine();
#define _WEND_;            }
#define FORWARD_DELAY(x);    motor(40,40);delay(x);
#define STOP_LOOK;           motor(0,0);beep(300);motor(20,20);
#define STOP;                motor(0, 0);while (1);


void init()
{
  B_start();
}

void repeat()
{
 _WHILE_START_(1)//路口循环，里面宏定义了基本寻轨

/*(ll，m)或(ll,l)都判断到了说明抵达了路口B，下面写对路口的处理*/
  if ((ll + m) == 2 || (rr + ll) == 2) {   
    FORWARD_L;                                             /*小车探出半身，用hl去判断*/
    STOP_LOOK;                                             /*停止200ms，防止打滑*/
    RINGHT_TURN;                                         /*用右边和中间探头右转，让小车正向朝D*/
    FORWARD_DELAY(100);                            /*延时向前一小段*/
    STOP_LOOK;                                          /*停止200ms，防止打滑*/
    RINGHT_TURN;                                        /*用右边和中间探头右转，让小车正向朝C*/
    break;                                                       /*跳出循环，进入下一个路口的循环*/
  }
  _WEND_;

    _WHILE_START_(1)
   /*(ll，m)或(rr,ll)都判断到了说明抵达了路口C，下面写对路口的处理*/
  if ((ll + m) == 2 || (ll + l) == 2) {
    FORWARD_L;                                           /*小车探出半身，用hl去判断*/
    STOP_LOOK;                                           /*停止200ms，防止打滑*/
    LEFT_TURN;                                           /*用左边和中间探头右转，让小车正向朝D*/
    break;
  }
  _WEND_;

  STOP;                                                        /*小车停止*/
}
/*基本寻轨*/
void lookUpLine()
{
  readFrontData();
  if (m) motor(35, 35);
  if (l) motor(0, 30);
  if (r) motor(30, 0);
}


void readBackData()
{
  hr = b_w?(AR(6)>data[6]):!(AR(6)>data[6]);
  hl = b_w?(AR(7)>data[5]):!(AR(7)>data[5]);
}

void readFrontData()
{
  ll = b_w?(AR(4)>data[0]):!(AR(4) > data[0]);
  l  = b_w?(AR(2)>data[1]):!(AR(2)>data[1]);
  m  = b_w?(AR(1)>data[2]):!(AR(1)>data[2]);
  r  = b_w?(AR(3)>data[3]):!(AR(3)>data[3]);
  rr = b_w?(AR(5)>data[4]):!(AR(5)>data[4]);
}

 

 

查看程序我们对每个路口都进行了处理，保证了小车的出错率能够降到最低，上面是我演示的直角左转和右转，在遇到了如菱角、米字、不规则路口我们要根据实践情况进行转，思考怎么才能使出错率降到最低。

下面是一段循规实例：

 代码：

#include <LNDZ.h>

/*黑白线转换的变量（黑线寻轨true,白线寻轨false）*/
bool b_w = true;
bool l, m, r, ll, rr, hl, hr;
/*4,2,1,3,5,7,6探头（LL,L,M,R,RR,HL,HR）的光值*/
int data[7] = {338 , 328 , 268 , 289 , 245, 400 , 350};

/*宏命名规则
LEFT和RINGHT是转弯的方向，LINGHT_L、LEFT_LINGHT_M和LINGHT_R是用哪个哪个灯进行判断分别对应（ll,m,rr）；
LEFT_TURN和RINGHT_TURN是分别靠ll和rr探头进行判断和转弯；
FORWARD_L、FORWARD_R和FORWARD_M前进直到（hl,hr,hl || hr)到达过了黑线才结束（用hl,hr去做判断），通常用于小车精确探出半个车身，利于转弯；
_WHILE_START_(x)和_WEND_; 每新的路口进入新的循环(每个循环对不同的路口进行处理）
STOP_LOOK；小车停留一段时间，通常用于多个动作组合中防止小车打滑；
*/
#define LEFT_LINGHT_L;   readFrontData(); while(ll == 0){readFrontData();motor(-40, 40);}
#define LEFT_LINGHT_M;   readFrontData(); while(m  == 0){readFrontData();motor(-40, 40);}
#define RINGHT_LINGHT_R; readFrontData(); while(rr == 0){readFrontData();motor(40, -40);}
#define RINGHT_LINGHT_M; readFrontData(); while(m == 0) {readFrontData();motor(40, -40);}
#define LEFT_TURN;       readFrontData(); while(ll == 0){readFrontData();motor(-40, 40);} while (m  == 0){readFrontData();motor(-40, 40);}
#define RINGHT_TURN;     readFrontData(); while(rr == 0){readFrontData();motor(40, -40);} while (m  == 0){readFrontData();motor(40, -40);}
#define FORWARD_L;       readBackData();  while(hl == 0){readBackData();motor(40, 40);}   while(hl == 1){readBackData();motor(40, 40);}
#define FORWARD_R;       readBackData();  while(hr == 0){readBackData();motor(40, 40);}   while(hr == 1){readBackData();motor(40, 40);}
#define FORWARD_M;       readBackData();  while(hr == 0 || hl == 0){readBackData();motor(40, 40);}   while(hr == 1 || hl == 1){readBackData();motor(40, 40);}
#define _WHILE_START_(x)   while (true) { lookUpLine();
#define _WEND_;            }
#define FORWARD_DELAY(x);    motor(40,40);delay(x);
#define STOP_LOOK;           motor(0,0);beep(300);motor(20,20);
#define STOP;                motor(0, 0);while (1);


void init()
{
  B_start();
}

void repeat()
{
  
  while (true) {
    readFrontData();
    if (l || r || m || ll || rr) {
       FORWARD_M;
      break;
    }
    motor(5, 5);
  }


  _WHILE_START_(1)
  if ((ll + rr) == 2 || (ll + m) == 2) {
    FORWARD_R;
    STOP_LOOK;
    break;
  }
  _WEND_;

  _WHILE_START_(1)
  if ((rr + r) ==2 || (rr + m) == 2) {
    FORWARD_R;
    STOP_LOOK;
    RINGHT_TURN;
    break;
  }
  _WEND_;

  
  _WHILE_START_(1)
  if ((ll + rr) == 2 || (rr + r) == 2) {
    FORWARD_R;
    STOP_LOOK;
    LEFT_TURN;
    STOP_LOOK;
    LEFT_TURN;
    break;
  }
  _WEND_;

  _WHILE_START_('A')
  if ((ll + rr) == 2 || (rr + r) == 2) {
    FORWARD_R;
    STOP_LOOK;
    RINGHT_TURN;
    break;
  }
  _WEND_;

  _WHILE_START_(1)
  if ((ll + m) == 2 || (ll + l) == 2 || (rr + ll) == 2) {
    FORWARD_L;
    STOP_LOOK;
    RINGHT_TURN;
    FORWARD_DELAY(100);
    STOP_LOOK;
    RINGHT_TURN;
    break;
  }
  _WEND_;

  _WHILE_START_(1)
  if ((ll + m) == 2 || (ll + l) == 2) {
    FORWARD_L;
    STOP_LOOK;
    LEFT_TURN;
    break;
  }
  _WEND_;

  _WHILE_START_(1)
  if ((ll + m) == 2 || (ll + l) == 2) {
    FORWARD_L;
    STOP_LOOK;
    RINGHT_TURN;
    STOP_LOOK;
    readBackData();  while (hr == 0) {
      readBackData();
      motor(-40, -40);
    }
    STOP_LOOK;
    RINGHT_TURN;
    break;
  }
  _WEND_;

  _WHILE_START_("十字路口")
  if ((ll + rr) == 2 || (l + r) == 2) {
    FORWARD_L;
    STOP_LOOK;
    motor(-30, 0);
    break;
  }
  _WEND_;

  _WHILE_START_(1)
  if ((ll + l) == 2 || (ll + m) == 2) {
    FORWARD_M;
    STOP_LOOK;
    break;
  }
  _WEND_;

  _WHILE_START_(1)
    motor(15, 40);
    if ((ll + l) == 2 || (ll + m) == 2) {
      FORWARD_L;
      STOP_LOOK;
      LEFT_TURN;
      break;
    }
   _WEND_;

  STOP;
}

void lookUpLine()
{
  readFrontData();
  if (m) motor(35, 35);
  if (l) motor(0, 30);
  if (r) motor(30, 0);
}


void readBackData()
{
  hr = AR(6) > data[6];
  hl = AR(7) > data[5];
}

void readFrontData()
{
  ll = AR(4) > data[0];
  l  = AR(2) > data[1];
  m  = AR(1) > data[2];
  r  = AR(3) > data[3];
  rr = AR(5) > data[4];
}

 

超声波

想必大家在初中的时候就对超声波有所了解，下面我来通过一段代码告诉大家超声波是如何实现的。

#include <LNDZ.h>
ult csb;//定义一个超声波设备
int d;
void init()
{
    B_star();
}

void repeat()
{
    d=csb.dis();//得到前方物体的距离
    if (d>0 && d<8)//判断距离是否在0~8之间，如果在则绕过物体
{
  motor(10,60);//圆周运动
    }
    else
    {
        motor(40,40);
    }
}

在需要实现蔽障的实验中就要运用超声波。

转载于:https://www.cnblogs.com/StringSir/p/8443340.html

weixin_30710457
关注
  • 2
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
项目实训（七）——车辆寻路算法的实现
Fancy145的博客
04-30 477
车辆寻路
c语言小车路径规划算法,自动驾驶汽车四种常用的路径规划算法解析
weixin_29662775的博客
05-23 3939
描述自动驾驶汽车的路径规划算法最早源于机器人的路径规划研究，但是就工况而言却比机器人的路径规划复杂得多，自动驾驶车辆需要考虑车速、道路的附着情况、车辆最小转弯半径、外界天气环境等因素。本文将为大家介绍四种常用的路径规划算法，分别是搜索算法、随机采样、曲线插值和人工势场法。1．搜索算法搜索算法主要包括遍历式和启发式两种，其中Dijkstra算法属于传统的遍历式，A＊算法属于启发式，在A＊算法的基础上...
循迹车辆的一些应用方式
weixin_74155302的博客
05-15 686
行进方向的两个传感器都检测到黑线时到达路口，越过黑线并到达下一条黑线时小车位于路口中央，可根据需要进行转向或直行。转向直至每个传感器都两次越过黑线表示转过90°，直行越过黑线离开路口。需要转向时向相应方向转向越过黑线，直行直到两个传感器都检测到黑线，最后再向相应方向转向越过黑线离开路口。说明：下文主要讲解路口的形式，在实际使用时应当确认每个路口所代表的位置并结合车辆初始位置和通过路口情况来判断车辆位置，并到达需要的位置。在路口中可以直接切换横竖方向，同样是越过黑线代表进入或离开路口，校正方式也相同。
灰度巡线技巧
热门推荐
戚晨夕的博客
05-02 1万+
灰度巡线 文章目录灰度巡线一、走直线和圆形线路二、走弧形弯道三、判断“T”字形路口四、判断不规则路口五、转向解决方案总结 一、走直线和圆形线路 这种情况很简单，随便写的循迹都能过。 二、走弧形弯道 这种路线如果走的比较慢可以用走直线的方法寻迹，如果是跑的比较快的话就需要用到激光传感器，进行路口提前检测，然后降速通过弯道。 三、判断“T”字形路口 这里以八路灰度传感器为例进行讲解，白底黑线，线宽 24mm。图中箭头是我们小车行驶的方向，如果我们的小车没有到达 T 形路口时是不是只有一部分灰度传感器在黑线
【智能车】从零写一份自己的完全模型智能车寻路算法（有手就行） --- 01
JYSimilar的博客
02-03 3594
智能车完全模型寻路算法01，目前更新完图像处理。
基于MATLAB+PID算法实现小车巡线功能
毕业作品网站
05-23 5301
资源下载地址：https://download.csdn.net/download/sheziqiong/85737921 资源下载地址：https://download.csdn.net/download/sheziqiong/85737921本次实验我们采用比例、积分、微分控制, 即 PID 控制, 来对小车的巡线功能进行调节, 更好地控制小车转向时左右两个车轮的速度。该算法的原理如下:比例控制是一种最简单的控制方式。其控制器的输出与输入误差信号成比例关系, 当仅有比例控制时系统输出存在稳态误差。在积分
巡线小车学习笔记（arduino 四路循迹）
weixin_47180458的博客
04-19 5980
巡线小车代码学习笔记 红外布局原理 中间两路巡线一直在黑线上，小车会直行，当任意一个出来，小车会自动纠正。如果最外面的检测到黑线。则小车以更大速度纠正到黑线上去。在算法上，优先处理锐角，直角等外围传感器检测到黑线的状况 目前进度：无PID算法之路况已得全套 具体见PPT且补充只有左边或者右边探得线之况 遗留问题：此套路况分析适用于含PID算法之程序否？ ...
基于CMOS和红外传感器的自动寻路小车的设计
01-19
　我们设计的智能寻径小车主要由路径检测、转向控制、电机驱动、车速检测和电拥管理等 功能模块以及软件控制算法组成。小车以飞思卡尔公司的16位单片机MC9S12DG128B 为 控制器，根据黑色与白色反射率的不同.采用红外...
传感技术中的基于CMOS和红外传感器的自动寻路小车的设计
10-21
　我们设计的智能寻径小车主要由路径检测、转向控制、电机驱动、车速检测和电拥管理等 功能模块以及软件控制算法组成。小车以飞思卡尔公司的16位单片机MC9S12DG128B 为 核心控制器，根据黑色与白色反射率的不同.采用...
IRCtrol.zip_irctrol_小车红外线程序_臂章
09-15
实现小车的红外传感器运动，可以实现小车的臂章运动，很有用，亲测有效。
基于STM32开发板的小车寻路程序+源代码+文档说明
最新发布
12-02
基于STM32开发板的小车寻路程序（代码+文档说明） ## 项目备注 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动...
电赛智能送药小车_OpenMV巡线&识别十字路口完整代码
m0_66760074的博客
04-27 4095
【代码】电赛智能送药小车_OpenMV巡线&识别十字路口完整代码。
自己做的巡线小车 ，可实现白线十字路口计数、拐弯
11-14
本小车能够在亚太机器人大赛场地上精确定位，采用双机通信实现，由于自己录得视频过大，没往上传，仅传了代码
基于python的小车走黑线
10-11
一个简单的基于python的小车走黑线项目，结合了OpenCV
Python-基于树莓派的自动驾驶小车利用树莓派和tensorflow实现小车在赛道的自动驾驶
08-12
基于树莓派的自动驾驶小车，利用树莓派和tensorflow实现小车在赛道的自动驾驶。（Self-driving car based on raspberry pie（tensorflow））
十字路口处理方法
05-23
这里提供一份我见到的认为挺好的飞思卡尔十字处理方法，希望能给十字问题还在困扰的同学们帮助
基于深度优先寻路的路径规划算法
04-18
深度优先寻路算法是路径规划算法中的经典路径规划算法。
2021年电赛小车openmv巡线十字路口左右拐弯，定点停止
qq_53357019的博客
09-22 1066
openmv摄像头巡线代码
巡线小车程序
12-18
智能巡线小车 51单片机完整代码 void PWMInit(void) { //while(!TF0) //{ ENA=1;//PWM 输出高电平 ENB=1; //} // ********* 用户补充单片机产生PWM初始化代码 ********** // ********* 注：初始化时将占空比设为0********* ?????/???????? } /***************************************************************定时器初始化,中断周期为 1/frq，高点平的输出时间是 1/frq */ void TimerInit(unsigned short frq) { unsigned short T=1000*(1/frq); TMOD=0x01;/* 设定T0的工作模式为方式 1*/ EA=1; /* 开中断 */ ET0=1; /* 定时器0允许中断 */ TH0=(65536-1000*T)/256; /* 装入定时器的初值 */ TL0=(65536-1000*T)%6; TR0=1; /************ 启动定时器0 ，可以考虑放在 main() 中*/ while(!TF0) { PWMInit();
嵌入式通过IDE实现小车跑动操作和代码
06-07
嵌入式小车跑动的代码可以使用各种IDE进行开发，比如Keil、...以上代码实现了小车向前行驶的功能，通过GPIO控制小车四个轮子的转动方向。在IDE中，可以使用调试功能实现单步调试和观察变量值等操作，方便开发和调试。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值