程序员经验分享-hwhale

魔方机器人之下位机编程------下位机完整程序

2023-11-17 

  //头文件包含
  #include "Includes.h"                   //总头文件  
  //在此添加全局变量定义
  uint8 msg[14] = "Hello! World!";     
  void PWM_Init(void)
  {
       //PWM0----------------------------------------上侧旋转舵机
      PWME_PWME0=0x00;  // Disable  PWM            禁止(通道0)             
      PWMPRCLK=0x33;    // 0011 0011 A=B=32M/8=4M  时钟预分频寄存器设置 
      PWMSCLA=200;      // SA=A/2/200=10k          时钟设置 
      PWMSCLB=200;      // SB=B/2/200 =10k         时钟设置                     
      PWMCLK_PCLK0=1;   // PWM3-----SB             时钟源的选择 
      PWMPOL_PPOL0=1;   // Duty=High Time          极性设置 
      PWMCAE_CAE0=0;    // Left-aligned            对齐方式设置 
      PWMCTL=0x00;      // no concatenation        控制寄存器设置  
      PWMPER0=200;      // Frequency=SB/200=50HZ   周期寄存器设置 
      PWMDTY0=14;       // 1.6ms对应的占空比       占空比寄存器设置 
      PWME_PWME0=1;     // Enable  PWM             使能
      //PWM1----------------------------------------右侧旋转舵机
      PWME_PWME1=0x00;  // Disable  PWM            禁止(通道1)             
      PWMPRCLK=0x33;    // 0011 0011 A=B=32M/8=4M  时钟预分频寄存器设置 
      PWMSCLA=200;      // SA=A/2/200=10k          时钟设置 
      PWMSCLB=200;      // SB=B/2/200 =10k         时钟设置                     
      PWMCLK_PCLK1=1;   // PWM3-----SB             时钟源的选择 
      PWMPOL_PPOL1=1;   // Duty=High Time          极性设置 
      PWMCAE_CAE1=0;    // Left-aligned            对齐方式设置 
      PWMCTL=0x00;      // no concatenation        控制寄存器设置  
      PWMPER1=200;      // Frequency=SB/200=50HZ   周期寄存器设置 
      PWMDTY1=15;       // 1.4ms对应的占空比       占空比寄存器设置 
      PWME_PWME1=1;     // Enable  PWM             使能
       //PWM7----------------------------------------右侧推进舵机
      PWME_PWME7=0x00;  // Disable  PWM            禁止(通道7)             
      PWMPRCLK=0x33;    // 0011 0011 A=B=32M/8=4M  时钟预分频寄存器设置 
      PWMSCLA=200;      // SA=A/2/200=10k          时钟设置 
      PWMSCLB=200;      // SB=B/2/200 =10k         时钟设置                     
      PWMCLK_PCLK7=1;   // PWM4-----SA             时钟源的选择 
      PWMPOL_PPOL7=1;   // Duty=High Time          极性设置 
      PWMCAE_CAE7=0;    // Left-aligned            对齐方式设置 
      PWMCTL=0x00;      // no concatenation        控制寄存器设置  
      PWMPER7=200;      // Frequency=SB/200=50HZ   周期寄存器设置 
      PWMDTY7=12;       // 1.3ms对应的占空比       占空比寄存器设置 
      PWME_PWME7=1;     // Enable  PWM             使能 
      //PWM2----------------------------------------下侧旋转舵机
      PWME_PWME2=0x00;  // Disable  PWM            禁止(通道2)             
      PWMPRCLK=0x33;    // 0011 0011 A=B=32M/8=4M  时钟预分频寄存器设置 
      PWMSCLA=200;      // SA=A/2/200=10k          时钟设置 
      PWMSCLB=200;      // SB=B/2/200 =10k         时钟设置                     
      PWMCLK_PCLK2=1;   // PWM3-----SB             时钟源的选择 
      PWMPOL_PPOL2=1;   // Duty=High Time          极性设置 
      PWMCAE_CAE2=0;    // Left-aligned            对齐方式设置 
      PWMCTL=0x00;      // no concatenation        控制寄存器设置  
      PWMPER2=200;      // Frequency=SB/200=50HZ   周期寄存器设置 
      PWMDTY2=12;       // 1.2ms对应的占空比       占空比寄存器设置 
      PWME_PWME2=1;     // Enable  PWM             使能 
      //PWM5----------------------------------------下侧推进舵机
      PWME_PWME5=0x00;  // Disable  PWM            禁止(通道5)             
      PWMPRCLK=0x33;    // 0011 0011 A=B=32M/8=4M  时钟预分频寄存器设置 
      PWMSCLA=200;      // SA=A/2/200=10k          时钟设置 
      PWMSCLB=200;      // SB=B/2/200 =10k         时钟设置                     
      PWMCLK_PCLK5=1;   // PWM4-----SA             时钟源的选择 
      PWMPOL_PPOL5=1;   // Duty=High Time          极性设置 
      PWMCAE_CAE5=0;    // Left-aligned            对齐方式设置 
      PWMCTL=0x00;      // no concatenation        控制寄存器设置  
      PWMPER5=200;      // Frequency=SB/200=50HZ   周期寄存器设置 
      PWMDTY5=11;       // 1.1ms对应的占空比       占空比寄存器设置 
      PWME_PWME5=1;     // Enable  PWM             使能 
      //PWM3----------------------------------------左侧旋转舵机
      PWME_PWME3=0x00;  // Disable  PWM            禁止(通道3)             
      PWMPRCLK=0x33;    // 0011 0011 A=B=32M/8=4M  时钟预分频寄存器设置 
      PWMSCLA=200;      // SA=A/2/200=10k          时钟设置 
      PWMSCLB=200;      // SB=B/2/200 =10k         时钟设置                     
      PWMCLK_PCLK3=1;   // PWM3-----SB             时钟源的选择 
      PWMPOL_PPOL3=1;   // Duty=High Time          极性设置 
      PWMCAE_CAE3=0;    // Left-aligned            对齐方式设置 
      PWMCTL=0x00;      // no concatenation        控制寄存器设置  
      PWMPER3=200;      // Frequency=SB/200=50HZ   周期寄存器设置 
      PWMDTY3=14;       // 1.4ms对应的占空比       占空比寄存器设置 
      PWME_PWME3=1;     // Enable  PWM             使能 
      //PWM4----------------------------------------左侧推进舵机
      PWME_PWME4=0x00;   // Disable  PWM           禁止(通道4)             
      PWMPRCLK=0x33;     // 0011 0011 A=B=32M/8=4M 时钟预分频寄存器设置 
      PWMSCLA=200;       // SA=A/2/200=10k         时钟设置 
      PWMSCLB=200;       // SB=B/2/200 =10k        时钟设置                     
      PWMCLK_PCLK4=1;    // PWM4-----SA            时钟源的选择 
      PWMPOL_PPOL4=1;    // Duty=High Time         极性设置 
      PWMCAE_CAE4=0;     // Left-aligned           对齐方式设置 
      PWMCTL=0x00;       // no concatenation       控制寄存器设置  
      PWMPER4=200;       // Frequency=SB/200=50HZ  周期寄存器设置 
      PWMDTY4=5;         // 0.7ms对应的占空比      占空比寄存器设置 
      PWME_PWME4=1;      // Enable  PWM            使能    
      //PWM--A0          A0口模拟的PWM
      PA_PWM(5);       //1.5ms对应的占空比  
  } 
  void main()
  {
       
         //关总中断-------0.1
         DisableInterrupt(); 
         //芯片初始化-----0.2     
         MCUInit(FBUS_32M);        
         //模块初始化-----0.3
         SCIInit(0,FBUS_32M,9600);    //串口0初始化
         GPIO_Init(PA,0,1,0);         //模拟PWM输出口PA0   
         // 开放中断------0.4
         EnableSCIReInt0;           //开放SCI0接收中断
         EnableInterrupt();         //开放总中断     
 
         PWM_Init();             //PWM初始化    
         while(1);//for_end(主循环结束)  
  } //main_end
