Arduino自制实验用切割装置-自动控制机床程序

如题，使用ardunio编写的一个自动控制机床实现简单切割的小程序，串口实时通信控制。

单片机源程序如下:

1. #include "Arduino.h"
   
2. #define CLK 5
   
3. #define CLK_X 3
   
4. #define CLK_Y 6
   
5. #define CLK_Z 9
   
6. #define DIR_X 2
   
7. #define DIR_Y 5
   
8. #define DIR_Z 8
   
9. #define Stretch_1 A3
   
10. #define Stretch_2 A2
    
11. #define Scalpel_1 A1
    
12. #define Scalpel_2 A0 //pin parament
    
13. #define Choice_SW 16
    
14. #define Forward_SW 14
    
15. #define Backward_SW 15
    
16. #define FORWARD 0
    
17. #define BACKWARD 1 //motor direct parament
    
18. #define STOP 100
    
19. #define Solenoid 10
    
20. #define FAST 98
    
21. #define SLOW 99
    
22. 
    
23. int case_var;
    
24. float distance;
    
25. float time_1;
    
26. int m_var;
    
27. 
    
28. 
    
29. //电机控制部分 //步进电机使用1600HZ CLK时钟 1600细分
    
30. void motor_x(float); //输入浮点型位移 distance 行进完自动停止
    
31. void motor_y(float); //输入浮点型位移 distance 行进完自动停止
    
32. void motor_z(float); //输入浮点型位移 distance 行进完自动停止
    
33. void motor_Scalpel(int); //输入 FORWARD前进 BACKWARD后退 STOP停止 (行进后必须再输入停止命令STOP才可以停止）
    
34. void motor_Stretch(int); //输入 FORWARD前进 BACKWARD后退 STOP停止
    
35. void motor_mx(int,int); //输入 FORWARD前进 BACKWARD后退 STOP停止 && 输入FAST快速模式,SLOW慢速模式,停止时随意速度模式
    
36. void motor_my(int,int); //输入 FORWARD前进 BACKWARD后退 STOP停止 && 输入FAST快速模式,SLOW慢速模式,停止时随意速度模式
    
37. void motor_mz(int,int); //输入 FORWARD前进 BACKWARD后退 STOP停止 && 输入FAST快速模式,SLOW慢速模式,停止时随意速度模式
    
38. 
    
39. void setup()
    
40. {
    
41.   // put your setup code here, to run once:
    
42. 
    
43.   pinMode(DIR_X,OUTPUT);
    
44.   pinMode(DIR_Y,OUTPUT);
    
45.   pinMode(DIR_Z,OUTPUT);
    
46.   pinMode(CLK_X,OUTPUT);
    
47.   pinMode(CLK_Y,OUTPUT);
    
48.   pinMode(CLK_Z,OUTPUT);
    
49.   pinMode(Scalpel_1,OUTPUT);
    
50.   pinMode(Scalpel_2,OUTPUT);
    
51.   pinMode(Stretch_1,OUTPUT);
    
52.   pinMode(Stretch_2,OUTPUT);
    
53.   pinMode(Choice_SW,INPUT_PULLUP);
    
54.   pinMode(Forward_SW,INPUT);
    
55.   pinMode(Backward_SW,INPUT); //Setting mode
    
56.   Serial.begin(9600);
    
57.   analogWrite(CLK_X,0);
    
58.   analogWrite(CLK_Y,0);
    
59.   analogWrite(CLK_Z,0); //Duty cycle is 0/255
    
60.   delay(1200);
    
61.   Serial.println("cutting start, please confirm air pump is working");
    
62. }
    
63. 
    
64. void loop()
    
65. {
    
66.   // put your main code here, to run repeatedly:
    
67.   Serial.println("Select a control mode:");
    
68.   Serial.println("x.x axis");
    
69.   Serial.println("y.y axis");
    
70.   Serial.println("z.z axis");
    
71.   Serial.println("m.manual mode");
    
72.   while(Serial.read()>=0){}//clear buffer
    
73.   delay(100);
    
74.   while(Serial.available()<=0){}
    
75.   if (Serial.available()>0)
    
76. {
    
77.      case_var=Serial.read();
    
78.          delay(100);
    
79.      switch(case_var)
    
80.            {
    
81.           case 120: //x axis
    
82.           Serial.println("Enter a distance:");
    
83.           while(Serial.available()<=0){}
    
84.           distance = Serial.parseFloat();
    
85.           delay(100);
    
86.     while(Serial.read()>=0){}//clear buffer
    
87.           Serial.print("Advance in x axis: ");
    
88.           Serial.println(distance);
    
89.           motor_x(distance);
    
90.           //Control stepper motor
    
91.           break;
    
92.         
    
93.           case 121: //y axis
    
94.           Serial.println("Enter a distance:");
    
95.           while(Serial.available()<=0){}
    
96.           distance = Serial.parseFloat();
    
97.           delay(100);
    
98.     while(Serial.read()>=0){}//clear buffer
    
99.           Serial.print("Advance in y axis: ");
    
100.           Serial.println(distance);
     
101.           motor_y(distance);
     
102.           //Control stepper motor
     
103.           break;
     
104.         
     
105.           case 122: //z axis
     
106.           Serial.println("Enter a distance:");
     
107.           while(Serial.available()<=0){}
     
108.           distance = Serial.parseFloat();
     
109.           delay(100);
     
110.     while(Serial.read()>=0){}//clear buffer
     
111.           Serial.print("Advance in z axis: ");
     
112.           Serial.println(distance);
     
113.           motor_z(distance);
     
114.           //Control stepper motor
     
115.           break;
     
116. 
     
117.           case 109: //manunal
     
118.           manuallycontrol();
     
119.           break;
     
120. 
     
121.     default:
     
122.       break;
     
123. 
     
124.     }
     
125. }
     
126. }
     
