自动送料系统半成品

njzt

这自从有了孩子，感觉好些空闲的时间都没了，老早就想给激光机配个自动送料的系统，主要用于激光切割纸，身在帝都，手头边没有工具，都是每次回家看孩子，趁孩子睡觉的时候才动手做，所以这都拖了两个多月了才弄了个雏形。好久不焊电路了，焊的比较难看大家多见谅。送料的机械结构有个大概的想法，但是还没有实施
1. 主控用的Arduino Nano
2. 电路也比较简单，多数是继电器控制
3. 位置检测用激光对管
目前先做一个最简单的版本，不带液晶显示的，用于串口连接电脑配置参数，配置参数主要是配加工次数。


=======================================贴上现在的代码========================================

1. /*
   
2. * Description: auto feed system
   
3. * Hardware   : Arduino nano 328p
   
4. * Version    : V1.0
   
5. * Author     : Ninja
   
6. * Date       : 2016-06
   
7. */
   
8. #include<stdio.h>
   
9. #include<stdlib.h>
   
10. //#include <U8glib.h>
    
11. 
    
12. #define SENSOR     5   //位移传感器信号
    
13. #define SENSOR_POWER 7 //位移传感器电源开关
    
14. #define LASER      10  //加工停止信号
    
15. 
    
16. #define CUT_START  9   //加工启动面板
    
17. #define CUT_STOP   8   //加工停止面板
    
18. 
    
19. #define KEY_START  19   //开始按钮
    
20. #define KEY_CONFIG 18   //参数配置按钮
    
21. #define KEY_ESTOP  17   //急停按钮
    
22. 
    
23. #define MOTOR      6   //送料电机
    
24. 
    
25. #define DEBUG      1   //串口DEBUG开关
    
26. 
    
27. #if 0
    
28. #define CS         5   //LCD12864 CS
    
29. #define RESET      7   //LCD12864 RESET
    
30. 
    
31. U8GLIB_ST7920_128X64_1X LCD(CS,RESET);   // HW SPI: SCK MOSI
    
32. 
    
33. #endif
    
34. 
    
35. /*
    
36. * 函数返回值
    
37. */
    
38. typedef enum rs_s{
    
39.   RS_OK,
    
40.   RS_FAIL
    
41. }rs_t;
    
42. 
    
43. /*
    
44. *信号状态
    
45. */
    
46. typedef enum signal_state_s{
    
47.   ON,
    
48.   OFF
    
49. }signal_state_t;
    
50. 
    
51. /*
    
52. * 系统状态
    
53. */
    
54. typedef enum state_s{
    
55.   INIT,
    
56.   CONFIG,
    
57.   READY_CUT,
    
58.   CUTTING,
    
59.   FEEDING,
    
60.   ESTOP
    
61. }state_t;
    
62. 
    
63. typedef struct feed_obj_s{
    
64.   unsigned int cut_times;
    
65.   unsigned char state;
    
66. }feed_obj_t;
    
67. 
    
68. 
    
69. typedef struct action_s{
    
70.   rs_t (*sys_init)(feed_obj_t *feed_obj);
    
71.   rs_t (*sys_config)(feed_obj_t *feed_obj);
    
72.   rs_t (*sys_ready)(feed_obj_t *feed_obj);
    
73.   rs_t (*sys_cutting)(feed_obj_t *feed_obj);
    
74.   rs_t (*sys_feeding)(feed_obj_t *feed_obj);
    
75.   rs_t (*sys_estop)(feed_obj_t *feed_obj);
    
76.   void (*sys_key)(feed_obj_t *feed_obj);
    
77. }action_t;
    
78. 
    
79. 
    
80. /*
    
81. * 启动送料电机
    
82. */
    
83. void motor_start(){
    
84.   if(DEBUG){
    
85.     Serial.println("motor_start\n");
    
86.     delay(100);
    
87.   }
    
88.   digitalWrite(MOTOR,HIGH);
    
89.   delay(2);
    
90. }
    
91. 
    
92. /*
    
93. * 停止送料电机
    
94. */
    
95. void motor_stop(){
    
96.    if(DEBUG){
    
97.     Serial.println("motor_stop\n");
    
98.     delay(100);
    
99.   }
    
100.   digitalWrite(MOTOR,LOW);
     
101.   delay(2);
     
102. }
     
103. 
     
104. /*
     
105. * 清除加工参数
     
106. */
     
107. void reset_cut_params(feed_obj_t *feed_obj){
     
108.   if(DEBUG){
     
109.     Serial.println("reset_cut_params");
     
110.     delay(100);
     
111.   }
     
112.   feed_obj->cut_times = 0;
     
113.   feed_obj->state = INIT;
     
114.   sensor_power_off();
     
115. }
     
