亚洲春色中文字幕久久久-三上亚,一吻二脱三床四吻胸,国产真实伦对白视频全集,在线毛片观看,精品成品入口黄网,国产毛aⅴ片久久久,亚洲AV色香蕉一区二区三区老师,萧皇后A级艳片,色情日本视频更新,99久久亚洲精品日本无码

<xmp id="2ykas"><code id="2ykas"></code></xmp>

<del id="2ykas"><center id="2ykas"></center></del>

<tr id="2ykas"></tr>

標(biāo)題: 風(fēng)力擺控制系統(tǒng)全套設(shè)計(jì)資料（代碼+圖+報(bào)告）15年電賽作品 [打印本頁(yè)]

---

作者: 1112的    時(shí)間: 2018-7-18 15:18
標(biāo)題: 風(fēng)力擺控制系統(tǒng)全套設(shè)計(jì)資料（代碼+圖+報(bào)告）15年電賽作品
這是15年電賽的風(fēng)力擺控制系統(tǒng)，里面包含完整的代碼和完整的報(bào)告以及實(shí)物圖，可以學(xué)到很多東西。


論文：


單片機(jī)源程序如下:

1. #include<rtx51tny.h>                 /* RTX51 tiny functions & defines */
   
2. #include <intrins.h>
   
3. #include "LCD12864.h"
   
4. #include "key.h"
   
5. #include "stc12uart1定時(shí)器1.h"
   
6. #include "stc12uart2.h"
   
7. #include "HW_PWM.h"
   
8. #include<math.h>
   
9. #include<stdio.h>
   
10. 
    
11. #define uchar unsigned char
    
12. #define uint  unsigned int
    
13. 
    
14. unsigned char Key=0x00;                         //確定當(dāng)前哪個(gè)按鍵按下
    
15. 
    
16. sbit LED11=P0^2;
    
17. sbit LED12=P0^3;
    
18. sbit LED13=P0^4;
    
19. sbit LED14=P0^7;
    
20. 
    
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測(cè)得的x軸的角度
    
27. xdata float Angle_x_set=10;                //x軸設(shè)定的角度 角度與位移的公式 L*tan(Angle_x_set)=x
    
28. xdata float x;                                                        //L為萬(wàn)向節(jié)到紙面原點(diǎn)的垂直距離(單位cm)  Angle_x_set為需要設(shè)定的角度
    
29. 
    
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 當(dāng)前偏差 Last_error 上一次偏差  Pre_error上上一次偏差
    
32. xdata int uk_x=0,uk1_x=0.01,duk_x=0;
    
33. 
    
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 當(dāng)前偏差 Last_error 上一次偏差  Pre_error上上一次偏差
    
36. xdata int uk_y=0,uk1_y=0,duk_y=0;
    
37. 
    
38. xdata float setjiaodu3=0;
    
39. uchar m,i;
    
40. bit Basic04Flag=0;      //基礎(chǔ)部分4標(biāo)志位
    
41. //bit Basic04Flag2=0;
    
42.                                                         //x為紙面的位移
    
43. int PID_control();
    
44. /*------------------------------------------------------------------------------------
    
45. ------------------------------------------------------------------------------------*/
    
46. 
    
47. void SystemInit(void) _task_  0                                //任務(wù)0----------------系統(tǒng)初始化
    
48. {        
    
49.         LCD12864_Init();                   //12864液晶初始化
    
50.         KeyInit();                                   //按鍵初始化
    
51.         UART2_Init();                 //STC12C5A串口2初始化，獨(dú)立波特率發(fā)生器產(chǎn)生波特率
    
52.         UART1_Init();                 //STC12C5A串口1初始化，定時(shí)器1產(chǎn)生波特率
    
53.         HW_PWMInit();
    
54.         
    
55.         HW_PWM0Set(1);
    
56.         HW_PWM1Set(1);
    
57.         PWM1=1;
    
58.         PWM2=1;
    
59. 
    
60.         MenuOperate(0);
    
61.         MenuOperate(0);
    
62.         MenuOperate(0);
    
63. 
    
64.         LED11=1;
    
65.         LED12=1;
    
66.         LED13=1;
    
67.         LED14=1;
    
68. 
    
69.         os_create_task(1);                        //創(chuàng)建任務(wù)1
    
70.         os_create_task(2);                        //創(chuàng)建任務(wù)2
    
71.         os_create_task(3);          //創(chuàng)建任務(wù)3
    
72.         os_create_task(4);          //創(chuàng)建任務(wù)4
    
73.         os_create_task(5);                        //創(chuàng)建任務(wù)5
    
74.         os_create_task(6);          //創(chuàng)建任務(wù)6
    
75.         os_create_task(7);          //創(chuàng)建任務(wù)7
    
76.         os_create_task(8);          //創(chuàng)建任務(wù)8
    
77.         os_create_task(9);          //創(chuàng)建任務(wù)9
    
78. 
    
79.         os_delete_task(0);                        //刪除初始化函數(shù)
    
80. }
    