以上为main函数代码

以下为中断服务程序代码： 
/--------------------------------------------------------------------------*
//文件名: isr.c                                                             *
//说  明: 中断处理函数,本文件包含:                                          *                                                             *  
//        isr_default: 中断处理程序                                         *
//--------------------------------------------------------------------------*

//头文件包含，及宏定义区

    //头文件包含
    #include "Includes.h"       //包含总头文件
    uint8 Serial[100];  //存放去除空格和0之后的字符串
    #pragma CODE_SEG __NEAR_SEG NON_BANKED

//中断服务程序区

    //未定义的中断处理函数,本函数不能删除,默认
    __interrupt void isr_default(void)
    {   
       DisableInterrupt();
       EnableInterrupt();
    }

    //串行接受中断
    __interrupt void SCI0_Recv(void)
    {    
        int i=0;
        int j=0;
        int m=0;
        int k=0;
        uint8 SerialBuff[100];                       //存放从上位机接收到的字符串 
        for(i=0;i<100;i++) 
        {
           SerialBuff[i]=0;
        }
        DisableInterrupt();                          //禁止总中断
        SCIReN(0,100,SerialBuff);                    //等待接收150个数据
        for(j=0;j<100;j++) 
        { 
          if((SerialBuff[j]!=' ')&&(SerialBuff[j]!=0)) 
          {
             Serial[k]=SerialBuff[j];
             k++;
          }
        }
        for(m=0;m<k;) 
        {
            if((Serial[m]=='L')&&(Serial[m+1]=='0'))
            L0(); //初始状态 
            else if((Serial[m]=='L')&&(Serial[m+1]=='1'))
            L1(); //左旋90度
            else if((Serial[m]=='L')&&(Serial[m+1]=='2'))
            L2(); //左旋180度
            else if((Serial[m]=='L')&&(Serial[m+1]=='3'))
            L3(); //左旋270度
            else if((Serial[m]=='L')&&(Serial[m+1]=='J'))
            LJ(); //左侧----进
            else if((Serial[m]=='L')&&(Serial[m+1]=='T'))
            LT(); //左侧----退
            
            else if((Serial[m]=='D')&&(Serial[m+1]=='0'))
            D0(); //初始状态 
            else if((Serial[m]=='D')&&(Serial[m+1]=='1'))
            D1(); //下旋90度  
            else if((Serial[m]=='D')&&(Serial[m+1]=='2'))
            D2(); //下旋180度  
            else if((Serial[m]=='D')&&(Serial[m+1]=='3'))
            D3(); //下旋270度  
            else if((Serial[m]=='D')&&(Serial[m+1]=='J'))
            DJ(); //下----进 
            else if((Serial[m]=='D')&&(Serial[m+1]=='T'))
            DT(); //下----退
            
            
            else if((Serial[m]=='R')&&(Serial[m+1]=='0'))
            R0(); //初始状态 
            else if((Serial[m]=='R')&&(Serial[m+1]=='1'))
            R1(); //右旋90度 
            else if((Serial[m]=='R')&&(Serial[m+1]=='2'))
            R2(); //右旋180度 
            else if((Serial[m]=='R')&&(Serial[m+1]=='3'))
            R3(); //右旋270度 
            else if((Serial[m]=='R')&&(Serial[m+1]=='J'))
            RJ(); //右----进
            else if((Serial[m]=='R')&&(Serial[m+1]=='T'))
            RT(); //右----退 
            
            
            else if((Serial[m]=='U')&&(Serial[m+1]=='0'))
            U0(); //初始状态 
            else if((Serial[m]=='U')&&(Serial[m+1]=='1'))
            U1(); //上旋90度 
            else if((Serial[m]=='U')&&(Serial[m+1]=='2'))
            U2(); //上旋180度 
            else if((Serial[m]=='U')&&(Serial[m+1]=='3'))
            U3(); //上旋270度 
            else if((Serial[m]=='U')&&(Serial[m+1]=='T'))
            UT(); //上----退
            else if((Serial[m]=='U')&&(Serial[m+1]=='J'))
            UJ(); //上----进
            
            else if((Serial[m]=='F')&&(Serial[m+1]=='0'))
            F0(); //将前面旋转为上面
            else if((Serial[m]=='F')&&(Serial[m+1]=='1'))
            F1(); //前旋90度
            else if((Serial[m]=='F')&&(Serial[m+1]=='2'))
            F2(); //前旋180度
            else if((Serial[m]=='F')&&(Serial[m+1]=='3'))
            F3(); //前旋270度
            else if((Serial[m]=='F')&&(Serial[m+1]=='B'))
            FB(); //将上面转换为前面
            
            
            else if((Serial[m]=='B')&&(Serial[m+1]=='0'))
            B0(); //将后面旋转为上面
            else if((Serial[m]=='B')&&(Serial[m+1]=='1'))
            B1(); //后旋90度
            else if((Serial[m]=='B')&&(Serial[m+1]=='2'))
            B2(); //后旋180度
            else if((Serial[m]=='B')&&(Serial[m+1]=='3'))
            B3(); //后旋270度
            else if((Serial[m]=='B')&&(Serial[m+1]=='B'))
            BB(); //将上面转换为后面
             
            m=m+2;  
        }
        SCISendN(0,k-1,Serial);
        EnableInterrupt();                           //开放总中断
    }
    
    //复制上述默认中断处理函数isr_default()，作为模板而得到相应的中断程序
    
    #pragma CODE_SEG DEFAULT

