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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 电子技术分类讨论区 › 资料共享 › 四足爬坡机器人单片机程序
返回列表 发新帖
查看: 1874|回复: 2
打印 上一主题 下一主题
收起左侧

四足爬坡机器人单片机程序

[复制链接]
跳转到指定楼层
楼主
ID:481221 发表于 2019-2-26 21:14 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
  1. #include<reg60s2.h>//芯片头文件  寄存器已经修改
  2. #include<math.h>
  3. #include<delay.h>  //延时程序  通过示波器测试
  4. #define uchar unsigned char            
  5. #define uint  unsigned int
  6. sbit KG=P1^7;                 //开关的位置
  7. uchar position[8];//用于记录8个舵机的位置
  8. uchar pick_up[8];           //kouchu[8];各个io口轮流输出是屏蔽其它位
  9. uchar arr[8];               //提供排序空间 paixu_ncha[8]=0;中间过度用      
  10. uchar t0bit=0;                            //定时器0周期相同标志位
  11. uchar N;
  12. void first();
  13. void second();
  14. void three();
  15. //void four();
  16. //关于扫尾值的参数
  17. //uchar zsax=15; //14h,z 平面sa 修正参数                                   p da  z  xiao  
  18. //uchar psax=10; //15h,p 平面sa 修正参数交互2
  19. //uchar zsag=20; //16h,z 平面sa 过渡参数
  20. //uchar psag=20;//17h,p 平面sa 过渡参数
  21. /*************************************************************************************
  22. 函数名称：void low_level_500u
  23. 函数功能：PWM信号低电平时间子程序，控制舵机PWM信号的低电平时间决定舵机转动的速度  积分思想
  24. 输入    ：  time
  25. 输出    ：无
  26. *************************************************************************************/
  27. void low_level_500u(uint time)
  28. {
  29.   uint i;
  30.   for(i=0;i<time;i++)
  31.   {delay500us(1);}
  32. }
  33. /*************************************************************************************
  34. 函数名称：void t0_init
  35. 函数功能：t0定时器初始化，用于舵机2.5ms定时
  36. 输入    ：无
  37. 输出    ：无
  38. 备注    ：没有开启定时
  39. *************************************************************************************/
  40. void t0_init(void)           //定时器初始化
  41. {                                                                        
  42.   TMOD  = TMOD & 0xf0;        //初始化定时器1的计数方式为方式1     无用
  43.   TMOD  = TMOD | 0x01;

  45.   TH0=0xee;                                  //22.1184MHz,2.5Ms定时ee00
  46.   TL0=0x00;
  47.   ET0=1;                                                
  48.   EA=1;
  49.   t0bit=1;
  50. }
  51. /*************************************************************************************
  52. 函数名称：void low_level_t0
  53. 函数功能：同周期定时器0设置及启动程序，使每变化一个变化量的周期相同         给寄存器填值
  54. 输入    ：THTL
  55. 输出    ：无
  56. *************************************************************************************/
  57. void low_level_t0(uint THTL)   //定时器调用函数
  58. {
  59.   TH0=THTL>>8;                          //22.1184MHz,2.5Ms定时ee00
  60.   TL0=THTL;
  61.   t0bit=0;
  62.   TR0=1;
  63. }
  64. /*************************************************************************************
  65. 函数名称：void T0_Interrupt(void) interrupt 1
  66. 函数功能：定时器t0中断服务函数函数        中断一次填一次值 标记一次一个2.5ms到了
  67. 输入    ：
  68. 输出    ：无
  69. *************************************************************************************/
  70. void T0_Interrupt(void) interrupt 1                //定时器中断函数   中断一次填一次值 标记一次一个2.5ms到了
  71. {  
  72.    TH0=0xee;                     //22.1184MHz,2.5Ms定时ee00
  73.    TL0=0x00;
  74.    t0bit=1;
  75. }
  76. /*************************************************************************************
  77. 函数名称：init_cpu
  78. 函数功能：单片机初始化程序
  79. 输入    ：无
  80. 输出    ：无
  81. *************************************************************************************/
  82. void  init_cpu(void)
  83. {                                                                                          
  84.         t0_init();                                                //定时器0初始化
  85.         delay500us(10);
  86. }

  88. /*************************************************************************************
  89. 函数名称：array()
  90. 函数功能：排序子程序，将各个口的8位根据时间的长短排序 提供arr[i]=arr[i]- arr[i+1]相邻差值
  91. 输入    ：无
  92. 输出    ：无
  93. *************************************************************************************/
  94. void array()
  95. {
  96.         uchar i=0,j=0,x=0;

  98.         pick_up[0]=0xFE;
  99.     pick_up[1]=0xFD;
  100.     pick_up[2]=0xFB;
  101.     pick_up[3]=0xF7;
  102.     pick_up[4]=0xEF;
  103.     pick_up[5]=0xDF;
  104.     pick_up[6]=0xBF;
  105.     pick_up[7]=0x7F;        //赋值

  107.         //冒泡排序
  108.         for(i=0;i<=7;i++)
  109.         {    for(j=i+1;j<=8;j++)
  110.          {
  111.                          if(arr[i]<arr[j])//交换数据
  112.                         {
  113.                                 x=arr[j];
  114.                                 arr[j]=arr[i];
  115.                                 arr[i]=x;
  116.                                           
  117.                                 x=pick_up[j];
  118.                                 pick_up[j]=pick_up[i];
  119.                 pick_up[i]=x;  
  120.              }
  121.          }
  122.         }        
  123.         for(i=0;i<7;i++)
  124.     {
  125.                 arr[i]= arr[i]- arr[i+1];
  126.     }                 
  127. }
  128. /*************************************************************************************
  129. 函数名称：void PWM_8()
  130. 函数功能：8路舵机输出子程序，实现8路舵机的PWM信号在最短的时间内输出
  131. 输入    ：position[i]
  132. 输出    ：无
  133. 备注    ：P0口
  134. *************************************************************************************/
  135. void PWM_8()
  136. {
  137.         uchar i=0,j;

  139.         for(i=0;i<8;i++)          //取P0口舵机对应的值
  140.         {arr[i]=position[i];}
  141.     array();                 //排序计算   
  142.         low_level_t0(0xee00);          //开启定时器并赋初始值,   22.1184MHz,2.5Ms定时ee00                                                      
  143.     P0=0xff;                  //使口P0全部拉高
  144.     delay500us(1);            //调用延时500us函数
  145.     for(i=0;i<8;i++)          //P0口8路同时输出
  146.     {      
  147.                 for(j=0;j<arr[7-i];j++)          //此时arr为（安位置大小）相邻舵机位置相差值
  148.                 {delay8us(1);}
  149.         P0=P0&pick_up[7-i];                  //此时pick_up为 代表的是那一位为0 逻辑与后拉低
  150.     }
  151.     while(t0bit==0);                             //等待2.5ms应该说是一个周期的到来  可自定义               
  152.         TR0=0;                                                    //关闭定时器0
  153. }
  154. /*************************************************************************************
  155. 函数名称：initial_position();
  156. 函数功能：初始位置子程序，根据各个舵机的不同位置设置初始位置
  157. 输入    ：无
  158. 输出    ：无
  159. *************************************************************************************/
  160. void initial_position(void)                 
  161. {
  162.         uint i,j,x=0;
  163.         for(i=0;i<30;i++)
  164.         {        x++;

  166. /////初始                                 

  168. //        position[0]=143;          //-后
  169. //        position[1]=92;          //-后
  170. //        position[2]=126;          //-前
  171. //        position[3]=131;      // +后
  172. //        position[4]=128;      //+前
  173. //        position[5]=136;          // -后
  174. //        position[6]=127;    //+后                                                                       
  175. //        position[7]=172;   // -前
  176.         
  177.         
  178.         position[0]=145;          //-后        
  179.         position[1]=100;          //-后
  180.         position[2]=88;          //-前
  181.         position[3]=100;      // +后                     
  182.         position[4]=96;      //+前
  183.         position[5]=169;          // -后
  184.         position[6]=167;    //+后                                                                       
  185.         position[7]=137;   // -前         



  189.                 PWM_8();
  190.                 if(x<10)
  191.         {j=20;j--;
  192.                 low_level_500u(j);
  193.                 }
  194.                 else
  195.         {        j=10;
  196.                     j++;
  197.                    low_level_500u(j);
  198.         }                                       
  199.         }
  200.                }

  202. /*************************************************************************************
  203. 函数名称：main
  204. 函数功能：入口函数
  205. 输入    ：无
  206. 输出    ：无
  207. *************************************************************************************/
  208. void main(void)
  209. {   
  210.     SP=0x70;     //堆栈指针初始化
  211.         P0M1 = 0x00;//P0 as Digital OUTPUT
  212.         P0M0 = 0x00;   
  213.            
  214.         init_cpu();//初始化cpu  设置定时器

  216.      delay500us(10);
  217.      P0=0xff;
  218.          delay500ms(1);
  219.          initial_position();//初始位置
  220.          delay500ms(1);        
  221.          
  222.                  while(KG)   
  223.         {
  224.                 if(!KG)
  225.                 delay500us(1);            //调用延时500us函数
  226.                 if(!KG)
  227.                 break;
  228.         }                                                                  


  231.                 while(1)
  232.         {
  233.                                 first();
  234. //                        second();        
  235. //                        three();
  236. //                                four();        
  237.                         }   
  238.             while(1);




  243. }









  253. //前进****************************************************************************************************************
  254. //---------------------------------------------  
  255.    void first ()
  256.   {


  259. uint i=0;
  260.                 for(i=0;i<1;i++)
  261.           {

  263.         position[0]=145;          //-后        
  264.         position[1]=95;          //-后
  265.         position[2]=88;          //-前
  266.         position[3]=100;      // +后                     
  267.         position[4]=96;      //+前
  268.         position[5]=169;          // -后
  269.         position[6]=167;    //+后                                                                       
  270.         position[7]=137;   // -前

  272.          PWM_8();
  273.         delay10ms(50);

  275.         }                                                                                                                                                               



  279.                 for(i=0;i<1;i++)
  280.           {

  282.         position[0]=90;          //-后        
  283.         position[1]=95;          //-后
  284.         position[2]=88;          //-前
  285.         position[3]=100;      // +后                     
  286.         position[4]=96;      //+前
  287.         position[5]=169;          // -后
  288.         position[6]=167;    //+后                                                                       
  289.         position[7]=137;   // -前

  291.          PWM_8();
  292.         delay1s(2);

  294.         }

  296.                 for(i=0;i<1;i++)
  297.           {

  299.         position[0]=145;          //-后        
  300.         position[1]=95;          //-后
  301.         position[2]=88;          //-前
  302.         position[3]=100;      // +后                     
  303.         position[4]=96;      //+前
  304.         position[5]=169;          // -后
  305.         position[6]=167;    //+后                                                                       
  306.         position[7]=137;   // -前

  308.          PWM_8();
  309.         delay1s(1);

  311.         }

  313.                 for(i=0;i<1;i++)
  314.           {

  316.         position[0]=145;          //-后        
  317.         position[1]=100;          //-后
  318.         position[2]=88;          //-前
  319.         position[3]=100;      // +后                     
  320.         position[4]=96;      //+前
  321.         position[5]=169;          // -后
  322.         position[6]=167;    //+后                                                                       
  323.         position[7]=137;   // -前

  325.          PWM_8();
  326.         delay1s(1);

  328.         }

  330.                
  331.                                  
  332.         
  333.         
  334.         }                  
  335. //*************************************************************





  341. //----------------------------------------------------------------------------------------------------

  343. //前进****************************************************************************************************************
  344. //
  345. //
  346. //
  347. ////向左****************************************************************************************************************
  348. ////---------------------------------------------  
  349. //   void first ()
  350. //  {
  351. //
  352. //
  353. // uint i=0;
  354. //                for(i=0;i<1;i++)
  355. //          {
  356. //
  357. //        position[0]=106;          //-后        
  358. //        position[1]=67;          //-后
  359. //        position[2]=108;          //-前
  360. //        position[3]=80;      // +后                     
  361. //        position[4]=76;      //+前
  362. //        position[5]=169;          // -后
  363. //        position[6]=167;    //+后                                                                       
  364. //        position[7]=137;   // -前
  365. //
  366. //         PWM_8();
  367. //        delay10ms(50);
  368. //        }                                                                                                                                                               
  369. //
  370. ////*****************************************************
  371. //    for (i=0;i<40;i++)
  372. //        {
  373. //        position[1]+=1;          //-后
  374. //                        if (i>10&&i<38)
  375. //        {
  376. //        position[1]-=1;      //+前
  377. //        }
  378. //
  379. //        position[2]+=1;          //-前
  380. //                        if (i>20)
  381. //        {
  382. //        position[2]-=1;      //+前
  383. //        }            
  384. //        position[3]+=1;      // +后
  385. //                                if (i>20)
  386. //        {
  387. //        position[3]-=1;      //+前
  388. //        }                     
  389. //        position[4]+=1;      //+前
  390. //                if (i>10&&i<38)
  391. //        {
  392. //        position[4]-=1;      //+前
  393. //        }               
  394. //                 PWM_8();                          
  395. //        delay1ms(5);                          
  396. //        
  397. //        }
  398. //
  399. ////**************************************************************************
  400. //
  401. //
  402. //        
  403. //                        for (i=0;i<1;i++)
  404. //                {
  405. //        position[0]=108;          //-后
  406. //        position[1]=84;          //-后
  407. //        position[2]=126;          //-前
  408. //        position[3]=131;      // +后
  409. //        position[4]=125;      //+前
  410. //        position[5]=180;          // -后
  411. //        position[6]=165;    //+后
  412. //        position[7]=137;   // -前
  413. //                        
  414. //                        PWM_8();
  415. //                 delay10ms(5);
  416. //                }
  417. //
  418. //
  419. //                        for (i=0;i<1;i++)
  420. //                {
  421. //        position[0]=108;          //-后
  422. //        position[1]=84;          //-后
  423. //        position[2]=126;          //-前
  424. //        position[3]=131;      // +后
  425. //        position[4]=125;      //+前
  426. //        position[5]=235;          // -后
  427. //        position[6]=165;    //+后
  428. //        position[7]=25;   // -前
  429. //                        
  430. //                        PWM_8();
  431. //                 delay10ms(10);
  432. //                }
  433. //
  434. //                for (i=0;i<1;i++)
  435. //                {
  436. //
  437. //        position[0]=155;          //-后
  438. //        position[1]=84;          //-后
  439. //        position[2]=126;          //-前
  440. //        position[3]=131;      // +后
  441. //        position[4]=125;      //+前
  442. //        position[5]=235;          // -后
  443. //        position[6]=90;    //+后
  444. //        position[7]=25;   // -前               
  445. //                        PWM_8();
  446. //                 delay10ms(10);
  447. //                }
  448. //
  449. //                for (i=0;i<1;i++)
  450. //                {
  451. //
  452. //        position[0]=155;          //-后
  453. //        position[1]=84;          //-后
  454. //        position[2]=126;          //-前
  455. //        position[3]=131;      // +后
  456. //        position[4]=125;      //+前
  457. //        position[5]=235;          // -后
  458. //        position[6]=90;    //+后
  459. //        position[7]=60;   // -前               
  460. //                        PWM_8();
  461. //                 delay10ms(10);
  462. //                }
  463. //
  464. // //**************************************************************
  465. //    for (i=0;i<40;i++)
  466. //        {
  467. //        position[0]+=1;          //-后
  468. //                        if (i>27)
  469. //        {
  470. //        position[0]-=1;      //+前
  471. //        }
  472. //        position[1]+=1;          //-后
  473. //                        if (i>15&&i<32)
  474. //        {
  475. //        position[1]-=1;      //+前
  476. //        }
  477. //        position[2]+=1;          //-前
  478. //        position[3]+=1;      // +后
  479. //        position[4]+=1;      //+前
  480. //        position[5]-=4;          // -后
  481. //                        if (i>35)
  482. //        {
  483. //        position[5]+=4;      //+前           
  484. //        }
  485. //        position[6]-=1;    //+后
  486. //                        if (i>3)
  487. //        {
  488. //        position[6]+=1;      //+前
  489. //        }
  490. //        position[7]+=4;   // -前
  491. //                        if (i>39)
  492. //        {
  493. //        position[7]-=4;      //+前
  494. //        }        
  495. //                 PWM_8();
  496. //        delay1ms(5);
  497. //        
  498. //        }
  499. //
  500. ////**************************************************************
  501. //
  502. // }        
  503. //
  504. //
  505. //
  506. //
  507. //
  508. //
  509. //
  510. //        
  511. //        
  512. //
  513. //
  514. //
  515. // void  second ()
  516. // {
  517. //           uint i=0;
  518. //                for(i=0;i<1;i++)
  519. //          {
  520. //
  521. //        position[0]=163;          //-后
  522. //        position[1]=124;          //-后
  523. //        position[2]=166;          //-前
  524. //        position[3]=171;      // +后
  525. //        position[4]=165;      //+前
  526. //        position[5]=110;          // -后
  527. //        position[6]=107;    //+后                                                                       
  528. //        position[7]=194;   // -前        
  529. //            PWM_8();
  530. //           delay10ms(50);
  531. //           }
  532. //
  533. ////**************************************************************
  534. //    for (i=0;i<40;i++)
  535. //        {
  536. //        position[0]-=1;          //-后
  537. //                                        if (i>20)
  538. //        {
  539. //        position[0]-=1;      //+前
  540. //        }
  541. //        position[5]+=1;          //-前
  542. //                                        if (i>5)
  543. //        {
  544. //        position[5]-=1;      //+前
  545. //        }   
  546. //        position[6]+=1;      // +后
  547. //                                        if (i>20)
  548. //        {
  549. //        position[6]-=1;      //+前
  550. //        }                     
  551. //        position[7]-=1;      //+前
  552. //        if (i>5&&i<40)
  553. //        {
  554. //        position[7]+=1;      //+前
  555. //        }        
  556. //                 PWM_8();
  557. //        delay1ms(5);
  558. //        
  559. //        }
  560. //
  561. ////**************************************************************
  562. //                for (i=0;i<1;i++)
  563. //                {
  564. //        position[0]=143;          //-后
  565. //        position[1]=139;          //-后
  566. //        position[2]=174;          //-前
  567. //        position[3]=177;      // +后
  568. //        position[4]=171;      //+前
  569. //        position[5]=132;          // -后
  570. //        position[6]=127;    //+后
  571. //        position[7]=176;   // -前               
  572. //                        PWM_8();
  573. //                 delay10ms(5);
  574. //                }
  575. //
  576. //                for (i=0;i<1;i++)
  577. //                {
  578. //        position[0]=143;          //-后
  579. //        position[1]=240;          //-后
  580. //        position[2]=174;          //-前
  581. //        position[3]=177;      // +后
  582. //        position[4]=235;      //+前
  583. //        position[5]=132;          // -后
  584. //        position[6]=127;    //+后
  585. //        position[7]=176;   // -前               
  586. //                        PWM_8();
  587. //                 delay10ms(10);
  588. //                }
  589. //
  590. //                for (i=0;i<1;i++)
  591. //                {
  592. //        position[0]=143;          //-后
  593. //        position[1]=240;          //-后
  594. //        position[2]=114;          //-前
  595. //        position[3]=120;      // +后
  596. //        position[4]=235;      //+前
  597. //        position[5]=132;          // -后
  598. //        position[6]=127;    //+后
  599. //        position[7]=176;   // -前
  600. //        PWM_8();
  601. //   delay10ms(10);
  602. //        }
  603. //
  604. //
  605. //                for (i=0;i<1;i++)
  606. //                {
  607. //        position[0]=143;          //-后
  608. //        position[1]=200;          //-后
  609. //        position[2]=114;          //-前
  610. //        position[3]=120;      // +后
  611. //        position[4]=235;      //+前
  612. //        position[5]=132;          // -后
  613. //        position[6]=127;    //+后
  614. //        position[7]=176;   // -前
  615. //        PWM_8();
  616. //   delay10ms(10);
  617. //        }
  618. //
  619. //
  620. //
  621. ////******************************************************
  622. //    for (i=0;i<40;i++)
  623. //        {
  624. //        position[0]-=1;          //-后
  625. //                if (i>36)
  626. //        {
  627. //        position[0]+=1;      //+前
  628. //        }
  629. //        position[1]-=3;          //-后
  630. //                if (i>37)
  631. //        {
  632. //        position[1]+=3;      //+前
  633. //        }
  634. //        position[2]-=1;          //-前
  635. //                if (i>27)
  636. //        {
  637. //        position[2]+=1;      //+前
  638. //        }
  639. //        position[3]-=1;      // +后
  640. //                if (i>25)
  641. //        {
  642. //        position[3]+=1;      //+前
  643. //        }
  644. //        position[4]-=4;      //+前
  645. //                if (i>35)
  646. //        {
  647. //        position[4]+=4;      //+前
  648. //        }
  649. //        position[5]+=1;          // -后
  650. //                if (i>37)
  651. //        {
  652. //        position[5]-=1;      //+前
  653. //        }
  654. //        position[6]+=1;    //+后
  655. //        position[7]-=2;   // -前
  656. //                        if (i>15&&i<32)
  657. //        {
  658. //        position[7]+=2;      //+前
  659. //        }        
  660. //                 PWM_8();
  661. //        delay1ms(5);
  662. //        
  663. //        }                  
  664. ////*************************************************************
  665. //
  666. //
  667. //
  668. // }
  669. //

  671. //----------------------------------------------------------------------------------------------------
  672. ////向左****************************************************************************************************************


  675. ////向右****************************************************************************************************************
  676. ////---------------------------------------------  
  677. //   void first ()
  678. //  {
  679. //
  680. //
  681. // uint i=0;                                                                                                                                                                                                                                                           
  682. //                for(i=0;i<1;i++)
  683. //          {
  684. //
  685. //        position[0]=108;          //-后        
  686. //        position[1]=70;          //-后
  687. //        position[2]=66;          //-前
  688. //        position[3]=92;      // +后                     
  689. //        position[4]=92;      //+前
  690. //        position[5]=167;          // -后
  691. //        position[6]=165;    //+后                                                                       
  692. //        position[7]=97;   // -前
  693. //
  694. //         PWM_8();
  695. //        delay10ms(50);
  696. //        }                                                                                                                                                               
  697. //
  698. ////*****************************************************
  699. //    for (i=0;i<41;i++)
  700. //        {
  701. //        position[1]+=1;          //-后
  702. //        position[2]+=1;          //-前   
  703. //        position[3]+=1;      // +后                     
  704. //        position[4]+=1;      //+前        
  705. //                 PWM_8();
  706. //        delay1ms(1);
  707. //        
  708. //        }
  709. //
  710. ////**************************************************************************
  711. //
  712. //
  713. //        
  714. //                        for (i=0;i<1;i++)
  715. //                {
  716. //        position[0]=108;          //-后
  717. //        position[1]=132;          //-后
  718. //        position[2]=131;          //-前
  719. //        position[3]=139;      // +后
  720. //        position[4]=137;      //+前
  721. //        position[5]=167;          // -后
  722. //        position[6]=165;    //+后
  723. //        position[7]=97;   // -前
  724. //                        
  725. //                        PWM_8();
  726. //                 delay10ms(20);
  727. //                }
  728. //
  729. //
  730. //                        for (i=0;i<1;i++)
  731. //                {
  732. //        position[0]=108;          //-后
  733. //        position[1]=132;          //-后
  734. //        position[2]=131;          //-前
  735. //        position[3]=139;      // +后
  736. //        position[4]=137;      //+前
  737. //        position[5]=204;          // -后
  738. //        position[6]=165;    //+后
  739. //        position[7]=20;   // -前
  740. //                        
  741. //                        PWM_8();
  742. //                 delay10ms(20);
  743. //                }
  744. //
  745. //                for (i=0;i<1;i++)
  746. //                {
  747. //
  748. //        position[0]=150;          //-后
  749. //        position[1]=132;          //-后
  750. //        position[2]=129;          //-前
  751. //        position[3]=139;      // +后
  752. //        position[4]=137;      //+前
  753. //        position[5]=204;          // -后
  754. //        position[6]=90;    //+后
  755. //        position[7]=20;   // -前               
  756. //                        PWM_8();
  757. //                 delay10ms(20);
  758. //                }
  759. //
  760. //
  761. //
  762. //
  763. //
  764. // }        
  765. //
  766. //
  767. //
  768. //
  769. //
  770. //
  771. //
  772. //        
  773. //        
  774. //
  775. //
  776. //
  777. // void  second ()
  778. // {
  779. //           uint i=0;
  780. //                for(i=0;i<1;i++)
  781. //          {
  782. //
  783. //        position[0]=178;          //-后
  784. //        position[1]=179;          //-后
  785. //        position[2]=174;          //-前
  786. //        position[3]=177;      // +后
  787. //        position[4]=171;      //+前
  788. //        position[5]=66;          // -后
  789. //        position[6]=63;    //+后                                                                       
  790. //        position[7]=169;   // -前        
  791. //            PWM_8();
  792. //           delay10ms(50);
  793. //           }
  794. //
  795. ////**************************************************************
  796. //    for (i=0;i<41;i++)                                                                                                                                                                                                                                 
  797. //        {
  798. //        position[0]-=1;          //-后
  799. //        position[5]+=1;          //-前   
  800. //        position[6]+=1;      // +后                     
  801. //        position[7]-=1;      //+前
  802. //        if (i>36)
  803. //        {
  804. //        position[7]+=1;      //+前
  805. //        }        
  806. //                 PWM_8();
  807. //        delay1ms(1);
  808. //        
  809. //        }
  810. //
  811. ////**************************************************************
  812. //                for (i=0;i<1;i++)
  813. //                {
  814. //        position[0]=136;          //-后
  815. //        position[1]=179;          //-后
  816. //        position[2]=174;          //-前
  817. //        position[3]=177;      // +后
  818. //        position[4]=171;      //+前
  819. //        position[5]=130;          // -后
  820. //        position[6]=130;    //+后
  821. //        position[7]=132;   // -前               
  822. //                        PWM_8();
  823. //                 delay10ms(20);
  824. //                }
  825. //
  826. //                for (i=0;i<1;i++)
  827. //                {
  828. //        position[0]=136;          //-后
  829. //        position[1]=254;          //-后
  830. //        position[2]=174;          //-前
  831. //        position[3]=177;      // +后
  832. //        position[4]=202;      //+前
  833. //        position[5]=130;          // -后
  834. //        position[6]=130;    //+后
  835. //        position[7]=132;   // -前               
  836. //                        PWM_8();
  837. //                 delay10ms(20);
  838. //                }
  839. //
  840. //                for (i=0;i<1;i++)
  841. //                {
  842. //        position[0]=136;          //-后
  843. //        position[1]=254;          //-后
  844. //        position[2]=124;          //-前
  845. //        position[3]=120;      // +后
  846. //        position[4]=202;      //+前
  847. //        position[5]=130;          // -后
  848. //        position[6]=130;    //+后
  849. //        position[7]=132;   // -前
  850. //        PWM_8();
  851. //   delay10ms(20);
  852. //        }
  853. //
  854. //}                  
  855. //
  856. //
  857. //
  858. //
  859. //
  860. //////----------------------------------------------------------------------------------------------------
  861. //////向右****************************************************************************************************************
复制代码
分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏1 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:1 发表于 2019-2-27 02:39 | 只看该作者
本帖需要重新编辑补全电路原理图,源码,详细说明与图片即可获得100+黑币(帖子下方有编辑按钮)
回复

使用道具 举报

板凳
ID:199471 发表于 2019-7-10 08:38 | 只看该作者
好东西，有没有电路图或者机器人结构图片？
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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