比赛终于结束了，终于可以好好睡一觉了。比赛从四月份延到了七月份，但这丝毫没有影响我把这比赛硬生生打成电赛，前前后后制作的时间加起来可能也就只有完完整整一星期吧，还能拿到省三我已经很满足了。就开个贴给今后要参加比赛的同学们讲讲这段经历，讲讲我觉得比较重要的几点。

队友

  有没有好队友非常的关键，有两个好队友就成功了一半。我做的是超市购物组，相对来说比较好的搭配是一个机械的一个信电的一个计算的。不管是从车的结构还是底层驱动还是图像识别上都能够考虑到。由于我们组没有学机械的同学，对于一些车的结构来说虽然我们可以想到，但是要是做出来非常困难，AutoCAD这些画图建模软件也都不会用，丧失了一些竞争力。现场看到的一些车的结构真的是令人感到震撼。

  队友的关系也要好，最好是自己比较熟的，交流起来也比较方便。这次比赛过去心态崩了两天，队友硬是给我心态整回来了，这点非常感谢我的队友。总之，队友最好不要是那种带来划水的，没啥时间观念的，否则真的会很累，除非是大佬，轻松一带二。

训练场地

  可以说这次是吃了场地的大亏了，学校里的场地出发区并没有涂成红色的，而实际的比赛场地变成了红色的。赛场上调试的时候，巡线传感器直接懵逼了，连出发区都走不出去，心态直接爆炸了一点点。抓取货物的时候，发现学校里测试的场地和实际比赛的场地高度还是有个2~3cm的差别，直接导致了机械臂根本抓不到东西，心态又炸了一次。场地还是得严格按照规则来搭，否则真的到了场上心态要崩。要么机械臂程序的容错率要够高，才能避免场地制作带来的误差。

赛前准备

  说实话这个比赛的制作准备时间还是非常充裕的，千万不要像我一样把这个比赛做成电赛，连续肝几天几夜，一天只睡两三个小时。一定不要拖到最后几天才做。早做早调试早发现问题早解决。要用到的模块一定要多准备一些，至少完完全全的准备额外的一套。能带多少去就带多少！！！！不然场上坏了想换都换不了。我们的破机器人可以说是从头换到了尾，第二天舵机坏了，找隔壁组借了一个，连夜换了调试，舵机驱动板烧了一块，比赛开始前半小时，降压模块还莫名其妙地烧掉了，电压表还找不到借了一个，赶紧换了一个模块。多带一套还是非常有必要的。

硬件

  说真的，硬件真的是一分钱一分货，还是得买性能好的，该花的钱还是得花，不然赛场上就会出现各种模块爆炸的情况。我们一开始电机驱动用的是那种最便宜的L298N，起初重量没上去还是比较正常的，但是搭完车，电机的电流就开始增加了，小车旋转30s驱动就滚烫。后来换了一块70+的驱动，承载电流大了很多，也不是很烫了。隔壁做运输对抗的他们用两百一块的驱动，峰值电流还可以到200A，这驱动想烧了都难。

  再说说机械臂，由于我们并没有什么机械制作的基础，也就只能想到用机械臂了。大家买的时候一定要买那种结构比较稳定的！！！！！我们从上上届的车上拆了一条机械臂，动的时候晃的不行，每抓一次都捏一把汗。舵机也得全新的，本来还想着废物利用，后来全换成新的了。扭矩一定要够大！！！！https://item.taobao.com/item.htm?spm=a1z09.2.0.0.299e2e8dl9HVl5&id=578661255198&_u=d2jd14b827f9这家店应该是淘宝上比较便宜的了，质量也还行，但是我调的时候可能堵转太久了，还是烧了一个。

  机械臂的调试一直是非常麻烦的事情，本来想直接用arduino写程序调，但是后来觉得实在是太麻烦了，搞了一块舵机调试板子，还有上位机，拖拖拽拽就能调，还是比较方便的。尽管如此，机械臂的调试还是非常花时间，如果有什么东西可以把机械臂用手调好的状态记录下来那就太好了！（我在想peach）

  巡线传感器我看到很多人用的16路传感器，网上一搜价格劝退，但是前面用单个单个拼在一起又感觉太容易松动了，而且间距不太好控制。前期准备的时候我索性自己做了一个六路和单路的传感器，前面还有灯，再也不怕光线影响了，夜车都能开嘿嘿。但是这个电位器好像没啥用，调节不了灵敏度，在红色上还是认为是白的。可能这个地方大家需要自己再改进改进。这两个传感器我也都开源了网址附上：

