机器人制作开源方案 | 网球收纳机器人

机器谱

作者：孙宇晗、刘子昊、单正扬、李悦、张紫琦

单位：山东大学（威海）

指导老师：庞豹

1. 场景调研
1.1 宏观背景
      体育作为社会经济、政治、文化的重要组成部分,越来越受政府、社会、学校等各阶层的关注。近年来，国家为推进“健康中国”建设、提高人民健康水平，印发并实施《“健康中国2030”规划纲要》和《体育强国纲要》。各大高校为响应国家号召也加强对学生的身体素质的培养，重视体育建设，增加对体育建设的资金投入。
      同时，在机器人成为热门话题的今天，机器人被期待应用于更多领域。其中，体育行业就是机器人可以发挥作用的一片沃土。老牌体育用品公司彪马研发“BeatBot”陪跑机器人，2016年四川省暨成都市科技活动周上成都电子科大的羽毛球机器人产品引起轰动，越来越多机器人将应用于体育行业。目前体育机器人大多作为辅助训练装置，然而体育运动中能运用机器人的场景远不止于此，对于喜爱体育运动的普通消费者，更加渴望一些能更好地服务于日常体育锻炼的机器人的出现。

1.2 应用需求

      目前高校的体育设施配置普遍提升，一般高校都配置有标准网球场，并且开设网球课程。一片标准网球场地的占地面积不小于670平方米，长36.60米，宽18.30米。在这个面积内，有效双打场地的标准尺寸达到23.77米（长）×10.97米（宽），有效单打场地的标准尺寸达到23.77米（长）×8.23米（宽），并且实际上高校的网球场往往是多个连接在一起的一大片空旷场地。而一个标准网球大小在6.541~6.858 cm之间，在训练网球时通常需要使用大量网球，作为网球训练的发球机器人一次可以发出几十个球。由于网球弹性大，每次训练之后，几十个网球散落在场地各个地方，捡球是一件非常麻烦的事。为了给高校网球训练者提供一个更方便、更流畅、更轻松的训练或娱乐体验，我们设计了这一款体育器械智能收纳机器人。

1.3 应用场景
       由于高校消费能力相较于个人更强，网球场广阔，几乎每天使用，并且对于新兴产品的接受度较高。所以，该网球收纳机器人前期主要应用于高校网球场的收纳。机器人轻便小巧，工作能力强，一个机器可以适应与完成不同大小，环境场地网球的收纳，所以机器人在高校的应用趋于稳定后，后期可将其应用于其它网球场区域总体较大、较为平旷、使用率高、具有较高的网球收纳需求的场景，如网球俱乐部、私人网球馆等。

2. 网球收纳机器人介绍2.1 关于此网球收纳机器人
       该机器人是一款基于“探索者”平台搭建的能够自主识别并收纳体育器械的小型机器人。目前我们主要设想将它运用于高校网球场地上网球的捡拾与收纳。

2.2 与市面上已有网球收集机器对比
       市面上一般的网球机器人体型较大，主要依赖于人将装置带至网球散落处，然后装置将网球收集，整个过程并非全自动，仅仅是简化了人弯腰捡拾起网球这一动作，并没有解放使用者双手。并且由于装置一般体型较大，占地大，机器的收纳与转移较为不便，这使得使用者在装置的保存与转移上需要耗费空间与精力，增加了使用负担。
       而在自动模式下使用机器人时，只需要使用者启动机器人，机器人便可自动完成网球的收纳，几乎完全解放用户双手。即使是手动模式，也只需要使用者操控遥控器，不需要使用者在网球场上来回走动。并且该网球收纳机器人机身小巧，重量较小，可以轻易拿起，无论是收纳或者是将其转移都十分方便，大大利于普通消费者的收纳与使用，不会给用户造成额外的收纳困难与使用烦恼。

3. 机器人技术说明3.1 主要技术参数
       （1）采用Basra主控板，堆叠BigFish扩展板
       （2）电机转速最高可达70r/min
       （3）前方装有二自由度机械臂，伸长可达30cm，单一维度活动范围0~180°
       （4）底盘距地面6cm
       （5）一个颜色模块，一个超声波测距模块，两个触须模块

3.2 机械结构
       体育器械收纳智能机器人的整体结构及各部分功能如下图所示：

机器人整体结构及各部分功能

3.2.1 底盘结构      该网球收集机器人主要零件均采用标准件进行装配，车身整体尺寸较小，可灵活穿梭于各类球场中。机器人底盘采用一块7*11孔平板，电机悬挂在外侧的四个3*5双折面板上，既缩小了车身宽度和长度，使其通过弯道时不容易被卡住，又增加了底盘的高度，使机器人通过草地和上台阶和窄桥时越野能力增强。
       机器人采用轮形结构，四驱动力设计，使其能够在复杂地形上获得足够的驱动力。当机器人需要转向或掉头时，左右两侧电机提供不同的转速，利用转速差的原理对小车进行转向或掉头动作，从而实现以极小的转弯半径完成转向及掉头动作。
Orderedlist

3.2.2 机械臂
       查阅相关资料可知，一般网球直径分布区间为6.541～6.858cm，重量分布区间为56.7～58.5g，按照误差正态分布，在设计时选用直径6.7cm，重量57g作为设计的标准尺寸。为了确保抓取的成功率和可靠性，与网球接触的弧形抓手设计为弦长为80mm，弦高为20mm的圆弧，可以将网球完全包裹。
       为了抓取和放置平地上距车身较远的工件，机器人机械臂模仿人类手臂和手指的构造，使用了三个M04舵机：一个控制机械爪，采用齿轮咬合结构，实现对工件的抓取；中间关节的舵机用于伸展机械臂；根部的M04舵机控制整体机械臂的抬升和降落。

3.3 控制方案
       该网球收纳机器人有自动和手动两种控制模式，两种模式下的控制方案如下图所示：

两种模式下的控制方案

3.3.1 自动模式
      机器人采取全局遍历算法巡回扫场，如下图所示：

全局遍历算法巡回扫场示意图

实现方式如下：
       1）变量设置：首先，设置一个变量a1作为标记以确定机器人旋转方        向，a1初始值为1。a1值为1为向右旋转，标志为0表示向左旋转。
       其次，设置三个距离常量，D1,D2，D3。D3>D2。
       用变量d1记录机器人每次旋转后直行距离。
       2）具体过程：
       ①当机器人识别到障碍物时，后退距离D1；
       ②a1==1?为真向右旋转否则向左旋转,d1=0；
       ③前进D2
       ④a1==1?向右旋转否则向左旋转,d1=0；
       ⑤前进
       ⑥d1>D3?为真a1取反
      这样设计当机器人前进至防护网或者障碍物处会自动变换方向继续搜索，重复这一过程，可以实现对网球场的遍历并且能够排除行至墙角被困住的情况。
       该算法的优点是复杂性较低、可靠性高，能显著提高网球的收纳率，缺点是机器人可能会在无球区域耗费很多时间。
       机器人通过超声波测距检测有无物体靠近，并确定物体的相对位置，相对位置允许存在6%～10%的误差。若测距结果小于6.5cm，说明有物体靠近，此时读取颜色传感器数据，采用色域识别法对网球进行识别。（色域识别法依靠其简易性在网球识别任务中有很大的优势。）若识别结果为网球，为顺利抓取网球，小车需要缓慢后退，当与网球相距10.3cm时，停止运动并进行抓取。抓取成功后，机械臂伸向车后，机械爪松开将网球抛入框。
       机器人的主体搭建基于一个全方位移动平台，检测系统位于平台前端，用于对网球的识别定位，网球信号确认后，系统控制机械手进行抓取动作，抓取确认成功后机械手松开，网球斜抛入框。

