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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 风力摆控制系统全套设计资料（代码+图+报告）15年电赛作 ...
返回列表 发新帖
查看: 18511|回复: 10
打印 上一主题 下一主题
收起左侧

风力摆控制系统全套设计资料（代码+图+报告）15年电赛作品

  [复制链接]
跳转到指定楼层
楼主
ID:374102 发表于 2018-7-18 15:18 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
这是15年电赛的风力摆控制系统，里面包含完整的代码和完整的报告以及实物图，可以学到很多东西。


论文：


单片机源程序如下:
  1. #include<rtx51tny.h>                 /* RTX51 tiny functions & defines */
  2. #include <intrins.h>
  3. #include "LCD12864.h"
  4. #include "key.h"
  5. #include "stc12uart1定时器1.h"
  6. #include "stc12uart2.h"
  7. #include "HW_PWM.h"
  8. #include<math.h>
  9. #include<stdio.h>

  11. #define uchar unsigned char
  12. #define uint  unsigned int

  14. unsigned char Key=0x00;                         //确定当前哪个按键按下

  16. sbit LED11=P0^2;
  17. sbit LED12=P0^3;
  18. sbit LED13=P0^4;
  19. sbit LED14=P0^7;

  21. /*------------------------------------------------------------------------------------
  22. ------------------------------------------------------------------------------------*/
  23. xdata float mpu6050[9];
  24. xdata unsigned char PWM1=1,PWM2=1;
  25. xdata float Gyro_y=0.0;
  26. xdata float Angle_x=0.0; //MPU6050测得的x轴的角度
  27. xdata float Angle_x_set=10;                //x轴设定的角度 角度与位移的公式 L*tan(Angle_x_set)=x
  28. xdata float x;                                                        //L为万向节到纸面原点的垂直距离(单位cm)  Angle_x_set为需要设定的角度

  30. xdata float Kp_x=10,Ki_x=0,Kd_x=0.1;
  31. xdata float Now_error_x=0,Last_error_x=0;         //Now_error 当前偏差 Last_error 上一次偏差  Pre_error上上一次偏差
  32. xdata int uk_x=0,uk1_x=0.01,duk_x=0;

  34. xdata float Kp_y=10,Ki_y=0,Kd_y=0.1;
  35. xdata float Now_error_y=0,Last_error_y=0;         //Now_error 当前偏差 Last_error 上一次偏差  Pre_error上上一次偏差
  36. xdata int uk_y=0,uk1_y=0,duk_y=0;

  38. xdata float setjiaodu3=0;
  39. uchar m,i;
  40. bit Basic04Flag=0;      //基础部分4标志位
  41. //bit Basic04Flag2=0;
  42.                                                         //x为纸面的位移
  43. int PID_control();
  44. /*------------------------------------------------------------------------------------
  45. ------------------------------------------------------------------------------------*/

  47. void SystemInit(void) _task_  0                                //任务0----------------系统初始化
  48. {        
  49.         LCD12864_Init();                   //12864液晶初始化
  50.         KeyInit();                                   //按键初始化
  51.         UART2_Init();                 //STC12C5A串口2初始化，独立波特率发生器产生波特率
  52.         UART1_Init();                 //STC12C5A串口1初始化，定时器1产生波特率
  53.         HW_PWMInit();
  54.         
  55.         HW_PWM0Set(1);
  56.         HW_PWM1Set(1);
  57.         PWM1=1;
  58.         PWM2=1;

  60.         MenuOperate(0);
  61.         MenuOperate(0);
  62.         MenuOperate(0);

  64.         LED11=1;
  65.         LED12=1;
  66.         LED13=1;
  67.         LED14=1;

  69.         os_create_task(1);                        //创建任务1
  70.         os_create_task(2);                        //创建任务2
  71.         os_create_task(3);          //创建任务3
  72.         os_create_task(4);          //创建任务4
  73.         os_create_task(5);                        //创建任务5
  74.         os_create_task(6);          //创建任务6
  75.         os_create_task(7);          //创建任务7
  76.         os_create_task(8);          //创建任务8
  77.         os_create_task(9);          //创建任务9

  79.         os_delete_task(0);                        //删除初始化函数
  80. }
  81. void  KeyScan(void)     _task_       1                           //任务1-----------------------按键扫描
  82. {
  83.         unsigned char keyvalue=KEY_NULL;
  84.         
  85.         while(1)
  86.         {
  87.                 GetKey(&keyvalue);                                                    //获取当前键值
  88.                 if(keyvalue==(KEY_VALUE_1|KEY_DOWN))         //按键一按下   指针减
  89.                 {
  90.                         Key=0x30;
  91.                         os_send_signal(2);
  92.                 }
  93.                 if(keyvalue==(KEY_VALUE_2|KEY_DOWN))         //按键er按下   指针加
  94.                 {
  95.                         Key=0x28;
  96.                         os_send_signal(2);
  97.                 }
  98.                 if(keyvalue==(KEY_VALUE_3|KEY_DOWN))         //按键san按下   确定
  99.                 {
  100.                         Key=0x18;
  101.                         os_send_signal(2);
  102.                 }
  103.                 if(keyvalue==(KEY_VALUE_4|KEY_DOWN))                  //按键四按下   返回
  104.                 {
  105.                         Key=0x08;
  106.                         os_send_signal(2);
  107.                 }
  108.                 os_wait(K_IVL,3,0);                                                 //进行周期性检测
  109.         }
  110. }
  111. void  LCD12864Display(void) _task_   2                          //任务2-----------------12864液晶显示
  112. {
  113.         while(1)
  114.         {
  115.                 os_wait(K_SIG,0,0);             //等待按键信号
  116.                 MenuOperate(Key);
  117.         }
  118. }
  119. void UartRec(void)      _task_       3                  //任务3-------------------串口收发
  120. {
  121. //    float Value[3];
  122. //        float x,y,z;
  123. //        xdata char str[16];

  125.         while(1)
  126.         {
  127. //                Value [0] = ((short)(ucStrAngle[1]<<8| ucStrAngle[0]))/32768.0*180;
  128. //                Value[1] = ((short)(ucStrAngle[3]<<8| ucStrAngle[2]))/32768.0*180;
  129. //                Value[2] = ((short)(ucStrAngle[5]<<8| ucStrAngle[4]))/32768.0*180;
  130. //                acc_x=(float)(((unsigned short)ucStra[3]<<8)|ucStra[2])/32768.0*16;
  131.                 Angle_x=((short)(ucStrAngle[3]<<8| ucStrAngle[2]))/32768.0*180;
  132.                 Gyro_y=((short)(ucStrw[3]<<8|ucStrw[2]))/32768.0*2000;

  134.                
  135. //                mpu6050[0]=(float)mpu[0]/32768.0*16;           //加速度
  136. //                mpu6050[1]=(float)mpu[1]/32768.0*16;
  137. //                mpu6050[2]=(float)mpu[2]/32768.0*16;

  139.                 mpu6050[3]=(float)mpu[3]/32768.0*2000;          //角速度
  140.                 mpu6050[4]=(float)mpu[4]/32768.0*2000;
  141.                 mpu6050[5]=(float)mpu[5]/32768.0*2000;

  143.                 mpu6050[6]=(float)mpu[6]/32768.0*180;           //角度
  144.                 mpu6050[7]=(float)mpu[7]/32768.0*180;
  145.                 mpu6050[8]=(float)mpu[8]/32768.0*180;

  147. //                sprintf(str,"%.3f %.3f\n",mpu6050[6],mpu6050[7]);
  148. //                UART1_SendStr(str);
  149.                 UART1_SendPWM(PWM1,PWM2);
  150. //                Data_Send_Status(Value[0],Value[1],Value[2]);
  151. //                Data_Receive(&x,&y,&z);
  152. //                UART1_SendPWM(64,64);
  153.                 os_switch_task();        
  154.         }        
  155. }                                          
  156. void TaskSwitch(void)   _task_       4                      //任务4
  157. {
  158.         while(1)
  159.         {
  160.                 switch(KeyFuncIndex)
  161.                 {
  162.                         case 10:          //基础1
  163.                         //        HW_PWM0Set(1);
  164.                         //        HW_PWM1Set(1);
  165.                                 os_send_signal(5);
  166.                                 break;
  167.                         case 11:          //基础2
  168.                                 //HW_PWM0Set(1);
  169.                                 //HW_PWM1Set(1);
  170.                                 os_send_signal(6);
  171.                                 break;
  172.                         case 12:          //基础3
  173.                                 os_send_signal(7);
  174.                                 break;
  175.                         case 16:          //基础4
  176.                                 os_send_signal(9);
  177.                                 break;
  178.                         case 13:                  //发挥1
  179.                                 os_send_signal(8);
  180.                                 break;
  181.                         case 14:           //发挥2
  182.                                 os_send_signal(9);
  183.                                 break;
  184.                         case 15:           //发挥3
  185.                                 break;
  186.                 }
  187.                 os_switch_task();
  188.         }
  189. }
  190. void PID_control_x()
  191. {
  192.         
  193.         Now_error_x=-mpu6050[6];        //偏差=设定值—实际值
  194.         duk_x=Kp_x*(Now_error_x-Last_error_x)+Ki_x*Now_error_x+Kd_x*mpu6050[3];          //pid增量式公式

  196.         uk_x=duk_x+uk1_x;          //通过pid调节所需要改变的值
  197.         
  198.         uk1_x=uk_x;        //变量值移位
  199.         Last_error_x=Now_error_x;

  201. }

  203. void PID_control_y()
  204. {
  205.         
  206.         Now_error_y=0.0-mpu6050[7];        //偏差=设定值—实际值
  207.         duk_y=Kp_y*(Now_error_y-Last_error_y)+Ki_y*Now_error_y+Kd_y*mpu6050[4];          //pid增量式公式

  209.         uk_y=duk_y+uk1_y;          //通过pid调节所需要改变的值        
  210.         uk1_y=uk_y;        //变量值移位
  211.         Last_error_y=Now_error_y;

  213. }
  214. void Basic01(void)      _task_       5              //任务5        基础部分1
  215. {
  216.         while(1)
  217.         {
  218.                 os_wait(K_SIG,0,0);
  219.         //        PID_control_x();
  220.                 if(Angle_x>-3.0&&Angle_x<10.5)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  221.                 {
  222.                         HW_PWM0Set(255);
  223.                         HW_PWM1Set(1);                                
  224.                 }
  225.                 else if(Angle_x<-3.0&&Angle_x>-7.5)
  226.                 {
  227.                         HW_PWM0Set(1);
  228.                         HW_PWM1Set(1);        
  229.                 }
  230.                 else if(Angle_x<-7.5&&Angle_x>-9.8)
  231.                 {
  232.                         HW_PWM0Set(1);
  233.                         HW_PWM1Set(255);        
  234.                 }
  235.                 else
  236.                 {
  237.                         HW_PWM0Set(1);
  238.                         HW_PWM1Set(1);
  239.                 }

  241. //                if(mpu6050[6]>2)
  242. //                {
  243. //                                uk_x=fabs(uk_x);
  244. //                                if(uk_x>=256)
  245. //                                {
  246. //                                        uk_x=255;
  247. //                                }
  248. //                                        PWM1=1;
  249. //                                PWM2=uk_x;
  250. //                         //hou yiwozhengqianfangweizuobuao
  251. //                //                LED14=1;
  252. //                }
  253. //                if(mpu6050[6]<-2)
  254. //                {
  255. //                                uk_x=fabs(uk_x);
  256. //                                if(uk_x>=256)
  257. //                                {
  258. //                                        uk_x=255;
  259. //                                }
  260. //                                PWM1=uk_x;
  261. //                                PWM2=1;         
  262. //                        
  263. //                }
  264. //                else
  265. //                {
  266. //                        PWM1=1;
  267. //                        PWM2=1;         
  268. //                }
  269.                         
  270. //                HW_PWM1Set(1);        
  271. //                   HW_PWM0Set(255);
  272. //                os_wait(K_TMO,122,0);
  273.         
  274.                
  275. //                HW_PWM0Set(1);
  276. //                HW_PWM1Set(155);
  277. //                os_wait(K_TMO,38,0);

  279.                 os_switch_task();
  280.         }
  281. }                                         
  282. void Basic02(void)      _task_       6           //任务6             基础部分2
  283. {
  284. //        xdata char str[16];

  286.          HW_PWM0Set(1);
  287.          HW_PWM1Set(1);

  289.          while(1)
  290.          {
  291.                 os_wait(K_SIG,0,0);

  293.                 Angle_x_set=atan(Basic02SetValue/2.0/92.0)*57.295;
  294.                   
  295. //                sprintf(str,"%.3f  %.3f\n",Angle_x,Gyro_y);
  296. //                UART1_SendStr(str);
  297.                 if(Basic02SetValue>=30&&Basic02SetValue<=32)
  298.                 {
  299.                           if(Angle_x>-1.0&&Angle_x<3.0)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  300.                         {
  301.                                 HW_PWM0Set(255);
  302.                                 HW_PWM1Set(1);                                
  303.                         }
  304.                         else if(Angle_x<0.0&&Angle_x>-3.0)
  305.                         {
  306.                                 HW_PWM0Set(1);
  307.                                 HW_PWM1Set(1);        
  308.                         }
  309.                         else if(Angle_x<-3.0&&Angle_x>-5.5)
  310.                         {
  311.                                 HW_PWM0Set(1);
  312.                                 HW_PWM1Set(245);        
  313.                         }
  314.                         else
  315.                         {
  316.                                 HW_PWM0Set(1);
  317.                                 HW_PWM1Set(1);
  318.                         }
  319.                 }
  320.                 if(Basic02SetValue>=33&&Basic02SetValue<=35)
  321.                 {
  322.                           if(Angle_x>-1.0&&Angle_x<3.3)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  323.                         {
  324.                                 HW_PWM0Set(255);
  325.                                 HW_PWM1Set(1);                                
  326.                         }
  327.                         else if(Angle_x<-1.0&&Angle_x>-3.3)
  328.                         {
  329.                                 HW_PWM0Set(1);
  330.                                 HW_PWM1Set(1);        
  331.                         }
  332.                         else if(Angle_x<-3.3&&Angle_x>-5.5)
  333.                         {
  334.                                 HW_PWM0Set(1);
  335.                                 HW_PWM1Set(245);        
  336.                         }
  337.                         else
  338.                         {
  339.                                 HW_PWM0Set(1);
  340.                                 HW_PWM1Set(1);
  341.                         }
  342.                 }
  343.                 if(Basic02SetValue==36)                //wucha
  344.                 {
  345.                           if(Angle_x>-1.2&&Angle_x<3.5)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  346.                         {
  347.                                 HW_PWM0Set(255);
  348.                                 HW_PWM1Set(1);                                
  349.                         }
  350.                         else if(Angle_x<-1.0&&Angle_x>-3.5)
  351.                         {
  352.                                 HW_PWM0Set(1);
  353.                                 HW_PWM1Set(1);        
  354.                         }
  355.                         else if(Angle_x<-3.5&&Angle_x>-5.5)
  356.                         {
  357.                                 HW_PWM0Set(1);
  358.                                 HW_PWM1Set(255);        
  359.                         }
  360.                         else
  361.                         {
  362.                                 HW_PWM0Set(1);
  363.                                 HW_PWM1Set(1);
  364.                         }
  365.                 }
  366.                 if(Basic02SetValue>=37&&Basic02SetValue<=39)
  367.                 {
  368.                           if(Angle_x>-2.0&&Angle_x<3.5)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  369.                         {
  370.                                 HW_PWM0Set(255);
  371.                                 HW_PWM1Set(1);                                
  372.                         }
  373.                         else if(Angle_x<-2.0&&Angle_x>-3.5)
  374.                         {
  375.                                 HW_PWM0Set(1);
  376.                                 HW_PWM1Set(1);        
  377.                         }
  378.                         else if(Angle_x<-3.5&&Angle_x>-6.0)
  379.                         {
  380.                                 HW_PWM0Set(1);
  381.                                 HW_PWM1Set(255);        
  382.                         }
  383.                         else
  384.                         {
  385.                                 HW_PWM0Set(1);
  386.                                 HW_PWM1Set(1);
  387.                         }
  388.                 }
  389.                 if(Basic02SetValue>=40&&Basic02SetValue<=43)
  390.                 {
  391.                           if(Angle_x>-2.0&&Angle_x<4.9)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  392.                         {
  393.                                 HW_PWM0Set(255);
  394.                                 HW_PWM1Set(1);                                
  395.                         }
  396.                         else if(Angle_x<-2.0&&Angle_x>-4.9)
  397.                         {
  398.                                 HW_PWM0Set(1);
  399.                                 HW_PWM1Set(1);        
  400.                         }
  401.                         else if(Angle_x<-4.9&&Angle_x>-7.3)
  402.                         {
  403.                                 HW_PWM0Set(1);
  404.                                 HW_PWM1Set(255);        
  405.                         }
  406.                         else
  407.                         {
  408.                                 HW_PWM0Set(1);
  409.                                 HW_PWM1Set(1);
  410.                         }
  411.                 }
  412.                 if(Basic02SetValue==44)
  413.                 {
  414.                           if(Angle_x>-2.0&&Angle_x<4.7)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  415.                         {
  416.                                 HW_PWM0Set(255);
  417.                                 HW_PWM1Set(1);                                
  418.                         }
  419.                         else if(Angle_x<-2.0&&Angle_x>-4.7)
  420.                         {
  421.                                 HW_PWM0Set(1);
  422.                                 HW_PWM1Set(1);        
  423.                         }
  424.                         else if(Angle_x<-4.7&&Angle_x>-7.2)
  425.                         {
  426.                                 HW_PWM0Set(1);
  427.                                 HW_PWM1Set(255);        
  428.                         }
  429.                         else
  430.                         {
  431.                                 HW_PWM0Set(1);
  432.                                 HW_PWM1Set(1);
  433.                         }
  434.                 }
  435.                 if(Basic02SetValue>=45&&Basic02SetValue<=46)
  436.                 {
  437.                           if(Angle_x>-2.0&&Angle_x<5.0)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  438.                         {
  439.                                 HW_PWM0Set(255);
  440.                                 HW_PWM1Set(1);                                
  441.                         }
  442.                         else if(Angle_x<-2.0&&Angle_x>-4.9)
  443.                         {
  444.                                 HW_PWM0Set(1);
  445.                                 HW_PWM1Set(1);        
  446.                         }
  447.                         else if(Angle_x<-4.9&&Angle_x>-7.5)
  448.                         {
  449.                                 HW_PWM0Set(1);
  450.                                 HW_PWM1Set(255);        
  451.                         }
  452.                         else
  453.                         {
  454.                                 HW_PWM0Set(1);
  455.                                 HW_PWM1Set(1);
  456.                         }
  457.                 }
  458.                 if(Basic02SetValue>=47&&Basic02SetValue<=49)
  459.                 {
  460.                           if(Angle_x>-2.0&&Angle_x<5.0)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  461.                         {
  462.                                 HW_PWM0Set(255);
  463.                                 HW_PWM1Set(1);                                
  464.                         }
  465.                         else if(Angle_x<-2.0&&Angle_x>-6.0)
  466.                         {
  467.                                 HW_PWM0Set(1);
  468.                                 HW_PWM1Set(1);        
  469.                         }
  470.                         else if(Angle_x<-6.0&&Angle_x>-8.6)
  471.                         {
  472.                                 HW_PWM0Set(1);
  473.                                 HW_PWM1Set(255);        
  474.                         }
  475.                         else
  476.                         {
  477.                                 HW_PWM0Set(1);
  478.                                 HW_PWM1Set(1);
  479.                         }
  480.                 }
  481.                 if(Basic02SetValue>=50&&Basic02SetValue<=51)
  482.                 {
  483.                           if(Angle_x>-2.0&&Angle_x<6.0)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  484.                         {
  485.                                 HW_PWM0Set(255);
  486.                                 HW_PWM1Set(1);                                
  487.                         }
  488.                         else if(Angle_x<-2.0&&Angle_x>-6.9)
  489.                         {
  490.                                 HW_PWM0Set(1);
  491.                                 HW_PWM1Set(1);        
  492.                         }
  493.                         else if(Angle_x<-6.9&&Angle_x>-9.8)
  494.                         {
  495.                                 HW_PWM0Set(1);
  496.                                 HW_PWM1Set(255);        
  497.                         }
  498.                         else
  499.                         {
  500.                                 HW_PWM0Set(1);
  501.                                 HW_PWM1Set(1);
  502.                         }
  503.                 }
  504.                 if(Basic02SetValue>=52&&Basic02SetValue<=53)
  505.                 {
  506.                           if(Angle_x>-2.0&&Angle_x<5.6)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  507.                         {
  508.                                 HW_PWM0Set(255);
  509.                                 HW_PWM1Set(1);                                
  510.                         }
  511.                         else if(Angle_x<-2.0&&Angle_x>-7.6)
  512.                         {
  513.                                 HW_PWM0Set(1);
  514.                                 HW_PWM1Set(1);        
  515.                         }
  516.                         else if(Angle_x<-7.6&&Angle_x>-10.5)
  517.                         {
  518.                                 HW_PWM0Set(1);
  519.                                 HW_PWM1Set(255);        
  520.                         }
  521.                         else
  522.                         {
  523.                                 HW_PWM0Set(1);
  524.                                 HW_PWM1Set(1);
  525.                         }
  526.                 }
  527.                 if(Basic02SetValue>=54&&Basic02SetValue<=55)
  528.                 {
  529.                           if(Angle_x>-2.0&&Angle_x<6.0)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  530.                         {
  531.                                 HW_PWM0Set(255);
  532.                                 HW_PWM1Set(1);                                
  533.                         }
  534.                         else if(Angle_x<-2.0&&Angle_x>-8.0)
  535.                         {
  536.                                 HW_PWM0Set(1);
  537.                                 HW_PWM1Set(1);        
  538.                         }
  539.                         else if(Angle_x<-8.0&&Angle_x>-11.5)
  540.                         {
  541.                                 HW_PWM0Set(1);
  542.                                 HW_PWM1Set(255);        
  543.                         }
  544.                         else
  545.                         {
  546.                                 HW_PWM0Set(1);
  547.                                 HW_PWM1Set(1);
  548.                         }
  549.                 }
  550.                 if(Basic02SetValue>=56&&Basic02SetValue<=58)
  551.                 {
  552.                           if(Angle_x>-2.0&&Angle_x<7.3)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  553.                         {
  554.                                 HW_PWM0Set(255);
  555.                                 HW_PWM1Set(1);                                
  556.                         }
  557.                         else if(Angle_x<-2.0&&Angle_x>-7.3)
  558.                         {
  559.                                 HW_PWM0Set(1);
  560.                                 HW_PWM1Set(1);        
  561.                         }
  562.                         else if(Angle_x<-7.3&&Angle_x>-11.5)
  563.                         {
  564.                                 HW_PWM0Set(1);
  565.                                 HW_PWM1Set(255);        
  566.                         }
  567.                         else
  568.                         {
  569.                                 HW_PWM0Set(1);
  570.                                 HW_PWM1Set(1);
  571.                         }
  572.                 }
  573.                 if(Basic02SetValue>=59&&Basic02SetValue<=60)
  574.                 {
  575.                           if(Angle_x>-2.0&&Angle_x<7.8)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  576.                         {
  577.                                 HW_PWM0Set(255);
  578.                                 HW_PWM1Set(1);                                
  579.                         }
  580.                         else if(Angle_x<-2.0&&Angle_x>-7.8)
  581.                         {
  582.                                 HW_PWM0Set(1);
  583.                                 HW_PWM1Set(1);        
  584.                         }
  585.                         else if(Angle_x<-7.8&&Angle_x>-12.5)
  586.                         {
  587.                                 HW_PWM0Set(1);
  588.                                 HW_PWM1Set(255);        
  589.                         }
  590.                         else
  591.                         {
  592.                                 HW_PWM0Set(1);
  593.                                 HW_PWM1Set(1);
  594.                         }
  595.                 }
  596.                  os_switch_task();        
  597.          }
  598. }



  602. void Basic03(void)      _task_       7           //任务7             基础部分3
  603. {

  605. while(1)
  606. {
  607.         
  608.         os_wait(K_SIG,0,0);
  609.         
  610.         if(Basic03SetValue==10)           //10度
  611.         {
  612.                
  613.                 if(mpu6050[3]>0)
  614.                 {
  615.                         HW_PWM0Set(1);
  616.                         HW_PWM1Set(1);
  617.                 }
  618.                 else
  619.                 {
  620.                         HW_PWM0Set(1);
  621.                         HW_PWM1Set(55);
  622.                 }
  623.                 if(mpu6050[7]>30)
  624.                 {
  625.                         HW_PWM0Set(1);
  626.                         HW_PWM1Set(1);
  627.                 }        
  628.                 /*处理Y轴*/
  629.                 if(mpu6050[4]>0)
  630.                 {
  631.                         PWM1=1;
  632.                         PWM2=55;               
  633.                 }
  634.                 else
  635.                 {
  636.                         PWM1=205;
  637.                         PWM2=1;        
  638.                 }
  639.                 if(mpu6050[6]>30)
  640.                 {
  641.                         HW_PWM0Set(1);
  642.                         HW_PWM1Set(1);
  643.                 }
  644.         }

  646.         if(Basic03SetValue==20)                         //20度
  647.         {
  648.         if(mpu6050[3]>0)
  649.                 {
  650.                         HW_PWM0Set(75);
  651.                         HW_PWM1Set(1);
  652.                 }
  653.                 else
  654.                 {
  655.                         HW_PWM0Set(1);
  656.                         HW_PWM1Set(205);
  657.                 }
  658.                 if(mpu6050[7]>30)
  659.                 {
  660.                         HW_PWM0Set(1);
  661.                         HW_PWM1Set(1);
  662.                 }        
  663.                 /*处理Y轴*/
  664.                 if(mpu6050[4]>0)
  665.                 {
  666.                         PWM1=1;
  667.                         PWM2=255;               
  668.                 }
  669.                 else
  670.                 {
  671.                         PWM1=255;
  672.                         PWM2=1;        
  673.                 }
  674.                 if(mpu6050[6]>30)
  675.                 {
  676.                         HW_PWM0Set(1);
  677.                         HW_PWM1Set(1);
  678.                 }
  679.         }

  681.         if(Basic03SetValue==30)
  682.         {
  683.                
  684.                         
  685.                 if(mpu6050[3]>0)
  686.                 {
  687.                         HW_PWM0Set(90);
  688.                         HW_PWM1Set(1);
  689.                 }
  690.                 else
  691.                 {
  692.                         HW_PWM0Set(1);
  693.                         HW_PWM1Set(205);
  694.                 }
  695.                 if(mpu6050[7]>15)
  696.                 {
  697.                         HW_PWM0Set(1);
  698.                         HW_PWM1Set(1);
  699.                 }        
  700.                 /*处理Y轴*/
  701.                 if(mpu6050[4]>0)
  702.                 {
  703.                         PWM1=1;
  704.                         PWM2=255;               
  705.                 }
  706.                 else
  707.                 {
  708.                         PWM1=255;
  709.                         PWM2=1;        
  710.                 }
  711.                 if(mpu6050[6]>30)
  712.                 {
  713.                         HW_PWM0Set(1);
  714.                         HW_PWM1Set(1);
  715.                 }
  716.         }

  718.         if(Basic03SetValue==40)
  719.         {
  720.         if(mpu6050[3]>0)
  721.                 {
  722.                         HW_PWM0Set(120);
  723.                         HW_PWM1Set(1);
  724.                 }
  725.                 else
  726.                 {
  727.                         HW_PWM0Set(1);
  728.                         HW_PWM1Set(205);
  729.                 }
  730.                 if(mpu6050[7]>15)
  731.                 {
  732.                         HW_PWM0Set(1);
  733.                         HW_PWM1Set(1);
  734.                 }        
  735.                 /*处理Y轴*/
  736.                 if(mpu6050[4]>0)
  737.                 {
  738.                         PWM1=1;
  739.                         PWM2=255;               
  740.                 }
  741.                 else
  742.                 {
  743.                         PWM1=255;
  744.                         PWM2=1;        
  745.                 }
  746.                 if(mpu6050[6]>15)
  747.                 {
  748.                         HW_PWM0Set(1);
  749.                         HW_PWM1Set(1);
  750.                 }
  751.         }

  753.         if(Basic03SetValue==50)
  754.         {
  755.                
  756.                 if(mpu6050[3]>0)
  757.                 {
  758.                         HW_PWM0Set(105);
  759.                         HW_PWM1Set(1);
  760.                 }
  761.                 else
  762.                 {
  763.                         HW_PWM0Set(1);
  764.                         HW_PWM1Set(168);
  765.                 }
  766.                 if(mpu6050[7]>30)
  767.                 {
  768.                         HW_PWM0Set(1);
  769.                         HW_PWM1Set(1);
  770.                 }        
  771.                 /*处理Y轴*/
  772.                 if(mpu6050[4]>0)
  773.                 {
  774.                         PWM1=1;
  775.                         PWM2=205;               
  776.                 }
  777.                 else
  778.                 {
  779.                         PWM1=205;
  780.                         PWM2=1;        
  781.                 }
  782.                 if(mpu6050[6]>30)
  783.                 {
  784.                         HW_PWM0Set(1);
  785.                         HW_PWM1Set(1);
  786.                 }
  787.         }

  789.         if(Basic03SetValue==60)
  790.         {
  791.                
  792.         if(mpu6050[3]>0)
  793.                 {
  794.                         HW_PWM0Set(205);
  795.                         HW_PWM1Set(1);
  796.                 }
  797.                 else
  798.                 {
  799.                         HW_PWM0Set(1);
  800.                         HW_PWM1Set(205);
  801.                 }
  802.                 if(mpu6050[7]>30)
  803.                 {
  804.                         HW_PWM0Set(1);
  805.                         HW_PWM1Set(1);
  806.                 }        
  807.                 /*处理Y轴*/
  808.                 if(mpu6050[4]>0)
  809.                 {
  810.                         PWM1=1;
  811.                         PWM2=205;               
  812.                 }
  813.                 else
  814.                 {
  815.                         PWM1=125; //145
  816.                         PWM2=1;        
  817.                 }
  818.                 if(mpu6050[6]>20)
  819.                 {
  820.                         HW_PWM0Set(1);
  821.                         HW_PWM1Set(1);
  822.                 }
  823.         }

  825.         if(Basic03SetValue==70)
  826.         {
  827.                 if(mpu6050[3]>0)
  828.                 {
  829.                         HW_PWM0Set(145); //145
  830.                         HW_PWM1Set(1);
  831.                 }
  832.                 else
  833.                 {
  834.                         HW_PWM0Set(1);
  835.                         HW_PWM1Set(145);
  836.                 }
  837.                 if(mpu6050[7]>30)
  838.                 {
  839.                         HW_PWM0Set(1);
  840.                         HW_PWM1Set(1);
  841.                 }        
  842.                 /*处理Y轴*/
  843.                 if(mpu6050[4]>0)
  844.                 {
  845.                         PWM1=1;
  846.                         PWM2=205;               
  847.                 }
  848.                 else
  849.                 {
  850.                         PWM1=1; //145
  851.                         PWM2=1;        
  852.                 }
  853.                 if(mpu6050[6]>20)
  854.                 {
  855.                         HW_PWM0Set(1);
  856.                         HW_PWM1Set(1);
  857.                 }
  858.         }

  860.         if(Basic03SetValue==80)
  861.         {
  862.                 if(mpu6050[3]>0)
  863.                 {
  864.                         HW_PWM0Set(145); //145
  865.                         HW_PWM1Set(1);
  866.                 }
  867.                 else
  868.                 {
  869.                         HW_PWM0Set(1);
  870.                         HW_PWM1Set(145);
  871.                 }
  872.                 if(mpu6050[7]>30)
  873.                 {
  874.                         HW_PWM0Set(1);
  875.                         HW_PWM1Set(1);
  876.                 }        
  877.                 /*处理Y轴*/
  878.                 if(mpu6050[4]>0)
  879.                 {
  880.                         PWM1=1;
  881.                         PWM2=205;               
  882.                 }
  883.                 else
  884.                 {
  885.                         PWM1=1; //145
  886.                         PWM2=1;        
  887.                 }
  888.                 if(mpu6050[6]>20)
  889.                 {
  890.                         HW_PWM0Set(1);
  891.                         HW_PWM1Set(1);
  892.                 }

  894.         }

  896.         if(Basic03SetValue==90)
  897.         {
  898.                         if(Angle_x>-3.0&&Angle_x<10.5)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  899.                 {
  900.                         HW_PWM0Set(255);
  901.                         HW_PWM1Set(1);                                
  902.                 }
  903.                 else if(Angle_x<-3.0&&Angle_x>-7.5)
  904.                 {
  905.                         HW_PWM0Set(1);
  906.                         HW_PWM1Set(1);        
  907.                 }
  908.                 else if(Angle_x<-7.5&&Angle_x>-9.8)
  909.                 {
  910.                         HW_PWM0Set(1);
  911.                         HW_PWM1Set(255);        
  912.                 }
  913.                 else
  914.                 {
  915.                         HW_PWM0Set(1);
  916.                         HW_PWM1Set(1);
  917.                 }

  919.         }

  921.         
  922.         if(Basic03SetValue==100)
  923.         {
  924.                
  925.                 if(mpu6050[3]>0)
  926.                 {
  927.                         HW_PWM0Set(1);
  928.                         HW_PWM1Set(210);
  929.                 }
  930.                 else
  931.                 {

  933.                         HW_PWM0Set(175);
  934.                         HW_PWM1Set(1);
  935.                 }
  936.                 if(mpu6050[7]>30)
  937.                 {
  938.                         HW_PWM0Set(1);
  939.                         HW_PWM1Set(1);
  940.                 }        
  941.                 /*处理Y轴*/
  942.                 if(mpu6050[4]>0)
  943.                 {
  944.         
  945.                         PWM1=45;
  946.                         PWM2=1;                        
  947.                 }
  948.                 else
  949.                 {
  950.                         PWM1=1;
  951.                         PWM2=45;
  952.                 }
  953.                 if(mpu6050[6]>30)
  954.                 {
  955.                         HW_PWM0Set(1);
  956.                         HW_PWM1Set(1);
  957.                 }
  958.         }

  960.         if(Basic03SetValue==110)
  961.         {
  962.                
  963.                 if(mpu6050[3]>0)
  964.                 {
  965.                         HW_PWM0Set(1);
  966.                         HW_PWM1Set(205);
  967.                 }
  968.                 else
  969.                 {

  971.                         HW_PWM0Set(175);
  972.                         HW_PWM1Set(1);
  973.                 }
  974.                 if(mpu6050[7]>30)
  975.                 {
  976.                         HW_PWM0Set(1);
  977.                         HW_PWM1Set(1);
  978.                 }        
  979.                 /*处理Y轴*/
  980.                 if(mpu6050[4]>0)
  981.                 {
  982.         
  983.                         PWM1=95;
  984.                         PWM2=1;                        
  985.                 }
  986.                 else
  987.                 {
  988.                         PWM1=1;
  989.                         PWM2=95;
  990.                 }
  991.                 if(mpu6050[6]>30)
  992.                 {
  993.                         HW_PWM0Set(1);
  994.                         HW_PWM1Set(1);
  995.                 }
  996.         }


  999.            if(Basic03SetValue==120)
  1000.         {
  1001.                
  1002.                 if(mpu6050[3]>0)
  1003.                 {
  1004.                         HW_PWM0Set(1);
  1005.                         HW_PWM1Set(185);
  1006.                 }
  1007.                 else
  1008.                 {

  1010.                         HW_PWM0Set(175);
  1011.                         HW_PWM1Set(1);
  1012.                 }
  1013.                 if(mpu6050[7]>30)
  1014.                 {
  1015.                         HW_PWM0Set(1);
  1016.                         HW_PWM1Set(1);
  1017.                 }        
  1018.                 /*处理Y轴*/
  1019.                 /*处理Y轴*/
  1020.                 if(mpu6050[4]>0)
  1021.                 {
  1022.         
  1023.                         PWM1=155;
  1024.                         PWM2=80;                        
  1025.                 }
  1026.                 else
  1027.                 {
  1028.                         PWM1=1;
  1029.                         PWM2=105;
  1030.                 }
  1031.                 if(mpu6050[6]>30)
  1032.                 {
  1033.                         HW_PWM0Set(1);
  1034.                         HW_PWM1Set(1);
  1035.                 }
  1036.         }

  1038.         if(Basic03SetValue==130)
  1039.         {
  1040.                
  1041.                 if(mpu6050[3]>0)
  1042.                 {
  1043.                         HW_PWM0Set(1);
  1044.                         HW_PWM1Set(205);
  1045.                 }
  1046.                 else
  1047.                 {

  1049.                         HW_PWM0Set(175);
  1050.                         HW_PWM1Set(1);
  1051.                 }
  1052.                 if(mpu6050[7]>30)
  1053.                 {
  1054.                         HW_PWM0Set(1);
  1055.                         HW_PWM1Set(1);
  1056.                 }        
  1057.                 /*处理Y轴*/
  1058.                 if(mpu6050[4]>0)
  1059.                 {
  1060.         
  1061.                         PWM1=195;  //185
  1062.                         PWM2=80;                        
  1063.                 }
  1064.                 else
  1065.                 {
  1066.                         PWM1=1;
  1067.                         PWM2=95;
  1068.                 }
  1069.                 if(mpu6050[6]>30)
  1070.                 {
  1071.                         HW_PWM0Set(1);
  1072.                         HW_PWM1Set(1);
  1073.                 }
  1074.         }

  1076.           if(Basic03SetValue==140)
  1077.         {
  1078.                
  1079.                 if(mpu6050[3]>0)
  1080.                 {
  1081.                         HW_PWM0Set(1);
  1082.                         HW_PWM1Set(165);
  1083.                 }
  1084.                 else
  1085.                 {

  1087.                         HW_PWM0Set(155);
  1088.                         HW_PWM1Set(1);
  1089.                 }
  1090.                 if(mpu6050[7]>30)
  1091.                 {
  1092.                         HW_PWM0Set(1);
  1093.                         HW_PWM1Set(1);
  1094.                 }        
  1095.                 /*处理Y轴*/
  1096.                 if(mpu6050[4]>0)
  1097.                 {
  1098.         
  1099.                         PWM1=205;
  1100.                         PWM2=1;                        
  1101.                 }
  1102.                 else
  1103.                 {
  1104.                         PWM1=1;
  1105.                         PWM2=105;
  1106.                 }
  1107.                 if(mpu6050[6]>30)
  1108.                 {
  1109.                         HW_PWM0Set(1);
  1110.                         HW_PWM1Set(1);
  1111.                 }
  1112.         }

  1114.         if(Basic03SetValue==150)
  1115.         {
  1116.                 if(mpu6050[3]>0)
  1117.                 {
  1118.                         HW_PWM0Set(1);
  1119.                         HW_PWM1Set(225);
  1120.                 }
  1121.                 else
  1122.                 {

  1124.                         HW_PWM0Set(35);
  1125.                         HW_PWM1Set(1);
  1126.                 }
  1127.                 if(mpu6050[7]>30)
  1128.                 {
  1129.                         HW_PWM0Set(1);
  1130.                         HW_PWM1Set(1);
  1131.                 }        
  1132.                 /*处理Y轴*/
  1133.                 if(mpu6050[4]>0)
  1134.                 {
  1135.         
  1136.                         PWM1=185;
  1137.                         PWM2=1;                        
  1138.                 }
  1139.                 else
  1140.                 {
  1141.                         PWM1=1;
  1142.                         PWM2=185;
  1143.                 }
  1144.                 if(mpu6050[6]>15)
  1145.                 {
  1146.                         HW_PWM0Set(1);
  1147.                         HW_PWM1Set(1);
  1148.                 }
  1149.         }

  1151.         if(Basic03SetValue==160)
  1152.         {
  1153.                
  1154.                 if(mpu6050[3]>0)
  1155.                 {
  1156.                         HW_PWM0Set(1);
  1157.                         HW_PWM1Set(185);
  1158.                 }
  1159.                 else
  1160.                 {

  1162.                         HW_PWM0Set(35);
  1163.                         HW_PWM1Set(1);
  1164.                 }
  1165.                 if(mpu6050[7]>30)
  1166.                 {
  1167.                         HW_PWM0Set(1);
  1168.                         HW_PWM1Set(1);
  1169.                 }        
  1170.                 /*处理Y轴*/
  1171.                 if(mpu6050[4]>0)
  1172.                 {
  1173.         
  1174.                         PWM1=205;
  1175.                         PWM2=1;                        
  1176.                 }
  1177.                 else
  1178.                 {
  1179.                         PWM1=1;
  1180.                         PWM2=205;
  1181.                 }
  1182.                 if(mpu6050[6]>30)
  1183.                 {
  1184.                         HW_PWM0Set(1);
  1185.                         HW_PWM1Set(1);
  1186.                 }
  1187.         }

  1189.         if(Basic03SetValue==170)
  1190.         {
  1191.                
  1192.                 if(mpu6050[3]>0)
  1193.                 {
  1194.                         HW_PWM0Set(1);
  1195.                         HW_PWM1Set(95);
  1196.                 }
  1197.                 else
  1198.                 {

  1200.                         HW_PWM0Set(5);
  1201.                         HW_PWM1Set(1);
  1202.                 }
  1203.                 if(mpu6050[7]>30)
  1204.                 {
  1205.                         HW_PWM0Set(1);
  1206.                         HW_PWM1Set(1);
  1207.                 }        
  1208.                 /*处理Y轴*/
  1209.                 if(mpu6050[4]>0)
  1210.                 {
  1211.         
  1212.                         PWM1=205;
  1213.                         PWM2=1;                        
  1214.                 }
  1215.                 else
  1216.                 {
  1217.                         PWM1=1;
  1218.                         PWM2=205;
  1219.                 }
  1220.                 if(mpu6050[6]>30)
  1221.                 {
  1222.                         HW_PWM0Set(1);
  1223.                         HW_PWM1Set(1);
  1224.                 }
  1225.         }
  1226.         
  1227. //                        mpu6050[5]=(float)mpu[5]/32768.0*2000;
  1228.         

  1230.         
  1231. //                if(mpu6050[3]<0&&mpu6050[4]>0)
  1232. //                {
  1233. //                        LED11=0;         //hou yiwozhengqianfangweizuobuao
  1234. //                        LED14=1;
  1235. //                        if(mpu6050[6]<3.0&&mpu6050[6]>0)
  1236. //                        {
  1237. //                                  PWM1=1;
  1238. //                                PWM2=255;
  1239. //                        }
  1240. //                        
  1241. //                }
  1242. //                if(mpu6050[3]<0&&mpu6050[4]<0)
  1243. //                {
  1244. //                        LED12=0;           //zuo
  1245. //                        LED13=1;
  1246. //                        HW_PWM0Set(uk);
  1247. //                }
  1248. //                if(mpu6050[3]>0&&mpu6050[4]>0)
  1249. //                {
  1250. //                        LED13=0;           //有
  1251. //                        LED12=1;
  1252. //                }
  1253. //                if(mpu6050[3]>0&&mpu6050[4]<0)
  1254. //                {
  1255. //                        LED14=0;//qian
  1256. //                        LED11=1;
  1257. //                        if(mpu6050[6]<0&&mpu6050[6]>-3.0)
  1258. //                        {
  1259. //                                  PWM1=255;
  1260. //                                PWM2=1;
  1261. //                        }
  1262. //                }
  1263.                

  1265.                 os_switch_task();
  1266.         }        
  1267. }

  1269. void High01(void) _task_           8                  //任务8               发挥1          High01SetValue
  1270. {
  1271.         PWM1=1;
  1272.         PWM2=1;
  1273.         HW_PWM0Set(1);
  1274.         HW_PWM1Set(1);

  1276.         while(1)
  1277.         {        
  1278.                 os_wait(K_SIG,0,0);
  1279.                 if(High01SetValue==15)
  1280.                 {
  1281.                         if(mpu6050[7]>-1.0&&mpu6050[7]<3.0)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  1282.                         {
  1283.                                 HW_PWM0Set(255);
  1284.                                 HW_PWM1Set(1);                                
  1285.                         }
  1286.                         else if(mpu6050[7]<0.0&&mpu6050[7]>-3.0)
  1287.                         {
  1288.                                 HW_PWM0Set(1);
  1289.                                 HW_PWM1Set(1);        
  1290.                         }
  1291.                         else if(mpu6050[7]<-3.0&&mpu6050[7]>-5.5)
  1292.                         {
  1293.                                 HW_PWM0Set(1);
  1294.                                 HW_PWM1Set(245);        
  1295.                         }
  1296.                         else
  1297.                         {
  1298.                                 HW_PWM0Set(1);
  1299.                                 HW_PWM1Set(1);
  1300.                         }
  1301.         
  1302.         
  1303.                         if(mpu6050[6]>-1.0&&mpu6050[6]<3.2)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  1304.                         {
  1305.                                 PWM1=255;
  1306.                                 PWM2=1;                                
  1307.                         }
  1308.                         else if(mpu6050[6]<-1.0&&mpu6050[6]>-5.0)
  1309.                         {
  1310.                                 PWM1=1;
  1311.                                 PWM2=1;        
  1312.                         }
  1313.                         else if(mpu6050[6]<6.0&&mpu6050[6]>3.2)
  1314.                         {
  1315.                                 PWM1=1;
  1316.                                 PWM2=245;        
  1317.                         }
  1318.                         else
  1319.                         {
  1320.                                 PWM1=1;
  1321.                                 PWM2=1;
  1322.                         }
  1323.                 }
  1324.                

  1326.                 if(High01SetValue>=16&&High01SetValue<=18)
  1327.                 {
  1328.                         if(Angle_x>-2.0&&Angle_x<4.9)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  1329.                         {
  1330.                                 HW_PWM0Set(255);
  1331.                                 HW_PWM1Set(1);                                
  1332.                         }
  1333.                         else if(Angle_x<-2.0&&Angle_x>-4.9)
  1334.                         {
  1335.                                 HW_PWM0Set(1);
  1336.                                 HW_PWM1Set(1);        
  1337.                         }
  1338.                         else if(Angle_x<-4.9&&Angle_x>-7.3)
  1339.                         {
  1340.                                 HW_PWM0Set(1);
  1341.                                 HW_PWM1Set(255);        
  1342.                         }
  1343.                         else
  1344.                         {
  1345.                                 HW_PWM0Set(1);
  1346.                                 HW_PWM1Set(1);
  1347.                         }
  1348.                
  1349.                
  1350.                         if(mpu6050[6]>-1.8&&mpu6050[6]<3.5)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  1351.                         {
  1352.                                 PWM1=255;
  1353.                                 PWM2=1;                                
  1354.                         }
  1355.                         else if(mpu6050[6]<-2.0&&mpu6050[6]>-5.0)
  1356.                         {
  1357.                                 PWM1=1;
  1358.                                 PWM2=1;        
  1359.                         }
  1360.                         else if(mpu6050[6]<7.0&&mpu6050[6]>3.5)
  1361.                         {
  1362.                                 PWM1=1;
  1363.                                 PWM2=255;        
  1364.                         }
  1365.                         else
  1366.                         {
  1367.                                 PWM1=1;
  1368.                                 PWM2=1;
  1369.                         }
  1370.                 }
  1371.                
  1372.                 if(High01SetValue>=18&&High01SetValue<=19)
  1373.                 {
  1374.                         if(Angle_x>-2.0&&Angle_x<6.0)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  1375.                         {
  1376.                                 HW_PWM0Set(255);
  1377.                                 HW_PWM1Set(1);                                
  1378.                         }
  1379.                         else if(Angle_x<-2.0&&Angle_x>-6.0)
  1380.                         {
  1381.                                 HW_PWM0Set(1);
  1382.                                 HW_PWM1Set(1);        
  1383.                         }
  1384.                         else if(Angle_x<-6.0&&Angle_x>-8.6)
  1385.                         {
  1386.                                 HW_PWM0Set(1);
  1387.                                 HW_PWM1Set(255);        
  1388.                         }
  1389.                         else
  1390.                         {
  1391.                                 HW_PWM0Set(1);
  1392.                                 HW_PWM1Set(1);
  1393.                         }
  1394.                         if(mpu6050[6]>-2.5&&mpu6050[6]<3.5)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  1395.                         {
  1396.                                 PWM1=255;
  1397.                                 PWM2=1;                                
  1398.                         }
  1399.                         else if(mpu6050[6]<-2.0&&mpu6050[6]>-5.0)
  1400.                         {
  1401.                                 PWM1=1;
  1402.                                 PWM2=1;        
  1403.                         }
  1404.                         else if(mpu6050[6]<8.0&&mpu6050[6]>3.5)
  1405.                         {
  1406.                                 PWM1=1;
  1407.                                 PWM2=255;        
  1408.                         }
  1409.                         else
  1410.                         {
  1411.                                 PWM1=1;
  1412.                                 PWM2=1;
  1413.                         }
  1414.                 }
  1415.                 if(High01SetValue>=20&&High01SetValue<=22)
  1416.                 {
  1417.                
  1418.                         if(Angle_x>-2.0&&Angle_x<6.9)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  1419.                         {
  1420.                                 HW_PWM0Set(255);
  1421.                                 HW_PWM1Set(1);                                
  1422.                         }
  1423.                         else if(Angle_x<-2.0&&Angle_x>-6.9)
  1424.                         {
  1425.                                 HW_PWM0Set(1);
  1426.                                 HW_PWM1Set(1);        
  1427.                         }
  1428.                         else if(Angle_x<-6.9&&Angle_x>-9.8)
  1429.                         {
  1430.                                 HW_PWM0Set(1);
  1431.                                 HW_PWM1Set(255);        
  1432.                         }
  1433.                         else
  1434.                         {
  1435.                                 HW_PWM0Set(1);
  1436.                                 HW_PWM1Set(1);
  1437.                         }


  1440.                         if(mpu6050[6]>-2.8&&mpu6050[6]<3.5)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  1441.                         {
  1442.                                 PWM1=255;
  1443.                                 PWM2=1;                                
  1444.                         }
  1445.                         else if(mpu6050[6]<-2.0&&mpu6050[6]>-5.0)
  1446.                         {
  1447.                                 PWM1=1;
  1448.                                 PWM2=1;        
  1449.                         }
  1450.                         else if(mpu6050[6]<8.5&&mpu6050[6]>3.5)
  1451.                         {
  1452.                                 PWM1=1;
  1453.                                 PWM2=255;        
  1454.                         }
  1455.                         else
  1456.                         {
  1457.                                 PWM1=1;
  1458.                                 PWM2=1;
  1459.                         }
  1460.                 }

  1462.                 if(High01SetValue>=23&&High01SetValue<=24)
  1463.                 {
  1464.                
  1465.                         if(Angle_x>-2.0&&Angle_x<8.0)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  1466.                         {
  1467.                                 HW_PWM0Set(255);
  1468.                                 HW_PWM1Set(1);                                
  1469.                         }
  1470.                         else if(Angle_x<-2.0&&Angle_x>-8.0)
  1471.                         {
  1472.                                 HW_PWM0Set(1);
  1473.                                 HW_PWM1Set(1);        
  1474.                         }
  1475.                         else if(Angle_x<-8.0&&Angle_x>-11.5)
  1476.                         {
  1477.                                 HW_PWM0Set(1);
  1478.                                 HW_PWM1Set(255);        
  1479.                         }
  1480.                         else
  1481.                         {
  1482.                                 HW_PWM0Set(1);
  1483.                                 HW_PWM1Set(1);
  1484.                         }
  1485.                         if(mpu6050[6]>-3.3&&mpu6050[6]<3.5)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  1486.                         {
  1487.                                 PWM1=255;
  1488.                                 PWM2=1;                                
  1489.                         }
  1490.                         else if(mpu6050[6]<-2.0&&mpu6050[6]>-5.0)
  1491.                         {
  1492.                                 PWM1=1;
  1493.                                 PWM2=1;        
  1494.                         }
  1495.                         else if(mpu6050[6]<9.0&&mpu6050[6]>3.5)
  1496.                         {
  1497.                                 PWM1=1;
  1498.                                 PWM2=255;        
  1499.                         }
  1500.                         else
  1501.                         {
  1502.                                 PWM1=1;
  1503.                                 PWM2=1;
  1504.                         }
  1505.                 }
  1506.         
  1507.                 if(High01SetValue==25)
  1508.                 {
  1509.                         if(Angle_x>-2.0&&Angle_x<8.0)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  1510.                         {
  1511.                                 HW_PWM0Set(255);
  1512.                                 HW_PWM1Set(1);                                
  1513.                         }
  1514.                         else if(Angle_x<-2.0&&Angle_x>-8.0)
  1515.                         {
  1516.                                 HW_PWM0Set(1);
  1517.                                 HW_PWM1Set(1);        
  1518.                         }
  1519.                         else if(Angle_x<-8.0&&Angle_x>-11.5)
  1520.                         {
  1521.                                 HW_PWM0Set(1);
  1522.                                 HW_PWM1Set(255);        
  1523.                         }
  1524.                         else
  1525.                         {
  1526.                                 HW_PWM0Set(1);
  1527.                                 HW_PWM1Set(1);
  1528.                         }
  1529.                
  1530.                         if(mpu6050[6]>-3.8&&mpu6050[6]<3.5)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  1531.                         {
  1532.                                 PWM1=255;
  1533.                                 PWM2=1;                                
  1534.                         }
  1535.                         else if(mpu6050[6]<-2.0&&mpu6050[6]>-5.0)
  1536.                         {
  1537.                                 PWM1=1;
  1538.                                 PWM2=1;        
  1539.                         }
  1540.                         else if(mpu6050[6]<9.8&&mpu6050[6]>3.5)
  1541.                         {
  1542.                                 PWM1=1;
  1543.                                 PWM2=255;        
  1544.                         }
  1545.                         else
  1546.                         {
  1547.                                 PWM1=1;
  1548.                                 PWM2=1;
  1549.                         }
  1550.                 }

  1552.                 if(High01SetValue>=26&&High01SetValue<=27)
  1553.                 {
  1554.                
  1555.                         if(Angle_x>-2.0&&Angle_x<7.3)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  1556.                         {
  1557.                                 HW_PWM0Set(255);
  1558.                                 HW_PWM1Set(1);                                
  1559.                         }
  1560.                         else if(Angle_x<-2.0&&Angle_x>-7.3)
  1561.                         {
  1562.                                 HW_PWM0Set(1);
  1563.                                 HW_PWM1Set(1);        
  1564.                         }
  1565.                         else if(Angle_x<-7.3&&Angle_x>-11.5)
  1566.                         {
  1567.                                 HW_PWM0Set(1);
  1568.                                 HW_PWM1Set(255);        
  1569.                         }
  1570.                         else
  1571.                         {
  1572.                                 HW_PWM0Set(1);
  1573.                                 HW_PWM1Set(1);
  1574.                         }

  1576.                         if(mpu6050[6]>-4.8&&mpu6050[6]<3.5)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  1577.                         {
  1578.                                 PWM1=255;
  1579.                                 PWM2=1;                                
  1580.                         }
  1581.                         else if(mpu6050[6]<-2.0&&mpu6050[6]>-5.0)
  1582.                         {
  1583.                                 PWM1=1;
  1584.                                 PWM2=1;        
  1585.                         }
  1586.                         else if(mpu6050[6]<11.0&&mpu6050[6]>3.5)
  1587.                         {
  1588.                                 PWM1=1;
  1589.                                 PWM2=255;        
  1590.                         }
  1591.                         else
  1592.                         {
  1593.                                 PWM1=1;
  1594.                                 PWM2=1;
  1595.                         }
  1596.                 }
  1597.                
  1598.                
  1599.                 if(High01SetValue>=28&&High01SetValue<=29)
  1600.                 {
  1601.                         if(Angle_x>-2.0&&Angle_x<7.8)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  1602.                         {
  1603.                                 HW_PWM0Set(255);
  1604.                                 HW_PWM1Set(1);                                
  1605.                         }
  1606.                         else if(Angle_x<-2.0&&Angle_x>-7.8)
  1607.                         {
  1608.                                 HW_PWM0Set(1);
  1609.                                 HW_PWM1Set(1);        
  1610.                         }
  1611.                         else if(Angle_x<-7.8&&Angle_x>-12.5)
  1612.                         {
  1613.                                 HW_PWM0Set(1);
  1614.                                 HW_PWM1Set(255);        
  1615.                         }
  1616.                         else
  1617.                         {
  1618.                                 HW_PWM0Set(1);
  1619.                                 HW_PWM1Set(1);
  1620.                         }

  1622.                         if(mpu6050[6]>-5.5&&mpu6050[6]<3.5)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  1623.                         {
  1624.                                 PWM1=255;
  1625.                                 PWM2=1;                                
  1626.                         }
  1627.                         else if(mpu6050[6]<-2.0&&mpu6050[6]>-5.0)
  1628.                         {
  1629.                                 PWM1=1;
  1630.                                 PWM2=1;        
  1631.                         }
  1632.                         else if(mpu6050[6]<12.0&&mpu6050[6]>3.5)
  1633.                         {
  1634.                                 PWM1=1;
  1635.                                 PWM2=255;        
  1636.                         }
  1637.                         else
  1638.                         {
  1639.                                 PWM1=1;
  1640.                                 PWM2=1;
  1641.                         }
  1642.                 }

  1644.                 if(High01SetValue>=30&&High01SetValue<=31)
  1645.                 {
  1646.                 if(Angle_x>-2.5&&Angle_x<7.8)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  1647.                         {
  1648.                                 HW_PWM0Set(255);
  1649.                                 HW_PWM1Set(1);                                
  1650.                         }
  1651.                         else if(Angle_x<-2.0&&Angle_x>-7.8)
  1652.                         {
  1653.                                 HW_PWM0Set(1);
  1654.                                 HW_PWM1Set(1);        
  1655.                         }
  1656.                         else if(Angle_x<-7.8&&Angle_x>-13.5)
  1657.                         {
  1658.                                 HW_PWM0Set(1);
  1659.                                 HW_PWM1Set(255);        
  1660.                         }
  1661.                         else
  1662.                         {
  1663.                                 HW_PWM0Set(1);
  1664.                                 HW_PWM1Set(1);
  1665.                         }

  1667.                         if(mpu6050[6]>-6.6&&mpu6050[6]<3.5)        //Angle_x为x轴的角度，电机的方向通过角度的正负确定
  1668.                         {
  1669.                                 PWM1=255;
  1670.                                 PWM2=1;                                
  1671.                         }
  1672.                         else if(mpu6050[6]<-2.0&&mpu6050[6]>-5.0)
  1673.                         {
  1674.                                 PWM1=1;
  1675. ……………………

  1677. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码


所有资料51hei提供下载:
风力摆控制系统.rar (16.72 MB, 下载次数: 588)



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

使用道具 举报

沙发
ID:308437 发表于 2018-7-19 10:02 | 只看该作者
想问，这个是你的原创么？因为这个我在其他论坛上看到过~~
回复

使用道具 举报

板凳
ID:374977 发表于 2018-7-19 17:00 | 只看该作者
写的不错
回复

使用道具 举报

地板
ID:456306 发表于 2019-6-16 12:10 | 只看该作者
用51做，真的厉害，很好奇实际效果，要是有视频就好了
回复

使用道具 举报

5#
ID:456306 发表于 2019-6-16 12:28 | 只看该作者
看了看报告，上面说是用的开环系统啊，又用了PID。。。
回复

使用道具 举报

6#
ID:540642 发表于 2019-7-16 09:43 | 只看该作者
原理图有吗

回复

使用道具 举报

7#
ID:584982 发表于 2019-7-16 11:26 | 只看该作者
一开始我以为用51板子做不出来，后来我学长跟我说51板子功能其实很强大的，32板子能做的，它都能做
回复

使用道具 举报

8#
ID:552132 发表于 2019-7-25 16:26 | 只看该作者
这个是用12做的吧，不是51
回复

使用道具 举报

9#
ID:445996 发表于 2019-8-6 22:08 | 只看该作者
小宠物 发表于 2019-7-25 16:26
这个是用12做的吧，不是51

51说的是8051内核的单片机都是51单片机
回复

使用道具 举报

10#
ID:591230 发表于 2019-10-29 22:29
实物出售吗
11#
ID:229821 发表于 2020-2-27 20:06 | 只看该作者
不错。谢谢分享。谢谢了。
回复

使用道具 举报

12#
ID:843761 发表于 2020-11-15 11:09 | 只看该作者
哪位大佬有全部的原理图啊
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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