https://lceda.cn/wywy/tcrt5000

https://lceda.cn/wywy/tcrt5000-6-lu

   降压模块也要多准备一些，主要还是要看电流的大小，给舵机、电机用电流一定得大，太小了一下子就很烫烧掉了，接线的时候一定要看清楚正负！！！！上次再实验室头昏了，接反了，一通电，一路火花带闪电，30块没了，实验室的小伙伴人都傻了，这也是我这么久来炸掉的第一个电容，人生圆满了。。。。附上降压模块遗照一张。

  最后我也不得不说一句，蓝牙模块拿来调车是真的好用，各种数据打回手机就行了，根本不用连电脑串口看数据，方便的很，和板子的TX、RX一连，手机app一开数据都有，爽得很。HC-04 HC-08都可以，强推蓝牙模块调车。

软件实现

  由于我只是做的底层控制，所以只能说说底层的软件怎么实现的。用的是比较简单的arduino mega2560，IO口也比较充足，串口也很多，完全足够连接各种模块。我也简单讲讲我都实现思路。下图是一开始没有考虑到出发区的红色，现场马上改了一下。

  修改之后是这样

  只走了外面的一大圈，但是拿奖还是够了，如果想冲省一，中间还是要拿的。

  附上我小车所有底盘代码：

1. #define jidianqi 13
2. #define wheel_left_en 44
3. #define wheel_right_en 45
4. #define left_wheel_in1 46
5. #define left_wheel_in2 47
6. #define right_wheel_in3 48
7. #define right_wheel_in4 49
8. #define qti_left 53 //黑色返回1
9. #define qti_right 52
10. #define f_qti1 38
11. #define f_qti2 39
12. #define f_qti3 40
13. #define f_qti4 41
14. #define f_qti5 42
15. #define f_qti6 43
16. #define b_qti1 32
17. #define b_qti2 33
18. #define b_qti3 34
19. #define b_qti4 35
20. #define b_qti5 36
21. #define b_qti6 37
23. unsigned char action0[5] = {0xFF, 0x09, 0x00, 0x00, 0x00};
24. unsigned char action1[5] = {0xFF, 0x09, 0x00, 0x01, 0x00};
25. unsigned char action2[5] = {0xFF, 0x09, 0x00, 0x02, 0x00};
26. unsigned char action3[5] = {0xFF, 0x09, 0x00, 0x03, 0x00};
27. unsigned char action4[5] = {0xFF, 0x09, 0x00, 0x04, 0x00};
28. unsigned char action5[5] = {0xFF, 0x09, 0x00, 0x05, 0x00};
29. unsigned char action6[5] = {0xFF, 0x09, 0x00, 0x06, 0x00};
31. unsigned char f_QTIS = 0xff;
32. unsigned char b_QTIS = 0xff;
33. unsigned char s_QTIS = 0xff;
35. int crossing_counts = 0;
36. byte stop_flag = 0; //路口停止位，stop为1表示车停止，stop为0表示车未停止
38. int incomingByte = 0; // for incoming serial data
39. int result[7] = {};
40. int count = 0;
42. void setup() {
43. delay(13000);
44. car_init();
45. motor_motion(80,80);
46. delay(2000);
47. stop_car();
48. start_car();
49. }
50. void loop(){
51. while(!stop_flag)
52. Robot_hunting_judge_crossing();
53. if((crossing_counts == 1)||(crossing_counts==2))
54. {
55. turn_left();
56. start_car();
57. motor_motion(255,255);
58. delay(300);
59. }
60. else if(crossing_counts==3)
61. {
62. turn_right();
63. start_car();
64. motor_motion(255,255);
65. delay(300);
66. }
67. else if((crossing_counts==12)||(crossing_counts==10)||(crossing_counts==11)||(crossing_counts==21)||(crossing_counts==19)||(crossing_counts==20)||(crossing_counts==30)||(crossing_counts==28)||(crossing_counts==29))
68. {
69. start_car();
70. motor_motion(255,255);
71. delay(300);
72. }
73. else if(((crossing_counts>=4)&&(crossing_counts<=8))||((crossing_counts>=13)&&(crossing_counts<=17))||((crossing_counts>=22)&&(crossing_counts<=26))||((crossing_counts>=31)&&(crossing_counts<=35)))
74. {
75. send_recieve_smd();
76. how_carry_things();
77. start_car();
78. motor_motion(255,255);
79. delay(300);
80. }
81. else if((crossing_counts==9)||(crossing_counts==18)||(crossing_counts==27)||(crossing_counts==36))
82. {
83. send_recieve_smd();
84. how_carry_things();
85. turn_right();
86. start_car();
87. motor_motion(255,255);
88. delay(300);
89. }
90. else if(crossing_counts==37)
91. {
92. park_car();
93. }
94. stop_flag = 0;
95. }
97. void car_init() //小车所用各个引脚初始化
98. {
99. Serial.begin (115200);
100. Serial1.begin (115200);
101. Serial3.begin (9600);
102. //初始化各IO,模式为OUTPUT 输出模式
103. pinMode(jidianqi,OUTPUT);
104. digitalWrite(jidianqi,LOW);
105. pinMode(wheel_right_en,OUTPUT);
106. pinMode(wheel_left_en,OUTPUT);
107. pinMode(left_wheel_in1,OUTPUT);
108. pinMode(left_wheel_in2,OUTPUT);
109. pinMode(right_wheel_in3,OUTPUT);
110. pinMode(right_wheel_in4,OUTPUT);
111. digitalWrite(wheel_right_en,HIGH); //给高电平
112. digitalWrite(wheel_left_en,HIGH); //给高电平
113. pinMode(f_qti1,INPUT);
114. pinMode(f_qti2,INPUT);
115. pinMode(f_qti3,INPUT);
116. pinMode(f_qti4,INPUT);
117. pinMode(f_qti5,INPUT);
118. pinMode(f_qti6,INPUT);
119. pinMode(b_qti1,INPUT);
120. pinMode(b_qti2,INPUT);
121. pinMode(b_qti3,INPUT);
122. pinMode(b_qti4,INPUT);
123. pinMode(b_qti5,INPUT);
124. pinMode(b_qti6,INPUT);
125. pinMode(qti_left,INPUT);
126. pinMode(qti_right,INPUT);
127. digitalWrite(left_wheel_in1,HIGH); //给高电平
128. digitalWrite(left_wheel_in2,LOW); //给低电平
129. digitalWrite(right_wheel_in3,HIGH); //给高电平
130. digitalWrite(right_wheel_in4,LOW); //给低电平
131. send_arm_action(action0);
132. }
134. int f_readqti() //读取前方QTI的值
135. {
136. int f_qti,f_q1,f_q2,f_q3,f_q4,f_q5,f_q6;
137. f_q1=digitalRead(f_qti1);
138. f_q2=digitalRead(f_qti2);
139. f_q3=digitalRead(f_qti3);
140. f_q4=digitalRead(f_qti4);
141. f_q5=digitalRead(f_qti5);
142. f_q6=digitalRead(f_qti6);
143. f_qti=32_f_q1+16_f_q2+8_f_q3+4_f_q4+2_f_q5+f_q6;
144. f_qti=f_qti & 0x3f;
145. return f_qti;
146. }
148. int b_readqti() //读取后方QTI的值
149. {
150. int b_qti,b_q1,b_q2,b_q3,b_q4,b_q5,b_q6;
151. b_q1=digitalRead(b_qti1);
152. b_q2=digitalRead(b_qti2);
153. b_q3=digitalRead(b_qti3);
154. b_q4=digitalRead(b_qti4);
155. b_q5=digitalRead(b_qti5);
156. b_q6=digitalRead(b_qti6);
157. b_qti=32_b_q1+16_b_q2+8_b_q3+4_b_q4+2_b_q5+b_q6;
158. b_qti=b_qti & 0x3f;
159. return b_qti;
160. }
162. int side_readqti() //读取两边QTI的值
163. {
164. int s_qti,l_q,r_q;
165. l_q=digitalRead(qti_left);
166. r_q=digitalRead(qti_right);
167. s_qti=2_l_q+r_q;
168. s_qti=s_qti & 0x03;
169. return s_qti;
170. }
172. void Robot_hunting()
173. {
174. f_QTIS = f_readqti();
175. switch (f_QTIS)
176. {
177. case 51:motor_motion(150, 150);break; //1 110011 1,直行
178. case 31:motor_motion(0, 255);break; //011111,大幅左转
179. case 15:motor_motion(0, 200);break; //001111,大幅左转
180. case 7:motor_motion(0, 150);break; //000111,小幅左转
181. case 39:motor_motion(0, 100);break; //100111,小幅左转
182. case 35:motor_motion(0, 100);break; //100011,小幅左转
183. case 55:motor_motion(0, 100);break; //110111,小幅左转
184. case 57:motor_motion(100, 0);break; //111001,小幅右转
185. case 49:motor_motion(100, 0);break; //110001,小幅右转
186. case 59:motor_motion(100, 0);break; //111011,小幅右转
187. case 56:motor_motion(150, 0);break; //111000,小幅右转
188. case 60:motor_motion(200, 0);break; //111100,大幅右转
189. case 62:motor_motion(255, 0);break; //111110,大幅右转
190. default:motor_motion(150, 150);break;
191. }
192. delay(5);
193. }
195. void Robot_hunting_judge_crossing() //小车巡线加判断路口
196. {
197. f_QTIS = f_readqti();
198. s_QTIS = side_readqti();
199. //Serial.print(“f_QTIS=”);
200. //Serial.println(s_QTIS);
201. if(s_QTIS==0){
202. stop_car();
203. delay(20);
204. stop_flag = 1;
205. crossing_counts++;
206. }
207. switch (f_QTIS)
208. {
209. case 51:motor_motion(80, 80);break; //1 110011 1,直行
210. case 31:motor_motion(0, 255);break; //011111,大幅左转
211. case 15:motor_motion(0, 200);break; //001111,大幅左转
212. case 7:motor_motion(0, 150);break; //000111,小幅左转
213. case 39:motor_motion(0, 100);break; //100111,小幅左转
214. case 35:motor_motion(0, 100);break; //100011,小幅左转
215. case 55:motor_motion(0, 100);break; //110111,小幅左转
216. case 57:motor_motion(100, 0);break; //111001,小幅右转
217. case 49:motor_motion(100, 0);break; //110001,小幅右转
218. case 59:motor_motion(100, 0);break; //111011,小幅右转
219. case 56:motor_motion(150, 0);break; //111000,小幅右转
220. case 60:motor_motion(200, 0);break; //111100,大幅右转
221. case 62:motor_motion(255, 0);break; //111110,大幅右转
222. default:motor_motion(80, 80);break;
223. }
224. delay(5);
225. }
227. void motor_motion(unsigned int left_val, unsigned int right_val)
228. {
229. analogWrite(wheel_right_en,right_val);
230. analogWrite(wheel_left_en,left_val);
231. }
233. void turn_right()
234. {
235. digitalWrite(left_wheel_in1,HIGH); //给高电平
236. digitalWrite(left_wheel_in2,LOW); //给低电平
237. digitalWrite(right_wheel_in3,LOW);
238. digitalWrite(right_wheel_in4,HIGH);
239. motor_motion(255, 255);
240. delay(600);
241. while(1){
242. f_QTIS = f_readqti();
243. if((f_QTIS == 51)||(f_QTIS == 49)||(f_QTIS == 35)||(f_QTIS == 57)||(f_QTIS == 39))
244. {
245. stop_car();
246. break;
247. }
248. }
249. }
252. /_
253. void turn_left()
254. {
255. digitalWrite(left_wheel_in1,LOW); //给高电平
256. digitalWrite(left_wheel_in2,HIGH); //给低电平
257. digitalWrite(right_wheel_in3,HIGH);
258. digitalWrite(right_wheel_in4,LOW);
259. motor_motion(255, 255);
260. delay(1800);
261. stop_car();
262. }
264. void turn_right()
265. {
266. digitalWrite(left_wheel_in1,HIGH); //给高电平
267. digitalWrite(left_wheel_in2,LOW); //给低电平
268. digitalWrite(right_wheel_in3,LOW);
269. digitalWrite(right_wheel_in4,HIGH);
270. motor_motion(255, 255);
271. delay(1800);
272. stop_car();
273. }
275. */
278. void turn_left()
279. {
280. digitalWrite(left_wheel_in1,LOW); //给高电平
281. digitalWrite(left_wheel_in2,HIGH); //给低电平
282. digitalWrite(right_wheel_in3,HIGH);
283. digitalWrite(right_wheel_in4,LOW);
284. motor_motion(255, 255);
285. delay(600);
286. while(1){
287. f_QTIS = f_readqti();
288. //b_QTIS = b_readqti();
289. if((f_QTIS == 51)||(f_QTIS == 49)||(f_QTIS == 35)||(f_QTIS == 57)||(f_QTIS == 39))
290. {
291. stop_car();
292. break;
293. }
294. }
295. }
298. void stop_car(){
299. digitalWrite(left_wheel_in1,LOW);
300. digitalWrite(left_wheel_in2,LOW);
301. digitalWrite(right_wheel_in3,LOW);
302. digitalWrite(right_wheel_in4,LOW);
303. }
305. void start_car()
306. {
307. digitalWrite(left_wheel_in1,HIGH); //给高电平
308. digitalWrite(left_wheel_in2,LOW); //给低电平
309. digitalWrite(right_wheel_in3,HIGH); //给高电平
310. digitalWrite(right_wheel_in4,LOW); //给低电平
311. }
313. void send_arm_action(unsigned char action[])
314. {
315. for(int i = 0; i < 5; i++)
316. {
317. Serial3.write(action[i]);
318. delay(50);
319. }
321. }
323. void send_recieve_smd()
324. {
325. delay(1000);
326. Serial1.write(49);
327. delay(20);
328. while(Serial1.read() >= 0){}//清空缓存，避免缓存的串口数据的影响
329. while(incomingByte != 55)
330. {
331. if (Serial1.available() > 0) {
332. // read the incoming byte:
333. incomingByte = Serial1.read();
334. result[count] = incomingByte;
335. count++;
336. // say what you got:
337. //Serial.print(“I received: “);
338. //Serial.println(incomingByte, DEC);
339. }
340. }
341. incomingByte = 0;
342. }
344. void how_carry_things()
345. {
346. if((count == 1)||(count>7))
347. ;
348. else
349. {
350. for(int i = 0; i < (count-1); i++)
351. {
352. if(result[i] == 49)
353. {
354. send_arm_action(action1);
355. delay(15000);
356. }
357. else if(result[i] == 50)
358. {
359. send_arm_action(action2);
360. delay(15000);
361. }
362. else if(result[i] == 51)
363. {
364. send_arm_action(action3);
365. delay(15000);
366. }
367. else if(result[i] == 52)
368. {
369. send_arm_action(action4);
370. delay(20000);
371. }
372. else if(result[i] == 53)
373. {
374. send_arm_action(action5);
375. delay(16000);
376. }
377. else if(result[i] == 54)
378. {
379. send_arm_action(action6);
380. delay(20000);
381. }
382. else
383. ;
384. }
385. }
386. count = 0;
387. }
389. void park_car()
390. {
391. turn_right();
392. digitalWrite(jidianqi,HIGH);
393. }

   代码其实并不多，也就三百行。loop里其实是一直在找路口，然后根据路口的计数来判断应该做什么，还是非常简洁的，和上面的图一起看还是很清楚的。但是就是有一个很大的问题，就是转弯按照我这么写其实很不好，但是由于时间有限，我也没有什么好想法，在一个由于车的重心没有完全在中心点，或多或少都有问题，只能靠前面的巡线传感器巡线把车身摆正。串口三和舵机控制板连，串口一和树莓派连。购物车靠电磁铁拉着。

 暂且就写这么多了，以后想到有什么可以补充再补充。也欢迎大家下面评论区交流，虽然这是我的第一次机器人竞赛，也是我最后一次机器人竞赛了。希望大家在竞赛中都能有好运气好名次。