3.3.2 手动模式
       当自动模式失灵或者网球位于机器人扫场盲区时，操作人员可以通过手动模式遥控机器人。手动模式下，机器人和2.4G手柄通过NRF24L01无线通信模块，实现手柄对机器人移动和机械臂抓取的遥控。

3.4 模块功能
3.4.1 颜色传感器模块
       TCS3200是一种全彩的颜色检测器，包括了一块RGB感应芯片TAOSTCS3200和4个白色LED灯，能在一定的范围内检测和测量几乎所有的可见光。
       本机器人采用的图像识别分析模型为HSI颜色空间模型，但由于TCS3200颜色传感器采集的图像是RGB格式，所以需要把RGB模型转换为HSI颜色模型。网球的颜色接近绿色，颜色分量Hue范围在45°到90°之间即有可能为网球。

Hue:

3.4.2 超声波模块

       HC-SR04超声波模块感应角度不大于15°，探测距离2cm-450cm，精度可达0.2cm。当颜色传感器检测到网球，小车缓慢后退，同时超声波模块对网球进行测距，当与网球相距10.3cm时，机器人停止移动并抓取网球。

3.4.3 触碰模块
       触碰模块安装在小车前方，上面有一个按键，可以切换自动模式和手动模式。机器人默认采用自动模式，当自动模式失灵或者网球位于机器人扫场盲区时，操作人员可以通过触碰模块将机器人切换为手动模式。

3.4.4 NRF24L01无线通信模块
       nRF24L01是由NORDIC生产的工作在2.4GHz~2.5GHz的ISM频段的单片无线收发器芯片。首先将机器人和手柄上的无线模块调节到相同的通道，依次打开机器人、手柄，即可实现通过2.4G手柄的按键、摇杆对机器人的移动和机械臂的抓取进行遥控。

3.5 调试与测试结果
       模拟场景大小为1.2m×1.2m。将机器人切换为自动模式，在测试场地内随机放置20个网球，捡球机器人从网球场一角开始搜索测试场地内的网球。在进行了约3min的自动捡球之后，机器人成功将16个网球捡起，自动捡球模式下的捡球效率达到80%；此时，将机器人切换为手动模式，将另外4个网球捡起，自动模式与手动模式搭配使用可使捡球效率达到100%。共约进行200组相同的测试，总的捡球效率均为100%。随机选取其中10次的数据统计，结果如表1所示。

表1机器人捡球效率实验数据
序号	自动捡球数	手动捡球数	自动捡球效率	总效率
1	17	3	85%	100%
2	17	3	85%	100%
3	16	4	80%	100%
4	18	2	90%	100%
5	18	2	90%	100%
6	18	2	90%	100%
7	18	2	90%	100%
8	17	3	85%	100%
9	18	2	90%	100%
10	18	2	90%	100%
平均值	17.5	2.5	87.5%	100%

4. 示例程序4.1 自动模式

1. int _ABVAR_1_yuzhi1 = 30 ;
   
2. 
   
3. int _ABVAR_2_yuzhi2 = 0 ;
   
4. 
   
5. int _ABVAR_3_yuzhi3 = 120 ;
   
6. 
   
7. bool _ABVAR_4_stop= false ;
   
8. 
   
9. int _ABVAR_5_state = 0 ;
   
10. 
    
11. void stop();
    
12. 
    
13. void xunzhixian();
    
14. 
    
15. void test();
    
16. 
    
17. void autocar();
    
18. 
    
19. void back();
    
20. 
    
21. void hengxian_right();
    
22. 
    
23. void push();
    
24. 
    
25. void forward();
    
26. 
    
27. void turn_right();
    
28. 
    
29. void left();
    
30. 
    
31. void hengxian_left();
    
32. 
    
33. void right();
    
34. 
    
35. void turn_left();
    
36. 
    
37. void youzhuan();
    
38. 
    
39. void setup()
    
40. 
    
41. {
    
42. 
    
43.   pinMode( 10, OUTPUT);
    
44. 
    
45.   pinMode( 6, OUTPUT);
    
46. 
    
47.   pinMode( 5, OUTPUT);
    
48. 
    
49.   pinMode( 9, OUTPUT);
    
50. 
    
51.   Serial.begin(9600);
    
52. 
    
53.   _ABVAR_1_yuzhi1 = 150 ;
    
54. 
    
55.   _ABVAR_2_yuzhi2 = 200 ;
    
56. 
    
57.   _ABVAR_3_yuzhi3 = 100 ;
    
58. 
    
59.   _ABVAR_4_stop = HIGH ;
    
60. 
    
61.   forward();
    
62. 
    
63. }
    
64. 
    
65. void loop()
    
66. 
    
67. {
    
68. 
    
69.   autocar();
    
70. 
    
71. }
    
72. 
    
73. void hengxian_right()
    
74. 
    
75. {
    
76. 
    
77.   if (( ( ( analogRead(14) ) >= ( _ABVAR_1_yuzhi1 ) ) && ( ( analogRead(18) ) >= ( _ABVAR_3_yuzhi3 ) ) ))
    
78. 
    
79.   {
    
80. 
    
81.     turn_right();
    
82. 
    
83.     _ABVAR_5_state = ( _ABVAR_5_state + 1 ) ;
    
84. 
    
85.   }
    
86. 
    
87.   else
    
88. 
    
89.   {
    
90. 
    
91.     xunzhixian();
    
92. 
    
93.   }
    
94. 
    
95. }
    
96. 
    
97. void xunzhixian()
    
98. 
    
99. {
    
100. 
     
101.   if (( ( analogRead(18) ) >= ( _ABVAR_3_yuzhi3 ) ))
     
102. 
     
103.   {
     
104. 
     
105.     right();
     
106. 
     
107.   }
     
108. 
     
109.   else
     
110. 
     
111.   {
     
112. 
     
113.     if (( ( analogRead(14) ) >= ( _ABVAR_1_yuzhi1 ) ))
     
114. 
     
115.     {
     
116. 
     
117.       left();
     
118. 
     
119.     }
     
120. 
     
121.     else
     
122. 
     
123.     {
     
124. 
     
125.       forward();
     
126. 
     
127.     }
     
128. 
     
129.   }
     
130. 
     
131. }
     
132. 
     