127. 
     
128. 
     
129. //电机控制部分
     
130. void motor_x(float a_1)  //x轴自动前进
     
131. {
     
132.         if(a_1 >= 0)
     
133.           {
     
134.                  time_1 = 250*a_1;
     
135.                  digitalWrite(DIR_X, HIGH);
     
136.                  tone(CLK_X,1600);
     
137.                  delay(time_1);
     
138.                  noTone(CLK_X);
     
139.           }
     
140.           else
     
141.           {
     
142.                   a_1 = -a_1;
     
143.                   time_1 = 250*a_1;
     
144.                   digitalWrite(DIR_X,LOW);
     
145.                   tone(CLK_X,1600);
     
146.                   delay(time_1);
     
147.                   noTone(CLK_X);
     
148.           }  
     
149. }
     
150. 
     
151. void motor_y(float b_1)  //y轴自动前进
     
152. {
     
153.         if(b_1 >= 0)
     
154.           {
     
155.                  time_1 = 250*b_1;
     
156.                  digitalWrite(DIR_Y, HIGH);
     
157.                  tone(CLK_Y,1600)
     
158.                  delay(time_1);
     
159.                  noTone(CLK_Y);
     
160.           }
     
161.           else
     
162.           {
     
163.                   b_1 = -b_1;
     
164.                   time_1 = 250*b_1;
     
165.                   digitalWrite(DIR_Y,LOW);
     
166.                   tone(CLK_Y,1600);
     
167.                   delay(time_1);
     
168.                   noTone(CLK_Y);
     
169.           }
     
170. }
     
171. 
     
172. void motor_z(float c_1)  //z轴自动前进
     
173. {
     
174.         if(c_1 >= 0)
     
175.           {
     
176.                  time_1 = 250*c_1;
     
177.                  digitalWrite(DIR_Z, HIGH);
     
178.                  tone(CLK_Z,1600);
     
179.                  delay(time_1);
     
180.                  noTone(CLK_Z);
     
181.           }
     
182.           else
     
183.           {
     
184.                   c_1 = -c_1;
     
185.                   time_1 = 250*c_1;
     
186.                   digitalWrite(DIR_Z,LOW);
     
187.                   tone(CLK_Z,1600);
     
188.                   delay(time_1);
     
189.                   noTone(CLK_Z);
     
190.           }
     
191. }
     
192. 
     
193. void motor_Scalpel(int d_1) //刀具旋转
     
194. {
     
195.         if( d_1 == FORWARD )
     
196.         {
     
197.                 digitalWrite(Scalpel_1,HIGH);
     
198.                 digitalWrite(Scalpel_2,LOW);
     
199.         }
     
200.         else if( d_1 == BACKWARD )
     
201.         {
     
202.                 digitalWrite(Scalpel_1,LOW);
     
203.                 digitalWrite(Scalpel_2,HIGH);
     
204.         }
     
205.         else
     
206.         {
     
207.                 digitalWrite(Scalpel_1,LOW);
     
208.                 digitalWrite(Scalpel_2,LOW);
     
209.         }
     
210. }
     
211. 
     
212. void motor_Stretch(int e_1) //拉伸收缩
     
213. {
     
214.         if( e_1 == FORWARD )
     
215.         {
     
216.                 digitalWrite(Stretch_1,HIGH);
     
217.                 digitalWrite(Stretch_2,LOW);
     
218.         }
     
219.         else if( e_1 == BACKWARD )
     
220.         {
     
221.                 digitalWrite(Stretch_1,LOW);
     
222.                 digitalWrite(Stretch_2,HIGH);
     
223.         }
     
224.         else
     
225.         {
     
226.                 digitalWrite(Stretch_1,LOW);
     
227.                 digitalWrite(Stretch_2,LOW);
     
228.         }
     
229. }
     