81. void  KeyScan(void)     _task_       1                           //任務(wù)1-----------------------按鍵掃描
    
82. {
    
83.         unsigned char keyvalue=KEY_NULL;
    
84.         
    
85.         while(1)
    
86.         {
    
87.                 GetKey(&keyvalue);                                                    //獲取當(dāng)前鍵值
    
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);                                                 //進(jìn)行周期性檢測(cè)
     
109.         }
     
110. }
     
111. void  LCD12864Display(void) _task_   2                          //任務(wù)2-----------------12864液晶顯示
     
112. {
     
113.         while(1)
     
114.         {
     
115.                 os_wait(K_SIG,0,0);             //等待按鍵信號(hào)
     
116.                 MenuOperate(Key);
     
117.         }
     
118. }
     
119. void UartRec(void)      _task_       3                  //任務(wù)3-------------------串口收發(fā)
     
120. {
     
121. //    float Value[3];
     
122. //        float x,y,z;
     
123. //        xdata char str[16];
     
124. 
     
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;
     
133. 
     
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;
     
138. 
     
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;
     
142. 
     
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;
     
146. 
     
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                      //任務(wù)4
     
157. {
     
158.         while(1)
     
159.         {
     
160.                 switch(KeyFuncIndex)
     
161.                 {
     
162.                         case 10:          //基礎(chǔ)1
     
163.                         //        HW_PWM0Set(1);
     
164.                         //        HW_PWM1Set(1);
     
165.                                 os_send_signal(5);
     
166.                                 break;
     
167.                         case 11:          //基礎(chǔ)2
     
168.                                 //HW_PWM0Set(1);
     
169.                                 //HW_PWM1Set(1);
     
170.                                 os_send_signal(6);
     
171.                                 break;
     
172.                         case 12:          //基礎(chǔ)3
     
173.                                 os_send_signal(7);
     
174.                                 break;
     
175.                         case 16:          //基礎(chǔ)4
     
176.                                 os_send_signal(9);
     
177.                                 break;
     
178.                         case 13:                  //發(fā)揮1
     
179.                                 os_send_signal(8);
     
180.                                 break;
     
181.                         case 14:           //發(fā)揮2
     
182.                                 os_send_signal(9);
     
183.                                 break;
     
184.                         case 15:           //發(fā)揮3
     
185.                                 break;
     
186.                 }
     
187.                 os_switch_task();
     
188.         }
     
189. }
     
190. void PID_control_x()
     
191. {
     
192.         
     
193.         Now_error_x=-mpu6050[6];        //偏差=設(shè)定值—實(shí)際值
     
194.         duk_x=Kp_x*(Now_error_x-Last_error_x)+Ki_x*Now_error_x+Kd_x*mpu6050[3];          //pid增量式公式
     
195. 
     
196.         uk_x=duk_x+uk1_x;          //通過(guò)pid調(diào)節(jié)所需要改變的值
     
197.         
     
198.         uk1_x=uk_x;        //變量值移位
     
199.         Last_error_x=Now_error_x;
     
200. 
     
201. }
     
202. 
     
203. void PID_control_y()
     
204. {
     
205.         
     
206.         Now_error_y=0.0-mpu6050[7];        //偏差=設(shè)定值—實(shí)際值
     
207.         duk_y=Kp_y*(Now_error_y-Last_error_y)+Ki_y*Now_error_y+Kd_y*mpu6050[4];          //pid增量式公式
     
208. 
     
209.         uk_y=duk_y+uk1_y;          //通過(guò)pid調(diào)節(jié)所需要改變的值        
     
210.         uk1_y=uk_y;        //變量值移位
     
211.         Last_error_y=Now_error_y;
     
212. 
     
213. }
     
214. void Basic01(void)      _task_       5              //任務(wù)5        基礎(chǔ)部分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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
     
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.                 }
     
240. 
     
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);
     
278. 
     
279.                 os_switch_task();
     
280.         }
     
281. }                                         
     
282. void Basic02(void)      _task_       6           //任務(wù)6             基礎(chǔ)部分2
     