133. void hengxian_left()
     
134. 
     
135. {
     
136. 
     
137.   if (( ( ( analogRead(14) ) >= ( _ABVAR_1_yuzhi1 ) ) && ( ( analogRead(18) ) >= ( _ABVAR_3_yuzhi3 ) ) ))
     
138. 
     
139.   {
     
140. 
     
141.     turn_left();
     
142. 
     
143.     _ABVAR_5_state = ( _ABVAR_5_state + 1 ) ;
     
144. 
     
145.   }
     
146. 
     
147.   else
     
148. 
     
149.   {
     
150. 
     
151.     xunzhixian();
     
152. 
     
153.   }
     
154. 
     
155. }
     
156. 
     
157. void left()
     
158. 
     
159. {
     
160. 
     
161.   analogWrite(10 , 0);
     
162. 
     
163.   analogWrite(9 , 160);
     
164. 
     
165.   analogWrite(6 , 160);
     
166. 
     
167.   analogWrite(5 , 0);
     
168. 
     
169. }
     
170. 
     
171. void right()
     
172. 
     
173. {
     
174. 
     
175.   analogWrite(10 , 160);
     
176. 
     
177.   analogWrite(9 , 0);
     
178. 
     
179.   analogWrite(6 , 0);
     
180. 
     
181.   analogWrite(5 , 160);
     
182. 
     
183. }
     
184. 
     
185. void turn_left()
     
186. 
     
187. {
     
188. 
     
189.   analogWrite(10 , 255);
     
190. 
     
191.   analogWrite(9 , 0);
     
192. 
     
193.   analogWrite(6 , 0);
     
194. 
     
195.   analogWrite(5 , 255);
     
196. 
     
197.   delay( 800 );
     
198. 
     
199.   forward();
     
200. 
     
201.   delay( 1000 );
     
202. 
     
203. }
     
204. 
     
205. void autocar()
     
206. 
     
207. {
     
208. 
     
209.   forward();
     
210. 
     
211.   delay( 6000 );
     
212. 
     
213.   while ( true )
     
214. 
     
215.   {
     
216. 
     
217.     if (( ( _ABVAR_5_state ) == ( 0 ) ))
     
218. 
     
219.     {
     
220. 
     
221.       hengxian_left();
     
222. 
     
223.     }
     
224. 
     
225.     if (( ( _ABVAR_5_state ) == ( 1 ) ))
     
226. 
     
227.     {
     
228. 
     
229.       push();
     
230. 
     
231.     }
     
232. 
     
233.     if (( ( _ABVAR_5_state ) == ( 2 ) ))
     
234. 
     
235.     {
     
236. 
     
237.       hengxian_left();
     
238. 
     
239.     }
     
240. 
     
241.     if (( ( _ABVAR_5_state ) == ( 3 ) ))
     
242. 
     
243.     {
     
244. 
     
245.       youzhuan();
     
246. 
     
247.     }
     
248. 
     
249.     if (( ( _ABVAR_5_state ) == ( 4 ) ))
     
250. 
     
251.     {
     
252. 
     
253.       youzhuan();
     
254. 
     
255.     }
     
256. 
     
257.     if (( ( _ABVAR_5_state ) == ( 5 ) ))
     
258. 
     
259.     {
     
260. 
     
261.       push();
     
262. 
     
263.     }
     
264. 
     
265.     if (( ( _ABVAR_5_state ) == ( 7 ) ))
     
266. 
     
267.     {
     
268. 
     
269.       hengxian_left();
     
270. 
     
271.     }
     
272. 
     
273.     if (( ( _ABVAR_5_state ) == ( 8 ) ))
     
274. 
     
275.     {
     
276. 
     
277.       youzhuan();
     
278. 
     
279.     }
     
280. 
     
281.     if (( ( _ABVAR_5_state ) == ( 10 ) ))
     
282. 
     
283.     {
     
284. 
     
285.       hengxian_right();
     
286. 
     
287.     }
     
288. 
     
289.     if (( ( _ABVAR_5_state ) == ( 11 ) ))
     
290. 
     
291.     {
     
292. 
     
293.       push();
     
294. 
     
295.     }
     
296. 
     
297.     if (( ( _ABVAR_5_state ) == ( 12 ) ))
     
298. 
     
299.     {
     
300. 
     
301.       hengxian_left();
     
302. 
     
303.     }
     
304. 
     
305.     if (( ( _ABVAR_5_state ) == ( 13 ) ))
     
306. 
     
307.     {
     
308. 
     
309.       youzhuan();
     
310. 
     
311.     }
     
312. 
     
313.     if (( ( _ABVAR_5_state ) == ( 14 ) ))
     
314. 
     
315.     {
     
316. 
     
317.       youzhuan();
     
318. 
     
319.     }
     
320. 
     
321.     if (( ( _ABVAR_5_state ) == ( 15 ) ))
     
322. 
     
323.     {
     
324. 
     
325.       push();
     
326. 
     
327.     }
     
328. 
     
329.     if (( ( _ABVAR_5_state ) == ( 16 ) ))
     
330. 
     
331.     {
     
332. 
     
333.       hengxian_left();
     
334. 
     
335.     }
     
336. 
     
337.     if (( ( _ABVAR_5_state ) == ( 17 ) ))
     
338. 
     
339.     {
     
340. 
     
341.       youzhuan();
     
342. 
     
343.     }
     
344. 
     
345.     if (( ( _ABVAR_5_state ) == ( 18 ) ))
     
346. 
     
347.     {
     
348. 
     
349.       hengxian_right();
     
350. 
     
351.       _ABVAR_5_state = 1 ;
     
352. 
     
353.     }
     
354. 
     
355.   }
     
356. 
     
357. }
     
358. 
     
359. void push()
     
360. 
     
361. {
     
362. 
     
363.   forward();
     
364. 
     
365.   delay( 2000 );
     
366. 
     
367.   back();
     
368. 
     
369.   _ABVAR_5_state = ( _ABVAR_5_state + 1 ) ;
     
370. 
     
371. }
     
372. 
     
373. void stop()
     
374. 
     
375. {
     
376. 
     
377.   analogWrite(10 , 0);
     
378. 
     
379.   analogWrite(9 , 0);
     
380. 
     
381.   analogWrite(6 , 0);
     
382. 
     
383.   analogWrite(5 , 0);
     
384. 
     
385. }
     
386. 
     
387. void turn_right()
     
388. 
     
389. {
     
390. 
     
391.   analogWrite(10 , 0);
     
392. 
     
393.   analogWrite(9 , 255);
     
394. 
     
395.   analogWrite(6 , 255);
     
396. 
     
397.   analogWrite(5 , 0);
     
398. 
     
399.   delay( 800 );
     
400. 
     
401.   forward();
     
402. 
     
403.   delay( 1000 );
     
404. 
     
405. }
     
406. 
     
407. void test()
     
408. 
     
