wifi四足机器人

Xiaoxiongai3

wifi四足机器人

wifi四足机器人

wifi四足机器人

wifi四足机器人

wifi四足机器人

四足机器人合并阶段.rar (38.34 KB, 下载次数: 88)

2012-12-26 14:51 上传

点击文件名下载附件
资源共享
同是一个论坛的人 希望大家都能够资源共享 共同进步
用的是51单片机atmal89s52  如果有错误希望大家指正
这个程序是控制12路舵机的 路由器通信的程序就是咱们论坛上
程序挺长一个帖子放不开 弄两个

1. #include<reg52.h>
   
2. #define uchar unsigned char
   
3. #define uint unsigned int
   
4. sbit dj0=P2^0;    sbit dj1=P2^6;
   
5. sbit dj2=P2^2;    sbit dj3=P2^3;
   
6. sbit dj4=P2^4;    sbit dj5=P2^5;
   
7. sbit dj6=P0^3;    sbit dj7=P0^4;
   
8. sbit dj8=P0^5;    sbit dj9=P0^0;
   
9. sbit dj10=P0^1;   sbit dj11=P0^2;
   
10. sbit dj12=P0^7;   sbit dj13=P2^7;
    
11. unsigned int aa1;         //aaaa                        
    
12. unsigned int aa2;                                       
    
13. unsigned int aa3;                                                  
    
14. 
    
15. unsigned int bb1 ;   //bbbb                                 
    
16. unsigned int bb2;                                
    
17. unsigned int bb3;                                                  
    
18. 
    
19. unsigned int cc1;         //cccc
    
20. unsigned int cc2 ;
    
21. unsigned int cc3;
    
22. 
    
23. unsigned int dd1;              //dddd
    
24. unsigned int dd2 ;
    
25. unsigned int dd3 ;
    
26. 
    
27. unsigned int ee1;              //eeee
    
28. unsigned int ee2 ;
    
29. void xqian();        //    向前走
    
30. void xhou();        //    向后走
    
31. void xzuoz();        //          左转弯
    
32. void xyouz();        //          右转弯
    
33. void fwcheng();         //          俯卧撑
    
34. void ztic();        //          做体操
    
35. void zhshou();        //          招收
    
36. void paxia();        //          趴下
    
37. void zhanli();        //          站立?
    
38. void ydtbu();        //    原地踏步
    
39. void dzuoz();  //          大左转
    
40. void ygwei();        //          云台归为
    
41. void yuntz();        //          云台左
    
42. void yunty();        //          云台右
    
43. void yunts();        //          云台上
    
44. void yuntx();        //          云台下
    
45. void twu();           //          跳舞
    
46. void dlian();  //          锻炼
    
47. void delay(unsigned int cnt)
    
48. {
    
49. while(--cnt);
    
50. }
    
51. void main()
    
