机器人制作开源方案 | 森林管理员

机器谱

作者：李佳骏、常睿康、张智斌、李世斌、高华耸

单位：山西能源学院

指导老师：赵浩成、郜敏

1. 研究背景
      森林作为地球上可再生自然资源及陆地生态的主体，在人类生存和发展的历史中起着不可代替的作用，它不仅能提供国家建设和人民生活所需的木材及林副产品，而且还肩负着释放氧气调节气候环境，涵养水源、保持水土、防风固沙、美化环境、净化空气、减少噪音及旅游保健等多种使命，同时森林还是农牧业稳产高产的重要条件。然而，森林火灾是森林最危险的敌人，也是林业最可怕的灾害，也会给森林带来最有害、具有毁灭性的后果。森林火灾不只是烧毀片片森林，伤害林内动物，而旦还降低森林的更新能力，引起土壤的贫瘠和破坏森林涵养水源的作用，甚至号致生态环境失去平衡。2019年3月30日，四川省凉山州木里县就曾经发生过一次非常严重的森林火灾。2019年3月30日是一个雨天，木里县喇嘛寺沟附近下午5点左右出现了雷雨天气，虽然只是一次持续了30秒左右的阵雨，但是隆隆雷声却一直回荡在天空，不绝于耳。下午6点时一场森林火灾在山上悄然而至，起火点位于海拔3800余米的山上，山中地形复杂，遍布沟壑，无论是交通还是通讯情况都非常不好，消防官兵难以迅速赶往现场进行救援。经过相关部门得知消息后初步判断本次火灾的原因，可能是由于之前降兩时的雷击导致，多个起火点都位于山崖上，火场平均海拔高达4千米。31日下午，689位救火人员带着各种设备登山，前往海拔4000余米的原始森林开展救火工作，由于当日风向不定，风力风向突变导致山火爆燃形成一个巨大的火球。救火人员兵分两路进行避险，其中一路安全撤离，另一路的27位森林消防指战员和三名地方救火人员就此和其他人失去了联系。4月2日早晨六点30分，田火山山上的明火终于被扑灭。而制作山林隔离带是有效制止森林大火蔓延的的有效方式，且该方面大多是通过人工下地来完成的，所以我们设计了一款可通过远程遥控来实现砍伐、运输一体化的全地形机器人，减少人工的需求量和危险性。同时，目前生活中的伐木大多由人工实地操作，我们的作品也可以代替其完成系统化的作业。

2. 主要功能
       本小组作品的主要功能有在大火发生时，及时进入火场中，对还未涉及到的地域进行砍伐树木，降低火灾面积。本小车为全地形小车，可以适应森林中的各种地形，如山坡、地坑等等。小车一侧设有抓夹，在另一侧砍伐完树木后抓夹可以及时将树枝抓起放到车后部，最终由小车将其带出森林。在救援的同时小车前部设有摄像头以及湿度传感器，实时监控并记录火灾情况。本作品不仅可以用作在森林防护中制作隔离带的一体化工作，也可以用作日常生活中做伐木一体机器人使用。

3. 场景调研
       森林火灾的起因主要有两大类：人为火和自然火。人为火包括：生产性火源（农、林、牧业生产用火，林副业生产用火，工矿运输生产用火等）、非生产性火源（野外吸烟、做饭、烧纸、取暖等）、故意纵火。自然火包括：雷电火、自燃等。由于我国的森林火灾中，由吸烟、烧荒和上坟烧纸引起的火灾占了绝大多数，所以我们小组场地模拟森林火灾的起因为烧荒。在实际的地形中会存在山坡和小断层，我们小组在模拟时，模拟机器人爬小山坡和爬小台阶（断层）。同时，模拟了砍伐树木的过程，再砍伐完后，车另一侧的抓夹会将树木夹起搬运出森林。在进行就救援以及砍伐树木时，车前的摄像头可进行实时监控，可记录下在砍伐树木时周遭的实时动态，同时还有湿度传感器的实时监测。