409. {
     
410. 
     
411.   Serial.print(analogRead(14));
     
412. 
     
413.   Serial.println();
     
414. 
     
415.   Serial.print(analogRead(16));
     
416. 
     
417.   Serial.println();
     
418. 
     
419.   Serial.print(analogRead(18));
     
420. 
     
421.   Serial.println();
     
422. 
     
423.   delay( 3000 );
     
424. 
     
425. }
     
426. 
     
427. void back()
     
428. 
     
429. {
     
430. 
     
431.   analogWrite(10 , 0);
     
432. 
     
433.   analogWrite(9 , 105);
     
434. 
     
435.   analogWrite(6 , 0);
     
436. 
     
437.   analogWrite(5 , 105);
     
438. 
     
439. }
     
440. 
     
441. void youzhuan()
     
442. 
     
443. {
     
444. 
     
445.   if (( ( ( ( analogRead(14) ) < ( _ABVAR_1_yuzhi1 ) ) && ( ( analogRead(18) ) >= ( _ABVAR_3_yuzhi3 ) ) ) && ( ( analogRead(16) ) >= ( _ABVAR_2_yuzhi2 ) ) ))
     
446. 
     
447.   {
     
448. 
     
449.     turn_right();
     
450. 
     
451.     _ABVAR_5_state = ( _ABVAR_5_state + 1 ) ;
     
452. 
     
453.   }
     
454. 
     
455.   else
     
456. 
     
457.   {
     
458. 
     
459.     xunzhixian();
     
460. 
     
461.   }
     
462. 
     
463. }
     
464. 
     
465. void forward()
     
466. 
     
467. {
     
468. 
     
469.   analogWrite(10 , 100);
     
470. 
     
471.   analogWrite(9 , 0);
     
472. 
     
473.   analogWrite(6 , 100);
     
474. 
     
475.   analogWrite(5 , 0);
     
476. 
     
477. }

复制代码

4.2手动模式

① control_mode_code_of_car.ino

1. #include <Servo.h>
   
2. 
   
3. int _ABVAR_1__data = 0 ;
   
4. 
   
5. int servo_pin_4 = 4;
   
6. 
   
7. int servo_pin_7 = 7;
   
8. 
   
9. int servo_pin_3 = 3;
   
10. 
    
11. int _ABVAR3 = 20;
    
12. 
    
13. int _ABVAR7 = 10;
    
14. 
    
15. int _ABVAR4 = 0;
    
16. 
    
17. int _ABVAR_2_i = 0 ;
    
18. 
    
19. int _ABVAR_3_i = 0 ;
    
20. 
    
21. int _ABVAR_4_i = 0 ;
    
22. 
    
23. //20 0
    
24. 
    
25. //130 100
    
26. 
    
27. void Right();
    
28. 
    
29. void Up_Close();
    
30. 
    
31. void Up_Open();
    
32. 
    
33. void Select();
    
34. 
    
35. void Down_Open();
    
36. 
    
37. void Down_Close();
    
38. 
    
39. void Mid_Open();
    
40. 
    
41. void Mid_Close();
    
42. 
    
43. void Left();
    
44. 
    
45. void Stop();
    
46. 
    
47. void Back();
    
48. 
    
49. void Forward();
    
50. 
    
51. void servo3();
    
52. 
    
53. void servo4();
    
54. 
    
55. void servo7();
    
56. 
    
57. void setup()
    
58. 
    
59. {
    
60. 
    
61.   Serial.begin(9600);
    
62. 
    
63.   pinMode( 5 , OUTPUT);
    
64. 
    
65.   pinMode( 6 , OUTPUT);
    
66. 
    
67.   pinMode( 9 , OUTPUT);
    
68. 
    
69.   pinMode( 10 , OUTPUT);
    
70. 
    
71.   // servo_pin_4.attach(4);
    
72. 
    
73.   // servo_pin_7.attach(7);
    
74. 
    
75.   //servo_pin_3.attach(3);
    
76. 
    
77.   pinMode(servo_pin_3,OUTPUT);
    
78. 
    
79.   pinMode(servo_pin_4,OUTPUT);
    
80. 
    
81.   pinMode(servo_pin_7,OUTPUT);
    
82. 
    
83.   servo3(_ABVAR3);
    
84. 
    
85.   servo4(_ABVAR4);
    
86. 
    
87.   servo7(_ABVAR7);
    
88. 
    
89.   _ABVAR_1__data = 0 ;
    
90. 
    
91. }
    
92. 
    
93. void loop()
    
94. 
    
95. {
    
96. 
    
97.   _ABVAR_1__data = Serial.parseInt() ;
    
98. 
    
99.   Select();
    
100. 
     
101.   delay( 1 );
     
102. 
     
103. }
     
104. 
     
105. void Select()
     
106. 
     
107. {
     
108. 
     
109.   Stop();
     
110. 
     
111.   if (( ( _ABVAR_1__data ) == ( 2 ) ))
     
112. 
     
113.   {
     
114. 
     
115.     Back();
     
116. 
     
117.   }
     
118. 
     
119.   else if (( ( _ABVAR_1__data ) == ( 1 ) ))
     
120. 
     
121.   {
     
122. 
     
123.     Forward();
     
124. 
     
125.   }
     
126. 
     
127.   else if (( ( _ABVAR_1__data ) == ( 0 ) ))
     
128. 
     
129.   {
     
130. 
     
131.     Stop();
     
132. 
     
133.   }
     
134. 
     
135.   else if (( ( _ABVAR_1__data ) == ( 4 ) ))
     
136. 
     
137.   {
     
138. 
     
139.     Left();
     
140. 
     
141.   }
     
142. 
     
143.   else if (( ( _ABVAR_1__data ) == ( 3 ) ))
     
144. 
     
145.   {
     
146. 
     
147.     Right();
     
148. 
     
149.   }
     
150. 
     
151.   else if (( ( _ABVAR_1__data ) == ( 5 ) ))
     
152. 
     
153.   {
     
154. 
     
155.     Down_Open();
     
156. 
     
157.   }
     
158. 
     
159.   else if (( ( _ABVAR_1__data ) == ( 6 ) ))
     
160. 
     
161.   {
     
162. 
     
163.     Down_Close();
     
164. 
     
165.   }
     
166. 
     
167.   else if (( ( _ABVAR_1__data ) == ( 7 ) ))
     
168. 
     
169.   {
     
170. 
     
171.     Mid_Open();
     
172. 
     
173.   }
     
174. 
     
175.   else if (( ( _ABVAR_1__data ) == ( 8 ) ))
     
176. 
     
177.   {
     
178. 
     
179.     Mid_Close();
     
180. 
     
181.   }
     
182. 
     
183.   else if (( ( _ABVAR_1__data ) == ( 9 ) ))
     
184. 
     
185.   {
     
186. 
     
187.     Up_Open();
     
188. 
     
189.   }
     
190. 
     
191.   else if (( ( _ABVAR_1__data ) == ( 10 ) ))
     
192. 
     
193.   {
     
194. 
     
195.     Up_Close();
     
196. 
     
197.   }
     
198. 
     
199.   else if (( ( _ABVAR_1__data ) == ( 11 ) ))
     
200. 
     
201.   {
     
202. 
     
203.     Down_Close();
     
204. 
     
205.   }
     
206. 
     
207.   else if (( ( _ABVAR_1__data ) == ( 12 ) ))
     
208. 
     
209.   {
     
210. 
     
211.     Down_Open();
     
212. 
     
213.   }
     
214. 
     
215.   else if (( ( _ABVAR_1__data ) == ( 13 ) ))
     
216. 
     
217.   {
     
218. 
     
219.     while(_ABVAR3<20)
     
220. 
     
221.     {
     
222. 
     
223.       Down_Open();
     
224. 
     
225.     }
     
226. 
     
227.     while(_ABVAR3>20)
     
228. 
     
229.     {
     
230. 
     
231.       Down_Close();
     
232. 
     
233.     }
     
234. 
     
235.     while(_ABVAR7<10)
     
236. 
     
237.     {
     
238. 
     
239.       Mid_Open();
     
240. 
     
241.     }
     
242. 
     
243.     while(_ABVAR7>10)
     
244. 
     
245.     {
     
246. 
     
247.       Mid_Close();
     
248. 
     
249.     }
     
250. 
     
251.   }
     
252. 
     
253.   else if (( ( _ABVAR_1__data ) == ( 14 ) ))
     
254. 
     
255.   {
     
256. 
     
257.     while(_ABVAR3<130)
     
258. 
     
259.     {
     
260. 
     
261.       Down_Open();
     
262. 
     
263.     }
     
264. 
     
265.     while(_ABVAR3>130)
     
266. 
     
267.     {
     
268. 
     
269.       Down_Close();
     
270. 
     
271.     }
     
272. 
     
273.     while(_ABVAR7<100)
     
274. 
     
275.     {
     
276. 
     
277.       Mid_Open();
     
278. 
     
279.     }
     
280. 
     
281.     while(_ABVAR7>100)
     
282. 
     
283.     {
     
284. 
     
285.       Mid_Close();
     
286. 
     
287.     }
     
288. 
     
289.   }
     
290. 
     
291. }
     
