单片机论坛

 找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 56|回复: 0
打印 上一主题 下一主题
收起左侧

四步进电机,自动,手动控制,数码管显示速度 单片机四轴机器人程序

[复制链接]
跳转到指定楼层
楼主
yangjiang1 发表于 2019-9-10 13:54 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
实物调试

游客,本帖隐藏的内容需要积分高于 1 才可浏览,您当前积分为 0


程序
  1. #include<reg52.h>
  2. #include<intrins.h>
  3. #define uchar unsigned char
  4. #define uint  unsigned int
  5. sbit SCL=P0^2;
  6. sbit SDA=P0^3;

  7.          //xainshi
  8. unsigned char z;        //运行的电机
  9. unsigned char x;        //正反
  10. unsigned char c;   //数字加

  11. uchar code FFW1[8]={0x10,0x30,0x20,0x60,0x40,0xc0,0x80,0x90};  //四相八拍正转编码 前四
  12. uchar code FFW[8]={0x01,0x03,0x02,0x06,0x04,0x0c,0x08,0x09};   //四相八拍正转编码 后四
  13. uchar code REV1[8]={0x90,0x80,0xc0,0x40,0x60,0x20,0x30,0x10};  ////四相八拍反转编码 前四
  14. uchar code REV[8]={0x09,0x08,0x0c,0x04,0x06,0x02,0x03,0x01};  ////四相八拍反转编码         后死
  15. sbit  BEEP = P0^7;       //蜂鸣器
  16. sbit  K1   = P0^4;                  //cwshi
  17. sbit  K111   = P1^0;                  //
  18. sbit  K112   = P1^1;                  //
  19. sbit  K121   = P1^2;                  //
  20. sbit  K122   = P1^3;                  //
  21. sbit  K131   = P1^4;                  //
  22. sbit  K132   = P1^5;                  //
  23. sbit  K141   = P1^6;                  //
  24. sbit  K142   = P1^7;                  //
  25. sbit  K166   = P0^5;         //全套动作

  26. unsigned char keyval;    //定义变量储存按键值
  27. unsigned char jianzhi;    //定义变量储存按键值
  28. unsigned char M1;
  29. unsigned char i1;


  30. unsigned char t,shi,ge,bai,dadt;
  31. unsigned char code xsbcdbuf[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77};
  32. /*************************************************************************

  33. ********************
  34. LCD WRITE 模式 连续写入数据
  35. *************************************************************************/  
  36. /*********************************************************

  37. *IIC_delay

  38. *******************************************************/

  39.   void led_delay(void)     
  40. {
  41.    unsigned char j;
  42.         for(j=0;j<200;j++)
  43.          {}
  44.   }

  45. void delay(uint t)
  46. {                           
  47.    uint k;
  48.    while(t--)
  49.    {
  50.      for(k=0; k<130; k++)
  51.      { }
  52.    }
  53. }


  54. //电机运转延时函数
  55. void delayB(uchar x)    //x*0.14MS
  56. {
  57.    uchar i;
  58.    while(x--)
  59.    {
  60.      for (i=0; i<13; i++)
  61.      { }
  62.    }
  63. }

  64. //dengmingqi
  65. void beep()
  66. {
  67.    uchar i;

  68.    for (i=0;i<100;i++)
  69.     {
  70.     // delayB(4);
  71.      BEEP=!BEEP;                 //BEEP取反
  72.     }
  73.      BEEP=1;                    //关闭蜂鸣器
  74. }


  75.   //一号主控电机
  76. //正转
  77. void  motor_ffw10()
  78. {
  79.    uchar i;
  80.   // uint  j;

  81.   // for (j=0; j<8; j++)         //转1*n圈


  82.       for (i=0; i<8; i++)       //一个周期转45度
  83.         {P2=FFW1[i];          //取数据
  84.           delay(1);            //调节转速
  85.                  c=i;
  86.   //      }
  87.     }
  88. }

  89. //反转
  90. void  motor_rev11()
  91. {

  92.      uchar i;
  93.          uint  j;
  94.          x=0;
  95.         z=1;
  96. //         for (j=0; j<8; j++)       //转1×n圈
  97.       {
  98.           //  if(K3==0)
  99.        //  {break;}               //退出此循环程序
  100.          
  101.         for (i=0; i<8; i++)     //一个周期转45度
  102.         {
  103.           P2 = REV1[i];          //取数据
  104.           delay(1);            //调节转速

  105.                                     c=i;

  106.         }
  107.       }
  108. }




  109. //二号主控电机


  110. //电机正转动


  111. void  motor_ffw20()
  112. {

  113.    uchar i;
  114.    uint  j;
  115.     x=1;
  116.            z=2;
  117.   // for (j=0; j<8; j++)         //转1*n圈
  118.     {
  119.            // if(K3==0)                           
  120.         //{break;}                //退出此循环程序
  121.       for (i=0; i<8; i++)       //一个周期转45度
  122.         {
  123.           P2 = FFW[i];          //取数据
  124.           delay(1);            //调节转速
  125.                   c=i;
  126.         }
  127.     }
  128. }

  129. //反转
  130. void  motor_rev21()
  131. {

  132.      uchar i;
  133.          uint  j;
  134.             x=0;
  135.                    z=2;
  136.         // for (j=0; j<8; j++)       //转1×n圈
  137.       {
  138.             //if(K3==0)
  139.         // {break;}               //退出此循环程序
  140.                 c=8;
  141.         for (i=0; i<8; i++)     //一个周期转45度
  142.         {
  143.           P2 = REV[i];          //取数据
  144.           delay(1);            //调节转速
  145.                   c=i;
  146.         }
  147.       }
  148. }




  149. //三号主控电机


  150. //电机正转动


  151. void  motor_ffw30()
  152. {

  153.    uchar i;
  154.    uint  j;
  155.     x=1;
  156.            z=3;
  157.    //for (j=0; j<8; j++)         //转1*n圈


  158.       for (i=0; i<8; i++)       //一个周期转45度
  159.         {
  160.           P3=FFW1[i];          //取数据
  161.           delay(1);
  162.                   c=i;           //调节转速
  163.         }

  164. }
  165. //反转

  166. void  motor_rev31()
  167. {

  168.      uchar i;
  169.          uint  j;
  170.            x=0;
  171.             z=3;
  172.         // for (j=0; j<8; j++)       //转1×n圈
  173.      // {
  174.            // if(K3==0)
  175.         // {break;}
  176.                                //退出此循环程序
  177.                                            c=j;
  178.         for (i=0; i<8; i++)     //一个周期转45度
  179.         {
  180.           P3 = REV1[i];          //取数据
  181.           delay(1);            //调节转速
  182.                                                //调节转速


  183.         }
  184.     //  }
  185. }



  186. //四号主控电机
  187. //电机正转动

  188. void  motor_ffw40()
  189. {

  190.    uchar i;
  191.    uint  j;
  192.     x=1;
  193.          z=4;
  194.   // for (j=0; j<8; j++)         //转1*n圈
  195.     {
  196.           //  if(K3==0)                           
  197.      //  {break;}
  198.                         //退出此循环程序
  199.                                 
  200.       for (i=0; i<8; i++)       //一个周期转45度
  201.         {
  202.           P3 = FFW[i];          //取数据
  203.            c=i;
  204.                   delay(2);            //调节转速
  205.         }
  206.     }
  207. }

  208. //反转

  209. void  motor_rev41()
  210. {

  211.      uchar i;
  212.          uint  j;
  213.          
  214.          x=0;
  215.           z=4;
  216. //         for (j=0; j<8; j++)       //转1×n圈
  217.       {
  218.                           c=j;
  219.         for (i=0; i<8; i++)     //一个周期转45度
  220.         {
  221.           P3 = REV[i];          //取数据
  222.           delay(2);            //调节转速
  223.         }
  224.       }
  225. }










  226.   //一号主控电机
  227. //正转
  228. void  motor_ffws10()
  229. {
  230.    uchar i;
  231.   // uint  j;

  232.   // for (j=0; j<8; j++)         //转1*n圈


  233.       for (i=0; i<8; i++)       //一个周期转45度
  234.         {P2=FFW1[i];          //取数据
  235.           delay(1);            //调节转速
  236.                  c=i;
  237.   //      }
  238.     }
  239. }

  240. //反转
  241. void  motor_revs11()
  242. {

  243.      uchar i;
  244.          uint  j;
  245.          x=0;
  246.         z=1;
  247. //         for (j=0; j<8; j++)       //转1×n圈
  248.       {
  249.           //  if(K3==0)
  250.        //  {break;}               //退出此循环程序
  251.          
  252.         for (i=0; i<8; i++)     //一个周期转45度
  253.         {
  254.           P2 = REV1[i];          //取数据
  255.           delay(1);            //调节转速

  256.                                     c=i;

  257.         }
  258.       }
  259. }




  260. //二号主控电机


  261. //电机正转动


  262. void  motor_ffws20()
  263. {

  264.    uchar i;
  265.    uint  j;
  266.     x=1;
  267.            z=2;
  268.   // for (j=0; j<8; j++)         //转1*n圈
  269.     {
  270.            // if(K3==0)                           
  271.         //{break;}                //退出此循环程序
  272.       for (i=0; i<8; i++)       //一个周期转45度
  273.         {
  274.           P2 = FFW[i];          //取数据
  275.           delay(1);            //调节转速
  276.                   c=i;
  277.         }
  278.     }
  279. }

  280. //反转
  281. void  motor_revs21()
  282. {

  283.      uchar i;
  284.          uint  j;
  285.             x=0;
  286.                    z=2;
  287.         // for (j=0; j<8; j++)       //转1×n圈
  288.       {
  289.             //if(K3==0)
  290.         // {break;}               //退出此循环程序
  291.                 c=8;
  292.         for (i=0; i<8; i++)     //一个周期转45度
  293.         {
  294.           P2 = REV[i];          //取数据
  295.           delay(1);            //调节转速
  296.                   c=i;
  297.         }
  298.       }
  299. }




  300. //三号主控电机


  301. //电机正转动


  302. void  motor_ffws30()
  303. {

  304.    uchar i;
  305.    uint  j;
  306.     x=1;
  307.            z=3;
  308.    //for (j=0; j<8; j++)         //转1*n圈


  309.       for (i=0; i<8; i++)       //一个周期转45度
  310.         {
  311.           P3=FFW1[i];          //取数据
  312.           delay(1);
  313.                   c=i;           //调节转速
  314.         }

  315. }
  316. //反转

  317. void  motor_revs31()
  318. {

  319.      uchar i;
  320.          uint  j;
  321.            x=0;
  322.             z=3;
  323.         // for (j=0; j<8; j++)       //转1×n圈
  324.      // {
  325.            // if(K3==0)
  326.         // {break;}
  327.                                //退出此循环程序
  328.                                            c=j;
  329.         for (i=0; i<8; i++)     //一个周期转45度
  330.         {
  331.           P3 = REV1[i];          //取数据
  332.           delay(1);            //调节转速
  333.                                                //调节转速


  334.         }
  335.     //  }
  336. }



  337. //四号主控电机
  338. //电机正转动

  339. void  motor_ffws40()
  340. {

  341.    uchar i;
  342.    uint  j;
  343.     x=1;
  344.          z=4;
  345.   // for (j=0; j<8; j++)         //转1*n圈
  346.     {
  347.           //  if(K3==0)                           
  348.      //  {break;}
  349.                         //退出此循环程序
  350.                                 
  351.       for (i=0; i<8; i++)       //一个周期转45度
  352.         {
  353.           P3 = FFW[i];          //取数据
  354.            c=i;
  355.                   delay(2);            //调节转速
  356.         }
  357.     }
  358. }

  359. //反转

  360. void  motor_revs41()
  361. {

  362.      uchar i;
  363.          uint  j;
  364.          
  365.          x=0;
  366.           z=4;
  367. //         for (j=0; j<8; j++)       //转1×n圈
  368.       {
  369.                           c=j;
  370.         for (i=0; i<8; i++)     //一个周期转45度
  371.         {
  372.           P3 = REV[i];          //取数据
  373.           delay(2);            //调节转速
  374.         }
  375.       }
  376. }




























  377. //一号主控电机
  378. //正转
  379. void  motor_ffwA10()
  380. {
  381.    uchar i;
  382.    uint  j;
  383.    x=1;
  384.     z=1;
  385.    for (j=0; j<50; j++)         //转1*n圈
  386.     {

  387.       for (i=0; i<8; i++)       //一个周期转45度
  388.         {
  389.           P2 = FFW1[i];          //取数据
  390.           delay(50);            //调节转速
  391.                   c=i;
  392.                     z=1;
  393.         }
  394.     }
  395. }

  396. //反转
  397. void  motor_revA11()
  398. {

  399.      uchar i;
  400.          uint  j;
  401.          x=0;
  402.          z=1;
  403. for (j=0; j<50; j++)       //转1×n圈
  404.       {
  405.           //  if(K3==0)
  406.        //  {break;}               //退出此循环程序
  407.          
  408.         for (i=0; i<8; i++)     //一个周期转45度
  409.         {
  410.           P2 = REV1[i];          //取数据
  411.           delay(50);            //调节转速
  412.                             z=1;
  413.                                     c=i;

  414.         }
  415.       }
  416. }




  417. //二号主控电机


  418. //电机正转动


  419. void  motor_ffwA20()
  420. {

  421.    uchar i;
  422.    uint  j;
  423.     x=1;
  424.            z=2;
  425.   for (j=0; j<20; j++)         //转1*n圈
  426.     {
  427.            // if(K3==0)                           
  428.         //{break;}                //退出此循环程序
  429.       for (i=0; i<8; i++)       //一个周期转45度
  430.         {
  431.           P2 = FFW[i];          //取数据
  432.           delay(50);            //调节转速
  433.                   c=i;
  434.                   z=2;
  435.         }
  436.     }
  437. }

  438. //反转
  439. void  motor_revA21()
  440. {

  441.      uchar i;
  442.          uint  j;
  443.             x=0;
  444.                    z=2;
  445.         for (j=0; j<20; j++)       //转1×n圈
  446.       {
  447.             //if(K3==0)
  448.         // {break;}               //退出此循环程序
  449.                 c=8;
  450.         for (i=0; i<8; i++)     //一个周期转45度
  451.         {
  452.           P2 = REV[i];          //取数据
  453.           delay(50);            //调节转速
  454.                   c=i;
  455.                   z=2;
  456.         }
  457.       }
  458. }




  459. //三号主控电机


  460. //电机正转动


  461. void  motor_ffwA30()
  462. {

  463.    uchar i;
  464.    uint  j;
  465.        x=1;
  466.            z=3;
  467.    for (j=0; j<50; j++)         //转1*n圈

  468.                   {

  469.       for (i=0; i<8; i++)       //一个周期转45度
  470.         {
  471.           P3=FFW1[i];          //取数据
  472.           delay(1);
  473.                   c=i;           //调节转速
  474.                    z=3;
  475.         }
  476.     }
  477. }
  478. //反转

  479. void  motor_revA31()
  480. {

  481.      uchar i;
  482.          uint  j;
  483.            x=0;
  484.             z=3;
  485.         for (j=0; j<50; j++)       //转1×n圈
  486.       {
  487.            // if(K3==0)
  488.         // {break;}
  489.                                //退出此循环程序
  490.                                            c=j;
  491.         for (i=0; i<8; i++)     //一个周期转45度
  492.         {
  493.           P3 = REV1[i];          //取数据
  494.           delay(1);            //调节转速
  495.                                                //调节转速
  496.                   z=3;


  497.         }
  498.       }
  499. }



  500. //四号主控电机
  501. //电机正转动

  502. void  motor_ffwA40()
  503. {

  504.    uchar i;
  505.    uint  j;
  506.     x=1;
  507.          z=4;
  508.    for (j=0; j<30; j++)         //转1*n圈
  509.     {
  510.           //  if(K3==0)                           
  511.      //  {break;}
  512.                         //退出此循环程序
  513.                                 
  514.       for (i=0; i<8; i++)       //一个周期转45度
  515.         {
  516.           P3 = FFW[i];          //取数据
  517.            c=i;
  518.                   delay(1);            //调节转速
  519.                            z=4;
  520.         }
  521.     }
  522. }

  523. //反转

  524. void  motor_revA41()
  525. {

  526.     uchar i;
  527.          uint  j;
  528.          
  529.          x=0;
  530.           z=4;
  531.          for (j=0; j<30; j++)       //转1×n圈
  532.       {
  533.                           c=j;
  534.         for (i=0; i<8; i++)     //一个周期转45度
  535.         {
  536.           P3 = REV[i];          //取数据
  537.           delay(2);
  538.                   z=4;   
  539.                            
  540.         }
  541.       }
  542. }




  543. void  motor_ffw1A40()
  544. {

  545.    uchar i;
  546.    uint  j;
  547.     x=1;
  548.          z=4;
  549.    for (j=0; j<30; j++)         //转1*n圈
  550.     {
  551.           //  if(K3==0)                           
  552.      //  {break;}
  553.                         //退出此循环程序
  554.                                 
  555.       for (i=0; i<8; i++)       //一个周期转45度
  556.         {
  557.           P3 = FFW[i];          //取数据
  558.            c=i;
  559.                   delay(1);            //调节转速
  560.                            z=4;
  561.         }
  562.     }
  563. }

  564. //反转

  565. void  motor_rev1A41()
  566. {

  567.     uchar i;
  568.          uint  j;
  569.          
  570.          x=0;
  571.           z=4;
  572.          for (j=0; j<30; j++)       //转1×n圈
  573.       {
  574.                           c=j;
  575.         for (i=0; i<8; i++)     //一个周期转45度
  576.         {
  577.           P3 = REV[i];          //取数据
  578.           delay(2);
  579.                   z=4;   
  580.                            
  581.         }
  582.       }
  583. }


  584. /*

  585. void Init_Timer0(void)
  586. {
  587. TMOD |= 0x01;          //使用模式1,16位定时器,使用"|"符号可以在使用多个定时器时不受影响                     
  588. TH0=0x00;              //给定初值,这里使用定时器最大值从0开始计数一直到65535溢出
  589. TL0=0x00;
  590. EA=1;            //总中断打开
  591. ET0=1;           //定时器中断打开
  592. TR0=1;           //定时器开关打开
  593. }

  594. */







  595. void init()
  596. {
  597.     TMOD=0X01;
  598.     TH0=(65535-50000)/256;
  599.     TL0=(65535-50000)%256;
  600.     ET0=1;
  601.     EA=1;
  602.     TR0=1;
  603. }

  604. void IIC_delay(void)
  605. {
  606.     unsigned char i;
  607.     for(i=0;i<20;i++) _nop_();
  608. }

  609. /*********************************************************
  610. *
  611. 启动IIC
  612. *********************************************************/

  613. void start_IIC(void)

  614. {
  615.     SCL=1; //给芯片发送开始信号
  616.     SDA=1;
  617.     IIC_delay();
  618.     SDA=0;
  619.     IIC_delay();
  620.     SCL=0; //开始信号传送完
  621.     IIC_delay();
  622. }

  623. /*******************************************************
  624. *
  625. 停止IIC
  626. *******************************************************/
  627. void stop_IIC(void)
  628. {
  629.     SCL=0;
  630.     IIC_delay();
  631.     SDA=0;
  632.     IIC_delay();
  633.     SCL=1;
  634.     IIC_delay();
  635.     SDA=1;
  636. }

  637. void ack_IIC()
  638. {
  639.     SCL=0;
  640.     _nop_();_nop_();_nop_();
  641.     while(SDA);
  642.     SCL=1;
  643.     _nop_();_nop_();_nop_();
  644.     SCL=0;
  645. }

  646. /*******************************************************
  647. *
  648. 写一个字节数据
  649. *******************************************************/

  650. void WriteByte(unsigned char WriteData)
  651. {
  652.     unsigned char i;
  653.     for(i=0;i<8;i++)//开始传送8位数据,每循环一次传送一位数据
  654.     {
  655.         SCL=0;
  656.         IIC_delay();
  657.         WriteData=WriteData>>1;
  658.         SDA=CY;
  659.         IIC_delay();
  660.         SCL=1;
  661.         IIC_delay();
  662.     }
  663. //8位数据传送完
  664.     ack_IIC(); //判断芯片发过来的ACK应答信号
  665. }
  666. /*******************************************************

  667. /************************************************
  668. 写一字节数据到LEDSROM
  669. **************************************************/

  670. void write_LEDSROM(unsigned char addr,unsigned char WData)
  671. {
  672.     start_IIC(); //调用开始信号
  673.     WriteByte(addr); //写起始地址命令(0C0H),地址00H单元。
  674.     WriteByte(WData);//给显示寄存器写显示数据,值可根据实参改变
  675.     stop_IIC(); //调用结束信号,一个字节命令发送完毕,可以发送下一个命令
  676. }
  677. /************************************************
  678. /************************************************
  679. *
  680. 分开写数据到LED
  681. **************************************************/
  682. void xsled(void)
  683. {
  684.     SDA=1;
  685.     SCL=1;
  686.     start_IIC(); //调用开始信号
  687.     WriteByte(0x44);//写命令40H(数据设置)
  688.     stop_IIC(); //调用结束信号,一个字节命令发送完毕,可以发送下一个命令
  689.     write_LEDSROM(0xC0,0x00); //第一个数码管
  690.     write_LEDSROM(0xC1,xsbcdbuf[bai]);  //第二个数码管
  691.     write_LEDSROM(0xC2,xsbcdbuf[shi]); //第三个数码管
  692.     write_LEDSROM(0xC3,xsbcdbuf[ge]);//第四个数码管
  693.     IIC_delay();
  694.     start_IIC(); //调用开始信号
  695.     WriteByte(0x8a); //送开屏命令,(8BH),亮度可以根据低三位调节。//显示亮度
  696.     stop_IIC(); //调用结束信号,一个字节命令发送完毕,可以发送下一个命令
  697. }

  698. void jisuan()
  699. {     
  700. bai=z  ;
  701. shi=x ;
  702. ge=c;
  703.     //bai=dadt/100;
  704.    // shi=dadt/10%10;
  705.    // ge=dadt%10;
  706. }










  707. main()
  708. {
  709.           P0=0xff;
  710.           M1=1;//chuzhi

  711. // unsigned char z;

  712.           z=1;
  713.     //P1=0xff;
  714.     init();




  715.      while(1)
  716.     {




  717. //motor_revA11();   
  718. //motor_revA10();




  719.        // jisuan();
  720.      //   xsled();
  721. jisuan();
  722. xsled();

  723.     K166=0;
  724.         
  725.         
  726.         P2=0x00;
  727.         
  728.         P3=0x00;
  729.         
  730.         P1=0x00;




  731.         if(t==1000)
  732.         {
  733.             t=0;


  734.         }






  735. //1号电机

  736.       if(K111==1)
  737.           {
  738.          //  K1=1;  //端口测试
  739.      //   beep();

  740.                   motor_ffw10();       //电机正转

  741.       }
  742. if(K112==1)
  743.        {

  744.                motor_rev11();       //电机反转

  745.        }

  746. //2号电机

  747. if(K121==1)
  748.           {

  749.                    motor_ffw20();       //电机正转

  750.       }
  751. if(K122==1)
  752.        {
  753.         
  754.                motor_rev21();       //电机反转

  755.        }
  756.    //3号电机

  757. if(K131==1)
  758.           {
  759.          
  760.                    motor_ffw30();       //电机正转
  761.                   
  762.       }
  763. if(K132==1)
  764.        {
  765.          
  766.                motor_rev31();       //电机反转
  767.                   
  768.        }


  769.    //4号电机

  770. if(K141==1)
  771.           {
  772.          
  773.                    motor_ffw40();       //电机正转
  774.                   
  775.       }
  776. if(K142==1)
  777.        {
  778.            
  779.                motor_rev41();       //电机反转
  780.                
  781.        }



  782. //quantao


  783. if(K166==1)
  784. {
  785. uchar i;
  786. for (i=0; i<1; i++)
  787.   {
  788.    K1=1;


  789.     {
  790.          
  791.                   // motor_ffwA20();       //电机正转
  792.                     motor_revA21();
  793.                      jisuan();
  794. xsled();
  795.       }
  796.                   jisuan();
  797.          xsled();

  798.                  delay(2000);

  799.                  jisuan();
  800.          xsled();

  801.    //#############################################################shang

  802.          
  803. // if(100>t>1)
  804.           {
  805.          
  806.                    motor_ffwA10();       //电机正转
  807.                     jisuan();
  808. xsled();
  809.                   
  810.       }
  811.                             delay(2000);   

  812.                      jisuan();
  813.              xsled();

  814.    //######################################################################xaunzhuanzhenti

  815. // if(30>t>25)
  816.           {
  817.          
  818.                    motor_ffwA30();       //电机正转
  819.                     jisuan();
  820. xsled();
  821.                   
  822.       }


  823.                    jisuan();
  824.          xsled();

  825.                  delay(1000);

  826.                   jisuan();
  827.          xsled();


  828. //if(30>t>25)
  829.           {
  830.          
  831.                   motor_revA31();       //电机正转
  832.                   
  833.                   jisuan();
  834. xsled();
  835.       }

  836.                  delay(100);

  837.            jisuan();
  838.        xsled();
  839.   //#####################################################xuanzhaunshouwan

  840. //下降之前展开机
  841.   //下降


  842.   //if(40>t>30)
  843.           {
  844.            jisuan();
  845. xsled();
  846.                                  motor_revA41();      
  847.         //           motor_ffwA40();       //电机正转
  848.                   jisuan();
  849. xsled();
  850.       }
  851.           delay(3000);
  852.                   jisuan();
  853.          xsled();




  854. // if(250>t>120)  #############################################xaijiang

  855.           {
  856.          
  857.                    motor_ffwA20();       //电机正转
  858.                    // motor_revA21();
  859.                    motor_ffwA20();
  860.                                                                      jisuan();
  861. xsled();
  862.       }
  863.                   jisuan();
  864.          xsled();

  865.                  delay(2000);

  866.                  jisuan();
  867.          xsled();



  868.    jisuan();
  869.        xsled();

  870. //#####################################################jiajing


  871. // if(40>t>30)
  872.           {
  873.          
  874. //                  motor_revA41();       //电机正转

  875.                                      motor_ffwA40();  
  876.                    jisuan();
  877. xsled();
  878.                   
  879.        M1=0;
  880.           }

  881.           jisuan();
  882. xsled();





  883.    //#############################################################shang

  884.          
  885. // if(100>t>1)
  886.           {
  887. jisuan();
  888. xsled();
  889.             motor_revA21();
  890.          
  891.         //           motor_ffwA20();       //电机正转

  892. jisuan();
  893. xsled();
  894.                   
  895.       }
  896.                             delay(2000);   

  897.                      jisuan();
  898.              xsled();




  899. jisuan();
  900.          xsled();
  901. //if(20>t>13)#####################################################huizhuan
  902.           {
  903.          
  904.                    motor_revA11();       //电机正转
  905.                     jisuan();
  906. xsled();
  907.                   
  908.       }

  909. //           delay(2000);
  910.                    jisuan();
  911.          xsled();



  912.           //z        =0;
  913.          // x





  914. // if(30>t>25)
  915.           {
  916.          
  917. ///                   motor_ffwA30();       //电机正转
  918.                   
  919.       }


  920.                    jisuan();
  921.          xsled();

  922. //                 delay(10000);

  923.                   jisuan();
  924.          xsled();



  925.   //if(40>t>30)
  926.           {
  927.          
  928.         //           motor_ffwA40();       //电机正转
  929.                   
  930.       }
  931.         //          delay(1000);
  932.                   jisuan();
  933.          xsled();
  934. //if(20>t>13)
  935.           {
  936.          
  937. //                   motor_revA11();       //电机正转
  938.                   
  939.       }

  940. //           delay(2000);
  941.                    jisuan();
  942.          xsled();
  943.   //if(25>t>20)
  944.           {
  945.          
  946. //                  motor_revA21();       //电机正转
  947.                   
  948.       }

  949. //                delay(2000);
  950.                 jisuan();
  951.         xsled();
  952.          
  953.   //if(30>t>25)
  954.           {
  955.          
  956.         //          motor_revA31();       //电机正转
  957.                   
  958.       }

  959. //                 delay(1000);

  960.            jisuan();
  961.        xsled();




  962. // if(40>t>30)
  963.           {
  964.          
  965.         //          motor_revA41();       //电机正转
  966.                   
  967.        M1=0;
  968.           }

  969.           jisuan();
  970. xsled();

  971. //          delay(2000);
  972.         }         
  973. }


  974. jisuan();
  975. xsled();


  976.           c        =0;

  977. }
  978. }



  979. void T0_time() interrupt 1
  980. {
  981.     TH0=(65535-80000)/256;
  982.     TL0=(65535-60000)%256;
  983.         // TH0 = 0x0FC;
  984.     // TL0 = 0xEC;
  985.      t++;
  986. }  
复制代码


评分

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

查看全部评分

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

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|手机版|小黑屋|单片机论坛 |51Hei单片机16群 联系QQ:125739409;技术交流QQ群7344883

Powered by 单片机教程网

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