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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 电子技术分类讨论区 › 智能小车/机器人 › D2-6循迹小车制作资料
返回列表 发新帖
查看: 7693|回复: 4
收起左侧

D2-6循迹小车制作资料

[复制链接]
ID:243552 发表于 2017-11-23 07:49 | 显示全部楼层 |阅读模式
D2-6 小车制作说明

一、功能介绍：
   该产品是D2系列小车的最新版本，带有4路红外线传感器，用于循迹避障功能，带有蓝牙模块的串口接口，可以连接蓝牙模块实现无线遥控，电机驱动部分
使用的是2个电机驱动的专用集成电路L9110S，相比以前使用三极管驱动电机只能前进，现在D2-6小车也可以控制后退了。小车PCB上带有一个功能按钮，可
以通过按键切换到不同的功能。

二、装配说明：

   装配时应该按照先装配电子元件部分，后装配机械传动部分的顺序进行。装配电子元件时，先装配贴片电子元件，再装配直插的电子元件。下面先介绍电子元件部分的装配。
无标题.png

单片机源程序如下:
  1. #include "STC15W201S.h"
  2. #include "intrins.h"

  4. typedef unsigned char BYTE;
  5. typedef unsigned int WORD;

  7. sbit D1 = P1^4;  //用于控制左边发光二极管
  8. sbit D2 = P3^7;   //用于控制右边发光二极管

  10. bit busy;

  12. bit l9110s_1 ;
  13. bit l9110s_2 ;

  15. bit R9110s_1 ;
  16. bit R9110s_2 ;

  18. unsigned char func;

  20. void Delay500ms()                //@11.0592MHz
  21. {
  22.         unsigned char i, j, k;

  24.         _nop_();
  25.         _nop_();
  26.         i = 2;
  27.         j = 2;
  28.         k = 2;
  29.         do
  30.         {
  31.                 do
  32.                 {
  33.                         while (--k);
  34.                 } while (--j);
  35.         } while (--i);
  36. }

  38. BYTE usart_recv;

  40. /*----------------------------
  41. UART 中断处理函数
  42. -----------------------------*/
  43. void Uart() interrupt 4 using 1
  44. {
  45.     if (RI)
  46.     {
  47.         RI = 0;                 //??RI?
  48.         usart_recv = SBUF;
  49.     }
  50.     if (TI)
  51.     {
  52.         TI = 0;                 //??TI?
  53.         busy = 0;               //????
  54.     }
  55. }

  57. //串口初始化为9600波特率
  58. void Usart_init(void)
  59. {
  60.         SCON = 0x50;       
  61.         T2L = 0xE0;               
  62.         T2H = 0xFE;               
  63.         AUXR |= 0x01;               
  64.         AUXR |= 0x4;               
  65.         AUXR |= 0x10;               
  66.         ES = 1;
  67.         EA = 1;
  68. }


  71. //电机PWM方式驱动

  73. void PWM_Init(void)                //100??@11.0592MHz
  74. {
  75.         AUXR |= 0x80;               
  76.         TMOD = 0x02;       
  77.         TL0 = 0x00;               
  78.         TH0 = 0x00;               
  79.         TF0 = 0;               
  80.         TR0 = 1;               
  81.         ET0 = 1;
  82.         EA  = 1;
  83. }

  85. unsigned char R_PWM,L_PWM;
  86. unsigned char count;
  87. void timer0_int (void) interrupt 1
  88. {
  89.         count++;
  90.         if(count > 100)
  91.         {
  92.                 P32 = l9110s_1;
  93.                 P33 = l9110s_2;
  94.                 P54 = R9110s_1;
  95.                 P55 = R9110s_2;
  96.                 count = 0;
  97.         }
  98.        
  99.         if(count == L_PWM)
  100.         {
  101.                 P54 = 0;
  102.                 P55 = 0;
  103.         }
  104.        
  105.         if(count == R_PWM)
  106.         {
  107.                 P32 = 0;
  108.                 P33 = 0;
  109.         }
  110.        
  111. }


  114. void SendData(BYTE dat)
  115. {
  116.     while (busy);               //???????????
  117.     busy = 1;
  118.     SBUF = dat;                 //????UART?????
  119. }


  122. //电机控制，注意电机驱动芯片9110两个控制端只能有一个为高电平，
  123. //若同时为高电平则芯片内部短路，危险，极易损坏芯片。
  124. void stop(void);
  125. void front(void);
  126. void back(void);
  127. void right(void);
  128. void left(void);

  130. //停止
  131. void stop(void)
  132. {
  133.         l9110s_1 = 0;
  134.         l9110s_2 = 0;
  135.         R9110s_1 = 0;
  136.         R9110s_2 = 0;
  137. }

  139. //前进
  140. void front(void)
  141. {
  142.                 l9110s_1 = 0;
  143.                 l9110s_2 = 1;
  144.                 R9110s_1 = 0;
  145.                 R9110s_2 = 1;
  146. }

  148. //倒退
  149. void back(void)
  150. {
  151.                 l9110s_1 = 1;
  152.                 l9110s_2 = 0;
  153.                 R9110s_1 = 1;
  154.                 R9110s_2 = 0;
  155. }


  158. //右转
  159. void right(void)
  160. {
  161.                 l9110s_1 = 1;
  162.                 l9110s_2 = 0;
  163.                 R9110s_1 = 0;
  164.                 R9110s_2 = 1;
  165. }

  167. //左转
  168. void left(void)
  169. {
  170.                 l9110s_1 = 0;
  171.                 l9110s_2 = 1;
  172.                 R9110s_1 = 1;
  173.                 R9110s_2 = 0;
  174. }




  179. //循迹避障 蓝牙控制功能选择
  180. unsigned char func_sel(void)
  181. {
  182.         unsigned long c;
  183.         unsigned char i;
  184.         i = 0;
  185.         c = 0;
  186.         D1 = D2 = 1;
  187.         stop();
  188.         Delay500ms();Delay500ms();Delay500ms();Delay500ms();
  189.         while((P15 == 0)&& (c <0x3ffff))
  190.         {
  191.                 c++;
  192.                 if((c > 0xffff) && (c < 0x1ffff))
  193.                 {
  194.                         D1 = 0;
  195.                         i = 1;
  196.                 }
  197.                
  198.                 if((c > 0x1ffff) && (c < 0x2ffff))
  199.                 {
  200.                         D1 = 1; D2 = 0;
  201.                         i = 2;
  202.                 }
  203.                
  204.                 if((c > 0x2ffff) && (c < 0x3ffff))
  205.                 {
  206.                         D1 = 0; D2 = 0;
  207.                         i = 3;
  208.                 }
  209.         }
  210.        
  211.          if(c < 0xffff)
  212.                 {
  213.                         return func;
  214.                 }
  215.                 return i;
  216. }



  220. void main(void)
  221. {
  222.         BYTE last_recv;
  223.        
  224.         P32 = P33 = P54 = P55 = 0;
  225.         l9110s_1 = l9110s_2 = R9110s_1 = R9110s_2 = 0;
  226.        
  227.         R_PWM = 99;
  228.         L_PWM = 99;
  229.         P3M1 = 0;
  230.         P3M0 = 0x0C;
  231.         P5M1 = 0;
  232.         P5M0 = 0x30;
  233.         P1M1 = 0xf;
  234.         P1M0 = 0;
  235.         IP =0x10;
  236.         PWM_Init();
  237.   Usart_init();
  238.         D1 = D2 = 1;
  239.         P15 = 1;
  240.         func = 1;
  241.    
  242.         while(func == 1)   //功能1:循迹
  243.         {
  244.                         while((P11 == 1)&& (P13 == 0))
  245.                         {
  246.                                         right(); D2 = 0;D1 = 1;
  247.                         }
  248.                         while((P13 == 1)&&(P11 == 0))
  249.                         {
  250.                                  left();D1 = 0;D2 =1;
  251.                         }
  252.                        
  253.                         while((P13 == 0)&&(P11 == 0))
  254.                         {
  255.                                  front();D1 = 0;D2 =0;
  256.                         }
  257.                         front();Delay500ms();
  258.                         if(P15 == 0)
  259.                         {
  260.                                 func = func_sel();
  261.                         }
  262.         }

  264.         while(func == 2)  //功能2：避障
  265.         {
  266.                 if(P15 == 0)
  267.                 {
  268.                         func = func_sel();
  269.                 }
  270.                
  271.                 while((P12 == 1)&& (P10 == 0))
  272.                 {
  273.                         left(); D2 = 0;D1 = 1;
  274.                 }
  275.                
  276.                 while((P12 == 0)&& (P10 == 1))
  277.                 {
  278.                         right(); D2 = 1;D1 = 0;
  279.                 }
  280.                
  281.                 while((P12 == 1)&& (P10 == 1))
  282.                 {
  283.                         front(); D2 = 0;D1 = 0;
  284.                 }
  285.                
  286.                 while((P12 == 0)&& (P10 == 0))
  287.                 {
  288.                         back(); D2 = 1;D1 = 1;
  289.                 }
  290.         }

  292.        
  293.         while(func == 3)    //功能3：蓝牙遥控
  294.         {
  295.                 if(P15 == 0)
  296.                 {
  297.                         func = func_sel();
  298.                 }
  299.                
  300.                 if(last_recv != usart_recv)
  301.                 {
  302.                         last_recv = usart_recv;
  303.                         switch(usart_recv)
  304.                         {
  305.                                 case 0x14:
  306.                                 case 0x15:
  307.                                 case 0x16:
  308.                                 case 0x17:
  309.                                 case 0x18:
  310.                                 case 0x19:
  311.                                 case 0x1a:
  312.                                 case 0x1b:
  313.                                 case 0x1c:
  314.                                 case 0x1d:
  315.                                 case 0x1e:
  316.                                 case 0x1f:       
  317.                                         front();
  318.                                         R_PWM = 69+(usart_recv-0x10)*2;
  319.                                         L_PWM = 69+(usart_recv-0x10)*2;
  320.                                         D1 = D2 = 0;
  321.                                         break;
  322.                                
  323.                                 case 0x24:
  324.                                 case 0x25:
  325.                                 case 0x26:
  326.                                 case 0x27:
  327.                                 case 0x28:
  328.                                 case 0x29:
  329.                                 case 0x2a:
  330.                                 case 0x2b:
  331.                                 case 0x2c:
  332.                                 case 0x2d:
  333.                                 case 0x2e:
  334.                                 case 0x2f:       
  335.                                         back();
  336.                                         R_PWM = 69+(usart_recv-0x20)*2;
  337.                                         L_PWM = 69+(usart_recv-0x20)*2;
  338.                                         D1 = D2 = 1;
  339.                                         break;
  340.                                
  341.                                 case 0x34:
  342.                                 case 0x35:
  343.                                 case 0x36:
  344.                                 case 0x37:
  345.                                 case 0x38:
  346.                                 case 0x39:
  347.                                 case 0x3a:
  348.                                 case 0x3b:
  349.                                 case 0x3c:
  350.                                 case 0x3d:
  351.                                 case 0x3e:
  352.                                 case 0x3f:       
  353.                                         left();
  354.                                         R_PWM = 69+(usart_recv-0x30)*2;
  355.                                         L_PWM = 69+(usart_recv-0x30)*2;
  356.                                         D1 = 0; D2 = 1;
  357.                                         break;               
  358.                                
  359.                                
  360.                                 case 0x44:
  361.                                 case 0x45:
  362.                                 case 0x46:
  363.                                 case 0x47:
  364.                                 case 0x48:
  365.                                 case 0x49:
  366.                                 case 0x4a:
  367.                                 case 0x4b:
  368.                                 case 0x4c:
  369.                                 case 0x4d:
  370.                                 case 0x4e:
  371.                                 case 0x4f:       
  372.                                         right();
  373.                                         R_PWM = 69+(usart_recv-0x40)*2;
  374.                                         L_PWM = 69+(usart_recv-0x40)*2;
  375.                                         D1 = 1; D2 = 0;
  376.                                         break;                       
  377.                                
  378.                                 case 0x54:
  379.                                 case 0x55:
  380.                                 case 0x56:
  381.                                 case 0x57:
  382.                                 case 0x58:
  383.                                 case 0x59:
  384.                                 case 0x5a:
  385.                                 case 0x5b:
  386.                                 case 0x5c:
  387.                                 case 0x5d:
  388.                                 case 0x5e:
  389.                                 case 0x5f:       
  390.                                         front();
  391.                                         R_PWM = 99;
  392.                                         L_PWM = 100-(usart_recv-0x50)*2;
  393.                                   D1 = 1; D2 = 0;
  394.                                         break;                                       
  395.                                

  397.                                 case 0x64:
  398.                                 case 0x65:
  399.                                 case 0x66:
  400.                                 case 0x67:
  401.                                 case 0x68:
  402.                                 case 0x69:
  403.                                 case 0x6a:
  404.                                 case 0x6b:
  405.                                 case 0x6c:
  406.                                 case 0x6d:
  407.                                 case 0x6e:
  408.                                 case 0x6f:       
  409.                                         front();
  410.                                         R_PWM = 100-(usart_recv-0x60)*2;
  411.                                         L_PWM = 99;
  412.                                   D1 = 0; D2 = 1;
  413. ……………………

  415. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码
0.png
所有资料51hei提供下载:
D2-6循迹小车资料1.rar (1.17 MB, 下载次数: 37)
回复

使用道具 举报

ID:257043 发表于 2017-12-4 09:37 | 显示全部楼层
好资料，51黑有你更精彩!!!
回复

使用道具 举报

ID:257060 发表于 2017-12-4 09:47 | 显示全部楼层
大神好厉害
回复

使用道具 举报

ID:921294 发表于 2021-6-11 09:54 | 显示全部楼层
非常感谢这位朋友的分享，因为在PDD上买了一套散件，商家的广告上说提供C语言程序，这一家到货后却不提供C语言程序，百般的东扯西拉，就是不提供，真的没有办法了。要学习没办法了，我想网络上可能有相近的，找了一下，还真的有，原先打算扔掉了，现在还没有做，先看着资料慢慢做。
有图片不知道怎么上传
回复

使用道具 举报

ID:932168 发表于 2021-6-19 13:15 | 显示全部楼层
谁能根据这个程序和电路板画一个原理图呢?
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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