52. {
    
53.         TMOD |=0x01;              //定时器0工作在方式1
    
54.         TH0=(65536-125)/256;
    
55.         TL0=(65536-125)%256;      //定时
    
56.     ET0=1;//定时器中断打开
    
57.     EA=1;//总中断
    
58.         //IE= 0x82;                 //打开中断
    
59.         TR0=1;
    
60.         
    
61.      P3=0xff;
    
62.          ygwei();
    
63.          zhanli();         //          站立?
    
64. 
    
65. 
    
66.    
    
67.             
    
68.   while(1)
    
69.   {         
    
70. 
    
71. 
    
72. 
    
73. 
    
74. 
    
75.          switch(P3)
    
76.            {   
    
77.                     case 0x01:
    
78.                  {
    
79.                                           while(1)
    
80.                                           {
    
81.                                                   xhou();
    
82.                                                 if(P3==0x0f)
    
83.                                                 {
    
84.                                                 zhanli();
    
85.                                                 break;
    
86.                                                 }
    
87.                                           }
    
88.                                          
    
89.                                 break;         
    
90.                 }
    
91.                  case 0x02:
    
92.                  {
    
93.                                          while(1)
    
94.                                          {
    
95.                                            xqian();
    
96.                                            if(P3==0x0f)
    
97.                                                 {
    
98.                                                 zhanli();        
    
99.                                                 break;
    
100.                                                 }
     
101.                                          }
     
102.                                           
     
103.                         }  break;
     
104.                  case 0x03:  
     
105.                  {
     
106.                                          while(1)
     
107.                                          {
     
108.                                           xzuoz();
     
109.                                           if(P3==0x0f)
     
110.                                         {
     
111.                                         zhanli();
     
112.                                                 break;
     
113.                                                 }
     
114.                                          }
     
115.                                                   
     
116.                 } break;  
     
117.                  case 0x04:        
     
118.                  {
     
119.                                          while(1)
     
120.                                          {
     
121.                                           xyouz();
     
122.                                           if(P3==0x0f)
     
123.                                                 {
     
124.                                                 zhanli();
     
125.                                                 break;
     
126.                                                 }
     
127. 
     
128.                                          }
     
129.                                           
     
130.                         } break;
     
131.                   case 0x05:
     
132.                   {
     
133.                                           while(1)
     
134.                                           {
     
135.                                            zhanli();
     
136.                                            if(P3==0x0f)
     
137.                                                 {
     
138.                                                 zhanli();
     
139.                                                 break;
     
140.                                                 }
     
141.                                           }
     
142.                                           
     
143.                                           
     
144.                         } break;
     
145. 
     
146. 
     
147.                         case 0x06:  
     
148.                         {
     
149.                                          while(1)
     
150.                                          {
     
151.                                           xzuoz();
     
152.                                           if(P3==0x0f)
     
153.                                         {
     
154.                                         zhanli();
     
155.                                                 break;
     
156.                                                 }
     
157.                                          }
     
158.                                                   
     
159.                         } break;  
     
160. 
     
161. 
     
162. 
     
163. 
     
164.                                          case 0x07:
     
165.                                         {
     
166.                                          while(1)
     
167.                                          {
     
168.                                           ydtbu();
     
169.                                           if(P3==0x0f)
     
170.                                         {
     
171.                                         zhanli();
     
172.                                                 break;
     
173.                                                 }
     
174.                                          }
     
175.                                                   
     
176.                                         } break;  
     
177. 
     
178. 
     
179. 
     
180.                                    case 0x08:
     
181.                                     {
     
182.                                          while(1)
     
183.                                          {
     
184.                                           ztic();
     
185.                                           if(P3==0x0f)
     
186.                                         {
     
187.                                         zhanli();
     
188.                                                 break;
     
189.                                                 }
     
190.                                          }
     
191.                                                   
     
192.                                         } break;  
     
193. 
     
194. 
     
195. 
     
196. 
     
197.                                         case 0x09:  
     
198.                                         {
     
199.                                          while(1)
     
200.                                          {
     
201.                                           fwcheng();
     
202.                                           if(P3==0x0f)
     
203.                                         {
     
204.                                         zhanli();
     
205.                                                 break;
     
206.                                                 }
     
207.                                          }
     
208.                                                   
     
209.                                         } break;  
     
210. 
     
211. 
     
212. 
     
213. 
     
214.                                          case 0x010:
     
215.                                           {
     
216.                                          while(1)
     
217.                                          {
     
218.                                           zhshou();
     
219.                                           if(P3==0x0f)
     
220.                                         {
     
221.                                         zhanli();
     
222.                                                 break;
     
223.                                                 }
     
224.                                          }
     
225.                                                   
     
226.                                         } break;  
     
227. 
     
228. 
     
229. 
     
230.                                         case 0x11:  
     
231.                                         {
     
232.                                          while(1)
     
233.                                          {
     
234.                                           twu();
     
235.                                           if(P3==0x0f)
     
236.                                         {
     
237.                                         zhanli();
     
238.                                                 break;
     
239.                                                 }
     
240.                                          }
     
241.                                                   
     
242.                                         } break;  
     
243. 
     
244. 
     
245. 
     
246.                                         case 0x12:
     
247.                                          {
     
248.                                          while(1)
     
249.                                          {
     
250.                                           dlian();
     
251.                                           if(P3==0x0f)
     
252.                                         {
     
253.                                         zhanli();
     
254.                                                 break;
     
255.                                                 }
     
256.                                          }
     
257.                                                   
     
258.                                         } break;  
     
259. 
     
260. 
     
261. 
     
262. 
     
263.                                         case 0x13:  
     
264.                                         {
     
265.                                          while(1)
     
266.                                          {
     
267.                                           dzuoz();
     
268.                                           if(P3==0x0f)
     
269.                                         {
     
270.                                         zhanli();
     
271.                                                 break;
     
272.                                                 }
     
273.                                          }
     
274.                                                   
     
275.                                         } break;  
     
276. 
     
277. 
     
278. 
     
279.                                         case 0x14:
     
280.                                          {
     
281.                                          while(1)
     
282.                                          {
     
283.                                           ygwei();
     
284.                                           if(P3==0x0f)
     
285.                                         {
     
286.                                         zhanli();
     
287.                                                 break;
     
288.                                                 }
     
289.                                          }
     
290.                                                   
     
291.                                         } break;  
     
292. 
     
293. 
     
294.                                    case 0x15:  
     
295.                                    {
     
296.                                          while(1)
     
297.                                          {
     
298.                                           yunts();
     
299.                                           if(P3==0x0f)
     
300.                                         {
     
301.                                         zhanli();
     
302.                                                 break;
     
303.                                                 }
     
304.                                          }
     
305.                                                   
     
306.                                         } break;  
     
307. 
     
308. 
     
309. 
     
310. 
     
311.                                    case 0x16:
     
312.                                     {
     
313.                                          while(1)
     
314.                                          {
     
315.                                           paxia();
     
316.                                           if(P3==0x0f)
     
317.                                         {
     
318.                                         zhanli();
     
319.                                                 break;
     
320.                                                 }
     
321.                                          }
     
322.                                                   
     
323.                                         } break;  
     
324. 
     
325. 
     
326. 
     
327.                                    case 0x17:  
     
328.                                    {
     
329.                                          while(1)
     
330.                                          {
     
331.                                           xzuoz();
     
332.                                           if(P3==0x0f)
     
333.                                         {
     
334.                                         zhanli();
     
335.                                                 break;
     
336.                                                 }
     
337.                                          }
     
338.                                                   
     
339.                                         } break;  
     
340. 
     
341. 
     
342. 
     
343. 
     
344.                                    case 0x18:  {
     
345.                                          while(1)
     
346.                                          {
     
347.                                           xzuoz();
     
348.                                           if(P3==0x0f)
     
349.                                         {
     
350.                                         zhanli();
     
351.                                                 break;
     
352.                                                 }
     
353.                                          }
     
354.                                                   
     
355.                                         } break;  
     
356. 
     
357. 
     
358. 
     
359.                                         case 0x19:
     
360.                                          {
     
361.                                          while(1)
     
362.                                          {
     
363.                                           xzuoz();
     
364.                                           if(P3==0x0f)
     
365.                                         {
     
366.                                         zhanli();
     
367.                                                 break;
     
368.                                                 }
     
369.                                          }
     
370.                                                   
     
371.                                         } break;  
     
372. 
     
373. 
     
374. 
     
375.                                         case 0x20:  
     
376.                                         {
     
377.                                          while(1)
     
378.                                          {
     
379.                                           xzuoz();
     
380.                                           if(P3==0x0f)
     
381.                                         {
     
382.                                         zhanli();
     
383.                                                 break;
     
384.                                                 }
     
385.                                          }
     
386.                                                   
     
387.                                         } break;  
     
388. 
     
389. 
     
390. 
     
391.                                    case 0x21:
     
392.                                     {
     
393.                                          while(1)
     
394.                                          {
     
395.                                           xzuoz();
     
396.                                           if(P3==0x0f)
     
397.                                         {
     
398.                                         zhanli();
     
399.                                                 break;
     
400.                                                 }
     
401.                                          }
     
402.                                                   
     
403.                                         } break;  
     
404. 
     
405. 
     
406. 
     
407.                                         case 0x22:  {
     
408.                                          while(1)
     
409.                                          {
     
410.                                                  yuntz();
     
411.                                           if(P3==0x0f)
     
412.                                         {
     
413.                                         zhanli();
     
414.                                                 break;
     
415.                                                 }
     
416.                                          }
     
417.                                                   
     
418.                                         } break;  
     
419. 
     
420. 
     
421. 
     
422.                                         case 0x23:  {
     
423.                                          while(1)
     
424.                                          {
     
425.                                           yuntx();
     
426.                                           if(P3==0x0f)
     
427.                                         {
     
428.                                         zhanli();
     
429.                                                 break;
     
430.                                                 }
     
431.                                          }
     
432.                                                   
     
433.                                         } break;  
     
434. 
     
435. 
     
436.                                         case 0x24:  {
     
437.                                          while(1)
     
438.                                          {
     
439.                                           yunty();
     
440.                                           if(P3==0x0f)
     
441.                                         {
     
442.                                         zhanli();
     
443.                                                 break;
     
444.                                                 }
     
445.                                          }
     
446.                                                   
     
447.                                         } break;  
     
448. 
     
449.                                    case 0x25:
     
450.                                     {   
     
451.                                          while(1)
     
452.                                          {
     
453.                                           xzuoz();
     
454.                                           if(P3==0x0f)
     
455.                                         {
     
456.                                         zhanli();
     
457.                                                 break;
     
458.                                                 }
     
459.                                          }
     
460.                                                   
     
461.                                         } break;  
     
462.                  default:break;         
     
463.            }
     
464.          
     
465.          
     
466.   }
     
467. }
     