//中断矢量表对应区

    //中断处理子程序类型定义
    typedef void (*near tIsrFunc)(void);
    
    //中断矢量表，如果需要定义其它中断函数，请修改下表中的相应项目
    const tIsrFunc _InterruptVectorTable[] @0xFF10 = { 
      // ISR name                     No.   Address  Pri Name            
      isr_default,                 // 0x08  0xFF10   -   ivVsi           
      isr_default,                 // 0x09  0xFF12   -   ivVsyscall      
      isr_default,                 // 0x0A  0xFF14   1   ivVReserved118  
      isr_default,                 // 0x0B  0xFF16   1   ivVReserved117  
      isr_default,                 // 0x0C  0xFF18   1   ivVReserved116  
      isr_default,                 // 0x0D  0xFF1A   1   ivVReserved115  
      isr_default,                 // 0x0E  0xFF1C   1   ivVReserved114  
      isr_default,                 // 0x0F  0xFF1E   1   ivVReserved113  
      isr_default,                 // 0x10  0xFF20   1   ivVReserved112  
      isr_default,                 // 0x11  0xFF22   1   ivVReserved111  
      isr_default,                 // 0x12  0xFF24   1   ivVReserved110  
      isr_default,                 // 0x13  0xFF26   1   ivVReserved109  
      isr_default,                 // 0x14  0xFF28   1   ivVReserved108  
      isr_default,                 // 0x15  0xFF2A   1   ivVReserved107  
      isr_default,                 // 0x16  0xFF2C   1   ivVReserved106  
      isr_default,                 // 0x17  0xFF2E   1   ivVReserved105  
      isr_default,                 // 0x18  0xFF30   1   ivVReserved104  
      isr_default,                 // 0x19  0xFF32   1   ivVReserved103  
      isr_default,                 // 0x1A  0xFF34   1   ivVReserved102  
      isr_default,                 // 0x1B  0xFF36   1   ivVReserved101  
      isr_default,                 // 0x1C  0xFF38   1   ivVReserved100  
      isr_default,                 // 0x1D  0xFF3A   1   ivVReserved99   
      isr_default,                 // 0x1E  0xFF3C   1   ivVReserved98   
      isr_default,                 // 0x1F  0xFF3E   1   ivVatd0compare  
      isr_default,                 // 0x20  0xFF40   1   ivVReserved96   
      isr_default,                 // 0x21  0xFF42   1   ivVReserved95   
      isr_default,                 // 0x22  0xFF44   1   ivVReserved94   
      isr_default,                 // 0x23  0xFF46   1   ivVReserved93   
      isr_default,                 // 0x24  0xFF48   1   ivVReserved92   
      isr_default,                 // 0x25  0xFF4A   1   ivVReserved91   
      isr_default,                 // 0x26  0xFF4C   1   ivVReserved90   
      isr_default,                 // 0x27  0xFF4E   1   ivVReserved89   
      isr_default,                 // 0x28  0xFF50   1   ivVReserved88   
      isr_default,                 // 0x29  0xFF52   1   ivVReserved87   
      isr_default,                 // 0x2A  0xFF54   1   ivVReserved86   
      isr_default,                 // 0x2B  0xFF56   1   ivVReserved85   
      isr_default,                 // 0x2C  0xFF58   1   ivVReserved84   
      isr_default,                 // 0x2D  0xFF5A   1   ivVReserved83   
      isr_default,                 // 0x2E  0xFF5C   1   ivVReserved82   
      isr_default,                 // 0x2F  0xFF5E   1   ivVReserved81   
      isr_default,                 // 0x30  0xFF60   1   ivVReserved79   
      isr_default,                 // 0x31  0xFF62   1   ivVReserved78   
      isr_default,                 // 0x32  0xFF64   1   ivVReserved77   
      isr_default,                 // 0x33  0xFF66   1   ivVReserved76   
      isr_default,                 // 0x34  0xFF68   1   ivVReserved75   
      isr_default,                 // 0x35  0xFF6A   1   ivVReserved74   
      isr_default,                 // 0x36  0xFF6C   1   ivVReserved73   
      isr_default,                 // 0x37  0xFF6E   1   ivVReserved72   
      isr_default,                 // 0x38  0xFF70   1   ivVReserved71   
      isr_default,                 // 0x39  0xFF72   1   ivVReserved70   
      isr_default,                 // 0x3A  0xFF74   1   ivVpit3         
      isr_default,                 // 0x3B  0xFF76   1   ivVpit2         
      isr_default,                 // 0x3C  0xFF78   1   ivVpit1         
      isr_default,                 // 0x3D  0xFF7A   1   ivVpit0         
      isr_default,                 // 0x3E  0xFF7C   1   ivVhti          
      isr_default,                 // 0x3F  0xFF7E   1   ivVapi          
      isr_default,                 // 0x40  0xFF80   1   ivVlvi          
      isr_default,                 // 0x41  0xFF82   1   ivVReserved62   
      isr_default,                 // 0x42  0xFF84   1   ivVReserved61   
      isr_default,                 // 0x43  0xFF86   1   ivVReserved60   
      isr_default,                 // 0x44  0xFF88   1   ivVReserved59   
      isr_default,                 // 0x45  0xFF8A   1   ivVReserved58   
      isr_default,                 // 0x46  0xFF8C   1   ivVpwmesdn      
      isr_default,                 // 0x47  0xFF8E   1   ivVportp        
      isr_default,                 // 0x48  0xFF90   1   ivVReserved55   
      isr_default,                 // 0x49  0xFF92   1   ivVReserved54   
      isr_default,                 // 0x4A  0xFF94   1   ivVReserved53   
      isr_default,                 // 0x4B  0xFF96   1   ivVReserved52   
      isr_default,                 // 0x4C  0xFF98   1   ivVReserved51   
      isr_default,                 // 0x4D  0xFF9A   1   ivVReserved50   
      isr_default,                 // 0x4E  0xFF9C   1   ivVReserved49   
      isr_default,                 // 0x4F  0xFF9E   1   ivVReserved48   
      isr_default,                 // 0x50  0xFFA0   1   ivVReserved47   
      isr_default,                 // 0x51  0xFFA2   1   ivVReserved46   
      isr_default,                 // 0x52  0xFFA4   1   ivVReserved45   
      isr_default,                 // 0x53  0xFFA6   1   ivVReserved44   
      isr_default,                 // 0x54  0xFFA8   1   ivVReserved43   
      isr_default,                 // 0x55  0xFFAA   1   ivVReserved42   
      isr_default,                 // 0x56  0xFFAC   1   ivVReserved41   
      isr_default,                 // 0x57  0xFFAE   1   ivVReserved40   
      isr_default,                 // 0x58  0xFFB0   1   ivVcan0tx       
      isr_default,                 // 0x59  0xFFB2   1   ivVcan0rx       
      isr_default,                 // 0x5A  0xFFB4   1   ivVcan0err      
      isr_default,                 // 0x5B  0xFFB6   1   ivVcan0wkup     
      isr_default,                 // 0x5C  0xFFB8   1   ivVflash        
      isr_default,                 // 0x5D  0xFFBA   1   ivVflashfd      
      isr_default,                 // 0x5E  0xFFBC   1   ivVReserved33   
      isr_default,                 // 0x5F  0xFFBE   1   ivVReserved32   
      isr_default,                 // 0x60  0xFFC0   1   ivVReserved31   
      isr_default,                 // 0x61  0xFFC2   1   ivVReserved30   
      isr_default,                 // 0x62  0xFFC4   1   ivVcrgscm       
      isr_default,                 // 0x63  0xFFC6   1   ivVcrgplllck    
      isr_default,                 // 0x64  0xFFC8   1   ivVReserved27   
      isr_default,                 // 0x65  0xFFCA   1   ivVReserved26   
      isr_default,                 // 0x66  0xFFCC   1   ivVporth        
      isr_default,                 // 0x67  0xFFCE   1   ivVportj        
      isr_default,                 // 0x68  0xFFD0   1   ivVReserved23   
      isr_default,                 // 0x69  0xFFD2   1   ivVatd0         
      isr_default,                 // 0x6A  0xFFD4   1   ivVsci1         
      SCI0_Recv,                   // 0x6B  0xFFD6   1   ivVsci0         
      isr_default,                 // 0x6C  0xFFD8   1   ivVspi0         
      isr_default,                 // 0x6D  0xFFDA   1   ivVtimpaie      
      isr_default,                 // 0x6E  0xFFDC   1   ivVtimpaaovf    
      isr_default,                 // 0x6F  0xFFDE   1   ivVtimovf       
      isr_default,                 // 0x70  0xFFE0   1   ivVtimch7       
      isr_default,                 // 0x71  0xFFE2   1   ivVtimch6       
      isr_default,                 // 0x72  0xFFE4   1   ivVtimch5       
      isr_default,                 // 0x73  0xFFE6   1   ivVtimch4       
      isr_default,                 // 0x74  0xFFE8   1   ivVtimch3       
      isr_default,                 // 0x75  0xFFEA   1   ivVtimch2       
      isr_default,                 // 0x76  0xFFEC   1   ivVtimch1       
      isr_default,                 // 0x77  0xFFEE   1   ivVtimch0       
      isr_default,                 // 0x78  0xFFF0   1   ivVrti          
      isr_default,                 // 0x79  0xFFF2   1   ivVirq          
      isr_default,                 // 0x7A  0xFFF4   -   ivVxirq         
      isr_default,                 // 0x7B  0xFFF6   -   ivVswi          
      isr_default                  // 0x7C  0xFFF8   -   ivVtrap           
    };