4. 机器人本体技术路线说明
       ① 机械结构：整体车身分为两部分，前端车体运用柔性结构，并采用履带式车轮，后部采用传统轮胎，有着很好的抓地力。车体大致结合军用坦克的履带的优越性并结合实际，改装了后置轮胎，使得前后轮可以通过配合，从而顺利翻越一些工作途中所遇到的障碍。

      ② 驱动系统：该车加装了6个双直流电机共同驱动，六个电机同时驱动，为小车提供了足够的动力，减少了动力的损失，为通过障碍物提供了足够的动力条件，电锯有单舵机制作的机械臂和电机控制的电锯体实现横向自由伸展，砍伐树木。机械爪由两个舵机控制的机械臂和单舵机控制的爪体构成，可实现横向伸展并调整爪子的摆动，实现抓取。
       ③ 控制系统：主板采用了Basra主控板，通过ESP8266Wi-Fi模块与电脑连接实现远程实时无限操作，通过摄像头、温湿度传感器来实时反馈现场情况，为人们的勘测和救援提供信息帮助。
       ④ 感知系统：车体全程操作由人工在远程通过WiFi模块实时操作，在车体的前方和中段均装有摄像头，前部摄像头可帮我我们锁定目标树木的方向，也可以规避障碍物，在侧端的摄像头可对目标数目进行定位，当其进入合适位置后进行砍伐和搬运。在车的顶部同时也装配了温湿度传感器，对周围环境进行监控，并及时反馈，为人工救援行动提供保障。

5. 示例程序

1. #include <Servo.h>
   
2. 
   
3. int _ABVAR_1_data = 0 ;
   
4. 
   
5. int in1 = 5;
   
6. 
   
7. int in2 = 6;
   
8. 
   
9. int in3 = 9;
   
10. 
    
11. int in4 = 10;
    
12. 
    
13. int in5 = 12;
    
14. 
    
15. int SERVO_SPEED=20;                                        //定义舵机转动快慢的时间
    
16. 
    
17. int ACTION_DELAY=200;                                      //定义所有舵机每个状态时间间隔
    
18. 
    
19. Servo myServo[4];
    
20. 
    
21. int f = 50;                                                     //定义舵机每个状态间转动的次数，以此来确定每个舵机每次转动的角度
    
22. 
    
23. int servo_port[4] = {3,4,7,8};                            //定义舵机引脚
    
24. 
    
25. int servo_num = sizeof(servo_port) / sizeof(servo_port[0]);     //定义舵机数量
    
26. 
    
27. float value_init[4] = {10, 40, 20, 40};                //定义舵机初始角度
    
28. 
    
29. //10, 110, 20, 40chu    100, 110, 60, 30   kaishi     100, 40, 60, 30zhua     100, 40, 40, 30qi    10, 40, 60, 30weizhi   
    
30. 
    
31. //float value_init[6] = {10, 130, 60, 30};                //定义舵机初始角度
    
32. 
    
33. //float value_init[6] = {0, 40, 40, 40};
    
34. 
    
35. void setup()
    
36. 
    
37. {
    
38. 
    
39. Serial.begin(9600);
    
40. 
    
41. pinMode(in1, OUTPUT);
    
42. 
    
43.   pinMode(in2, OUTPUT);
    
44. 
    
45.   pinMode(in3, OUTPUT);
    
46. 
    
47.   pinMode(in4, OUTPUT);
    
48. 
    
49.     pinMode(in5, OUTPUT);
    
50. 
    
51. 
    
52. 
    
53.        for(int i=0;i<servo_num;i++){
    
54. 
    
55.     ServoGo(i,value_init[i]);
    
56. 
    
57.   }
    
58. 
    
59. }
    
60. 
    
61. void ServoStart(int which)
    
62. 
    
63. {
    
64. 
    
65.   if(!myServo[which].attached())myServo[which].attach(servo_port[which]);
    
66. 
    
67.   pinMode(servo_port[which], OUTPUT);
    
68. 
    
69. }
    
70. 
    
71. void ServoStop(int which)
    
72. 
    
73. {
    
74. 
    
75.   myServo[which].detach();
    
76. 
    
77.   digitalWrite(servo_port[which],LOW);
    
78. 
    
79. }
    
80. 
    
81. void ServoGo(int which , int where)
    
82. 
    
83. {
    
84. 
    
85.   if(where!=200)
    
86. 
    
87.   {
    
88. 
    
89.     if(where==201) ServoStop(which);
    
90. 
    
91.     else
    
92. 
    
93.     {
    
94. 
    
95.       ServoStart(which);
    
96. 
    
97.       myServo[which].write(where);
    
98. 
    
99.     }
    
100. 
     
101.   }
     
102. 
     
103. }
     
104. 
     
105. void servo_move(float value0, float value1, float value2, float value3)
     
106. 
     