292. 
     
293. void Right()
     
294. 
     
295. {
     
296. 
     
297.   analogWrite(5 , 200);
     
298. 
     
299.   analogWrite(6 , 0);
     
300. 
     
301.   analogWrite(9 , 0);
     
302. 
     
303.   analogWrite(10 , 200);
     
304. 
     
305. }
     
306. 
     
307. void Stop()
     
308. 
     
309. {
     
310. 
     
311.   analogWrite(5 , 0);
     
312. 
     
313.   analogWrite(6 , 0);
     
314. 
     
315.   analogWrite(9 , 0);
     
316. 
     
317.   analogWrite(10 , 0);
     
318. 
     
319. }
     
320. 
     
321. void Forward()
     
322. 
     
323. {
     
324. 
     
325.   analogWrite(5 , 100);
     
326. 
     
327.   analogWrite(6 , 0);
     
328. 
     
329.   analogWrite(9 , 100);
     
330. 
     
331.   analogWrite(10 , 0);
     
332. 
     
333. }
     
334. 
     
335. void Back()
     
336. 
     
337. {
     
338. 
     
339.   analogWrite(5 , 0);
     
340. 
     
341.   analogWrite(6 , 100);
     
342. 
     
343.   analogWrite(9 , 0);
     
344. 
     
345.   analogWrite(10 , 100);
     
346. 
     
347. }
     
348. 
     
349. void Left()
     
350. 
     
351. {
     
352. 
     
353.   analogWrite(5 , 0);
     
354. 
     
355.   analogWrite(6 , 200);
     
356. 
     
357.   analogWrite(9 , 200);
     
358. 
     
359.   analogWrite(10 , 0);
     
360. 
     
361. }
     
362. 
     
363. void Down_Open()
     
364. 
     
365. {
     
366. 
     
367.   if(_ABVAR3<180)
     
368. 
     
369.   {
     
370. 
     
371.     _ABVAR3 ++;
     
372. 
     
373.     servo3(_ABVAR3);
     
374. 
     
375.     delay( 6 );
     
376. 
     
377.   }
     
378. 
     
379. }
     
380. 
     
381. void Down_Close()
     
382. 
     
383. {
     
384. 
     
385.   if(_ABVAR3>0)
     
386. 
     
387.   {
     
388. 
     
389.     _ABVAR3 --;
     
390. 
     
391.     servo3(_ABVAR3);
     
392. 
     
393.     delay( 6 );
     
394. 
     
395.   }
     
396. 
     
397. }
     
398. 
     
399. void Mid_Open()
     
400. 
     
401. {
     
402. 
     
403.   if(_ABVAR7<180)
     
404. 
     
405.   {
     
406. 
     
407.     _ABVAR7 ++;
     
408. 
     
409.     servo7(_ABVAR7);
     
410. 
     
411.     delay( 6 );
     
412. 
     
413.   }
     
414. 
     
415. }
     
416. 
     
417. void Mid_Close()
     
418. 
     
419. {
     
420. 
     
421.   if(_ABVAR7>0)
     
422. 
     
423.   {
     
424. 
     
425.     _ABVAR7 --;
     
426. 
     
427.     servo7(_ABVAR7);  
     
428. 
     
429.     delay( 6 );
     
430. 
     
431.   }
     
432. 
     
433. }
     
434. 
     
435. void Up_Open()
     
436. 
     
437. {
     
438. 
     
439.   if(_ABVAR4<150)
     
440. 
     
441.   {
     
442. 
     
443.     _ABVAR4 ++;
     
444. 
     
445.     servo4(_ABVAR4);
     
446. 
     
447.     delay( 6 );
     
448. 
     
449.   }
     
450. 
     
451. }
     
452. 
     
453. void Up_Close()
     
454. 
     
455. {
     
456. 
     
457.   if(_ABVAR4>0)
     
458. 
     
459.   {
     
460. 
     
461.     _ABVAR4 --;
     
462. 
     
463.     servo4(_ABVAR4);  
     
464. 
     
465.     delay( 6 );
     
466. 
     
467.   }
     
468. 
     
469. }
     
470. 
     
471. void servo7(int angle)
     
472. 
     
473. {
     
474. 
     
475.   for(int i=0;i<6;i++)
     
476. 
     
477.   {
     
478. 
     
479.     int pulsewidth = (angle * 11) + 500;
     
480. 
     
481.     digitalWrite(servo_pin_7, HIGH);
     
482. 
     
483.     delayMicroseconds(pulsewidth);
     
484. 
     
485.     digitalWrite(servo_pin_7, LOW);
     
486. 
     
487.     delayMicroseconds(20000 - pulsewidth);
     
488. 
     
489.   }
     
490. 
     
491. }
     
492. 
     
493. void servo4(int angle)
     
494. 
     