以下为PWM旋转函数代码： 
//--------------------------------------------------------------------------*
// 文件名: PWM.c                                                            *
// 说  明: 该头文件为PWM模块初始化及功能函数实现文件                        *
//         (1)PWMInit:PWM初始化                                             *
//         (2)PWMSetting:设置周期和占空比                                   *
//         (3)PWMEnable:使能PWM                                             *
//         (4)PWMDisEnable:禁止PWM                                          *
//--------------------------------------------------------------------------*
//头文件包含，及宏定义区

  //头文件包含 
  #include         "PWM.h"                    //PWM构件头文件
 
//构件函数实现

  //PWMInit:初始化输入捕捉系统配置------------------------------------------*
  //功  能:设置通道的PWM                                                    *
  //参  数:channel:所要设置的通道号(0~7)                                    *
  //返  回:无                                                               *
  //------------------------------------------------------------------------*
  void PWMInit(uint8 channel)
  {
     //参数越界处理 
     if (channel > 7)    channel = 7;
     //(1) 禁止PWM
     PWMDisEnable(channel);
     //(2) 设置A,B的时钟频率
 
     PWMPRCLK=0b00000000;
     //          ||| |||_  
     //          ||| ||__\时钟A频率为Fbus/2^0
     //          ||| |___/
     //          |||_
     //          ||__\时钟B频率为Fbus/2^0
     //          |___/
     //(3) PWM时钟源选择,选择A时钟作为PWM通道0的时钟源
     PWMCLK&=~(1<<channel);
     //(4) 设置对齐方式
     PWMCAE&=~(1<<channel);
     //(5) 设置极性
     PWMPOL|=1<<channel;                                 //正极性
  }

  //PWMSetting:PWM周期和占空比设置------------------------------------------*
  //功  能:根据参数设置f周期和占空比                                        *
  //参  数:period－PWM周期所占用的时钟周期个数                              *
  //       duty－PWM占空比所占用的时钟周期个数                              *
  //       channel:所要设置的通道号(0~7)                                    *
  //返  回:无                                                               *
  //说  明:duty的值<=period的值,并且两者的值都在0～65535之间                *
  //------------------------------------------------------------------------*
  void PWMSetting(uint8 channel, uint8 period, uint8 duty)
  {
      // 参数越界处理
      if (channel > 7)    channel = 7;		
  		//使相应通道的PWM无效
  		PWMDisEnable(channel);
  			switch(channel)
  		{
        case 0:
              //该路为8位
              //设置占空比寄存器
              PWMDTY0 = (uint8)duty;
              //设置周期寄存器
              PWMPER0 = (uint8)period;
              //清0通道X计数器
              PWMCNT0 = 0x00;
              break;
        case 1:
              //该路为8位
              //设置占空比寄存器
              PWMDTY1 = (uint8)duty;
              //设置周期寄存器
              PWMPER1 = (uint8)period;
              //清0通道X计数器
              PWMCNT1 = 0x00;
              break;
  	   case 2:
          	//该路为8位
              //设置占空比寄存器
              PWMDTY2 = (uint8)duty;
              //设置周期寄存器
              PWMPER2 = (uint8)period;
              //清0通道X计数器
              PWMCNT2 = 0x00;
              break;
        case 3:
              //设置占空比寄存器
              PWMDTY3 =(uint8)duty;
              //设置周期寄存器
              PWMPER3 = (uint8)period;
              //清0通道X计数器
              PWMCNT3 = 0x00;
              break;
  		  case 4:
              //该路为8位
              //设置占空比寄存器
              PWMDTY4 = (uint8)duty;
              //设置周期寄存器
              PWMPER4 = (uint8)period;
              //清0通道X计数器
              PWMCNT4 = 0x00;
              break;
        case 5:
              //该路为8位
              //设置占空比寄存器
              PWMDTY5 = (uint8)duty;
              //设置周期寄存器
              PWMPER5 = (uint8)period;
              //清0通道X计数器
              PWMCNT5 = 0x00;
              break;
        case 6:
              //该路为8位
              //设置占空比寄存器
              PWMDTY6 = (uint8)duty;
              //设置周期寄存器
              PWMPER6 = (uint8)period;
              //清0通道X计数器
              PWMCNT6 = 0x00;
              break;
  		  case 7:
  		    //该路为8位
              //设置占空比寄存器
              PWMDTY7 = (uint8)duty;
              //设置周期寄存器
              PWMPER7 = (uint8)period;
              //清0通道X计数器
              PWMCNT7 = 0x00;
              break;
        default:
              break;	
     }
     PWMEnable(channel);
  }
  //PWMEnable:PWM通道有效---------------------------------------------------*
  //功  能:根据参数设置相应通道PWM有效                                      *
  //参  数:channel:所要设置的通道号(0~7)                                    *
  //返  回:无                                                               *
  //------------------------------------------------------------------------*
  void PWMEnable(uint8 channel)
  {
     //参数越界处理 
     if (channel > 7)    channel = 7;
     //设置相应的通道PWM有效 
     if (channel < 8)
         PWME |= (1<<channel);
     else if (channel == 8)
         PWME |= (1<<1);
  }

  //PWMDisEnable:PWM通道无效------------------------------------------------*
  //功  能:根据参数设置相应通道PWM无效                                      *
  //参  数:channel:所要设置的通道号(0~7)                                    *
  //返  回:无                                                               *
  //------------------------------------------------------------------------*
  void PWMDisEnable(uint8 channel)
  {
     //参数越界处理
     if (channel > 7)    channel = 7;
     //设置相应的通道PWM无效
     if (channel < 8)
         PWME &= ~(1<<channel);
     else if (channel == 8)
         PWME &= ~(1<<1);
  }
  //**********************左侧旋转和推进舵机函数*********************************//
  void L_recover() 
  {
     LT();
     L0();
     LJ();
  }
  void L0()        //初始状态
  {
     PWMDTY3=14;         
     Delay(10000);
  }
  void LJ()          //左侧舵机推进
  {
      PWMDTY4=5;         
      Delay(10000);  
  }
   void LT()          //左侧舵机推进
  {
      PWMDTY4=16;         
      Delay(10000);  
  }
  void L1()            //左旋90度
  {
     PWMDTY4=7;         
     Delay(10000);  
     PWMDTY3=26;         
     Delay(10000);
     L_recover(); 
  } 
  void L2()           //旋转180度
  {
      LT(); 
      PWMDTY3=5;         
      Delay(10000);
      PWMDTY4=6;         
      Delay(10000); 
      PWMDTY3=25;         
      Delay(10000);
      L_recover();    
  }
  void L3()           //旋转270度
  {
     PWMDTY4=6;         
     Delay(10000);
     PWMDTY3=4;         
     Delay(10000);
     L_recover(); 
  }
  //**********************右侧旋转和推进舵机函数*********************************//   
  void R_recover() 
  {
     RT();
     R0();
     RJ();
  }
  void R0()
  {
      PWMDTY1=15;
      Delay(10000);
  }
  void R1()              //右旋90
  {
      PWMDTY7=13;
      Delay(10000);
      PWMDTY1=26; 
      Delay(10000);
      R_recover(); 
  }
   void R2()             //右旋180
  {
      RT();
      PWMDTY1=6;
      Delay(10000);
      PWMDTY7=13;
      Delay(10000);
      PWMDTY1=26; 
      Delay(10000);
      R_recover(); 
  }
  void R3()              //右旋270
  {
      PWMDTY7=13;
      Delay(10000);
      PWMDTY1=5;
      Delay(10000);
      R_recover();
  } 
  void RJ()             //右侧舵机-----进
  {
      PWMDTY7=12;
      Delay(10000);
  }
   void RT()            //右侧舵机-----退
  {
      PWMDTY7=25;
      Delay(10000);
  }
  //**********************下侧旋转和推进舵机函数*********************************//
   void D_recover() 
  {
     DT();
     D0();
     DJ();
  } 
  void D0()            //初始状态
  {
     
     PWMDTY2=12;         
     Delay(10000);
  } 
  void D1()            //下旋90度
  {
     PWMDTY5=12;     
     Delay(10000);
     PWMDTY2=2;         
     Delay(10000);
     D_recover(); 
  } 
  void D2()            //下旋180度
  {
      D1(); 
      D1(); 
  }
  void D3()            //下旋270度
  {
     PWMDTY5=12;      
     Delay(10000);
     PWMDTY2=23;         
     Delay(10000);
     D_recover();
  } 
  void DJ()
  {
     PWMDTY5=11;       //下------进
     Delay(10000);
  }
   void DT() 
 {
   
     PWMDTY5=23;       //下------退
     Delay(10000);
 }
 //**********************上侧旋转和推进舵机函数*********************************//
   void U_recover() 
  {
     UT();
     U0();
     UJ();
  } 
  void U0()            //初始状态
  { 
     PWMDTY0=14;         
     Delay(10000);
  } 
   void U1()            //上旋转90度
  { 
     PA_PWM(8);
     Delay(1000);
     PWMDTY0=26;       
     Delay(10000);
     U_recover();
  } 
   void U2()            //上旋转180度
  {
     UT();
     PWMDTY0=5;         
     Delay(10000);
     PA_PWM(8);
     Delay(10000);
     PWMDTY0=26;         
     Delay(10000);
     U_recover();   
  } 
   void U3()            //上旋转270度
  {
     PA_PWM(8);
     Delay(1000);
     PWMDTY0=1;         
     Delay(10000);
    U_recover(); 
  } 
   void UT()         //上----退
  {
     PA_PWM(16);
     Delay(10000);
  }   
   void UJ()         //上----进
  {
     PA_PWM(5);
     Delay(10000);
  }   
  //**********************前侧旋转函数*********************************//
 void F0()   //将前侧旋转到上侧,以便旋转上侧 
 {
    UT();
    DT();
    PWMDTY3=5;   
    PWMDTY1=25; 
    Delay(10000);
    DJ();
    UJ();
    LT();
    RT();
    L0();
    R0();
    LJ();
    RJ();
 }
 void F1()       //旋转90度
 {
   U1();
 }
 void F2()       //旋转180度
 {
   U2();
 }
  void F3()      //旋转270度
 {
   U3();
 }
 void FB()      //将上面恢复为前面
 {
    UT();
    DT();
    PWMDTY1=6; 
    PWMDTY3=25; 
    Delay(10000);
    DJ();
    UJ();
    LT();
    RT();
    L0();
    R0();
    LJ();
    RJ();  
 }
  //**********************后侧舵机旋转函数**********************
 void B0()        //将后侧旋转到上侧,以便旋转后侧 
 {
    FB();
 } 
 void B1()    //旋转90度
 {
    U1();
 }
 void B2()    //旋转180度
 {
    U2();
 }
 void B3()    //旋转270度
 {
    U3();
 }
 void BB()      //将上面恢复为前面
 {
    F0();
 }





