Rosmin--折腾USB Host Shield的日子

转自：http://blog.csdn.net/xiaoqiaoaidianzi/article/details/9170937

  好了，正式开始回忆了，去年夏天做完数模后，就开始了Rosmin的设计制作之旅，WTFROBOT中，我负责硬件及相关软件部分的任务，Rosmin中做的主要是arduino端的工作。 

     开始的日子很幸福，过着没有bug的日子，我们预先购买的Romeo（一款arduino小板）也很给面子完成了前期的大部分基本测试，可是随着功能的增多，Romeo终于hold不住了， bug频频，每天都是调不完的bug，具体的问题就是我们让Romeo通过USB Host Shield与android手机通信下完成驱动小车运动，控制2自由度云台和超声波模块，在实际测试中发现启用USB Host 模式后，超声波模块不可用，并且卡死进程，想了很多天后了，克服了乱花国家钱的心理障碍，花了MZD若干张，一切豁然开朗.....

    其实问题很明显，小板资源不够用了......

    在寻求解决方案的过程中，最开始想到了复用定时器的方案，进一步想到的是在Romeo运行一个类实时系统RTOS的方法，但是经过一番了解后发现，arduino上运行RTOS，学习使用那啥实时系统和具体代码修改时间过长，对项目的完成进度不利，舍弃！

    人生就是折腾，不折腾非人生也！手头上正好有一块TI 的launchpad，在energia（一个类似arduino 的IDE）下完成了由430控制超声波模块采集数据并传回给Romeo的任务，其中Romeo已经用完了所有定时器，无法利用串口或模拟串口通信，只好用采样电平的方法通信，此时，电平转换是一个喜闻乐见的问题，经过调换电阻后可以完成基本通信，在整体测试中，通信的稳定性与利用电平高低机制通信的方法带来的局限性让测试效果让人难以接受，这样launchpad+Romeo进行Rosmin硬件层控制的方案，只好舍弃！

   最后的出路，大出血（当然也不是我们的钱）买回了adk，引脚多了，再也不会担心引脚不够用的问题了，想想USB Host Shield会占用5个数字IO口，可怜的Rome一共才13个数字IO口，还好时间还够，进度还算赶上来了，最终完成了Rosmin的预期设计功能.

   下面是一些资料：

   https://github.com/PeterVranken/RTuinOS

   http://www.circuitsathome.com/mcu/usb-host-shield-library-version-2-0-released

    下面是源代码：

  

[cpp]  view plain copy