230. 
     
231. void motor_mx(int f_1,int f_2)   //手控x轴
     
232. {
     
233.         if(f_1 == FORWARD,f_2 == FAST)
     
234.         {
     
235.         digitalWrite(DIR_X,HIGH);
     
236.                 tone(CLK_X,1600);
     
237.         }
     
238.         else if(f_1 == FORWARD,f_2 == SLOW )
     
239.         {
     
240.         digitalWrite(DIR_X,HIGH);
     
241.                 tone(CLK_X,800);
     
242.         }
     
243.         else if(f_1 == BACKWARD, f_2 == FAST)
     
244.         {
     
245.                 digitalWrite(DIR_X,LOW);
     
246.                 tone(CLK_X,1600);
     
247.         }
     
248.         else if(f_1 == BACKWARD, f_2 == SLOW)
     
249.         {
     
250.                 digitalWrite(DIR_X,LOW);
     
251.                 tone(CLK_X,800);
     
252.         }
     
253.         else
     
254.         {
     
255.         noTone(CLK_X);
     
256.         }
     
257. }
     
258. 
     
259. void motor_my(int g_1,int g_2)   //手控y轴
     
260. {
     
261.         if(g_1 == FORWARD,g_2 == FAST)
     
262.         {
     
263.         digitalWrite(DIR_Y,HIGH);
     
264.                 tone(CLK_Y,1600);
     
265.         }
     
266.         else if(g_1 == FORWARD,g_2 == SLOW )
     
267.         {
     
268.         digitalWrite(DIR_Y,HIGH);
     
269.                 tone(CLK_Y,800);
     
270.         }
     
271.         else if(g_1 == BACKWARD, g_2 == FAST)
     
272.         {
     
273.                 digitalWrite(DIR_Y,LOW);
     
274.                 tone(CLK_Y,1600);
     
275.         }
     
276.         else if(g_1 == BACKWARD, g_2 == SLOW)
     
277.         {
     
278.                 digitalWrite(DIR_Y,LOW);
     
279.                 tone(CLK_Y,800);
     
280.         }
     
281.         else
     
282.         {
     
283.         noTone(CLK_Y);
     
284.         }
     
285. }
     
286. 
     
287. void motor_mz(int h_1,int h_2)   //手控z轴
     
288. {
     
289.         if(h_1 == FORWARD,h_2 == FAST)
     
290.         {
     
291.         digitalWrite(DIR_Z,HIGH);
     
292.                 tone(CLK_Z,1600);
     
293.         }
     
294.         else if(h_1 == FORWARD,h_2 == SLOW )
     
295.         {
     
296.         digitalWrite(DIR_Z,HIGH);
     
297.                 tone(CLK_Z,800);
     
298.         }
     
299.         else if(h_1 == BACKWARD, h_2 == FAST)
     
300.         {
     
301.                 digitalWrite(DIR_Z,LOW);
     
302.                 tone(CLK_Z,1600);
     
303.         }
     
304.         else if(h_1 == BACKWARD, h_2 == SLOW)
     
305.         {
     
306.                 digitalWrite(DIR_Z,LOW);
     
307.                 tone(CLK_Z,800);
     
308.         }
     
309.         else
     
310.         {
     
311.         noTone(CLK_Z);
     
312.         }
     
313. }
     
314. 
     
315. void manuallycontrolX()
     
316. {
     
317.         while(!digitalRead(Forward_SW)&&!digitalRead(Backward_SW)&&digitalRead(Choice_SW)){}
     
318.         while(1)
     
319.                 {
     
320.                 if(digitalRead(Forward_SW)) motor_mx(FORWARD);
     
321.                 else if(digitalRead(Backward_SW)) motor_mx(BACKWARD);
     
322.                 else motor_mx(STOP);
     
323.     if(!digitalRead(Choice_SW)){
     
324.       delay(50);
     
325.       if(!digitalRead(Choice_SW))
     
326.       break;
     
327.     }
     
328.                 }
     
329.         motor_mx(STOP);
     
330. }
     
331. 
     
332. void manuallycontrolY()
     
333. {
     
334.         while(!digitalRead(Forward_SW)&&!digitalRead(Backward_SW)&&digitalRead(Choice_SW)){}
     
335.         while(1)
     
336.                 {
     
337.                 if(digitalRead(Forward_SW)) motor_my(FORWARD);
     
338.                 else if(digitalRead(Backward_SW)) motor_my(BACKWARD);
     
339.                 else motor_my(STOP);
     
340.     if(!digitalRead(Choice_SW)){
     
341.       delay(50);
     
342.       if(!digitalRead(Choice_SW))
     
343.       break;
     
344.     }
     
345.                 }
     
346.         motor_my(STOP);
     
347. }
     