本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

魔方机器人

魔方机器人

下位机编程

魔方机器人之下位机编程------下位机完整程序 的相关文章

随机推荐

  • 无法访问目标主机的原因及其和请求超时的区别

    使用ping命令时经常会遇到这两种情况 就表示网络出了问题 无法访问目标主机的原因 可以看到 无法访问目标主机 是来自一个IP的回复 实际上那个IP是一个路由器 因此 无法访问目标主机 实际上数据是发出去并且收到回复的 只不过收到的回复是别

  • 数据结构和算法（递归概念、迷宫回溯问题和八皇后问题代码实现）

    递归的概念 递归能够做解决什么问题 使用递归时需要注意的问题 递归的第一个应用 迷宫回溯问题 迷宫模拟 定义一个8 7的数组模拟迷宫 1表示围墙 0表示可以走的路 图中左上红圈为起点 右下红圈为终点 利用代码找到从起点到终点的路径 使用递归

  • 【Python】代码实现LL(1),LR(1)上下文无关文法（Stack()类）

    任务要求 针对书上第三章中的表达式文法 采用LL 1 LR 1 进行分析 相关文法 需要进行消除左递归等操作 顺手分享一下课本资源好了 可能不是最新版 排版略有点别扭 后文的书上内容就是指这本书 编译原理 陈意云 文字版 提取码 e0ag

  • Android Studio如何添加工程（project）为library（针对非gradle）

    这篇文章还是针对非gradle build的工程 gradle build有一些差别 在Eclipse要引用别的工程为本工程的library很简单 但是在Android Studio还是稍稍有点小复杂的 那如何引用别的工程为本工程的libr

  • 网络编程——TCP并发服务器模型

    1 多线程中的newfd 能否修改成全局 不行 为什么 因为如果是全局变量 文件描述符就是唯一的 所有的客户端都会在同一个文件描述符通信 2 多线程中分支线程的newfd能否不另存 直接用指针间接访问主线程中的newfd 不行 为什么 如果

  • 微信小程序-仿智行火车票12306

    微信小程序 仿智行火车票12306 微信小程序 仿智行火车票12306 主页有轮播图 有导航栏 有个人中心 可以实现火车票 飞机票 汽车票的选择 适合初学者学习 下面是示例图片 下载链接 https download csdn net do

  • Linux系统图形界面和命令行界面之间的切换

    一 系统不在虚拟机中的情况 使用ctrl alt F1 6切换到命令行界面 ctrl alt F7切换到图形界面 二 系统在虚拟机中的情况 Ctrl Alt shift F1 6切换到命令行界面 使用Alt F7返回到图形界面 注 以上方法

  • hashmap中为什么使用红黑树？

    在回答这个问题之前 我们先了解一下有关二叉树的基本内容 二叉排序树 又称二叉查找树 1 若左子树不为空 则左子树上所有结点的值均小于根结点的值 2 若右子树不为空 则右子树上所有结点的值均大于根节点的值 3 左右子树也为二叉排序树 平衡二叉

  • 2017 ICCV之语义分割：Cascaded Feature Network for Semantic Segmentation of RGB-D Images

    Cascaded Feature Network for Semantic Segmentation of RGB D Images 目前的问题 1 为了计算对象 场景关系的表示 最近大量的分割网络使用一组感受野来丰富卷积特征的文本信息 这

  • book_read_link

    结构性改革 黄奇帆 微信读书 分析与思考 黄奇帆的复旦经济课 黄奇帆 微信读书

  • java通过web3j获取ETH交易明细

    我们在项目里面如果想要得到用户的ETH交易明细怎么做呢 有两种方式 1 直接获取ETH最新块的交易明细 2 通过块获取用户的交易明细 废话不多说 直接贴代码看了 package com example demo web3jLog impor

  • pdf.js引入方式及初始化配置

    官方下载地址 Getting StartedA general purpose web standards based platform for parsing and rendering PDFs http mozilla github

  • actuator--基础--04--Springboot集成

    actuator 基础 04 Springboot集成 代码位置 https gitee com DanShenGuiZu learnDemo tree master actuator learn actuator01 1 代码 1 1 依

  • MongoDB游标

    数据库会使用游标返回 find 的执行结果 游标的客户端实现通常能够在很大程度上对查询的最终输出进行控制 你可以限制结果的数量 跳过一些结果 按任意方向的任意键组合对结果进行排序 以及执行许多其他功能强大的操作 要使用 shell 创建游标

  • 爬虫实战之华为应用市场

    目录 一 需求说明 二 步骤 1 检查当前页面的URL所获得的响应的数据 笨办法 程序验证 不建议 简单办法 抓包 验证 抓包 推荐 动态加载验证 查找页面的信息 2 获取排行页面数据 操作 源码 信息解析 3 详情页面分析 寻找URL 验

  • leetcode 577

    给定一个字符串 s 你需要反转字符串中每个单词的字符顺序 同时仍保留空格和单词的初始顺序 示例 1 输入 s Let s take LeetCode contest 输出 s teL ekat edoCteeL tsetnoc 示例 2 输

  • C++中的强引用与弱引用

    https juejin cn post 7102838307062546445 1 weak ptr的原理 weak ptr 是为了配合 shared ptr 而引入的一种智能指针 它指向一个由 shared ptr 管理的对象而不影响所

  • 神经网络中的激活函数

    一 激活的概念 将输入映射为特定分布的输出 完成非线性变换 多细胞生物神经元的树突接收信息 触发区整合电位 产生神经冲动 末端的突触向下一个神经元传递刺激 以人脑为例 人脑的细胞受刺激产生活动 而刺激的强度需要达到一定的阈值 没有达到阈值的

  • 基于51单片机数字频率计的设计与实现

    目录 第一章 系统原理与总体设计 1 1系统组成 1 2系统原理 1 3测量原理 1 4频率测量与总体设计 第二章 硬件电路设计 2 1硬件电路框图 2 2数字频率计原理图 2 3硬件电路设计 第三章 软件程序设计 3 1程序流程图 3 2

  • 魔方机器人之下位机编程------下位机完整程序

    头文件包含 include Includes h 总头文件 在此添加全局变量定义 uint8 msg 14 Hello World void PWM Init void PWM0 上侧旋转舵机 PWME PWME0 0x00 Disable

热门标签