468. 
     
469. void tim(void) interrupt 1 using 1
     
470. {
     
471.         static unsigned int count;                  //static 静态常量
     
472. 
     
473.         TH0=(65536-125)/256;
     
474.         TL0=(65536-125)%256;  //定时
     
475. 
     
476.         if (count<aa1)                           //0舵机
     
477.     {
     
478.      dj0 = 1;            //给高电平
     
479.     }
     
480.         else
     
481.         {
     
482.           dj0=0 ;
     
483.         }
     
484. 
     
485.         if (count<aa2)                        //1舵机
     
486.     {
     
487.        dj1=1;        //给高电 平
     
488.     }
     
489.         else
     
490.         {
     
491.           dj1=0;
     
492.         }
     
493. 
     
494.         if (count<aa3)                        //2舵机
     
495.     {
     
496.        dj2=1;        //给高电 平
     
497.     }
     
498.         else
     
499.         {
     
500.           dj2=0;
     
501.         }
     
502. 
     
503.                 if (count<bb1)                        //3舵机
     
504.     {
     
505.        dj3=1;        //给高电 平
     
506.     }
     
507.         else
     
508.         {
     
509.           dj3=0;
     
510.         }
     
511. 
     
512.                 if (count<bb2)                        //4舵机
     
513.     {
     
514.        dj4=1;        //给高电 平
     
515.     }
     
516.         else
     
517.         {
     
518.           dj4=0;
     
519.         }
     
520.                         if (count<bb3)                        //5舵机
     
521.     {
     
522.        dj5=1;        //给高电 平
     
523.     }
     
524.         else
     
525.         {
     
526.           dj5=0;
     
527.         }
     
528. 
     
529.                         if (count<cc1)                        //6舵机
     
530.     {
     
531.        dj6=1;        //给高电 平
     
532.     }
     
533.         else
     
534.         {
     
535.           dj6=0;
     
536.         }
     
537.                         if (count<cc2)                        //7舵机
     
538.     {
     
539.        dj7=1;        //给高电 平
     
540.     }
     
541.         else
     
542.         {
     
543.           dj7=0;
     
544.         }
     
545.                            if (count<cc3)                        //8舵机
     
546.     {
     
547.        dj8=1;        //给高电 平
     
548.     }
     
549.         else
     
550.         {
     
551.           dj8=0;
     
552.         }
     
553.                         if (count<dd1)                        //9舵机
     
554.     {
     
555.        dj9=1;        //给高电 平
     
556.     }
     
557.         else
     
558.         {
     
559.           dj9=0;
     
560.         }
     
561.                         if (count<dd2)                        //10舵机
     
562.     {
     
563.        dj10=1;        //给高电 平
     
564.     }
     
565.         else
     
566.         {
     
567.           dj10=0;
     
568.         }
     
569.                    if (count<dd3)                        //11舵机
     
570.     {
     
571.        dj11=1;        //给高电 平
     
572.     }
     
573.         else
     
574.         {
     
575.           dj11=0;
     
576.         }
     
577.                 if (count<ee1)                        //12舵机
     
578.     {
     
579.        dj12=1;        //给高电 平
     
580.     }
     
581.         else
     
582.         {
     
583.           dj12=0;
     
584.         }
     
585.                  if (count<ee2)                        //13舵机
     
586.     {
     
587.        dj13=1;        //给高电 平
     
588.     }
     
589.         else
     
590.         {
     
591.           dj13=0;
     
592.         }
     
593. 
     
594.         count++;
     
595. 
     
596.         if(count==260)
     
597.     {
     
598.        count=0;   
     
599.         }               
     
600.                
     
601. }