116. 
     
117. /*
     
118. * 位移检测传感器
     
119. */
     
120. signal_state_t sensor_read(){
     
121.   if(DEBUG){
     
122.       Serial.println("sensor_read\n");
     
123.       delay(100);
     
124.   }
     
125.   if(digitalRead(SENSOR) != HIGH){
     
126.     return OFF;
     
127.   }
     
128.   else{
     
129.     return ON;
     
130.   }
     
131. }
     
132. 
     
133. /*
     
134. * 加工停止信号检测
     
135. */
     
136. signal_state_t laser_stop(){
     
137.   if(DEBUG){
     
138.     Serial.println("laser_stop\n");
     
139.     delay(100);
     
140.   }
     
141.   if(digitalRead(LASER) != HIGH){
     
142.     return OFF;
     
143.   }
     
144.   else{
     
145.     return ON;
     
146.   }
     
147. }
     
148. 
     
149. /*
     
150. * 自定义面板启动加工
     
151. */
     
152. void cut_start(){
     
153.   if(DEBUG){
     
154.     Serial.println("cut_start\n");
     
155.     delay(100);
     
156.   }
     
157.   digitalWrite(CUT_START,HIGH);
     
158.   delay(2);
     
159. }
     
160. 
     
161. /*
     
162. * 自定义面板停止加工
     
163. */
     
164. void cut_stop(){
     
165.   if(DEBUG){
     
166.     Serial.println("cut_stop\n");
     
167.     delay(100);
     
168.   }
     
169.   digitalWrite(CUT_STOP,HIGH);
     
170.   delay(2);
     
171. }
     
172. 
     
173. /*
     
174. * 开 位移传感器
     
175. */
     
176. void sensor_power_on(){
     
177.   if(DEBUG){
     
178.     Serial.println("sensor_power_on\n");
     
179.     delay(100);
     
180.   }
     
181.   digitalWrite(SENSOR_POWER,LOW);
     
182.   delay(2);
     
183. }
     
184. 
     
185. /*
     
186. * 关 位移传感器
     
187. */
     
188. void sensor_power_off(){
     
189.   if(DEBUG){
     
190.     Serial.println("sensor_power_off\n");
     
191.     delay(100);
     
192.   }
     
193.   digitalWrite(SENSOR_POWER,HIGH);
     
194.   delay(2);
     
195. }
     
196. 
     
197. /*
     
198. * 初始化系统
     
199. */
     
200. rs_t action_init(feed_obj_t *feed_obj){
     
201.   if(DEBUG){
     
202.     Serial.println("action_init");
     
203.     delay(100);
     
204.   }
     
205.   if(NULL == feed_obj){
     
206.     return RS_FAIL;
     
207.   }
     
208.   
     
209.   if(feed_obj->state != INIT){
     
210.     return RS_FAIL;
     
211.   }
     
212.   motor_stop();
     
213.   reset_cut_params(feed_obj);
     
214.   //feed_obj->state = CONFIG;
     
215.   while(!Serial){
     
216.    
     
217.   }
     
218.   Serial.println("\t");
     
219.   Serial.println("***********自动送料系统************\t");
     
220.   Serial.println("Version:V1.0 \t");
     
221.   Serial.println("Author :Ning Jiang \t");
     
222.   Serial.println("Date   :2016-06\t");
     
223.   Serial.println("*********************************\t");
     
224.   return RS_OK;
     
225. }
     
226. 
     
227. /*
     
228. * 加工参数配置
     
229. */
     
230. rs_t action_config(feed_obj_t *feed_obj){
     
231.   String val = "";
     
232.   unsigned int i = 0;
     
233.   if(DEBUG){
     
234.     Serial.println("action_config\n");
     
235.     delay(100);
     
236.   }
     
237.   if(NULL == feed_obj){
     
238.     return RS_FAIL;
     
239.   }
     
240.   
     
241.   if(feed_obj->state != CONFIG){
     
242.     return RS_FAIL;
     
243.   }
     
244. 
     
245.   Serial.println("请输入加工次数:\t");
     
246.   while(Serial.available() == 0){
     
247.     //等待串口输入
     
248.   }
     
249.   while(Serial.available() > 0){
     
250.     val += char(Serial.read());
     
251.     delay(2);
     
252.   }
     
253.   if(val.length() > 5 || val.toInt() > 65535){
     
254.     Serial.println("加工次数超出范围");
     
255.     feed_obj->state = CONFIG;
     
256.     return RS_FAIL;
     
257.   }
     
258.   for(i=0;i<val.length();i++){
     
259.     if(val[i] < '0' || val[i] > '9'){
     
260.       Serial.println("加工参数只能输入数字");
     
261.       feed_obj->state = CONFIG;
     
262.       return RS_FAIL;
     
263.     }
     
264.   }
     
265.   if(val.toInt() == 0){
     
266.     Serial.println("加工参数不能为0");
     
267.     feed_obj->state = CONFIG;
     
268.     return RS_FAIL;
     
269.   }
     
270.   feed_obj->cut_times = val.toInt();
     
271.   feed_obj->state = READY_CUT;
     
272.   Serial.println(feed_obj->cut_times,DEC);
     
273.   Serial.println("请按加工按钮\t");
     
274.   if(DEBUG){
     
275.     Serial.println(feed_obj->cut_times,DEC);
     
276.     delay(1000);
     
277.   }
     
278.   return RS_OK;
     
279. }
     