495. {
     
496. 
     
497.   for(int i=0;i<6;i++)
     
498. 
     
499.   {
     
500. 
     
501.     int pulsewidth = (angle * 11) + 500;
     
502. 
     
503.     digitalWrite(servo_pin_4, HIGH);
     
504. 
     
505.     delayMicroseconds(pulsewidth);
     
506. 
     
507.     digitalWrite(servo_pin_4, LOW);
     
508. 
     
509.     delayMicroseconds(20000 - pulsewidth);
     
510. 
     
511.   }
     
512. 
     
513. }
     
514. 
     
515. void servo3(int angle)
     
516. 
     
517. {
     
518. 
     
519.   for(int i=0;i<6;i++)
     
520. 
     
521.   {
     
522. 
     
523.     int pulsewidth = (angle * 11) + 500;
     
524. 
     
525.     digitalWrite(servo_pin_3, HIGH);
     
526. 
     
527.     delayMicroseconds(pulsewidth);
     
528. 
     
529.     digitalWrite(servo_pin_3, LOW);
     
530. 
     
531.     delayMicroseconds(20000 - pulsewidth);
     
532. 
     
533.   }
     
534. 
     
535. }

复制代码

② control_mode_code_of_controller.ino

1. int _ABVAR_1_Ctrl_Val_1 = 0 ;
   
2. 
   
3. int _ABVAR_2_Ctrl_Val_2 = 0 ;
   
4. 
   
5. int _ABVAR_3_A0Value = 0 ;
   
6. 
   
7. int _ABVAR_4_A1Value = 0 ;
   
8. 
   
9. int _ABVAR_5_A2Value = 0 ;
   
10. 
    
11. int _ABVAR_6_A3Value = 0 ;
    
12. 
    
13. void VAL_caculate();
    
14. 
    
15. void ADGet();
    
16. 
    
17. void SerialPrint();
    
18. 
    
19. void setup()
    
20. 
    
21. {
    
22. 
    
23.   Serial.begin(9600);
    
24. 
    
25. 
    
26. 
    
27. }
    
28. 
    
29. void loop()
    
30. 
    
31. {
    
32. 
    
33.   ADGet();
    
34. 
    
35.   VAL_caculate();
    
36. 
    
37.   SerialPrint();
    
38. 
    
39.   delay( 50 );
    
40. 
    
41. }
    
42. 
    
43. void SerialPrint()
    
44. 
    
45. {
    
46. 
    
47.   if( ( _ABVAR_1_Ctrl_Val_1 ) == ( 9 ) )
    
48. 
    
49.   {
    
50. 
    
51.        if( ( _ABVAR_2_Ctrl_Val_2 ) == ( 3 ) )
    
52. 
    
53.       {
    
54. 
    
55.     Serial.print("0");
    
56. 
    
57.     Serial.println();
    
58. 
    
59.       }
    
60. 
    
61.      else if( ( _ABVAR_2_Ctrl_Val_2 ) == ( 1 ) )
    
62. 
    
63.       {
    
64. 
    
65.     Serial.print("1");
    
66. 
    
67.     Serial.println();
    
68. 
    
69.       }
    
70. 
    
71.       else    if( ( _ABVAR_2_Ctrl_Val_2 ) == ( 2 ) )
    
72. 
    
73.       {
    
74. 
    
75.     Serial.print("2");
    
76. 
    
77.     Serial.println();
    
78. 
    
79.       }
    
80. 
    
81.     else      if( ( _ABVAR_2_Ctrl_Val_2 ) == ( 4 ) )
    
82. 
    
83.       {
    
84. 
    
85.     Serial.print("3");
    
86. 
    
87.     Serial.println();
    
88. 
    
89.       }
    
90. 
    
91.      else     if( ( _ABVAR_2_Ctrl_Val_2 ) == ( 5 ) )
    
92. 
    
93.       {
    
94. 
    
95.     Serial.print("4");
    
96. 
    
97.     Serial.println();
    
98. 
    
99.       }         
    
100. 
     
101.   }
     
102. 
     
103. 
     
104. 
     
105.   if ( ( _ABVAR_1_Ctrl_Val_1 ) == ( 6 ) )
     
106. 
     
107.   {
     
108. 
     
109.     if ( ( _ABVAR_2_Ctrl_Val_2 ) == ( 2 ) )
     
110. 
     
111.     {
     
112. 
     
113.     Serial.print("5");
     
114. 
     
115.     Serial.println();
     
116. 
     
117.     }
     
118. 
     
119.     else if ( ( _ABVAR_2_Ctrl_Val_2 ) == ( 1 ) )
     
120. 
     
121.       {
     
122. 
     
123.     Serial.print("6");
     
124. 
     
125.     Serial.println();
     
126. 
     
127.   }
     
128. 
     
129. }
     
130. 
     
131.   if ( ( _ABVAR_1_Ctrl_Val_1 ) == ( 10 ) )
     
132. 
     
133.   {
     
134. 
     
135.     if( ( _ABVAR_2_Ctrl_Val_2 ) == ( 2 ) )
     
136. 
     
137.     {
     
138. 
     
139.     Serial.print("7");
     
140. 
     
141.     Serial.println();
     
142. 
     
143.     }
     
144. 
     
145.     else if ( ( _ABVAR_2_Ctrl_Val_2 ) == ( 1 ) )
     
146. 
     
147.       {
     
148. 
     
149.     Serial.print("8");
     
150. 
     
151.     Serial.println();
     
152. 
     
153.       }
     
154. 
     
155.   }
     
156. 
     
157. 
     
158. 
     
159. 
     
160. 
     
161.   if   ( ( _ABVAR_1_Ctrl_Val_1 ) == ( 7 ) )
     
162. 
     
163.   {
     
164. 
     
165.     if( ( _ABVAR_2_Ctrl_Val_2 ) == ( 1 ) )
     
166. 
     
167.     {
     
168. 
     
169.     Serial.print("9");
     
170. 
     
171.     Serial.println();
     
172. 
     
173.     }
     
174. 
     
175.     else if( ( _ABVAR_2_Ctrl_Val_2 ) == ( 2 ) )
     
176. 
     
177.   {
     
178. 
     
179.     Serial.print("10");
     
180. 
     
181.     Serial.println();
     
182. 
     
183.   }   
     
184. 
     
185.   }
     
186. 
     
187. 
     
188. 
     
189.   if ( ( _ABVAR_1_Ctrl_Val_1 ) == ( 10 ) )
     
190. 
     
191.   {
     
192. 
     
193.     if( ( _ABVAR_2_Ctrl_Val_2 ) == ( 4 ) )
     
194. 
     
195.     {
     
196. 
     
197.     Serial.print("11");
     
198. 
     
199.     Serial.println();
     
200. 
     
201.     }
     
202. 
     
203.     else if( ( _ABVAR_2_Ctrl_Val_2 ) == ( 5 ) )
     
204. 
     
205.       {
     
206. 
     
207.     Serial.print("12");
     
208. 
     
209.     Serial.println();
     
210. 
     
211.   }
     
212. 
     
213.       else if( ( _ABVAR_2_Ctrl_Val_2 ) == ( 3 ) )
     
214. 
     
215.       {
     
216. 
     
217.     Serial.print("0");
     
218. 
     
219.     Serial.println();
     
220. 
     
221.   }
     
222. 
     
223.   }
     
224. 
     
225. 
     
226. 
     
227. if( (digitalRead(2)) == ( 0 ) )
     
228. 
     
229.       {
     
230. 
     
231.     Serial.print("13");
     
232. 
     
233.     Serial.println();
     
234. 
     
235.   }
     
236. 
     
237. 
     
238. 
     
239. 
     
240. 
     
241. if( (digitalRead(3)) == ( 0 ) )
     
242. 
     
243.       {
     
244. 
     
245.     Serial.print("14");
     
246. 
     
247.     Serial.println();
     
248. 
     
249.   }
     
250. 
     
251. 
     
252. 
     
253. }
     