1. #include <Max3421e.h>  
2. #include <Usb.h>  
3. #include <AndroidAccessory.h>  
4.   
5. #include <Servo.h>    //舵机控制库  
6. #include <MotorCar.h> //电机控制库  
7. #include <NewPing.h>  //ping  
8.   
9.   
10. #define X 9      ///Servo  
11. #define Y 10         
12.   
13. #define InitX 77     
14. #define InitY 7//145  
15. #define initX 157  
16. #define initY 150  
17.   
18. #define S   250   //motor大速度  
19. #define SS  200   //motor速度  
20. #define SSS 80    //motor小速度  
21. #define tt  150   //150ms  
22.   
23.   
24. #define TrigPin  24  // Arduino pin tied to trigger pin on the ultrasonic sensor.  
25. #define EchoPin  25  // Arduino pin tied to echo pin on the ultrasonic sensor.  
26. #define MAX_DISTANCE 100 // Maximum distance we want to ping for (in centimeters). Maximum sensor distance is rated at 400-500cm.  
27. #define MAX_Dis  90  
28.   
29. //long lastDistance = 0;  
30.   
31. AndroidAccessory acc("F120.",    
32. "Server",    
33. "F120 Arduino Board",    
34. "1.0",    
35. "http://www.imobilebbs.com",    
36. "0000000012345678");   
37.   
38. //2路舵机  
39. Servo servoX; //云台X轴舵机 左右  
40. Servo servoY; //云台Y轴舵机 上下  
41.   
42. MotorCar Motor(5,4,6,8);  
43.   
44. NewPing sonar(TrigPin, EchoPin, MAX_DISTANCE); // NewPing setup of pins and maximum distance.  
45.   
46. byte msg[4]={ 0x00 };//全局变量  
47.   
48. int ijk = 0;  
49. unsigned long cm=1,CM=1;  
50. int flag0=0;  
51. int flag=0;  
52. int flag1=0;  
53.   
54. //舵机左右转  
55. void servo_X(uint8_t servotemp)  
56. {  
57.     if(servotemp<180&&servotemp>0) //定义的舵机旋转角度为10度到170度  
58.         servoX.write(servotemp);  
59.     else if (servotemp<=0)  servoX.write(0);  
60.     else servoX.write(180);  
61. }  
62. //舵机上下转  
63. void servo_Y(uint8_t servotemp1)  
64. {  
65.     if(servotemp1<180&&servotemp1>0)//定义的舵机旋转角度为10度到170度  
66.         servoY.write(servotemp1);  
67.     else if (servotemp1<=0)  servoY.write(0);  
68.     else servoY.write(180);  
69. }  
70.   
71. //舵机追踪  
72. void servo_zz1(uint8_t val1)  
73. {  
74.     int servotemp1=servoX.read();//获取舵机目前的角度  
75.     servotemp1+=(val1-90);//舵机运动val1度  
76.     if(servotemp1<180&&servotemp1>0) //定义的舵机旋转角度为10度到170度  
77.         servoX.write(servotemp1);  
78.     else if (servotemp1<=0)  servoX.write(0);  
79.     else servoX.write(180);  
80. }  
81. void servo_zz2(uint8_t val2)  
82. {  
83.     int servotemp2=servoY.read();//获取舵机目前的角度值  
84.     servotemp2+=(val2-90);//舵机运动val2度  
85.     if(servotemp2<180&&servotemp2>0) //定义的舵机旋转角度为10度到170度  
86.         servoY.write(servotemp2);  
87.     else if (servotemp2<=0)  servoY.write(0);  
88.     else servoY.write(180);  
89. }  
90.   
91. void  init_servos0(void)  
92. {  
93.     servoX.attach(X);//水平舵机接9脚  
94.     servoY.attach(Y);//上下舵机接10脚  
95.   
96.     servoX.write(InitX);//输出舵机初始位置为77度  
97.     servoY.write(InitY);//输出舵机初始位置为145度  
98. }  
99. void  init_servos1(void)  
100. {  
101.     servoX.write(initX);//输出舵机初始位置为157度  
102.     servoY.write(initY);//输出舵机初始位置为150度  
103. }  
104.   
105. void setup()  
106. {       
107.     init_servos0();  
108.     Serial.begin(115200);//设置波特率为115200bps  
109.     acc.powerOn();      
110. }    
111.   
112. void loop()  
113. {      
114.     if( acc.isConnected() )   
115.     {    
116.      int len = acc.read(msg, sizeof(msg), 1);  
117.      if(len >=1)  
118.      {     
119.       do_task();      
120.      }   
121.     }  
122.     //sendMessage(2);//垃圾数据          
123.     msg[0] = 0x01; //清除缓存  
124. //  delay( 100 );   
125. }  
126. void do_task(void)  
127. {  
128.  if (msg[0] == 0x02)   
129.         {    
130.             switch( msg[1] )  
131.             {    
132.             case 0://reset  
133.   
134.                 Motor.stop();   
135.                 break;    
136.   
137.             case 1:  
138.   
139.                 if(msg[2]>128){  
140.                                      
141.                     Motor.forward(S);  
142.                 }  
143.                 break;       
144.             case 2:  
145.    
146.                 if(msg[2]>128){   
147.     
148.                     Motor.back(S);  
149.                 }  
150.                 break;  
151.             case 3:  
152.    
153.                 if(msg[2]>128){   
154.     
155.                     Motor.turnLeft(SSS);  
156.                 }  
157.                 break;   
158.             case 4:  
159.               
160.                 if(msg[2]>128){   
161.     
162.                     Motor.turnRight(SSS);  
163.                 }  
164.                 break;  
165.             case 5:  
166.               
167.                 if(msg[2]>128){   
168.                     Motor.turnLeft2(SSS);  
169.                 }  
170.                 break;   
171.             case 6:  
172.                    
173.                 if(msg[2]>128){   
174.                     Motor.turnRight2(SSS);  
175.                 }  
176.                 break;  
177.             case 7:  
178.                   
179.                 if(msg[2]>128){   
180.                     Motor.turnLeftOrigin(SSS);  
181.                 }  
182.                 break;  
183.             case 8:  
184.                   
185.                 if(msg[2]>128){   
186.                     Motor.turnRightOrigin(SSS);  
187.                 }  
188.                 break;    
189.             case 9:   
190.                   
191.                 servo_X(msg[2]);  
192.                 break;  
193.             case 10:   
194.                   
195.                 servo_X(msg[2]);  
196.                 break;  
197.             case 11:   
198.                   
199.                 servo_Y(msg[2]);  
200.                 break;  
201.             case 12:  
202.                   
203.                 servo_Y(msg[2]);  
204.                 break;  
205.             case 13:       //reset  
206.                   
207.                 init_servos0();  
208.                 break;             
209.             }    
210.         }  
211.         else if( msg[0] == 0x3)  
212.         {  
213.             switch( msg[1] )  
214.             {  
215.             case 10:                  
216.                 Motor.stop();  
217.                 servo_zz1(msg[2]);  
218.                 servo_zz2(msg[3]);  
219.                 break;  
220.             case  11:  
221.                                init_servos1();   
222.                             //   ssessage(2);    
223.                                break;  
224.             case  12:  
225.                               while(cm<MAX_Dis&&cm>0||flag==0)    
226.                               {  
227.                            //   if(ijk<3){  
228.                     yanqiang();                            
229.                             //  }  
230.                                int len = acc.read(msg, sizeof(msg), 1);  
231.                                if(len >=1)  
232.                            {      
233.                                flag=1;//QR码识别标志位  
234.                                if(msg[1]==1)  
235.                                {                                 
236.                                flag0=0;//初始化yanqiang  
237.                                flag1=1;//左右转标志位  
238.                                Motor.stop();  
239.                                int jj;  
240.                                for(jj=0;jj<174;jj++)  
241.                                {  
242.                                  servo_zz1(89);  
243.                                  delay(20);  
244.                                }  
245.                                }  
246.                                  //delay(tt);  
247.                                }  
248.                               }  
249.                              break;  
250.                              case  13:  
251.                              Motor.forward(SS);  
252.                              delay(msg[2]*1000);  
253.                              Motor.stop();  
254.                              break;  
255.                   }  
256.                }  
257.         else{                            
258.             Motor.stop();  
259.             }  
260. }  
261.   
262. void sendMessage( int value0,int value1,int value2,int value3)  
263. {  
264.   if (acc.isConnected())   
265.   {  
266.     byte msgS[4]={0x00};  
267.     msgS[0] = value0 & 0xff;  
268.     msgS[1] = value1 & 0xff;  
269.     msgS[2] = value2 & 0xff;  
270.     msgS[3] = value3 & 0xff;  
271.     acc.write(msgS, 4);  
272.   }  
273. }  
274.   
275. void yanqiang(void)  
276. {  
277.   
278.                                 cm=sonar.ping() / US_ROUNDTRIP_CM;  
279.                              // sendMessage(cm);  
280.                                 if(cm<MAX_Dis && cm >0)  
281.                                 {  
282.                                 if(flag0==0)  
283.                                 {  
284.                                  Motor.forward(SSS);   
285.                                  delay(tt);  
286.                                  CM=sonar.ping() / US_ROUNDTRIP_CM;  
287.                                  flag0=1;  
288.                                 }  
289.                                 else   
290.                                 {  
291.                                  int yy;  
292.                                  yy=cm;  
293.                                  cm=CM;  
294.                                  CM=yy;  
295.                                 }  
296.                             //     int Speed=map(abs(cm-CM),0,5,200,250);  
297.                                  if(flag1)  
298.                                  {  
299.                                  if(cm>CM)  
300.                                  {  
301.                                  Motor.turnRight(S);                                                
302.                                  }  
303.                                  else if (cm<CM)  
304.                                  {  
305.                                  Motor.turnLeft(S); //小速度  
306.                                  }  
307.                                 else  {  
308.                                        Motor.forward(SSS);   
309.                                       }  
310.                                  }  
311.                                  else  
312.                                  {  
313.                                  if(cm<CM)  
314.                                  {  
315.                                  Motor.turnRight(S);                                                
316.                                  }  
317.                                  else if (cm>CM)  
318.                                  {  
319.                                  Motor.turnLeft(S); //小速度  
320.                                  }  
321.                                 else  {  
322.                                        Motor.forward(SSS);   
323.                                       }  
324.                                  }  
325.                                  if(flag)  
326.                                  sendMessage(3,3,3,cm);  
327.                                 // ijk=0;  
328.                                  delay(tt);   
329.                                  Motor.stop();                                  
330.                                 }  
331.                                else   
332.                                {  
333.                                  if(flag==1)  
334.                                  Motor.stop();   
335.                                  else   
336.                                  {  
337.                                  Motor.forward(SSS);    
338.                                  flag0=0;  
339.                                  }  
340.                                  if(flag)  
341.                                  sendMessage(3,3,3,100);  
342.                                //  ijk++;  
343.                                //  delay(tt);  
344.                                }  
345.   
346. }  

P.S. 记得AndroidAccessory的库貌似有两种不同版本，普通的Arduino版有一个版本，ADK用的是一个特殊的AndroidAccessory库。

我们深刻体会到买东西一定要买贵的！包括舵机和Arduino板等等。。。