复制代码

Xiaoxiongai3

1. void xqian()         //向这炮火前进
   
2. {
   
3. aa1=16;         aa2=22;         aa3=16;         // ac3增大抬起减小放下
   
4. bb1=10; bb2=7; bb3=14;         // bd3增大放下减小抬起
   
5. cc1=12;         cc2=23; cc3=17;         //ac2增大放下减小抬起
   
6. dd1=20;         dd2=6; dd3=13;         //bd2减小放下增大抬起
   
7. delay(1000);
   
8. bb2=10; dd2=10;
   
9. delay(500);
   
10. aa1=10; aa2=25; aa3=14;
    
11. bb1=18;         bb2=8; bb3=12;
    
12. cc1=18;         cc2=26;         cc3=16;
    
13. dd1=13;         dd2=9;         dd3=15;
    
14. delay(1000);
    
15. aa2=24; cc2=24;
    
16. delay(500);
    
17. }
    
18. void xhou()         //打不过che回来
    
19. {       
    
20. aa1=11;         aa2=20; aa3=15; //cccc         // bd3增大放下减小抬起
    
21. bb1=19;         bb2=7; bb3=13; //dddd         // ac3增大抬起减小放下
    
22. cc1=19;         cc2=24;         cc3=17; //aaaa         //ac2增大放下减小抬起
    
23. dd1=13; dd2=6; dd3=14; //bbbb         //bd2减小放下增大抬起
    
24. delay(1000);
    
25. bb2=10;         dd2=8;
    
26. delay(500);
    
27. aa1=18;         aa2=23; aa3=14;
    
28. bb1=11;         bb2=8; bb3=15;
    
29. cc1=11;         cc2=26;        cc3=15;
    
30. dd1=20;         dd2=8;        dd3=13;
    
31. delay(1000);
    
32. aa2=21;         cc2=23;
    
33. delay(500);
    
34. }
    