254. 
     
255. void VAL_caculate()
     
256. 
     
257. {
     
258. 
     
259.   if (( ( ( _ABVAR_3_A0Value ) == ( 0 ) ) && ( ( _ABVAR_4_A1Value ) == ( 1 ) ) ))
     
260. 
     
261.   {
     
262. 
     
263.     _ABVAR_1_Ctrl_Val_1 = 7 ;
     
264. 
     
265.   }
     
266. 
     
267.   if (( ( ( _ABVAR_3_A0Value ) == ( 1 ) ) && ( ( _ABVAR_4_A1Value ) == ( 0 ) ) ))
     
268. 
     
269.   {
     
270. 
     
271.     _ABVAR_1_Ctrl_Val_1 = 9 ;
     
272. 
     
273.   }
     
274. 
     
275.   if (( ( ( _ABVAR_3_A0Value ) == ( 1 ) ) && ( ( _ABVAR_4_A1Value ) == ( 1 ) ) ))
     
276. 
     
277.   {
     
278. 
     
279.     _ABVAR_1_Ctrl_Val_1 = 8 ;
     
280. 
     
281.   }
     
282. 
     
283.   if (( ( ( _ABVAR_3_A0Value ) == ( 1 ) ) && ( ( _ABVAR_4_A1Value ) == ( 2 ) ) ))
     
284. 
     
285.   {
     
286. 
     
287.     _ABVAR_1_Ctrl_Val_1 = 10 ;
     
288. 
     
289.   }
     
290. 
     
291.   if (( ( ( _ABVAR_3_A0Value ) == ( 2 ) ) && ( ( _ABVAR_4_A1Value ) == ( 1 ) ) ))
     
292. 
     
293.   {
     
294. 
     
295.     _ABVAR_1_Ctrl_Val_1 = 6 ;
     
296. 
     
297.   }
     
298. 
     
299.   if (( ( ( _ABVAR_5_A2Value ) == ( 4 ) ) && ( ( _ABVAR_6_A3Value ) == ( 5 ) ) ))
     
300. 
     
301.   {
     
302. 
     
303.     _ABVAR_2_Ctrl_Val_2 = 2 ;
     
304. 
     
305.   }
     
306. 
     
307.   if (( ( ( _ABVAR_5_A2Value ) == ( 5 ) ) && ( ( _ABVAR_6_A3Value ) == ( 4 ) ) ))
     
308. 
     
309.   {
     
310. 
     
311.     _ABVAR_2_Ctrl_Val_2 = 4 ;
     
312. 
     
313.   }
     
314. 
     
315.   if (( ( ( _ABVAR_5_A2Value ) == ( 5 ) ) && ( ( _ABVAR_6_A3Value ) == ( 5 ) ) ))
     
316. 
     
317.   {
     
318. 
     
319.     _ABVAR_2_Ctrl_Val_2 = 3 ;
     
320. 
     
321.   }
     
322. 
     
323.   if (( ( ( _ABVAR_5_A2Value ) == ( 5 ) ) && ( ( _ABVAR_6_A3Value ) == ( 6 ) ) ))
     
324. 
     
325.   {
     
326. 
     
327.     _ABVAR_2_Ctrl_Val_2 = 5 ;
     
328. 
     
329.   }
     
330. 
     
331.   if (( ( ( _ABVAR_5_A2Value ) == ( 6 ) ) && ( ( _ABVAR_6_A3Value ) == ( 5 ) ) ))
     
332. 
     
333.   {
     
334. 
     
335.     _ABVAR_2_Ctrl_Val_2 = 1 ;
     
336. 
     
337.   }
     
338. 
     
339. }
     
340. 
     
341. void ADGet()
     
342. 
     
343. {
     
344. 
     
345.   _ABVAR_3_A0Value = analogRead(14) ;
     
346. 
     
347.   _ABVAR_4_A1Value = analogRead(15) ;
     
348. 
     
349.   _ABVAR_5_A2Value = analogRead(16) ;
     
350. 
     
351.   _ABVAR_6_A3Value = analogRead(17) ;
     
352. 
     
353.   _ABVAR_3_A0Value = map ( _ABVAR_3_A0Value , 0 , 1024 , 0 , 3 )   ;
     
354. 
     
355.   _ABVAR_4_A1Value = map ( _ABVAR_4_A1Value , 0 , 1024 , 0 , 3 )   ;
     
356. 
     
357.   _ABVAR_5_A2Value = map ( _ABVAR_5_A2Value , 0 , 1024 , 4 , 7 )   ;
     
358. 
     
359.   _ABVAR_6_A3Value = map ( _ABVAR_6_A3Value , 0 , 1024 , 4 , 7 )   ;
     
360. 
     
361. }

复制代码

5. 作品创新点5.1 技术创新点
5.1.1 防碰撞安全系统-超声波与颜色传感器的使用
      机器人在使用过程中可能会与人员或障碍物发生碰撞，为了提高安全性，减少损伤，我们增加了超声波模块，在机器人运动时进行物体的检测。当机器人前方出现物体时，超声波模块检测出遮挡，颜色传感器进行识别，确认物体非网球，则机器人进行避障操作，有效防止因碰撞而造成的损失，更有利于机器人在实际场景进行工作，提高机器人应用的稳定性。

5.1.2 基于颜色传感器与超声波传感器的物体识别与测距
       为了完成对目标物体的识别与抓取，我们在机器人前方安装了探索者套件中的颜色传感器。颜色传感器将物体颜色同前面已经示教过的参考颜色进行比较来检测颜色，当前方物体颜色与内设颜色（这里就是网球的颜色）在一定的误差范围内相吻合时，输出检测结果。如果前方物体颜色与内置颜色符合则进行抓取操作，不符合则进行避障操作。在识别到网球后，我们利用超声波传感器进行与目标物体距离的检测，从而能有效控制机器人与网球的距离，使对网球的抓取能够成功。
       由于网球场的环境较为空旷，场景物品较少，场景颜色较为单一，所以在这一场景下利用颜色模块进行物体检测这一设计可以在尽可能降低成本并且保证准确率的情况下实现对物体的识别与检测。这一设计相较于其他如利用红外检测进行识别更具分辨性，更符合只识别收集网球的要求，并且相比于利用相机进行检测的方式成本更低。

