四脚蜘蛛机器人代码

ID:891812 · 发表于 2021-4-11 17:08

#include "reg51.h"
#define uint8       unsigned char
#define uint16       unsigned short int
#define uint32       unsigned long

sbit SERVO0=P2^0;                      //控制舵机的PWM输出口
sbit SERVO1=P2^1;
sbit SERVO2=P2^2;
sbit SERVO3=P2^3;
sbit SERVO4=P2^4;
sbit SERVO5=P2^5;
sbit SERVO6=P2^6;
sbit SERVO7=P2^7;

uint16 Servo0PwmDuty=1500;       //PWM脉冲宽度
uint16 Servo1PwmDuty=1500;
uint16 Servo2PwmDuty=1500;
uint16 Servo3PwmDuty=1500;
uint16 Servo4PwmDuty=1500;
uint16 Servo5PwmDuty=1500;
uint16 Servo6PwmDuty=1500;
uint16 Servo7PwmDuty=1500;
uint16 k=0;
uint16 g=0;
uint16 h=0;
uint16 t=0;

void DelayMs(uint16 ms)    //延时ms毫秒
{
      uint16 i,j;
      for(i=0;i<85;i++)             //89单片机用85,12系列单片机用800
            for(j=0;j<ms;j++);
}

void InitTimer0(void) //时钟0初始化
{
      TMOD &= 0xF0;             //设置定时器模式
      TMOD |= 0x01;             //设置定时器模式
      TL0 = 0x00;                      //设置定时初值
      TH0 = 0x00;                      //设置定时初值
      TF0 = 0;                      //清除TF0标志
      TR0 = 1;                      //定时器0开始计时
      ET0 = 1;                      //开定时器0中断
}
/***********************************************************
* 名称：Timer0Value(uint16 pwm)
* 功能：给定时器0计数器赋值产生定时中断
* 入口参数：pwm             控制舵机的PWM脉冲宽度值（范围：500~2500）
* 出口参数：无
* 说明：12M晶振，12分频，所以计数器每递增一个数就是1微秒，完全满足舵机控制的精度要求
                     因为定时器是TH0，TL0都要全部计数到0xFF后在计1个数就会产生中断，所以要想产生
                     pwm毫秒的中断，那么TH0，TL0就应该赋值（0xFFFF-pwm）       从这个值开始计数产生定时中断
/**********************************************************/
void Timer0Value(uint16 pwm)
{
      uint16 value;
      value=0xffff-pwm;
      TR0 = 0;
      TL0=value;                      //16位数据给8位数据赋值默认将16位数据的低八位直接赋给八位数据
TH0=value>>8;             //将16位数据右移8位，也就是将高8位移到低八位，再赋值给8位数据
      TR0 = 1;
}

void up()
{
if(h==0)
{
      Servo0PwmDuty=1500;       //0
      Servo1PwmDuty=1500;
      Servo2PwmDuty=1500;
      Servo3PwmDuty=1500;
      Servo4PwmDuty=1500;
      Servo5PwmDuty=1500;
      Servo6PwmDuty=1500;
      Servo7PwmDuty=1500;
      DelayMs(1000);
      h++;
//       Servo0PwmDuty = 1750;
//       Servo1PwmDuty = 1750;
//       Servo2PwmDuty = 1750;
//       Servo3PwmDuty = 1750;
//       DelayMs(1000);

//       Servo0PwmDuty = 2000;    //45
//       Servo1PwmDuty = 2000;
//       Servo2PwmDuty = 2000;
//       Servo3PwmDuty = 2000;
//       DelayMs(1000);

//       Servo0PwmDuty = 2250;
//       Servo1PwmDuty = 2250;
//       Servo2PwmDuty = 2250;
//       Servo3PwmDuty = 2250;
//       DelayMs(1000);

//       Servo0PwmDuty = 2500;    //90
//       Servo1PwmDuty = 2500;
//       Servo2PwmDuty = 2500;
//       Servo3PwmDuty = 2500;
//       DelayMs(1000);
}
}