35. void xzuoz()         //         左转弯       
    
36. {
    
37. aa1=14;         aa2=22; aa3=15; //aaa // ac3增大抬起减小放下
    
38. bb1=15;         bb2=6; bb3=13; //bbb // bd3增大放下减小抬起
    
39. cc1=15;         cc2=23; cc3=14; //ccc         //ac2增大放下减小抬起
    
40. dd1=14; dd2=6; dd3=14; //ddd         //bd2减小放下增大抬起
    
41. delay(700);
    
42. aa1=20;         bb1=19; cc1=21; dd1=20;
    
43. delay(700);
    
44. bb1=14; bb2=9; dd1=15; dd2=9;
    
45. delay(700);
    
46. bb2=6; dd2=6;
    
47. delay(700);
    
48. aa2=18; cc2=20;
    
49. delay(700);
    
50. 
    
51. }
    
52. void xyouz()         //         右转弯       
    
53. {
    
54. aa1=17;         aa2=24; aa3=15; //aaa // ac3增大抬起减小放下
    
55. bb1=16;         bb2=6; bb3=13; //bbb // bd3增大放下减小抬起
    
56. cc1=21;         cc2=23; cc3=15;         //ccc         //ac2增大放下减小抬起
    
57. dd1=15; dd2=6; dd3=14;        //ddd         //bd2减小放下增大抬起
    
58. delay(700);
    
59. aa1=13;         bb1=9; cc1=14; dd1=10;
    
60. delay(700);
    
61. bb1=14; bb2=9;
    
62. dd1=15; dd2=9;
    
63. delay(700);
    
64. bb2=6; dd2=6;
    
65. delay(700);
    
66. aa2=18; cc2=20;
    
67. delay(700);
    
68. }
    