348. 
     
349. void manuallycontrolZ()
     
350. {
     
351.         while(!digitalRead(Forward_SW)&&!digitalRead(Backward_SW)&&digitalRead(Choice_SW)){}
     
352.         while(1)
     
353.                 {
     
354.                 if(digitalRead(Forward_SW)) motor_mz(FORWARD);
     
355.                 else if(digitalRead(Backward_SW)) motor_mz(BACKWARD);
     
356.                 else motor_mz(STOP);
     
357.     if(!digitalRead(Choice_SW)){
     
358.       delay(50);
     
359.       if(!digitalRead(Choice_SW))
     
360.       break;
     
361.     }
     
362.                 }
     
363.         motor_my(STOP);
     
364. }
     
365. 
     
366. void manuallycontrolS()
     
367. {
     
368.         while(!digitalRead(Forward_SW)&&!digitalRead(Backward_SW)&&digitalRead(Choice_SW)){}
     
369.         while(1)
     
370.                 {
     
371.                 if(digitalRead(Forward_SW)) motor_Scalpel(FORWARD);
     
372.                 else if(digitalRead(Backward_SW)) motor_Scalpel(BACKWARD);
     
373.                 else motor_Scalpel(STOP);
     
374.    if(!digitalRead(Choice_SW)){
     
375.       delay(50);
     
376.       if(!digitalRead(Choice_SW))
     
377.       break;
     
378.     }
     
379.                 }
     
380.         motor_Scalpel(STOP);
     
381. }
     
382. 
     
383. void manuallycontrolD()
     
384. {
     
385.         while(!digitalRead(Forward_SW)&&!digitalRead(Backward_SW)&&digitalRead(Choice_SW)){}
     
386.         while(1)
     
387.                 {
     
388.                 if(digitalRead(Forward_SW)) motor_Stretch(FORWARD);
     
389.                 else if(digitalRead(Backward_SW)) motor_Stretch(BACKWARD);
     
390.                 else motor_Stretch(STOP);
     
391.    if(!digitalRead(Choice_SW)){
     
392.       delay(50);
     
393.       if(!digitalRead(Choice_SW))
     
394.       break;
     
395.     }
     
396.                 }
     
397.         motor_Stretch(STOP);
     
398. }
     
399. 
     
400. void manuallycontrol()
     
401. {
     
402.         m_var=1;
     
403.         Serial.println("Select a control mode:");
     
404.     Serial.println("x.x axis");
     
405.     Serial.println("y.y axis");
     
406.     Serial.println("z.z axis");
     
407.     Serial.println("s.scalpel");
     
408.         Serial.println("d.drawing");
     
409.           while(m_var!=0)
     
410.           {
     
411.                   if(Serial.available()>0)
     
412.                   {
     
413.                           case_var=Serial.read();
     
414.                           delay(100);
     
415.                           switch(case_var)
     
416.                           {
     
417.                                   case 120:
     
418.                                   Serial.println("manually control x axis");
     
419.                                   manuallycontrolX();
     
420.                                   Serial.println("quit x manual mode");
     
421.                                   break;
     
422.                                  
     
423.                                   case 121:
     
424.                                   Serial.println("manually control y axis");
     
425.                                   manuallycontrolY();
     
426.                                   Serial.println("quit y manual mode");
     
427.                                   break;
     
428.                                  
     
429.                                   case 122:
     
430.                                   Serial.println("manually control z axis");
     
431.                                   manuallycontrolZ();
     
432.                                   Serial.println("quit x manual mode");
     
433.                                   break;
     
434.                                  
     
435.                                   case 115:
     
436.                                   Serial.println("rotate the scalpel");
     
437.                                   manuallycontrolS();
     
438.                                   Serial.println("quit scalpel mode");
     
439.                                   break;
     
440.                                  
     
441.                                   case 100:
     
442.                                   Serial.println("draw");
     
443.                                   digitalWrite(Solenoid,LOW);
     
444.                                   manuallycontrolD();
     
445.                                   digitalWrite(Solenoid,HIGH);
     
446.                                   Serial.println("quit drawing mode");
     
447.           break;
     
448.                                  
     
449.                                   case 48:
     
450.                                   m_var=0;
     
451.                                   break;
     
452. 
     
453.           default:
     
454.             break;
     
455. 
     
456.                           }
     
457.                   }
     
458.           }
     
459. }
     

复制代码

所有资料51hei提供下载:
M_Controller_v1.8.zip (2.17 KB, 下载次数: 34)

2019-3-24 11:58 上传

点击文件名下载附件
下载积分: 黑币 -5

本帖需要重新编辑补全电路原理图,源码,详细说明与图片即可获得100+黑币(帖子下方有编辑按钮)

谢谢分享