void go()
{
      {
      Servo0PwmDuty = 1500;             // 右前脚 1700——1200 ；右前腿 1200——1700             自己改参数
            DelayMs(300);                      // 延时0.5秒

            Servo1PwmDuty = 1500;
            DelayMs(300);

            Servo0PwmDuty = 1400;          // 脉冲宽度在1000微秒
            DelayMs(300);

            Servo1PwmDuty = 2000;
            DelayMs(300);
   }

      {
      Servo4PwmDuty = 1500;             // 左后脚 1700——1200 ；左后腿 1200——1700             自己改参数
            DelayMs(300);                      // 延时0.5秒

            Servo5PwmDuty = 1500;
            DelayMs(300);

            Servo4PwmDuty = 1700;          // 脉冲宽度在1000微秒，对应-45°
            DelayMs(300);

            Servo5PwmDuty = 2000;
            DelayMs(300);
   }

      {
      Servo2PwmDuty = 1500;             // 左前脚 1700——1200 ；右前腿 1200——1700
            DelayMs(300);             //延时0.5秒

            Servo3PwmDuty = 1500;
            DelayMs(300);

            Servo2PwmDuty = 1300;       //脉冲宽度在1000微秒，对应-45°
            DelayMs(300);

            Servo3PwmDuty = 1000;
            DelayMs(300);
   }

      {
      Servo6PwmDuty = 1500;             // 右后脚 1700——1200 ；左后腿 1200——1700
            DelayMs(300);             //延时0.5秒

            Servo7PwmDuty = 1500;
            DelayMs(300);

            Servo6PwmDuty = 1700;       //脉冲宽度在1000微秒，对应-45°
            DelayMs(300);

            Servo7PwmDuty = 2000;
            DelayMs(300);
   }

      Servo0PwmDuty=1500;
      Servo1PwmDuty=1500;
      Servo2PwmDuty=1500;
      Servo3PwmDuty=1500;
      Servo4PwmDuty=1500;
      Servo5PwmDuty=1500;
      Servo6PwmDuty=1500;
      Servo7PwmDuty=1500;

}

void right()
{
{    Servo0PwmDuty = 1000;             // 左前脚 1700——1200 ；左前腿 1200——1700             自己改参数
            DelayMs(200);             //延时0.5秒

            Servo1PwmDuty = 1500;
            DelayMs(200);

            Servo0PwmDuty = 1500;       //脉冲宽度在1000微秒，对应-45°
            DelayMs(200);

            Servo1PwmDuty = 1000;
            DelayMs(200);                      }

            DelayMs(200);

      {       Servo6PwmDuty = 1500;             // 左后脚 1700——1200 ；左后腿 1200——1700
            DelayMs(200);             //延时0.5秒

            Servo7PwmDuty = 1500;
            DelayMs(200);

            Servo6PwmDuty = 1000;       //脉冲宽度在1000微秒，对应-45°
            DelayMs(200);

            Servo7PwmDuty = 1000;
            DelayMs(200);                }

         DelayMs(200);
}

void left()
{
{       Servo2PwmDuty = 1500;             // 右前脚 1700——1200 ；右前腿 1200——1700
            DelayMs(200);                      // 延时0.5秒

            Servo3PwmDuty = 1000;
            DelayMs(200);

            Servo2PwmDuty = 1000;          // 脉冲宽度在1000微秒，对应-45°
            DelayMs(200);

            Servo3PwmDuty = 1500;
            DelayMs(200);                }

         DelayMs(200);

   {  Servo4PwmDuty = 1000;             // 右后脚 1700——1200 ；右后腿 1200——1700             自己改参数
            DelayMs(200);                      // 延时0.5秒

            Servo5PwmDuty = 1000;
            DelayMs(200);

            Servo4PwmDuty = 1500;          // 脉冲宽度在1000微秒，对应-45°
            DelayMs(200);

            Servo5PwmDuty = 1500;
            DelayMs(200);                      }

            DelayMs(200);
}

