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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › stc15单片机4足仿生机器人源程序
返回列表 发新帖
查看: 2004|回复: 1
打印 上一主题 下一主题
收起左侧

stc15单片机4足仿生机器人源程序

[复制链接]
跳转到指定楼层
楼主
ID:336397 发表于 2018-9-29 09:34 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
单片机源程序如下:
  1. #include "stc15.H"
  2. #include "stdio.h"
  3. #include <string.h>
  4. #include   <intrins.h>
  5. #include "类型.h"
  6. #define dingshi 0xfd46 //20us中断一次
  7. #define gao (dingshi>>8)
  8. #define di dingshi

  10. //#define FOSC 11059200L         
  11. //#define FOSC 22118400L
  12. #define FOSC   27000000L
  13. //#define BAUD 115200   
  14. #define BAUD 1200
  15. #define S1_S0 0x40              //P_SW1.6
  16. #define S1_S1 0x80              //P_SW1.7
  17. #define max 20
  18. #define jiange 2000             //接收到两个字节中间的最大间隔 单位是中断个数
  19. #define duo_ji_shu 18             //舵机数
  20. #define su_du 3000


  23. #define qian1 0x45
  24. #define qian2 0x39
  25. #define qian3 0x2b
  26. #define qian4 0x2b
  27. #define hou1 0x33
  28. #define hou2 0x29
  29. #define hou3 0x3b
  30. #define hou4 0x3b
  31. #define shang1 0x29
  32. #define shang2 0x55
  33. #define shang3 0x29
  34. #define shang4 0x55
  35. #define xia1 0x39
  36. #define xia2 0x3f
  37. #define xia3 0x39
  38. #define xia4 0x43

  40. #define jiaozhun1 5
  41. #define jiaozhun2 5
  42. #define jiaozhun3 5
  43. sbit DJ1=P0^5;
  44. sbit DJ2=P0^6;
  45. sbit DJ3=P0^7;
  46. sbit DJ4=P1^0;
  47. sbit DJ5=P1^1;
  48. sbit DJ6=P4^7;
  49. sbit DJ7=P1^2;
  50. sbit DJ8=P1^3;
  51. sbit DJ9=P1^4;
  52. sbit DJ10=P1^5;
  53. sbit DJ11=P1^5;

  55. sbit DJ12=P1^5;
  56. sbit DJ13=P1^5;
  57. sbit DJ14=P1^5;
  58. sbit DJ15=P1^5;
  59. sbit DJ16=P1^5;
  60. sbit DJ17=P1^5;
  61. sbit DJ18=P1^5;

  63. sbit RX=P4^3;
  64. sbit TX=P4^4;

  66. code uchar qian[8*6]={                 //动作数组-向前走
  67. hou1,shang1,qian2,xia2,hou3,shang3,qian4,xia4,
  68. qian1,shang1,hou2,xia2,qian3,shang3,hou4,xia4,
  69. qian1,xia1,hou2,xia2,qian3,xia3,hou4,xia4,
  70. qian1,xia1,hou2,shang2,qian3,xia3,hou4,shang4,
  71. hou1,xia1,qian2,shang2,hou3,xia3,qian4,shang4,
  72. hou1,xia1,qian2,xia2,hou3,xia3,qian4,xia4
  73. };

  75. code uchar hou[8*6]={                 //动作数组-向后走
  76. hou1,xia1,qian2,xia2,hou3,xia3,qian4,xia4,
  77. hou1,xia1,qian2,shang2,hou3,xia3,qian4,shang4,
  78. qian1,xia1,hou2,shang2,qian3,xia3,hou4,shang4,
  79. qian1,xia1,hou2,xia2,qian3,xia3,hou4,xia4,
  80. qian1,shang1,hou2,xia2,qian3,shang3,hou4,xia4,
  81. hou1,shang1,qian2,xia2,hou3,shang3,qian4,xia4
  82. };

  84. code uchar you[8*6]={                 //动作数组-向右转
  85. hou1,shang1,qian2,xia2,qian3,shang3,hou4,xia4,
  86. qian1,shang1,hou2,xia2,hou3,shang3,qian4,xia4,
  87. qian1,xia1,hou2,xia2,hou3,xia3,qian4,xia4,
  88. qian1,xia1,hou2,shang2,hou3,xia3,qian4,shang4,
  89. hou1,xia1,qian2,shang2,qian3,xia3,hou4,shang4,
  90. hou1,xia1,qian2,xia2,qian3,xia3,hou4,xia4
  91. };
  92. code uchar zuo[8*6]={                 //动作数组-向左转
  93. hou1,xia1,qian2,xia2,qian3,xia3,hou4,xia4,
  94. hou1,xia1,qian2,shang2,qian3,xia3,hou4,shang4,
  95. qian1,xia1,hou2,shang2,hou3,xia3,qian4,shang4,
  96. qian1,xia1,hou2,xia2,hou3,xia3,qian4,xia4,
  97. qian1,shang1,hou2,xia2,hou3,shang3,qian4,xia4,
  98. hou1,shang1,qian2,xia2,qian3,shang3,hou4,xia4,
  99. };
  100. code uchar tiao[8*6]={                 //动作数组-跳舞
  101. hou1,xia1,qian2,xia2,qian3,xia3,hou4,xia4,
  102. hou1,xia1,qian2,shang2,qian3,xia3,hou4,shang4,
  103. qian1,xia1,hou2,shang2,hou3,xia3,qian4,shang4,
  104. qian1,xia1,hou2,xia2,hou3,xia3,qian4,xia4,
  105. qian1,shang1,hou2,xia2,hou3,shang3,qian4,xia4,
  106. hou1,shang1,qian2,xia2,qian3,shang3,hou4,xia4,
  107. };
  108. uchar sheding[duo_ji_shu];                //现在设定值
  109. uchar xinzhi[duo_ji_shu];                //新角度

  111. bit   jieshou=0;        //接收成功标志
  112. bit jk=0;//测试
  113. bit jk2=0;//测试
  114. uchar len=0;   //数据长度
  115. uchar ml=0;   //要执行的命令
  116. uchar shuju[max];
  117. uint jishu_jg=0;
  118. bit shijian_l=0;
  119. bit wancheng=0;
  120. bit zhi_xing=0;    //开始执行标志
  121. bit MS_1=0;
  122.         unsigned int  time=0;
  123.         unsigned int  timer=0;
  124.         float         S=0;
  125.     bit           flag =0;
  126. void Delay1ms()                //@27.000MHz
  127. {
  128.         unsigned char i, j;

  130. ;
  131. ;
  132.         i = 7;
  133.         j = 141;
  134.         do
  135.         {
  136.                 while (--j);
  137.         } while (--i);
  138. }
  139. void yanshi_ms(uint m)
  140. {
  141.         while(m--)Delay1ms();
  142. }
  143. void fu_wei()
  144. {
  145.         uchar i=0;
  146.         sheding[0]=0x33;
  147.         sheding[1]=0x3d;//1f
  148.         sheding[2]=0x37;
  149.         sheding[3]=0x43;
  150.         sheding[4]=0x2f;
  151.         sheding[5]=0x39;
  152.         sheding[6]=0x3b;
  153.         sheding[7]=0x41;

  155. }
  156. void chushihua(void)                //初始化20us中断22.1184MHz
  157. {
  158.         uchar i=0;
  159.           ACC = P_SW1;
  160.     ACC &= ~(S1_S0 | S1_S1);    //S1_S0=0 S1_S1=0
  161.     P_SW1 = ACC;                //(P3.0/RxD, P3.1/TxD)
  162.     SCON = 0x50;                //8位可变波特率
  163.     T2L = (65536 - (FOSC/4/BAUD));   //设置波特率重装值
  164.     T2H = (65536 - (FOSC/4/BAUD))>>8;
  165.     AUXR = 0x14;                //T2为1T模式, 并启动定时器2
  166.     AUXR |= 0x01;               //选择定时器2为串口1的波特率发生器
  167.         

  169.         AUXR |= 0x80;               
  170.         TMOD &= 0xF0;               
  171.         TL0 = di;               
  172.         TH0 = gao;               
  173.         TF0 = 0;               
  174.         TR0 = 1;               
  175.         ET0=0;
  176.         ES=1;
  177.         EA=1;

  179.         AUXR &= 0xdf;                //定时器时钟12T模式
  180.         TMOD &= 0x0F;                //设置定时器模式

  182.         TF1 = 0;                //清除TF1标志
  183.         TR1 = 0;                //定时器1开始计时

  185.         fu_wei();
  186. }

  188. void yanshi(uint m)
  189. {

  191.         while(m--)
  192.         {
  193.                 if(!zhi_xing)break;
  194.         }
  195. }
  196.         

  198. void send(uchar *j,l)
  199. {
  200.         uchar i=0;
  201.         for(i=0;i<l;i++)
  202.         {
  203.                 SBUF=*(j+i);
  204.                 while(!TI);
  205.                 TI=0;
  206.         }
  207.         yanshi(40000);
  208.         yanshi(40000);
  209.         yanshi(40000);
  210.         yanshi(40000);
  211. }

  213. bit Hand(unsigned char *a)                 //是否包含文本
  214. {
  215.     if(strstr(shuju,a)!=NULL)
  216.             return 1;
  217.         else
  218.                 return 0;
  219. }
  220. void Uart() interrupt 4
  221. {
  222.         if (RI)
  223.         {
  224.                 RI = 0;

  226.                 if(len<max)               
  227.                 {
  228.                         shuju[len++]=SBUF;
  229.                         jishu_jg=0;//清零时间间隔变量
  230.                         shijian_l=1;

  232.                 }
  233.         }
  234. //        if(TI)TI=0;
  235. }
  236. void zhongduan() interrupt 1   //中断服务
  237. {
  238.         uchar i=0;
  239.         static int jishu=0;
  240. //        static uchar MS=0;
  241.         ET0=0;

  243. //        DJ1=!DJ1;

  245.         if(shijian_l)
  246.         {
  247.                 jishu_jg++;

  249.                 if(jishu_jg>jiange)
  250.                 {

  252.                         jieshou=1;//间隔时间到就说明接收到一个完整的字符串
  253.                         shijian_l=0;
  254.                 }
  255.         }
  256.         if(jishu++==900)
  257.         {
  258.                 jishu=0;
  259.         }

  261.         
  262.         DJ1=(jishu<sheding[0]);
  263.         DJ2=(jishu<sheding[1]);
  264.         DJ3=(jishu<sheding[2]);
  265.         DJ4=(jishu<sheding[3]);
  266.         DJ5=(jishu<sheding[4]);
  267.         DJ6=(jishu<sheding[5]);
  268.         DJ7=(jishu<sheding[6]);
  269.         DJ8=(jishu<sheding[7]);
  270.         DJ9=(jishu<sheding[8]);
  271.         DJ10=(jishu<sheding[9]);
  272.         DJ11=(jishu<sheding[10]);
  273.         DJ12=(jishu<sheding[11]);
  274.         DJ13=(jishu<sheding[12]);
  275.         DJ14=(jishu<sheding[13]);
  276.         DJ15=(jishu<sheding[14]);
  277.         DJ16=(jishu<sheding[15]);
  278.         DJ17=(jishu<sheding[16]);
  279.         DJ18=(jishu<sheding[17]);

  281.         TL0 = di;               
  282.         TH0 = gao;
  283.         ET0=1;
  284. }
  285.    void  StartModule()                          //T1中断用来扫描数码管和计800MS启动模块
  286.   {
  287.           TX=1;                                         //800MS  启动一次模块
  288.           _nop_();
  289.           _nop_();
  290.           _nop_();
  291.           _nop_();
  292.           _nop_();
  293.           _nop_();
  294.           _nop_();
  295.           _nop_();
  296.           _nop_();
  297.           _nop_();
  298.           _nop_();
  299.           _nop_();
  300.           _nop_();
  301.           _nop_();
  302.           _nop_();
  303.           _nop_();
  304.           _nop_();
  305.           _nop_();
  306.           _nop_();
  307.           _nop_();
  308.           _nop_();
  309.           TX=0;
  310.   }
  311. float juli()
  312. {
  313.      StartModule();
  314.          TH1=0;
  315.          TL1=0;
  316.          while(!RX);                //当RX为零时等待
  317.          TR1=1;                            //开启计数
  318.           while(RX);                        //当RX为1计数并等待
  319.          TR1=0;                                //关闭计数
  320.          time=TH1*256+TL1;
  321.          TH1=0;
  322.          TL1=0;
  323.          S=(time*2.0)/1000;     //算出来是CM
  324.          if(flag==1)
  325.          {
  326.                  flag=0;
  327.                 S=1000;
  328.          }
  329.          return S;
  330.         
  331. }
  332. void qingkong()                  //清空接收缓存
  333. {
  334.         uchar i=0;
  335.         for(i=0;i<max;i++)
  336.         {
  337.                 shuju[i]=0;
  338.         }
  339. }


  342. void WIFI()
  343. {
  344.         while(!Hand("OK"))                            //判断是否握手成功,如果不成功延时一会,再发送AT握手指令
  345.     {
  346.                         len=0;
  347.                         qingkong();
  348.                         send("AT\r\n",4);                         //发送联机指令
  349.                         yanshi_ms(1000);
  350.     }
  351.                 qingkong();
  352.                 while(!Hand("OK"))                           
  353.                 {
  354.                         len=0;
  355.                         qingkong();
  356.                         send("AT+CWMODE=2\r\n",13);       //设置为AP模式 让手机链接wifi   
  357.                         yanshi_ms(1000);        
  358.                 }
  359.                 qingkong();
  360.                 while(!Hand("OK"))                           
  361.     {
  362.                         len=0;
  363.                         qingkong();
  364.                         send("AT+CIPMUX=1\r\n",13);          //设置为多连接模式   
  365.                         yanshi_ms(1000);                        
  366.     }        
  367.                 qingkong();
  368.                 send("AT+CIPSERVER=1,8349\r\n",21);  
  369.                 yanshi_ms(1000);        
  370.                 send("AT+CIPSERVER=1,8349\r\n",21);  
  371.                 yanshi_ms(1000);
  372.                 send("AT+CIPSERVER=1,8349\r\n",21);
  373.                 qingkong();
  374.                 len=0;
  375.                 yanshi_ms(1000);
  376.                 wancheng=1;             //初始化完成 置标志位

  378. }


  381. uchar to_uchar(uchar g,uchar d)
  382. {
  383.                 if(g>=97)
  384.                 {
  385.                         g=g-87;
  386.                 }
  387.                 else
  388.                 {
  389.                         if(g<=57)
  390.                         {
  391.                                 g=g-48;
  392.                         }
  393.                 }
  394.                 if(d>=97)
  395.                 {
  396.                         d=d-87;
  397.                 }
  398.                 else
  399.                 {
  400.                         if(d<=57)
  401.                         {
  402.                                 d=d-48;
  403.                         }
  404.                 }
  405.                 return (g<<4)|d;
  406. }


  409. void qianjin()
  410. {
  411.         uchar j=0;
  412.         static uchar i=0;
  413.         static uint y=0;
  414.         if(zhi_xing)
  415.         {
  416.                 if(y++>su_du)
  417.                 {
  418.                         y=0;
  419.                         for(j=0;j<8;j++)
  420.                         {
  421.                                 sheding[j]=qian[i*8+j];
  422.                         }
  423.                         if(i++==5)i=0;
  424.                 }
  425.         }
  426. }
  427. void houtui()
  428. {
  429.         uchar j=0;
  430.         static uchar i=0;
  431.         static uint y=0;
  432.         if(zhi_xing)
  433.         {
  434.                 if(y++>su_du)
  435.                 {
  436.                         y=0;
  437.                         for(j=0;j<8;j++)
  438.                         {
  439.                                 sheding[j]=hou[i*8+j];
  440.                         }
  441.                         if(i++==5)i=0;
  442.                 }
  443.         }
  444. }
  445. void zuozhuan()
  446. {
  447.         uchar j=0;
  448.         static uchar i=0;
  449.         static uint y=0;
  450.         if(zhi_xing)
  451.         {
  452.                 if(y++>su_du)
  453.                 {
  454.                         y=0;
  455.                         for(j=0;j<8;j++)
  456.                         {
  457.                                 sheding[j]=zuo[i*8+j];
  458.                         }
  459.                         if(i++==5)i=0;
  460.                 }
  461.         }
  462. }
  463. void youzhuan()
  464. {
  465.         uchar j=0;
  466.         static uchar i=0;
  467.         static uint y=0;
  468.         if(zhi_xing)
  469.         {
  470.                 if(y++>su_du)
  471.                 {
  472.                         y=0;
  473.                         for(j=0;j<8;j++)
  474.                         {
  475.                                 sheding[j]=you[i*8+j];
  476.                         }
  477.                         if(i++==5)i=0;
  478.                 }
  479.         }
  480. }
  481. void tiaowu()
  482. {
  483.         uchar j=0;
  484.         static uchar i=0;
  485.         static uint y=0;
  486.         if(zhi_xing)
  487.         {
  488.                 if(y++>su_du)
  489.                 {
  490.                         y=0;
  491.                         for(j=0;j<8;j++)
  492.                         {
  493.                                 sheding[j]=tiao[i*8+j];
  494.                         }
  495.                         if(i++==5)i=0;
  496.                 }
  497.         }
  498. }                  
  499. void zhixing()        //执行遥控命令
  500. {
  501.         uchar i=0;
  502.         if(zhi_xing)
  503.         {
  504.                 switch(ml)
  505.                 {
  506.                         case 18:
  507.                                 qianjin(); //前进
  508.                         break;
  509.                         case 19:
  510.                                 houtui();  //后退
  511.                         break;
  512.                         case 20:
  513.                                 zuozhuan();//左转
  514.                         break;
  515.                         case 21:
  516.                                 youzhuan();//右转
  517.                         break;
  518.                         case 22:
  519.                                 tiaowu();//跳舞
  520.                         break;
  521.                         case 88:         //遥控按键抬起
  522.                         zhi_xing=0;
  523.                         break;
  524.                 }
  525.         }else fu_wei();
  526. }

  528. void main()
  529. {
  530.         uchar k=0,chang=0,i=0,pian_yi=0;
  531.         bit jj=0;
  532.         chushihua();//初始化
  533.         yanshi(40000);               
  534.         yanshi(40000);
  535.         yanshi(40000);
  536.         yanshi(40000);
  537.         yanshi(40000);               
  538.         yanshi(40000);
  539.         yanshi(40000);
  540.         yanshi(40000);
  541.         WIFI();
  542.         yanshi(40000);
  543.         jk=1;

  545.         ET0=1;
  546. //        while(1)
  547. //        {
  548. //                sheding[0]=0x18;        
  549. //        }
  550.         while(1)
  551.         {

  553.                 if(jieshou)
  554.                 {

  556.                         if(Hand("+IPD"))
  557.                         {
  558.                                 k=(uchar)strstr(shuju,"+IPD");
  559.                                 if(shuju[10]==':')//+IPD,2,9:123456789  +IPD,2,12:123456789012
  560.                                 {
  561.                                         chang=to_uchar('0',shuju[7]);//取出数据长度
  562.                                         pian_yi=11;

  564.                                 }else if (shuju[9]==':')
  565.                                 {
  566.                                         chang=to_uchar(shuju[7],shuju[8]);
  567.                                         pian_yi=10;
  568.                                 }else if (shuju[8]==':')
  569.                                 {
  570.                                         pian_yi=9;
  571.                                 }
  572.                                 ml=to_uchar(shuju[pian_yi],shuju[pian_yi+1]);           //保存命令
  573.                                 if(ml<18)//命令小于18 是设定单个舵机角度值
  574.                                 {
  575.                                         sheding[ml]=to_uchar(shuju[pian_yi+2],shuju[pian_yi+3]);//把接收来的角度值赋给相应的舵机
  576.                                 }else
  577.                                 {
  578.                                    zhi_xing=1;                             //命令大于17 是遥控指令 置执行标志 执行相应的遥控动作
  579.                                 }
  580.                         }
  581.                         jieshou=0;
  582.                         len=0;
  583.                         qingkong();
  584.                 }
  585.                 zhixing();   //调用执行子程序

  587.         }
  588. }
复制代码

所有资料51hei提供下载:
4足仿生机器人.zip (167.91 KB, 下载次数: 14)



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

使用道具 举报

沙发
ID:1 发表于 2018-9-29 17:42 | 只看该作者
补全原理图或者详细说明一下电路连接即可获得100+黑币
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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