283. {
     
284. //        xdata char str[16];
     
285. 
     
286.          HW_PWM0Set(1);
     
287.          HW_PWM1Set(1);
     
288. 
     
289.          while(1)
     
290.          {
     
291.                 os_wait(K_SIG,0,0);
     
292. 
     
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
     
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
     
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
     
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
     
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
     
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
     
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
     
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
     
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
     
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
     
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
     
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
     
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
     
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. }
     
599. 
     
600. 
     
601. 
     
602. void Basic03(void)      _task_       7           //任務(wù)7             基礎(chǔ)部分3
     
603. {
     
604. 
     
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.         }
     
645. 
     
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.         }
     
680. 
     
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.         }
     
717. 
     
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.         }
     
752. 
     
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.         }
     
788. 
     
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.         }
     
824. 
     
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.         }
     
859. 
     
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.                 }
     
893. 
     
894.         }
     
895. 
     
896.         if(Basic03SetValue==90)
     
897.         {
     
898.                         if(Angle_x>-3.0&&Angle_x<10.5)        //Angle_x為x軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
     
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.                 }
     
918. 
     
919.         }
     
920. 
     
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.                 {
     
932. 
     
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.         }
     
959. 
     
960.         if(Basic03SetValue==110)
     
961.         {
     
962.                
     
963.                 if(mpu6050[3]>0)
     
964.                 {
     
965.                         HW_PWM0Set(1);
     
966.                         HW_PWM1Set(205);
     
967.                 }
     
968.                 else
     
969.                 {
     
970. 
     
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.         }
     
997. 
     
998. 
     
999.            if(Basic03SetValue==120)
     
1000.         {
      
1001.                
      
1002.                 if(mpu6050[3]>0)
      
1003.                 {
      
1004.                         HW_PWM0Set(1);
      
1005.                         HW_PWM1Set(185);
      
1006.                 }
      
1007.                 else
      
1008.                 {
      
1009. 
      
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.         }
      
1037. 
      
1038.         if(Basic03SetValue==130)
      
1039.         {
      
1040.                
      
1041.                 if(mpu6050[3]>0)
      
1042.                 {
      
1043.                         HW_PWM0Set(1);
      
1044.                         HW_PWM1Set(205);
      
1045.                 }
      
1046.                 else
      
1047.                 {
      
1048. 
      
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.         }
      
1075. 
      
1076.           if(Basic03SetValue==140)
      
1077.         {
      
1078.                
      
1079.                 if(mpu6050[3]>0)
      
1080.                 {
      
1081.                         HW_PWM0Set(1);
      
1082.                         HW_PWM1Set(165);
      
1083.                 }
      
1084.                 else
      
1085.                 {
      
1086. 
      
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.         }
      
1113. 
      
1114.         if(Basic03SetValue==150)
      
1115.         {
      
1116.                 if(mpu6050[3]>0)
      
1117.                 {
      
1118.                         HW_PWM0Set(1);
      
1119.                         HW_PWM1Set(225);
      
1120.                 }
      
1121.                 else
      
1122.                 {
      
1123. 
      
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.         }
      
1150. 
      
1151.         if(Basic03SetValue==160)
      
1152.         {
      
1153.                
      
1154.                 if(mpu6050[3]>0)
      
1155.                 {
      
1156.                         HW_PWM0Set(1);
      
1157.                         HW_PWM1Set(185);
      
1158.                 }
      
1159.                 else
      
1160.                 {
      
1161. 
      
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.         }
      
1188. 
      
1189.         if(Basic03SetValue==170)
      
1190.         {
      
1191.                
      
1192.                 if(mpu6050[3]>0)
      
1193.                 {
      
1194.                         HW_PWM0Set(1);
      
1195.                         HW_PWM1Set(95);
      
1196.                 }
      
1197.                 else
      
1198.                 {
      
1199. 
      
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.         
      
1229. 
      
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.                
      
1264. 
      
1265.                 os_switch_task();
      
1266.         }        
      
1267. }
      
1268. 
      
1269. void High01(void) _task_           8                  //任務(wù)8               發(fā)揮1          High01SetValue
      
1270. {
      
1271.         PWM1=1;
      
1272.         PWM2=1;
      
1273.         HW_PWM0Set(1);
      
1274.         HW_PWM1Set(1);
      
1275. 
      
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
      
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
      
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.                
      
1325. 
      
1326.                 if(High01SetValue>=16&&High01SetValue<=18)
      
1327.                 {
      
1328.                         if(Angle_x>-2.0&&Angle_x<4.9)        //Angle_x為x軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
      
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
      
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
      
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
      
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
      
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.                         }
      
1438. 
      
1439. 
      
1440.                         if(mpu6050[6]>-2.8&&mpu6050[6]<3.5)        //Angle_x為x軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
      
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.                 }
      
1461. 
      
1462.                 if(High01SetValue>=23&&High01SetValue<=24)
      
1463.                 {
      
1464.                
      
1465.                         if(Angle_x>-2.0&&Angle_x<8.0)        //Angle_x為x軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
      
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
      
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
      
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
      
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.                 }
      
1551. 
      
1552.                 if(High01SetValue>=26&&High01SetValue<=27)
      
1553.                 {
      
1554.                
      
1555.                         if(Angle_x>-2.0&&Angle_x<7.3)        //Angle_x為x軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
      
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.                         }
      
1575. 
      
1576.                         if(mpu6050[6]>-4.8&&mpu6050[6]<3.5)        //Angle_x為x軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
      
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軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
      
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.                         }
      
1621. 
      
1622.                         if(mpu6050[6]>-5.5&&mpu6050[6]<3.5)        //Angle_x為x軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
      
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.                 }
      
1643. 
      
1644.                 if(High01SetValue>=30&&High01SetValue<=31)
      
1645.                 {
      
1646.                 if(Angle_x>-2.5&&Angle_x<7.8)        //Angle_x為x軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
      
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.                         }
      
1666. 
      
1667.                         if(mpu6050[6]>-6.6&&mpu6050[6]<3.5)        //Angle_x為x軸的角度，電機(jī)的方向通過(guò)角度的正負(fù)確定
      
1668.                         {
      
1669.                                 PWM1=255;
      
1670.                                 PWM2=1;                                
      
1671.                         }
      
1672.                         else if(mpu6050[6]<-2.0&&mpu6050[6]>-5.0)
      
1673.                         {
      
1674.                                 PWM1=1;
      
1675. ……………………
      
1676. 
      
1677. …………限于本文篇幅 余下代碼請(qǐng)從51黑下載附件…………
      

復(fù)制代碼

所有資料51hei提供下載:
風(fēng)力擺控制系統(tǒng).rar (16.72 MB, 下載次數(shù): 588)

2018-7-18 15:18 上傳

點(diǎn)擊文件名下載附件
下載積分: 黑幣 -5

---

作者: yousunny    時(shí)間: 2018-7-19 10:02
想問(wèn)，這個(gè)是你的原創(chuàng)么？因?yàn)檫@個(gè)我在其他論壇上看到過(guò)~~

---

作者: 小學(xué)生愛(ài)學(xué)習(xí)    時(shí)間: 2018-7-19 17:00
寫(xiě)的不錯(cuò)

---

作者: 15621048596    時(shí)間: 2019-6-16 12:10
用51做，真的厲害，很好奇實(shí)際效果，要是有視頻就好了

---

作者: 15621048596    時(shí)間: 2019-6-16 12:28
看了看報(bào)告，上面說(shuō)是用的開(kāi)環(huán)系統(tǒng)啊，又用了PID。。。

---

作者: chen132    時(shí)間: 2019-7-16 09:43
原理圖有嗎

---

作者: Y_yc123    時(shí)間: 2019-7-16 11:26
一開(kāi)始我以為用51板子做不出來(lái)，后來(lái)我學(xué)長(zhǎng)跟我說(shuō)51板子功能其實(shí)很強(qiáng)大的，32板子能做的，它都能做

---

作者: 小寵物    時(shí)間: 2019-7-25 16:26
這個(gè)是用12做的吧，不是51

---

作者: 許你一世柔情    時(shí)間: 2019-8-6 22:08

小寵物 發(fā)表于 2019-7-25 16:26
這個(gè)是用12做的吧，不是51

51說(shuō)的是8051內(nèi)核的單片機(jī)都是51單片機(jī)

---

作者: saya0769    時(shí)間: 2020-2-27 20:06
不錯(cuò)。謝謝分享。謝謝了。

---

作者: wjnnn    時(shí)間: 2020-11-15 11:09
哪位大佬有全部的原理圖啊

---

歡迎光臨 (http://www.denmoz.com/bbs/)

Powered by Discuz! X3.1

感谢您访问我们的网站，您可能还对以下资源感兴趣：

亚洲春色中文字幕久久久-三上亚

<tr id="qoua8"></tr>

<source id="qoua8"><del id="qoua8"></del></source>

<kbd id="qoua8"><samp id="qoua8"></samp></kbd>