280. 
     
281. /*
     
282. * 准备加工
     
283. */
     
284. rs_t action_ready(feed_obj_t *feed_obj){
     
285.   if(DEBUG){
     
286.     Serial.println("action_ready\n");
     
287.     delay(100);
     
288.   }
     
289.   feed_obj->state = READY_CUT;
     
290.   return RS_OK;
     
291. }
     
292. 
     
293. /*
     
294. * 启动加工
     
295. */
     
296. rs_t action_cutting(feed_obj_t *feed_obj){
     
297.   if(DEBUG){
     
298.     Serial.println("action_cutting\n");
     
299.     delay(100);
     
300.   }
     
301.   if(NULL == feed_obj){
     
302.     return RS_FAIL;
     
303.   }
     
304.   if(feed_obj->cut_times == 0){
     
305.     feed_obj->state = CONFIG;
     
306.     return RS_FAIL;
     
307.   }
     
308.   cut_start();
     
309.   while(laser_stop() != OFF){
     
310.     //等待加工结束
     
311.   }
     
312.   feed_obj->state = FEEDING;
     
313.   (feed_obj->cut_times)--;
     
314.   if(DEBUG){
     
315.     Serial.println(feed_obj->cut_times,DEC);
     
316.     delay(1000);
     
317.   }
     
318.   return RS_OK;
     
319. }
     
320. 
     
321. /*
     
322. * 启动送料
     
323. */
     
324. rs_t action_feeding(feed_obj_t *feed_obj){
     
325.   if(DEBUG){
     
326.     Serial.println("action_feeding\n");
     
327.     delay(100);
     
328.   }
     
329.   if(feed_obj->state != FEEDING){
     
330.     return RS_FAIL;
     
331.   }
     
332.   if(feed_obj->cut_times == 0){
     
333.     feed_obj->state = CONFIG;
     
334.     return RS_OK;
     
335.   }
     
336.   motor_start();
     
337.   while(sensor_read() != OFF){
     
338.     //等待位移检测信号
     
339.   }
     
340.   sensor_power_on();
     
341.   motor_stop();
     
342.   feed_obj->state = CUTTING;
     
343.   sensor_power_off();
     
344.   return RS_OK;
     
345. }
     
346. 
     
347. /*
     
348. * 急停
     
349. */
     
350. rs_t action_estop(feed_obj_t *feed_obj){
     
351.   if(DEBUG){
     
352.     Serial.println("action_estop\n");
     
353.     delay(100);
     
354.   }
     
355.   if(NULL == feed_obj){
     
356.     return RS_FAIL;
     
357.   }
     
358.   cut_stop();
     
359.   feed_obj->cut_times = 0;
     
360.   feed_obj->state = INIT;
     
361.   return RS_OK;
     
362. }
     
363. 
     
364. void func_init(action_t *action){
     
365.   if(DEBUG){
     
366.     Serial.println("func_init\n");
     
367.     delay(100);
     
368.   }
     
369.   action->sys_init = action_init;
     
370.   action->sys_config = action_config;
     
371.   action->sys_ready = action_ready;
     
372.   action->sys_cutting = action_cutting;
     
373.   action->sys_feeding = action_feeding;
     
374.   action->sys_estop = action_estop;
     
375.   action->sys_key = key_scan;
     
376. }
     
377. 
     
378. /*
     
379. * 控制引脚初始化
     
380. */
     