107. {
     
108. 
     
109.   float value_arguments[] = {value0, value1, value2, value3};
     
110. 
     
111.   float value_delta[servo_num];
     
112. 
     
113.   for(int i=0;i<servo_num;i++)
     
114. 
     
115.   {
     
116. 
     
117.     value_delta[i] = (value_arguments[i] - value_init[i]) / f;
     
118. 
     
119.   }
     
120. 
     
121.   for(int i=0;i<f;i++)
     
122. 
     
123.   {
     
124. 
     
125.     for(int k=0;k<servo_num;k++)
     
126. 
     
127.     {
     
128. 
     
129.       value_init[k] = value_delta[k] == 0 ? value_arguments[k] : value_init[k] + value_delta[k];
     
130. 
     
131.       /**************************串口查看输出*****************************/
     
132. 
     
133. //      Serial.print(value_init[k]);
     
134. 
     
135. //      Serial.print(" ");
     
136. 
     
137.     }
     
138. 
     
139. //    Serial.println();
     
140. 
     
141.       /**************************串口查看输出*****************************/
     
142. 
     
143. 
     
144. 
     
145.     for(int j=0;j<servo_num;j++)
     
146. 
     
147.     {
     
148. 
     
149.       ServoGo(j,value_init[j]);
     
150. 
     
151.     }
     
152. 
     
153.     delay(SERVO_SPEED);
     
154. 
     
155.   }
     
156. 
     
157.   delay(ACTION_DELAY);
     
158. 
     
159. }
     
160. 
     
161. void loop()
     
162. 
     
163. {
     
164. 
     
165. /*   servo_move(10, 40, 20, 40);
     
166. 
     
167.      delay(500);
     
168. 
     
169.        servo_move(100, 20, 20, 40);
     
170. 
     
171.      delay(500);
     
172. 
     
173.      servo_move(100, 110, 20, 40);
     
174. 
     
175.      delay(500);
     
176. 
     
177.      servo_move(100, 110, 60, 40);
     
178. 
     
179.      delay(500);   
     
180. 
     
181.     servo_move(100, 40, 60, 40);
     
182. 
     
183.      delay(500);
     
184. 
     
185.   servo_move(10, 40, 60, 40);
     
186. 
     
187.    delay(500);
     
188. 
     
189.   servo_move(10, 40, 20, 40);*/
     
190. 
     
191. _ABVAR_1_data = Serial.read() ;
     
192. 
     
193. if (( ( _ABVAR_1_data ) == ( 1 ) ))
     
194. 
     
195. {
     
196. 
     
197.        analogWrite(in1, 0);                        
     
198. 
     
199.       analogWrite(in2, 0);
     
200. 
     
201.       analogWrite(in3, 0);
     
202. 
     
203.       analogWrite(in4, 160);
     
204. 
     
205.       delay (10);
     
206. 
     
207. }
     
208. 
     
209. if (( ( _ABVAR_1_data ) == ( 2 ) ))
     
210. 
     
211. {
     
212. 
     
213.   for(int i=0;i<10;i++)
     
214. 
     
215. {
     
216. 
     
217.     analogWrite(in1, 160);
     
218. 
     
219.       analogWrite(in2, 0);
     
220. 
     
221.       analogWrite(in3, 0);
     
222. 
     
223.       analogWrite(in4, 0);
     
224. 
     
225.       delay (10);
     
226. 
     
227. }
     
228. 
     
229. }
     
230. 
     
231. if (( ( _ABVAR_1_data ) == ( 12 ) ))
     
232. 
     
233. {     
     
234. 
     
235.    for(int i=0;i<10;i++)
     
236. 
     
237. {
     
238. 
     
239.   servo_move(190, 40, 20, 130);
     
240. 
     
241.   analogWrite(in1,150);
     
242. 
     
243.       analogWrite(in2,0);     
     
244. 
     
245.         analogWrite(in4,150);
     
246. 
     
247.       analogWrite(in3,0);
     
248. 
     
249.     delay (1000);
     
250. 
     
251. }
     
252. 
     
253. }
     
254. 
     
255. if (( ( _ABVAR_1_data ) == ( 3 ) ))
     
256. 
     
257. {     
     
258. 
     
259.    
     
260. 
     
261.   analogWrite(in1,150);
     
262. 
     
263.       analogWrite(in2,0);     
     
264. 
     
265.         analogWrite(in4,150);
     
266. 
     
267.       analogWrite(in3,0);
     
268. 
     
269.     delay (1000);
     
270. 
     
271. }
     
272. 
     
273. if (( ( _ABVAR_1_data ) == ( 0 ) ))
     
274. 
     
275. {       analogWrite(in1,0);
     
276. 
     
277.       analogWrite(in2,0);     
     
278. 
     
279.         analogWrite(in4,0);
     
280. 
     
281.       analogWrite(in3,0);
     
282. 
     
283. }
     
284. 
     
285. if (( ( _ABVAR_1_data ) == ( 4) ))   //jixiebi1
     
286. 
     
287. {     
     
288. 
     
289. servo_move(10, 40, 40, 130);
     
290. 
     
291. delay(500);
     
292. 
     
293.   delay(500);
     
294. 
     
295.    delay(500);
     
296. 
     
297.   analogWrite(in5, 250);
     
298. 
     
299.    delay(500);
     
300. 
     
301. }
     
302. 
     
303. if (( ( _ABVAR_1_data ) == ( 5) ))   //jixiebi1
     
304. 
     
305. {     
     
306. 
     
307. servo_move(10, 40, 20, 60);
     
308. 
     
309.      delay(500);
     
310. 
     
311.   analogWrite(in5, 0);
     
312. 
     
313. }
     
314. 
     
315. if (( ( _ABVAR_1_data ) == ( 7) ))   //10, 110, 20, 40chu    100, 110, 60, 30   kaishi     100, 40, 60, 30zhua     100, 40, 40, 30qi    10, 40, 60, 30weizhi   
     
316. 
     
317. {     
     
318. 
     
319. servo_move(100, 110, 60, 30);
     
320. 
     
321.      delay(500);
     
322. 
     
323. 
     
324. 
     
325. }
     
326. 
     
327. if (( ( _ABVAR_1_data ) == ( 8) ))   //qi
     
328. 
     
329. {     
     
330. 
     
331. servo_move(100, 40, 60, 30);
     
332. 
     
333.      delay(500);
     
334. 
     
335. 
     
336. 
     
337. }
     
338. 
     
339. if (( ( _ABVAR_1_data ) == ( 9) ))   //fan
     
340. 
     
341. {     
     
342. 
     
343. servo_move( 100, 40, 40, 30);
     
344. 
     
345.   delay(1000);  
     
346. 
     
347. 
     
348. 
     
349. }
     
350. 
     
351. if (( ( _ABVAR_1_data ) == ( 10) ))   //fan
     
352. 
     
353. {     
     
354. 
     
355. servo_move( 10, 40, 60, 30);
     
356. 
     
357.   delay(1000);  
     
358. 
     
359. 
     
360. 
     
361. }
     
362. 
     
363. if (( ( _ABVAR_1_data ) == ( 11) ))   //fan
     
364. 
     
365. {   
     
366. 
     
367.     servo_move(10, 40, 20, 40);
     
368. 
     
369.      delay(500);
     
370. 
     
371.        servo_move(100, 20, 20, 40);
     
372. 
     
373.      delay(500);
     
374. 
     
375.      servo_move(100, 130, 20, 40);
     
376. 
     
377.      delay(500);
     
378. 
     
379.      servo_move(100, 130, 50, 40);
     
380. 
     
381.      delay(500);   
     
382. 
     
383.     servo_move(100, 40, 50, 40);
     
384. 
     
385.      delay(500);
     
386. 
     
387.   servo_move(10, 40, 50, 40);
     
388. 
     
389.    delay(500);
     
390. 
     
391.   servo_move(10, 40, 20, 40);
     
392. 
     
393. }
     
394. 
     
395. }