69. void zhanli()         //         站立
    
70. {
    
71. aa1=15 ; aa2=23;         aa3=15;         //aaaa         //ac2增大放下减小抬起
    
72. bb1=14; bb2=8; bb3=13;         //bbbb         //bd2减小放下增大抬起
    
73. cc1=16;         cc2=24; cc3=17; //cccc         // ac增大抬起减小放下
    
74. dd1=15;         dd2=8; dd3=13 ; //dddd         // bd增大放下减小抬起
    
75. delay(1000);
    
76. }
    
77. void fwcheng()         //         俯卧撑
    
78. {
    
79. yuntx();
    
80. yuntx();
    
81. yuntx();
    
82. yuntx();
    
83. yuntx();
    
84. aa1=14;         aa2=24; aa3=15; //aaa         // ac3增大抬起减小放下
    
85. bb1=9;         bb2=14; bb3=16 ; //bbb         // bd3增大放下减小抬起
    
86. cc1=21;         cc2=18;         cc3=13;         //ccc         //ac2增大放下减小抬起
    
87. dd1=16; dd2=6; dd3=11;        //ddd         //bd2减小放下增大抬起
    
88. 
    
89. delay(1500);
    
90. aa2=18;         aa3=8;
    
91. dd2=10;         dd3=19;       
    
92. delay(1500);
    
93. yunts();
    
94. yunts();
    
95. yunts();
    
96. yunts();
    
97. yunts();         // bd3增大放下减小抬起
    
98. }
    
99. void ztic()         //         做体操
    
100. {
     
101. aa1=10;         aa2=27; aa3=17; //aaa         // ac3增大抬起减小放下
     
102. bb1=19;         bb2=7; bb3=12; //bbb         // bd3增大放下减小抬起
     
103. cc1=11;         cc2=24; cc3=15; //ccc         //ac2增大放下减小抬起
     
104. dd1=20; dd2=8; dd3=15; //ddd         //bd2减小放下增大抬起
     
105. delay(1500);
     
106. aa2=28; aa3=15;
     
107. bb2=6; bb3=14;
     
108. cc2=16;         cc3=10;       
     
109. dd2=14;         dd3=20;
     
110. delay(1500);
     
111. aa1=10;         aa2=23; aa3=15; //aaa         // bd3增大放下减小抬起
     
112. bb1=19;         bb2=7; bb3=13; //bbb         // ac3增大抬起减小放下
     
113. cc1=11;         cc2=24; cc3=17;         //ccc         //ac2增大放下减小抬起
     
114. dd1=20; dd2=7; dd3=13;         //ddd         //bd2减小放下增大抬起
     
115. delay(1500);
     
116. aa2=17;         aa3=10;       
     
117. bb2=14;         bb3=20;
     
118. cc2=26; cc3=16;
     
119. dd2=6; dd3=15;
     
120. delay(1500);
     
121. }
     