void turnright()
{
         Servo0PwmDuty=1500;       //0
      Servo1PwmDuty=1500;
      Servo2PwmDuty=1500;
      Servo3PwmDuty=1500;
      Servo4PwmDuty=1500;
      Servo5PwmDuty=1500;
      Servo6PwmDuty=1500;
      Servo7PwmDuty=1500;
      DelayMs(100);

//       Servo0PwmDuty = 1750;
//       DelayMs(100);
//       Servo1PwmDuty = 1750;
//       DelayMs(100);
//       Servo2PwmDuty = 1750;
//       DelayMs(100);
//       Servo3PwmDuty = 1750;
//       DelayMs(100);

      Servo1PwmDuty = 2000;    //45
      DelayMs(200);
      Servo5PwmDuty = 2000;    //45
      DelayMs(200);
      Servo3PwmDuty = 2000;    //45
      DelayMs(200);
      Servo7PwmDuty = 2000;    //45
      DelayMs(200);

//       Servo0PwmDuty = 1750;
//       DelayMs(100);
//       Servo1PwmDuty = 1750;
//       DelayMs(100);
//       Servo2PwmDuty = 1750;
//       DelayMs(100);
//       Servo3PwmDuty = 1750;
//       DelayMs(100);

      Servo1PwmDuty = 1500;    //0
      Servo5PwmDuty = 1500;    //0
      Servo3PwmDuty = 1500;    //0
            Servo7PwmDuty = 1500;    //0
      DelayMs(100);
      g++;
}

void main()
{
      InitTimer0();       //定时器0初始化
      EA = 1;                      //开总中断
      while(1)             //大循环
      {
      if(h==0)       //起
      {
         up();
         h++;
      }

      for(g=0;g<10;g++)
      {
      go();
      up();
      }
//          left();
//          right();

//       if(g==0)       //转弯
//       {
//          turnright();
//          g++;
//       }
//
//       if(h!=0)       //恢复初态
//       {
//          up();
//          h++;
//       }
}
}

void Timer0_isr(void) interrupt 1 using 1    //时钟0中断处理
{
      static uint16 i = 1;       //静态变量：每次调用函数时  $$保持上一次所赋的值$$
                                                      //跟全局变量类似，不同是它只能用于此函数内部
      switch(i)
      {
            case 1:
                     SERVO0 = 1;       //PWM控制脚高电平
//给定时器0赋值，计数Pwm0Duty个脉冲后产生中断，下次中断会进入下一个case语句
                     Timer0Value(Servo0PwmDuty);
                     break;
            case 2:
                     SERVO0 = 0; //PWM控制脚低电平
//高脉冲结束后剩下的时间(20000-Pwm0Duty)全是低电平了，Pwm0Duty + (20000-Pwm0Duty) = 20000个脉冲正好为一个周期20毫秒
                     Timer0Value(20000-Servo0PwmDuty);
                     break;

      case 3:
                     SERVO1 = 1;       //PWM控制脚高电平
                     Timer0Value(Servo1PwmDuty);
                     break;
      case 4:
                     SERVO1 = 0; //PWM控制脚低电平
         Timer0Value(20000-Servo1PwmDuty);
                     break;

      case 5:
                     SERVO2 = 1;       //PWM控制脚高电平
                     Timer0Value(Servo2PwmDuty);
                     break;
      case 6:
                     SERVO2 = 0; //PWM控制脚低电平
         Timer0Value(20000-Servo2PwmDuty);
                     break;

      case 7:
                     SERVO3 = 1;       //PWM控制脚高电平
                     Timer0Value(Servo3PwmDuty);
                     break;
      case 8:
                     SERVO3 = 0; //PWM控制脚低电平
         Timer0Value(20000-Servo3PwmDuty);

                     break;

      case 9:
                     SERVO4 = 1;       //PWM控制脚高电平
                     Timer0Value(Servo4PwmDuty);
                     break;
      case 10:
                     SERVO4 = 0; //PWM控制脚低电平
         Timer0Value(20000-Servo4PwmDuty);
                     break;

      case 11:
                     SERVO5 = 1;       //PWM控制脚高电平
                     Timer0Value(Servo1PwmDuty);
                     break;
      case 12:
                     SERVO5 = 0; //PWM控制脚低电平
         Timer0Value(20000-Servo5PwmDuty);
                     break;

      case 13:
                     SERVO6 = 1;       //PWM控制脚高电平
                     Timer0Value(Servo6PwmDuty);
                     break;
      case 14:
                     SERVO6 = 0; //PWM控制脚低电平
         Timer0Value(20000-Servo6PwmDuty);
                     break;

      case 15:
                     SERVO7 = 1;       //PWM控制脚高电平
                     Timer0Value(Servo7PwmDuty);
                     break;
      case 16:
                     SERVO7 = 0; //PWM控制脚低电平
         Timer0Value(20000-Servo7PwmDuty);
         i=0;
                     break;
      }
      i++;
}

帐号		自动登录	找回密码
密码			立即注册