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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › Arduino › 基于arduino2560的循线小车制作 附程序
返回列表 发新帖
查看: 3223|回复: 2
收起左侧

基于arduino2560的循线小车制作 附程序

[复制链接]
ID:698281 发表于 2020-2-26 01:00 | 显示全部楼层 |阅读模式
基于arduino2560的循线小车的整体图

小车的整体图

小车的整体图

部分代码如下
  1. /*

  3. * 电机：
  4. *      10 -> 左侧：前进( > 90 ) ; 后退( < 90 ) ; 停止( 82 - 92)
  5. *      12 -> 右侧：前进( < 90 ) ; 后退( > 90 ) ; 停止( 93 - 103);
  6. * F表示前B为后，D是在双线上，S表示单线上
  7. *
  8. */
  9. /****************************整体实验例程****************************/
  10. #include <Arduino.h>
  11. #include <Wire.h>
  12. #include <MultiLCD.h>
  13. #include <ServoTimer2.h>

  15. //定义车行进方向
  16. enum Dir{
  17.   FORWARD = 1, BACK, LEFT, RIGHT, STOP
  18. };


  21. enum Trackingmode{
  22.   FD= 1, BD, FS, BS       //举例FD就表示在双线上前进循迹，主要前传感器
  23. };//

  25. enum Turnmode{
  26.   RFD= 1, LFD, RBD, LBD, RFS, LFS, RBS, LBS  
  27. //举例RFD表示 R向右转弯，F转完后要前进，D表示在双线上
  28. };


  31. //Motor
  32. int left_motor_port = 4; //定义左侧电机引脚
  33. int right_motor_port = 7; //定义右侧电机引脚
  34. int motor_speed = 135; //定义电机停止速度


  37. void setup() {
  38.   Serial.begin(9600);
  39.   SensorInit();
  40.   MotorInit();

  42. }


  45. /******************************设备初始化部分********************************/
  46. //传感器引脚初始化
  47. void SensorInit(){
  48.   //pinMode(f[3], INPUT);
  49.   //pinMode(rf_s, INPUT);
  50.   for(int i=0;i<8;i++){pinMode(f[i], INPUT);}    //前传感器数组
  51.   //pinMode(b[3], INPUT);
  52.   //pinMode(b[6], INPUT);
  53.   for(int i=0;i<8;i++){pinMode(b[i], INPUT);}    //后传感器数组
  54.   //pinMode(l_s, INPUT);
  55.   //pinMode(r_s, INPUT);
  56.   for(int i=0;i<8;i++){pinMode(l[i], INPUT);}    //中间传感器数组
  57.   pinMode(debug_sensor, INPUT);
  58.   //digitalWrite(A1,LOW);
  59.   //digitalWrite(A5,LOW);
  60.   
  61. }

  63. /******************************车行进控制部分********************************/
  64. int left_speed = 20;
  65. int right_speed = 20;

  67. void SpeedSet(int l, int r){
  68.   left_speed = l; right_speed = r;
  69. }

  71. void Forward(){
  72.   l_Servo.write(Angle2Pwm(motor_speed + left_speed));
  73.   r_Servo.write(Angle2Pwm(motor_speed - right_speed));
  74. }

  76. void Back(){
  77.   l_Servo.write(Angle2Pwm(motor_speed - left_speed));
  78.   r_Servo.write(Angle2Pwm(motor_speed + right_speed));
  79. }

  81. void Left(){
  82.   l_Servo.write(Angle2Pwm(motor_speed - 1.5*left_speed));
  83.   r_Servo.write(Angle2Pwm(motor_speed - 1.5*right_speed));
  84. }

  86. void Right(){
  87.   l_Servo.write(Angle2Pwm(motor_speed + 1.5*left_speed));
  88.   r_Servo.write(Angle2Pwm(motor_speed + 1.5*right_speed));
  89. }

  91. void Stop(){
  92.   l_Servo.write(Angle2Pwm(motor_speed));
  93.   r_Servo.write(Angle2Pwm(motor_speed));
  94.   delay(1000);
  95. }

  97. void Move(int dir){
  98.   switch(dir){
  99.     case FORWARD: Forward(); break;
  100.     case BACK: Back(); break;
  101.     case LEFT: Left(); break;
  102.     case RIGHT: Right(); break;   
  103.     case STOP: Stop(); break;
  104.     default: break;  
  105.   }
  106. }
  107.   //电机速度写入函数，调速的时候使用
  108. void CorrectLeftF(){
  109.   l_Servo.write(Angle2Pwm(motor_speed));
  110.   r_Servo.write(Angle2Pwm(motor_speed - 20));
  111. }

  113. void CorrectRightF(){
  114.   l_Servo.write(Angle2Pwm(motor_speed + 20));
  115.   r_Servo.write(Angle2Pwm(motor_speed));
  116. }

  118. void CorrectRightB(){
  119.   l_Servo.write(Angle2Pwm(motor_speed - 20));
  120.   r_Servo.write(Angle2Pwm(motor_speed));
  121. }

  123. void CorrectLeftB(){
  124.   l_Servo.write(Angle2Pwm(motor_speed ));
  125.   r_Servo.write(Angle2Pwm(motor_speed + 20));
  126. }  






  133. /*
  134. void Turn(int mode){   //转向函数
  135.   switch(mode){
  136.    
  137.     case 1:              //RF_D
  138.   Move(RIGHT);
  139.   while(!digitalRead(f[7]));
  140.   //delay(500);
  141.   while(!digitalRead(f[5]));
  142.   SpeedSet(15,15);
  143.   Move(RIGHT);
  144.   //delay(dy);
  145.   while(!digitalRead(f[2]));
  146.   Move(STOP);
  147.   SpeedSet(20,20);
  148.   break;
  149.   
  150.     case 2:             //LF_D
  151.   Move(LEFT);
  152.   while(!digitalRead(f[0]));
  153.   //delay(500);
  154.   while(!digitalRead(f[2]));
  155.   SpeedSet(15,15);
  156.   Move(LEFT);
  157.   //delay(dy);
  158.   while(!digitalRead(f[5]));
  159.   Move(STOP);
  160.   SpeedSet(20,20);
  161.   break;
  162.   
  163.     case 3:               //RB_D
  164.   Move(RIGHT);
  165.   while(!digitalRead(b[7]));
  166.   //delay(500);
  167.   while(!digitalRead(b[5]));
  168.   SpeedSet(15,15);
  169.   Move(RIGHT);
  170.   //delay(dy);
  171.   while(!digitalRead(b[2]));
  172.   Move(STOP);
  173.   SpeedSet(20,20);
  174.   break;
  175.   
  176.     case 4:               //LB_D
  177.   Move(LEFT);
  178.   while(!digitalRead(b[0]));
  179.   //delay(500);
  180.   while(!digitalRead(b[2]));
  181.   SpeedSet(15,15);
  182.   Move(LEFT);
  183.   //delay(dy);
  184.   while(!digitalRead(b[5]));
  185.   Move(STOP);
  186.   SpeedSet(20,20);
  187.   break;
  188.   
  189.       case 5:                 //RF_S
  190.   Move(RIGHT);
  191.   while(!digitalRead(f[7]));
  192.   //delay(500);
  193.   while(!digitalRead(f[6]));
  194.   SpeedSet(15,15);
  195.   Move(RIGHT);
  196.   //delay(dy);
  197.   while(!digitalRead(f[3]));
  198.   Move(STOP);
  199.   SpeedSet(20,20);
  200.   break;
  201.   
  202.     case 6:             //LF_S
  203.   Move(LEFT);
  204.   while(!digitalRead(f[0]));
  205.   //delay(500);
  206.   while(!digitalRead(f[1]));
  207.   SpeedSet(15,15);
  208.   Move(LEFT);
  209.   //delay(dy);
  210.   while(!digitalRead(f[4]));
  211.   Move(STOP);
  212.   SpeedSet(20,20);
  213.   break;
  214.   
  215.     case 7:            //RB_S
  216.   Move(RIGHT);
  217.   while(!digitalRead(b[7]));
  218.   //delay(500);
  219.   while(!digitalRead(b[6]));
  220.   SpeedSet(15,15);
  221.   Move(RIGHT);
  222.   //delay(dy);
  223.   while(!digitalRead(b[3]));
  224.   Move(STOP);
  225.   SpeedSet(20,20);
  226.   break;
  227.   
  228.     case 8:            //LB_S
  229.   Move(LEFT);
  230.   while(!digitalRead(b[0]));
  231.   //delay(500);
  232.   while(!digitalRead(b[1]));
  233.   SpeedSet(15,15);
  234.   Move(LEFT);
  235.   //delay(dy);
  236.   while(!digitalRead(b[4]));
  237.   Move(STOP);
  238.   SpeedSet(20,20);
  239.   break;
  240. }
  241. }



  245. /******************************路径部分********************************/
  246. /*
  247. * 循迹函数
  248. * 返回值：无
  249. * 参数：mode：
  250. *       FD：前进双线循迹
  251. *       BD：后退双线循迹
  252. *       FS：前进单线循迹
  253. *       BS：后退单线循迹
  254. * 功能：通过车底传感器检测路线进行循迹
  255. */
  256. void Tracking(int mode){
  257. if(mode==1){//FD
  258.     if(digitalRead(f[2]) && digitalRead(f[5])){
  259.       Move(FORWARD);
  260.       delay(20);
  261.     }
  262.     else if(digitalRead(f[2])){
  263.        CorrectLeftF();
  264.       }
  265.     else if(digitalRead(f[5])){
  266.        CorrectRightF();
  267.       }
  268.     else
  269.       Move(FORWARD);
  270.       delay(20);
  271.       
  272. }   
  273.       
  274. if(mode==2){    //BD
  275.     if(digitalRead(b[2]) && digitalRead(b[5])){
  276.       Move(BACK);
  277.       delay(20);
  278.     }
  279.     else if(digitalRead(b[2])){
  280.      CorrectRightB();  
  281.     }
  282.     else if(digitalRead(b[5])){
  283.      CorrectLeftB();  
  284.     }
  285.     else
  286.       Move(BACK);
  287.       delay(20);
  288.       
  289. }   
  290.       
  291. if(mode==3){   //FS
  292.     if(digitalRead(f[3]) && digitalRead(f[4])){
  293.       Move(FORWARD);
  294.       delay(20);
  295.     }
  296.     else if(digitalRead(f[3])){
  297.        CorrectLeftF();
  298.       }
  299.     else if(digitalRead(f[4])){
  300.        CorrectRightF();
  301.       }
  302.     else
  303.       Move(FORWARD);
  304.       delay(20);
  305.    
  306.     }
  307.       
  308. if(mode==4){  //BS
  309.     if(digitalRead(b[3]) && digitalRead(b[4])){
  310.       Move(BACK);
  311.       delay(20);
  312.     }
  313.     else if(digitalRead(b[3])){
  314.      CorrectRightB();  
  315.     }
  316.     else if(digitalRead(b[4])){
  317.      CorrectLeftB();  
  318.     }
  319.     else
  320.       Move(BACK);
  321.       delay(20);
  322.   }
  323. }


  326. /*
  327. * 循线计数函数
  328. * 返回值：无
  329. * 参数：mode：
  330. *       FD：前进双线循迹
  331. *       BD：后退双线循迹
  332. *       FS：前进单线循迹
  333. *       BS：后退单线循迹
  334. * 参数：line：表示准备走几条线
  335. * 功能：确定走的线数
  336. */

  338. void Trackingline(int mode, int line){
  339.   switch(mode){
  340.   case 1:
  341.     for(int i=0;i<20;i++){Tracking(FD);}
  342.     while(1){
  343.     if(meridians < line){
  344.       if(meridians < line-1){
  345.         if(digitalRead(l[3])){
  346.           meridians++;
  347.           while(digitalRead(l[3]));
  348.           delay(200);
  349.           }
  350.         else{
  351.           Tracking(FD);  
  352.       }
  353.       }
  354.       else{
  355.         if(digitalRead(l[3])){meridians++;}
  356.         else{Tracking(FD);}
  357.       }
  358.     }
  359.     else{
  360.       //Move(BACK);
  361.       //delay(200);
  362.       //Move(STOP);
  363.       meridians = 0;
  364.       //Move(BACK);
  365.       //while(!digitalRead(l[3]));
  366.       Move(STOP);
  367.       break;
  368.     }
  369.    
  370.     }
  371.   break;


  374.   case 2:
  375.   for(int i=0;i<20;i++){Tracking(BD);}
  376.     while(1){
  377.     if(meridians < line){
  378.       if(meridians < line-1){
  379.         if(digitalRead(l[4])){
  380.           meridians++;
  381.           while(digitalRead(l[4]));
  382.           delay(200);
  383.           }
  384.         else{
  385.           Tracking(BD);  
  386.       }
  387.       }
  388.       else{
  389.         if(digitalRead(l[4])){meridians++;}
  390.         else{Tracking(BD);}
  391.       }
  392.     }
  393.     else{
  394.       //Move(FORWARD);
  395.       //delay(200) ;
  396.       //Move(STOP);
  397.       meridians = 0;
  398.       //Move(FORWARD);
  399.       //while(!digitalRead(l[4]));
  400.       Move(STOP);
  401.       break;
  402.     }
  403.     }
  404.     break;
  405.    
  406.    
  407.     case 3:
  408.   for(int i=0;i<20;i++){Tracking(FS);}
  409.     while(1){
  410.     if(meridians < line){
  411.       if(meridians < line-1){
  412.         if(digitalRead(l[3])){
  413.           meridians++;
  414.           while(digitalRead(l[3]));
  415.           delay(600);
  416.           }
  417.         else{
  418.           Tracking(FS);  
  419.       }
  420.       }
  421.       else{
  422.         if(digitalRead(l[3])){meridians++;}
  423.         else{Tracking(FS);}
  424.       }
  425.     }
  426.     else{
  427.       //Move(BACK);
  428.       //delay(200);
  429.       //Move(STOP);
  430.       meridians = 0;
  431.       //Move(BACK);
  432.       //while(!digitalRead(l[3]));
  433.       Move(STOP);
  434.       break;
  435.     }
  436.     }
  437.   break;

  439.   case 4:
  440.   for(int i=0;i<20;i++){Tracking(BS);}
  441.     while(1){
  442.     if(meridians < line){
  443.       if(meridians < line-1){
  444.         if(digitalRead(l[4])){
  445.           meridians++;
  446.           while(digitalRead(l[4]));
  447.           delay(600);
  448.           }
  449.         else{
  450.           Tracking(BS);  
  451.       }
  452.       }
  453.       else{
  454.         if(digitalRead(l[4])){meridians++;}
  455.         else{Tracking(BS);}
  456.       }
  457.     }
  458.     else{
  459.       //Move(FORWARD);
  460.       //delay(200);
  461.       //Move(STOP);
  462.       meridians = 0;
  463.       //Move(FORWARD);
  464.       //while(!digitalRead(l[4]));
  465.       Move(STOP);
  466.       break;
  467.     }
  468.     }
  469.     break;  
  470.    
  471. }
  472. }



  476. /******************************路段部分********************************/

  478. //主函数部分,直接写入要走的路
  479. void loop (){
  480.   Turn(LFD);
  481.   Trackingline(FD,3);
  482.   Turn(RBS);
  483.   Trackingline(BS,1);
  484.   Turn(LBD);
  485.   Trackingline(BD,2);
  486.   Turn(RFS);
  487.   Trackingline(FS,1);
  488. }
复制代码

使用的八路巡线传感器 前中后各一 全部接在数字口上

使用的八路巡线传感器 前中后各一 全部接在数字口上

小车跑的场地，由单双线交叉构成的网格，本程序让小车沿线跑

小车跑的场地，由单双线交叉构成的网格，本程序让小车沿线跑

sketch_mar30a.zip

6.61 KB, 下载次数: 27, 下载积分: 黑币 -5

程序的源码

评分

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

查看全部评分

回复

使用道具 举报

ID:859280 发表于 2021-11-3 21:26 | 显示全部楼层
里面有一些库文件用不了，库文件能分享吗？
回复

使用道具 举报

ID:417658 发表于 2021-11-28 16:50 | 显示全部楼层
小车底盘是自己制作的吗？
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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