122. void zhshou()         //         招收
     
123. {
     
124. yunty();
     
125. yunty();
     
126. yunty();
     
127. yunty();
     
128. yunty();
     
129. aa1=15;         aa2=9; aa3=21; //aaa         // ac3增大抬起减小放下
     
130. bb1=17;         bb2=8; bb3=13; //bbb // bd3增大放下减小抬起
     
131. cc1=19;         cc2=21; cc3=14; //ccc         //ac2增大放下减小抬起
     
132. dd1=12; dd2=8; dd3=13; //ddd         //bd2减小放下增大抬起
     
133. delay(800);
     
134. aa1=20;
     
135. delay(800);
     
136. aa1=12;
     
137. delay(800);
     
138. yuntz();
     
139. yuntz();
     
140. yuntz();
     
141. yuntz();
     
142. yuntz();
     
143. }
     
144. void paxia()         //         趴下
     
145. {
     
146. aa1=15;         aa2=22; aa3=6; //aaaa         //ac2增大放下减小抬起
     
147. bb1=14; bb2=9; bb3=26;        //bbbb         //bd2减小放下增大抬起
     
148. cc1=14;         cc2=21; cc3=6; //cccc         // ac3增大抬起减小放下
     
149. dd1=15;         dd2=8; dd3=25; //dddd // bd3增大放下减小抬起
     
150. delay(2000);
     
151. }
     
152. void ydtbu()         // 原地踏步
     
153. {
     
154. aa1=15; aa2=22;         aa3=14;         //aaaa         //ac2增大放下减小抬起
     
155. bb1=14; bb2=7; bb3=13; //bbbb         //bd2减小放下增大抬起
     
156. cc1=15;         cc2=24; cc3=15; //cccc         // ac增大抬起减小放下
     
157. dd1=15;         dd2=7; dd3=13 ; //dddd         // bd增大放下减小抬起
     
158. delay(100);
     
159. bb2=11; bb3=18;
     
160. dd2=11; dd3=18;
     
161. delay(500);
     
162. bb2=7; bb3=13;
     
163. dd2=7; dd3=13;
     
164. delay(500);
     
165. aa2=18; aa3=10;
     
166. cc2=18; cc3=11;
     
167. delay(500);
     
168. aa2=22;         aa3=14;
     
169. cc2=24;         cc3=15;
     
170. delay(500);
     
171. }
     
172. void dzuoz()         //         大左转
     
173. {
     
174. aa1=10;         aa2=23; aa3=15; //aaa         // bd3增大放下减小抬起
     
175. bb1=18;         bb2=8; bb3=14; //bbb // ac3增大抬起减小放下
     
176. cc1=11;         cc2=22; cc3=15; //ccc         //ac2增大放下减小抬起
     
177. dd1=20; dd2=8; dd3=14;         //ddd         //bd2减小放下增大抬起
     
178. delay(1800);
     
179. bb2=12;         dd2=12;
     
180. delay(400);
     
181. cc1=18;         aa1=16;
     
182. delay(900);
     
183. bb1=9; dd1=10;
     
184. delay(900);
     
185. aa2=23;         aa3=14;         //aaa         // ac3增大抬起减小放下
     
186. bb1=9;         bb2=8; bb3=15; //bbb // bd3增大放下减小抬起       
     
187. cc2=22; cc3=15;         //ccc         //ac2增大放下减小抬起
     
188. dd1=10; dd2=8; dd3=14;         //ddd         //bd2减小放下增大抬起
     
189. delay(1800);
     
190. aa2=20; cc2=19;
     
191. delay(900);
     
192. bb1=19;         dd1=20;
     
193. delay(900);
     
194. }
     