381. void port_init(){
     
382.   pinMode(SENSOR,INPUT);
     
383.   digitalWrite(SENSOR,HIGH);
     
384.   pinMode(LASER,INPUT);
     
385.   digitalWrite(LASER,LOW);
     
386. 
     
387.   pinMode(SENSOR_POWER,OUTPUT);
     
388.   digitalWrite(SENSOR_POWER,HIGH);
     
389. 
     
390.   pinMode(CUT_START,OUTPUT);
     
391.   digitalWrite(CUT_START,LOW);
     
392.   pinMode(CUT_STOP,OUTPUT);
     
393.   digitalWrite(CUT_STOP,LOW);
     
394. 
     
395.   pinMode(KEY_START,INPUT);
     
396.   digitalWrite(KEY_START,HIGH);
     
397.   pinMode(KEY_CONFIG,INPUT);
     
398.   digitalWrite(KEY_CONFIG,HIGH);
     
399.   pinMode(KEY_ESTOP,INPUT);
     
400.   digitalWrite(KEY_ESTOP,HIGH);
     
401. 
     
402.   pinMode(MOTOR,OUTPUT);
     
403.   digitalWrite(MOTOR,LOW);
     
404. }
     
405. 
     
406. /*
     
407. * 操作按钮检测
     
408. */
     
409. void key_scan(feed_obj_t *feed_obj){
     
410.   if(DEBUG){
     
411.     Serial.println("key_scan\n");
     
412.   }
     
413.   if(digitalRead(KEY_START) == LOW){
     
414.     delay(10);
     
415.     if(digitalRead(KEY_START) == LOW){
     
416.       feed_obj->state = CUTTING;
     
417.       if(DEBUG){
     
418.         Serial.println("KEY_START");
     
419.       }
     
420.     }
     
421.   }
     
422.   else if(digitalRead(KEY_CONFIG) == LOW){
     
423.     delay(10);
     
424.     if(digitalRead(KEY_CONFIG) == LOW){
     
425.       feed_obj->state = CONFIG;
     
426.       if(DEBUG){
     
427.         Serial.println("KEY_CONFIG");
     
428.       }
     
429.     }
     
430.   }
     
431.   else if(digitalRead(KEY_ESTOP) == LOW){
     
432.     delay(10);
     
433.     if(digitalRead(KEY_ESTOP) == LOW){
     
434.       feed_obj->state = ESTOP;
     
435.       Serial.println("KEY_ESTOP");
     
436.     }
     
437.   }
     
438.   else{
     
439.     //feed_obj->state = INIT;
     
440.     return;
     
441.   }
     
442. }
     
443. 
     
444. void setup() {
     
445.   // put your setup code here, to run once:
     
446.   port_init();
     
447.   Serial.begin(9600);
     
448. // while(!Serial){
     
449.     //等待串口连接
     
450. // }
     
451. 
     
452. }
     
453. 
     
454. void loop() {
     
455.   // put your main code here, to run repeatedly:
     
456.   feed_obj_t feed_obj;
     
457.   action_t action;
     
458.   state_t state;
     
459.   memset(&feed_obj,0,sizeof(feed_obj_t));
     
460.   memset(&action,0,sizeof(action_t));
     
461.   feed_obj.state = INIT;
     
462.   func_init(&action);
     
463.   while(1){
     
464.     action.sys_key(&feed_obj);
     
465.     switch(feed_obj.state){
     
466.       case INIT:
     
467.             action.sys_init(&feed_obj);
     
468.             break;
     
469.       case CONFIG:
     
470.             action.sys_config(&feed_obj);
     
471.             break;
     
472.       case READY_CUT:
     
473.             action.sys_ready(&feed_obj);
     
474.           //  action.sys_key(&feed_obj);
     
475.             break;
     
476.       case CUTTING:
     
477.             action.sys_cutting(&feed_obj);
     
478.             break;
     
479.       case FEEDING:
     
480.             action.sys_feeding(&feed_obj);
     
481.             break;
     
482.       case ESTOP:
     
483.             action.sys_estop(&feed_obj);
     
484.             break;
     
485.       default:
     
486.             break;
     
487.     }
     
488.   }
     
489. 
     
490. }

复制代码

100abc

雕刻盒子的激光功率要多大，也想添置一个激光雕刻头

blueruby

哈哈  我想了解的也是雕刻的方面

ain365

同问楼主用的激光头是多大的功率

njzt

100abc 发表于 2016-7-18 07:12
雕刻盒子的激光功率要多大，也想添置一个激光雕刻头

60W的激光管

njzt

blueruby 发表于 2016-7-18 07:58
哈哈  我想了解的也是雕刻的方面

想问哪方面的 我知无不言

njzt

ain365 发表于 2016-7-18 09:09
同问楼主用的激光头是多大的功率

60W的激光管

junyee

60W 的激光管太危险了...不敢玩.