5.1.3 自动+手动双模式
       针对自动模式下可能遗漏部分角落处网球问题，我们加入了手动模式。在手动模式下，可以遥控机器人进行网球收纳，实现场地全识别，不遗漏任何网球。自动为主，手动为辅，两模式双辅双成，实现目标100%检测收纳。

5.2 设计创新点
       目前机器人的研究已经十分深入，机器人技术与机器人产品已十分成熟，人们现在迫切需要的是如何将现有的机器人产品与技术应用于实际生活生产，将机器人产品产业化。我们基于此，细心观察生活细节，立足于大众日常生活，发现了将机器人运用于器械收纳这一方面的空白与应用价值。
       基于高校的网球场地大且空旷，网球较小且弹力大，训练时使用量大，每次打完网球后会有大量网球散布场地各地不方便检拾，这一令网球爱好者与网球训练者头疼的问题提出了自动网球收纳机器人这一想法。区别于市面上需要人员推动找到网球所在地的“半自动化”网球收纳机器人，该网球收纳机器人可以在无人指挥情况下进行自主器械收纳，具有高度自主性，彻底解放用户。并且，机器人的手动与自动两挡模式可以针对自动模式下的未识别物体进行遥控抓取收纳，更好的实现网球收纳不遗漏，高质量完成场地网球收纳任务。
       外观设计上，我们在机器人的前端安装了两个向斜外方向延伸的直杆，这样设计可以在机器人运动时将前方区域物体带至前方检测区。在方便机器人检测的同时，增大了机器人扫场检测的检测范围，能够更好的提高机器人工作效率。机器人整体材质坚硬，结构坚固，机身小巧，方便运输，不易损坏，可很好的适用于多种场地，多种环境，具有优秀的环境适用性与稳定性。立足于体育领域，将机器人应用于器械收纳的这种创新性想法可以大大方便人们的体育活动生活，提升体育运动幸福度。

6. 作品难点及解决方案6.1 遇到的问题
6.1.1 机器人全局遍历问题
       首先，由于场地相对于机器人来说较大，网球散落点多且不定，所以需要机器人具有良好的全局遍历能力才能对场地实现较好的搜索，识别到场地上全部散落网球。但是如何规划，才能让机器人在成本较低，没有安装摄像头，没有导航的情况下实现良好的全局遍历这是一个棘手的问题。

6.1.2 目标物体识别问题
       在不依赖摄像头的情况下，实现对目标物体也就是网球的识别，这同样是一个难题。由于目标物体体积较小，且运动自由度高，对目标物体的识别难度较高。

6.1.3 物体抓取问题
       在目标物体成功识别之后，如何使机械臂抓取到目标物体也是一大难题。

6.1.4 自动模式下，部分网球未识别问题
       在自动模式下，小车进行遍历，检测场地内所有目标物体，但是有时仍可能出现场地部分角落位置网球遗落问题。

6.2 解决方案
6.2.1 对于机器人遍历问题的解决
       在基于网球场地的环境调研与思考以后，我们想到了利用好环境特点。由于网球弹力较大，所以网球场几乎全部在四周安装防护网，以防止球被打击至网球场外部区域，对于高校，网球场区域的防护措施做得更为完善。我们实地考察了几所高校，山东大学（威海）、哈工大（威海）、重庆大学，在校园网球场四周都设置有防护网。
       所以，基于这种环境特点，我们决定在机器人身上安装超声波传感器，当机器人检测到前方有遮挡时，颜色传感器进行检测，当颜色非绿色时，识别物体为障碍物，启动避障措施。机器人后退，旋转一定角度，前进一小段距离，向后旋转，再继续前进的动作。为了确定具体旋转方向，这里我们设置一个变量作为标记，初始小车行驶时标志为1，表示向右旋转。0表示向左旋转。当遇到障碍物时，后退，根据标志数值进行旋转，前进一小段距离D1，旋转，继续前进。当继续前进距离大于一定距离时(这段距离大于D1)将标志取反。这样设计当机器人前进至防护网或者障碍物处时会自动变换方向继续搜索，重复这一过程，可以实现对网球场的遍历。这样的设计也能防止机器人运动至墙角被困住。

6.2.2 对于目标识别问题的解决方案
       由于网球场场地空旷，场地物体较少，场地颜色单一，所以我们提出了基于颜色传感器进行目标物体检测的想法。我们利用颜色传感器，内设目前物体网球的颜色信息，让机器人能够通过检测目标物体颜色来实现目标物体的检测。同时，针对网球体积小不利于检测这一问题，我们将颜色传感器安装于机器人前端较低位置处，由于机器人本身体积小巧，这样的安排可以使得机器人能够更为灵敏地识别到地上物体颜色，完成对于地上网球的识别。

6.2.3 对物体抓取问题的解决方案
       我们在机器人前端放置了超声波传感器，由于超声波传感器可以检测与物体距离，所以利用超声波传感器检测机械臂与目标物体的距离，超声波传感器将距离信息实时传输，算法调整机械臂位置姿态，直至触碰目标物体，进行抓取。

6.2.4 对部分网球遗漏问题的解决方案
       针对自动识别模式下可能出现的部分网球遗落问题，我们加入了手动模式。追加遥控功能辅助，在部分网球未识别成功时，进行手动识别。利用遥控器操控机器人到达遗漏网球处，进行抓取。

7. 机器人目前不足与后续改良
       目前机器人的主要不足在于避障与物体识别功能基于一些传感器，虽然可以完成规定任务但是智能性可以进一步提高。后续可以加上摄像模块，通过摄像头记录场景信息，并且通过模式识别算法识别筛选出网球位置，计算出目标距离，向机器人发送运动与后续指令。

8. 后续应用发展
       前期，该网球收纳机器人主要设想在对新智能技术包容与接受度较高的高校进行使用，但如果前期发展良好，一段时间后可以将目光投向其他网球使用环境，如网球俱乐部，网球训练基地等。由于机器人本身轻便、方便转移的特点，可以实现在多个场地的切换，大大地提高其利用率。
将机器人应用于体育行业，将智能技术融入体育生活这一想法是未来体育行业的一大期待趋势，其发展潜力无限。并且，只需要稍微的改动，机器人也可应用于对羽毛球与乒乓球等其他小型球类的收纳，但由于羽毛球与乒乓球等收纳困难度相较于网球较小，所以这一领域可以在后续机器人的应用已初具规模，成本进一步下降的时候涉及。
       最后，我们的机器人不止可以收纳网球，只需要作进一步的算法与设备调整（如加装摄像头，加入模式识别算法），机器人可以检测并收集人们希望收集的小型物品，如地面上被丢弃的垃圾，有害物品等，实现向更多领域的突破。

*更多资料请见：【S036】网球收纳机器人 https://www.robotway.com/h-col-299.html