复制代码

6. 创新点
      小车行进结构利用“太极”式刚柔结合进行翻越障碍。当小车遇到有一定角度的倾斜坡的时候，此时小车的刚性材料组成的车轮即可派上用场，通过调整履带的旋转自由度，使得小车在上坡的过程中不会发射管前倾和后倾。在小车遇到有断崖（台阶）的地面环境时，其柔性材料做成的车轮，经过调整前轮的自由度和前轮和后轮之间的距离，可以做出俯仰抬头的动作，从而轻松爬上断崖（台阶}。与此同时，俩种不同材料组成的车轮，也解决了在移动过程中出现的打滑问题，使小车的稳定性更高。其次，小车的机械臂可以180°进行旋转，不仅使小车在工作时候可接触的范围更广，还减小了车的体积，从而加快了小车的速度，车身在此期间也可以保持到最佳的位置。在此期间，同时可以利用小车体积小的优势，可以顺利通过小的隧道进行工作。最后，我们设计的小车使其重心集中在了整个小车的最中心，减少了了在通过障碍工作途中造成小车前倾或者后倾，从而翻车的情况，加强了小车的稳定性。

7. 作品难点
       ① 本作品在左右两侧分别装有不同的机械结构，应对其进行有效合理的位置和结构设计，保证其相对应与其他传感器的配合。
       ② 小车在运行过程中需通过不同的障碍结构，而由于车身较小，故掌握小车在登台阶和上坡时的平衡很是关键，防止侧翻。故我们在进行上（下）坡（台阶）会将左右机械臂摆至前（后）进行平衡。
       ③ 在小车砍到设计的隔离带树木后，放在车后方拉出时，怎么样去寻找最合适的路线去拉走树木，从而防止其他树木在路途中阻挡砍到的树木撤离火源。

更多详情请见 ：【S043】森林管理员 https://www.robotway.com/h-col-309.html