195. void ygwei()         //         云台归为
     
196. {
     
197. ee1=16; ee2=18;
     
198. delay(10);
     
199. }
     
200. void yuntz()         //         云台左
     
201. {
     
202. ee1--;
     
203. delay(100);
     
204. if(ee1<6)
     
205. {
     
206. ee1=6;
     
207. }
     
208. }
     
209. void yunty()         //         云台右
     
210. {       
     
211. ee1++;
     
212. delay(100);
     
213. if(ee1>25)
     
214. {
     
215. ee1=25;
     
216. }
     
217. }
     
218. void yunts()         //         云台上
     
219. {       
     
220. ee2--;
     
221. delay(100);
     
222. if(ee2<6)
     
223. {
     
224. ee2=6;
     
225. }
     
226. }
     
227. void yuntx()         //         云台下
     
228. {       
     
229. ee2++;
     
230. delay(100);
     
231. if(ee2>25)
     
232. {
     
233. ee2=25;
     
234. }
     
235. }
     
236. void twu()         //         跳舞
     
237. {
     
238. 
     
239. zhshou();
     
240. zhshou();       
     
241. zhshou();
     
242. zhshou();
     
243. zhanli();
     
244. ygwei();
     
245. ydtbu();
     
246. ydtbu();
     
247. ydtbu();
     
248. ydtbu();
     
249. ydtbu();
     
250. ydtbu();
     
251. ydtbu();
     
252. ydtbu();
     
253. zhanli();
     
254. paxia();
     
255. zhanli();
     
256. delay(1000);
     
257. paxia();
     
258. zhanli();
     
259. delay(1000);
     
260. paxia();
     
261. zhanli();
     
262. delay(1000);
     
263. paxia();
     
264. zhanli();
     
265. delay(1000);
     
266. dzuoz();
     
267. dzuoz();
     
268. dzuoz();
     
269. dzuoz();
     
270. zhanli();
     
271. ygwei();
     
272. }
     
273. void dlian()         //         锻炼
     
274. {
     
275. fwcheng();
     
276. fwcheng();
     
277. fwcheng();
     
278. zhanli();
     
279. ygwei();
     
280. ztic();
     
281. ztic();
     
282. ztic();
     
283. ztic();
     
284. zhanli();
     
285. fwcheng();
     
286. fwcheng();
     
287. fwcheng();
     
288. zhanli();
     
289. ygwei();
     
290. ydtbu();
     
291. ydtbu();
     
292. ydtbu();
     
293. ydtbu();
     
294. ydtbu();
     
295. ydtbu();
     
296. zhanli();
     
297. ztic();
     
298. ztic();
     
299. ztic();
     
300. ztic();
     
301. ygwei();
     
302. }

复制代码

Xiaoxiongai3

希望大家尽早完成心目中的作品 0.0

赤龙之吼

赤龙之吼

       人才啊  代码高手

Xiaoxiongai3

赤龙之吼 发表于 2012-12-26 15:57

真厉害 甘拜下风 六足的 还有超声波测距 他是自己走的还是什么控制呢 有视频吗 求资料

最后一滴血

牛人，佩服

赤龙之吼

Xiaoxiongai3 发表于 2012-12-26 16:18
真厉害 甘拜下风 六足的 还有超声波测距 他是自己走的还是什么控制呢 有视频吗 求资料

我就是做着玩 用的现成的舵机控制板  程序的话基本不用写

掌心化雪

犀利啊，好好学习！

Xiaoxiongai3

赤龙之吼 发表于 2012-12-26 16:56
我就是做着玩 用的现成的舵机控制板  程序的话基本不用写

真漂亮 你看我的线太乱了 花了多少钱 肯定贵着呢