Balloon Printer

My kids love balloons, and they know that daddy is almighty. :)

Apr 23, 2019

•

12128 views

•

14 respects

entertainment system

kids

Components and supplies

NEMA 17 Stepper Motor

Arduino Mega 2560

NEMA 23 Stepper Motor

Tools and machines

Drill / Driver, Cordless

Wire Stripper & Cutter, 18-10 AWG / 0.75-4mm² Capacity Wires

Laser cutter (generic)

Apps and platforms

Arduino IDE

Project description

Code

Core code

c_cpp

Runs the machine

1#include <GyverButton.h>
2
3#include <AccelStepper.h>
4#include  <MultiStepper.h>
5
6
7AccelStepper stepperX(1, 3, 2);   // 1 режим, 2 степ,  5 дир 
8AccelStepper stepperZ(1, 9, 8);                                
9AccelStepper  stepperA(1, 5, 4);
10AccelStepper stepperY(1, 7, 6); 
11AccelStepper stepperXB(1,  11, 10);
12AccelStepper stepperYB(1, 13, 12);                               
13AccelStepper  stepperR(1, 23, 25);
14AccelStepper stepperP(1, 27, 29);
15
16#define home_switchX  56 // дефайним пины концевиков
17#define home_switchXB 57 // x back
18#define  home_switchZ 64
19#define home_switchZD 65
20#define home_switchY 55
21#define  home_switchA 54
22#define home_switchXBB 62 // x back bottom
23#define home_switchXBF  58 // x front bottom
24#define home_switchYB 63 // y bottom
25#define pedal 18  // дефайнми пин педали
26#define relay 16 // пин реле
27#define DEBOUNCE 100 //  антидребзг дебоунсер
28#define TIMEOUT 500 // таймают парсера
29#define buttonG  21 // init button
30#define buttonR 20
31#define buttonB 19
32// перемешки хоминга
33  GButton switchX(home_switchX, HIGH_PULL, NORM_OPEN); // назначаем входы концевиков  через библиотеку
34  GButton switchXB(home_switchXB, HIGH_PULL, NORM_OPEN);
35  GButton switchZ(home_switchZ, HIGH_PULL, NORM_OPEN);
36  GButton switchZD(home_switchZD,  HIGH_PULL, NORM_OPEN); 
37  GButton switchY(home_switchY, HIGH_PULL, NORM_OPEN);
38  GButton switchA(home_switchA, HIGH_PULL, NORM_OPEN);
39  GButton switchXBB(home_switchXBB,  HIGH_PULL, NORM_OPEN);
40  GButton switchXBF(home_switchXBF, HIGH_PULL, NORM_OPEN);
41  GButton switchYB(home_switchYB, HIGH_PULL, NORM_OPEN);
42
43  GButton pedalsw(pedal,  HIGH_PULL, NORM_OPEN);  // пинчик педальки запускаем как входик и подтягиваем
44  GButton greensw(buttonG, HIGH_PULL, NORM_OPEN);
45  GButton blacksw(buttonB,  HIGH_PULL, NORM_OPEN);
46  GButton redsw(buttonR, HIGH_PULL, NORM_OPEN);
47
48int  step=0;  // глобальная закладка switch
49
50// педаль
51boolean pedal_state,  pedal_flag; // бульки педали
52boolean buttonG_state, buttonG_flag, buttonR_state,  buttonR_flag, buttonB_state, buttonB_flag;
53unsigned long debounceTimer; // шоб  работало без всяких дребезгав!! :)
54
55
56
57void setup() {
58  
59
60  pinMode(relay,  OUTPUT);
61  digitalWrite(relay, HIGH);
62
63
64  switchX.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
65  switchX.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
66  switchXB.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
67  switchXB.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
68  switchZD.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
69  switchZD.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
70  switchZ.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
71  switchZ.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
72  switchY.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
73  switchY.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
74  switchA.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
75  switchA.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
76  switchXBB.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
77  switchXBB.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
78  switchXBF.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
79  switchXBF.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
80  switchYB.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
81  switchYB.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
82  pedalsw.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
83  pedalsw.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
84  greensw.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
85  greensw.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
86  blacksw.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
87  blacksw.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
88  redsw.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
89  redsw.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
90
91  switchX.setTickMode(AUTO);
92  switchXB.setTickMode(AUTO);
93  switchY.setTickMode(AUTO);
94  switchA.setTickMode(AUTO);
95  switchXBB.setTickMode(AUTO);
96  switchXBF.setTickMode(AUTO);
97  switchYB.setTickMode(AUTO);
98  pedalsw.setTickMode(AUTO);
99  greensw.setTickMode(AUTO);
100  blacksw.setTickMode(AUTO);
101  redsw.setTickMode(AUTO);
102  switchZ.setTickMode(AUTO);
103  switchZD.setTickMode(AUTO);
104
105
106  stepperX.setMaxSpeed(600);      // дефолтим скорость для хоминга
107  stepperX.setAcceleration(600);
108  stepperZ.setMaxSpeed(200);
109  stepperZ.setAcceleration(500);
110  stepperY.setMaxSpeed(4000);
111  stepperY.setAcceleration(4000);
112  stepperA.setMaxSpeed(4000);
113  stepperA.setAcceleration(4000);
114  stepperXB.setMaxSpeed(600);
115  stepperXB.setAcceleration(600);
116  stepperYB.setMaxSpeed(4000);  
117  stepperYB.setAcceleration(4000); 
118  stepperP.moveTo(7500);      
119  
120  Serial.begin(9600);
121}
122
123void loop() {
124//Serial.print(digitalRead(18));  Serial.print(digitalRead(19)); Serial.print(digitalRead(20)); Serial.println(digitalRead(21));  
125//Serial.print(stepperR.currentPosition()); Serial.print("  "); Serial.println(step);  
126//Serial.println(step);
127switch(step){
128  //последовательность инициализации
129  case 0:
130  if(switchXB.isPress()){ // если замкнут концевик при старте, отходим
131    stepperX.moveTo(200);
132    step = 1;
133  }
134  else{
135  step = 2;
136  }
137  break;
138  case 1:
139  if(switchXB.isPress()){
140     stepperX.run();
141  }
142  else{
143    step = 2;
144  }
145  break;
146  case 2:
147  if(switchXBB.isPress()){
148    stepperXB.moveTo(200);
149    step = 3;
150  }
151  else{
152    step = 4;
153  }
154  break;
155  case 3:
156  if(switchXBB.isPress()){
157    stepperXB.run();
158  }
159  else{
160    step = 4;
161  }
162  break;
163  case 4:
164  if(switchY.isPress()){  // если замкнут концевик при старте, отходим
165    stepperY.moveTo(200);
166    step  = 5;
167  }
168  else{
169  step = 6;
170  }
171  break;
172  case 5:
173  if(switchY.isPress()){
174  stepperY.run();
175  }
176  else{
177    step = 6;
178  }
179  break;
180  case  6:
181  if(switchA.isPress()){ // если замкнут концевик при старте, отходим
182    stepperA.moveTo(200);
183    step = 7;
184  }
185  else{
186  step = 8;
187  }
188  break;
189  case 7:
190 
191  if(switchA.isPress()){
192     stepperA.run();
193  }
194  else{
195    step = 8;
196  }
197  break;
198  case 8:
199  if(switchYB.isPress())){  // если замкнут концевик при старте, отходим
200    stepperYB.moveTo(100);
201    step  = 9;
202  }
203  else{
204  step = 10;
205  }
206  break;
207  case 9:
208  if(switchYB.isPress()){
209     stepperYB.run();
210  }
211  else{
212    step = 10;
213  }
214  break;
215  
216  case 10:  // поиск нолей
217  if(!switchXB.isPress()){
218  stepperX.moveTo(-2000);
219  step = 11;
220  }
221  else {
222    step = 0;
223  }
224  break;
225  case 11:
226  if(!switchXB.isPress()){
227    stepperX.run();
228  }
229  else{
230    stepperX.setCurrentPosition(0);
231    step = 12;
232  }
233  break;
234  
235   case 12:  // поиск нолей
236  if(!switchXBB.isPress()){
237  stepperXB.moveTo(-2000);
238  step = 13;
239  }
240  else {
241    step = 0;
242  }
243  break;
244  case 13:
245  if(!switchXBB.isPress()){
246    stepperXB.run();
247  }
248  else{
249    stepperXB.setCurrentPosition(0);
250    step = 14;
251  }
252  break;
253  case 14:  // поиск нолей
254  if(!switchZ.isPress()){
255  stepperZ.moveTo(-1000);
256  step = 15;
257  }
258  else {
259    step = 15;
260  }
261 
262  break;
263  case  15:
264  if(!switchZ.isPress()){
265    stepperZ.run();
266  }
267  else{
268    stepperZ.setCurrentPosition(0);
269    step = 16;
270  }
271  break;
272
273  case 16:
274  if(!switchY.isPress()){
275    stepperY.moveTo(-600);
276    step = 17;
277    }
278    else{
279      step  = 0;
280    }
281    break;
282    case 17:
283    if(!switchY.isPress()){
284      stepperY.run();
285    }
286    else{
287      stepperY.setCurrentPosition(0);
288      stepperY.moveTo(250);
289      step = 18;
290    }
291    break;
292    case 18:
293    if(stepperY.currentPosition()  != 250){
294      stepperY.run();
295    }
296    else{
297      stepperY.setCurrentPosition(0);
298      step = 19;
299    }
300    break;
301    case 19:
302    if(!switchA.isPress()){
303    stepperA.moveTo(-600);
304    step = 20;
305    }
306    else{
307      step  = 0;
308    }
309    break;
310    case 20:
311    if(!switchA.isPress())){
312      stepperA.run();
313    }
314    else{
315      stepperA.setCurrentPosition(0);
316      stepperA.moveTo(250);
317      step = 21;
318    }
319    break;
320    case  21:
321    if(stepperA.currentPosition() != 250){
322       stepperA.run();
323    }
324    else{
325      stepperA.setCurrentPosition(0);
326      step = 22;
327    }
328    break;
329    case 22:
330    if(!switchYB.isPress()){
331    stepperYB.moveTo(-800);
332    step = 23;
333    }
334    else{
335      step = 0;
336    }
337    break;
338    case 23:
339    if(!switchYB.isPress()){
340      stepperYB.run();
341    }
342    else{
343      stepperYB.setCurrentPosition(0);
344      stepperYB.moveTo(50);
345      step = 24;
346    }
347    break;
348    case 24:
349    if(stepperYB.currentPosition()  != 50){
350      stepperYB.run();
351    }
352    if(stepperYB.currentPosition()  == 50){
353      stepperYB.setCurrentPosition(0);
354      step = 25;
355    }
356    break;
357    case 25:
358  stepperX.setMaxSpeed(10000);      
359  stepperX.setAcceleration(6000);
360  stepperZ.setMaxSpeed(1000);
361  stepperZ.setAcceleration(1000);
362  stepperY.setSpeed(15000);
363  stepperY.setAcceleration(15000);
364  stepperA.setMaxSpeed(15000);
365  stepperA.setAcceleration(15000);
366  stepperXB.setMaxSpeed(10000);
367  stepperXB.setAcceleration(6000);
368  stepperYB.setMaxSpeed(15000);      
369  stepperYB.setAcceleration(15000);
370  stepperR.setMaxSpeed(5000);      
371  stepperR.setAcceleration(5000);
372  stepperP.setMaxSpeed(15000);      
373  stepperP.setAcceleration(15000);
374  step = 26;
375  break;
376
377    case 26: //ОБРАБОТЧИК КНОПОК
378    
379        //  обработчик педали
380    if(pedalsw.isPress()) { //knopka pressed
381    stepperP.moveTo(7500);
382    step = 27;
383    }
384 // black button
385    if(blacksw.isPress()) { //knopka  pressed
386     step = 14;
387    }
388    // red button     
389    if(redsw.isPress())  { //knopka pressed
390    step = 44;
391    }
392   // green button
393    if(greensw.isPress())  { //knopka pressed
394    step = 62;
395    }
396 
397break;
398     case 27: //  два прохода две стороны
399     
400     if(stepperP.currentPosition() != 7500){
401      stepperP.runToPosition();
402     }
403     else {
404      step = 28;
405     }
406     break;
407     case 28:
408     if(stepperP.currentPosition() ==  7500){
409      delay(500);
410      stepperP.moveTo(0);
411      step = 29;
412     }
413     break;
414     case 29:
415     if(stepperP.currentPosition() !=  0){
416      stepperP.runToPosition();
417     }
418     else{
419      step = 30;
420     }
421     break;
422     case 30:
423     digitalWrite(relay, LOW);
424     delay(1300);
425     digitalWrite(relay, HIGH);
426     step = 31;
427     
428     break;
429     case  31:
430     if(!switchZD.isPress()){
431      stepperZ.moveTo(500);
432      step  = 32;
433     }
434     else{
435      step = 33; 
436     }
437     break;
438     case 32:
439     if(!switchZD.isPress()){
440      stepperZ.run();
441     }
442     else{
443      step = 33;
444     }
445     break;
446     case 33:
447     if(switchZD.isPress()){
448      stepperZ.setCurrentPosition(stepperZ.currentPosition());
449      stepperY.moveTo(-250);
450      stepperA.moveTo(250);
451      stepperYB.moveTo(550);
452      step = 34;
453     }
454     break;
455     case 34:
456     if(stepperY.distanceToGo() != 0){
457       stepperY.run();
458     }
459     if(stepperA.distanceToGo() != 0){
460      stepperA.run();
461     }
462     if(stepperYB.distanceToGo() != 0){
463      stepperYB.run();
464     }
465     
466     if(stepperY.currentPosition() == -250 && stepperA.currentPosition()  == 250 && stepperYB.currentPosition() == 550){
467      step = 35;
468     }
469     break;
470     case 35:
471     if(stepperY.currentPosition() == -250 && stepperA.currentPosition()  == 250 && stepperYB.currentPosition() == 550){
472      stepperX.moveTo(1200);
473      stepperXB.moveTo(1200);
474      step = 36;
475     }
476     break;
477     case  36:
478     if(!switchXBF.isPress() && !switchX.isPress()){
479      stepperX.run();
480      stepperXB.run();
481     }
482     else {
483      step = 37;
484     }
485     break;
486     case 37:
487     if(!switchX.isPress()){
488      stepperX.run();
489     }
490     if(!switchXBF.isPress()){
491      stepperXB.run();
492     }
493     if(switchXBF.isHold()) && switchX.isHold()){
494       stepperXB.setCurrentPosition(stepperXB.currentPosition());
495       stepperX.setCurrentPosition(stepperX.currentPosition());
496      step =  38;
497     }
498     break;//
499     case 38:
500      if(!digitalRead(home_switchXBF)  && !digitalRead(home_switchX)){
501      stepperY.moveTo(250);
502      stepperA.moveTo(-250);
503      stepperYB.moveTo(0);
504      step = 39;
505     }
506     break;
507     case  39:
508     if(stepperY.distanceToGo() != 0){
509      stepperY.run();
510     }
511     if(stepperA.distanceToGo() != 0){
512      stepperA.run();
513     }
514     if(stepperYB.distanceToGo()  != 0){
515      stepperYB.run();
516     }
517     else{
518      step = 40;
519     }
520     break;
521     case 40:
522   
523     if(stepperY.currentPosition()  == 250 && stepperA.currentPosition() == -250 && stepperYB.currentPosition() == 0){
524      stepperX.moveTo(-100);
525      stepperXB.moveTo(-100);
526      step = 41;
527     }
528     break;
529    case 41:
530    if(digitalRead(home_switchXB)){
531      stepperX.run();
532    }
533    if(digitalRead(home_switchXBB)){
534      stepperXB.run();
535    }
536    if(!digitalRead(home_switchXB) && !digitalRead(home_switchXBB)){
537      stepperX.setCurrentPosition(0);
538      stepperXB.setCurrentPosition(0);
539      step = 42;
540    }
541    break;
542    case 42:
543    if(stepperX.currentPosition()  == 0 && stepperXB.currentPosition() == 0){
544      stepperZ.moveTo(-50);
545      step  = 43;
546    }
547    break;
548    case 43:
549    if(digitalRead(home_switchZ)){
550      stepperZ.run();
551    }
552    if(!digitalRead(home_switchZ)){
553      stepperZ.setCurrentPosition(0);
554      step = 26;
555    }
556    break;
557    case 44:
558        pedal_state =  !digitalRead(pedal); // сетапим педаль
559     buttonG_state = !digitalRead(buttonG);  // сетапим кнопарь
560     buttonR_state = !digitalRead(buttonR);
561     buttonB_state  = !digitalRead(buttonB);
562
563     // обработчик педали
564    if(pedal_state  && !pedal_flag && (millis() - debounceTimer > DEBOUNCE)) { //knopka pressed
565    pedal_flag = true;
566    debounceTimer = millis();
567    stepperP.moveTo(7500);
568    step = 45;
569    }// if pedal state bracket
570     if(!pedal_state && pedal_flag)  { //knopka released, debounce code
571     pedal_flag = false;
572     debounceTimer  = millis();
573     }// if !pedal state bracket
574// black button
575    if(buttonB_state  && !buttonB_flag && (millis() - debounceTimer > DEBOUNCE)) { //knopka pressed
576    buttonB_flag = true;
577    debounceTimer = millis();
578    step = 14;
579    }
580    if(!buttonB_state && buttonB_flag) { //knopka released, debounce code
581     buttonB_flag = false;
582     debounceTimer = millis();
583     }
584    break;
585     case 45: // два прохода одна сторона
586     
587     if(stepperP.currentPosition()  != 7500){
588      stepperP.runToPosition();
589     }
590     else {
591      step  = 46;
592     }
593     break;
594     case 46:
595     if(stepperP.currentPosition()  == 7500){
596      delay(500);
597      stepperP.moveTo(0);
598      step = 47;
599     }
600     break;
601     case 47:
602     if(stepperP.currentPosition() !=  0){
603      stepperP.runToPosition();
604     }
605     else{
606      step = 48;
607     }
608     break;
609     case 48:
610     digitalWrite(relay, LOW);
611     delay(1300);
612     digitalWrite(relay, HIGH);
613     step = 49;
614     
615     break;
616     case  49:
617     if(digitalRead(home_switchZD)){
618      stepperZ.moveTo(500);
619      step  = 50;
620     }
621     else{
622      step = 51; 
623     }
624     break;
625     case 50:
626     if(digitalRead(home_switchZD)){
627      stepperZ.run();
628     }
629     else{
630      step = 51;
631     }
632     break;
633     case 51:
634     if(!digitalRead(home_switchZD)){
635      stepperZ.setCurrentPosition(stepperZ.currentPosition());
636      stepperY.moveTo(-250);
637      stepperA.moveTo(250);
638     // stepperYB.moveTo(550);
639      step = 52;
640     }
641     break;
642     case 52:
643     if(stepperY.distanceToGo()  != 0){
644       stepperY.run();
645     }
646     if(stepperA.distanceToGo() !=  0){
647      stepperA.run();
648     }
649    // if(stepperYB.distanceToGo() !=  0){
650    //  stepperYB.run();
651    // }
652     
653     if(stepperY.currentPosition()  == -250 && stepperA.currentPosition() == 250){
654      step = 53;
655     }
656     break;
657     case 53:
658     if(stepperY.currentPosition() == -250 && stepperA.currentPosition()  == 250){
659      stepperX.moveTo(1200);
660      //stepperXB.moveTo(1200);
661      step = 54;
662     }
663     break;
664     case 54:
665     if(digitalRead(home_switchX)){
666      stepperX.run();
667      //stepperXB.run();
668     }
669     else {
670      step  = 55;
671     }
672     break;
673     case 55:
674     if(digitalRead(home_switchX)){
675      stepperX.run();
676     }
677     //if(digitalRead(home_switchXBF)){
678      //stepperXB.run();
679     //}
680     if(!digitalRead(home_switchX)){
681      // stepperXB.setCurrentPosition(stepperXB.currentPosition());
682       stepperX.setCurrentPosition(stepperX.currentPosition());
683      step =  56;
684     }
685     break;//
686     case 56:
687      if(!digitalRead(home_switchX)){
688      stepperY.moveTo(250);
689      stepperA.moveTo(-250);
690     // stepperYB.moveTo(0);
691      step = 57;
692     }
693     break;
694     case 57:
695     if(stepperY.distanceToGo()  != 0){
696      stepperY.run();
697     }
698     if(stepperA.distanceToGo() !=  0){
699      stepperA.run();
700     }
701     //if(stepperYB.distanceToGo() !=  0){
702     // stepperYB.run();
703     //}
704     else{
705      step = 58;
706     }
707     break;
708     case 58:
709   
710     if(stepperY.currentPosition()  == 250 && stepperA.currentPosition()){
711      stepperX.moveTo(-100);
712     //  stepperXB.moveTo(-100);
713      step = 59;
714     }
715     break;
716    case  59:
717    if(digitalRead(home_switchXB)){
718      stepperX.run();
719    }
720    //if(digitalRead(home_switchXBB)){
721    //  stepperXB.run();
722   // }
723    if(!digitalRead(home_switchXB)){
724      stepperX.setCurrentPosition(0);
725     // stepperXB.setCurrentPosition(0);
726      step = 60;
727    }
728    break;
729    case 60:
730    if(stepperX.currentPosition() == 0){
731      stepperZ.moveTo(-50);
732      step = 61;
733    }
734    break;
735    case 61:
736    if(digitalRead(home_switchZ)){
737      stepperZ.run();
738    }
739    if(!digitalRead(home_switchZ)){
740      stepperZ.setCurrentPosition(0);
741      step = 44;
742    }
743    break;
744
745
746    case 62:
747
748     pedal_state  = !digitalRead(pedal); // сетапим педаль
749     buttonG_state = !digitalRead(buttonG);  // сетапим кнопарь
750     buttonR_state = !digitalRead(buttonR);
751     buttonB_state  = !digitalRead(buttonB);
752
753      if(pedal_state && !pedal_flag && (millis()  - debounceTimer > DEBOUNCE)) { //knopka pressed
754    pedal_flag = true;
755    debounceTimer  = millis();
756    stepperP.moveTo(7500);
757    step = 63;
758    }// if pedal  state bracket
759     if(!pedal_state && pedal_flag) { //knopka released, debounce  code
760     pedal_flag = false;
761     debounceTimer = millis();
762     }// if  !pedal state bracket
763// black button
764    if(buttonB_state && !buttonB_flag  && (millis() - debounceTimer > DEBOUNCE)) { //knopka pressed
765    buttonB_flag  = true;
766    debounceTimer = millis();
767    step = 14;
768    }
769    if(!buttonB_state  && buttonB_flag) { //knopka released, debounce code
770     buttonB_flag = false;
771     debounceTimer = millis();
772     }
773// red button     
774    if(buttonR_state  && !buttonR_flag && (millis() - debounceTimer > DEBOUNCE)) { //knopka pressed
775    buttonR_flag = true;
776    debounceTimer = millis();
777    step = 44;
778    }
779    if(!buttonR_state && buttonR_flag) { //knopka released, debounce code
780     buttonR_flag = false;
781     debounceTimer = millis();
782     }
783     break;
784
785     case 63: // два прохода 4 стороны
786     
787     if(stepperP.currentPosition()  != 7500){
788      stepperP.runToPosition();
789     }
790     else {
791      step  = 64;
792     }
793     break;
794     case 64:
795     if(stepperP.currentPosition()  == 7500){
796      delay(500);
797      stepperP.moveTo(0);
798      step = 65;
799     }
800     break;
801     case 65:
802     if(stepperP.currentPosition() !=  0){
803      stepperP.runToPosition();
804     }
805     else{
806      step = 66;
807     }
808     break;
809     case 66:
810     digitalWrite(relay, LOW);
811     delay(1300);
812     digitalWrite(relay, HIGH);
813     step = 67;
814     
815     break;
816     case  67:
817     if(digitalRead(home_switchZD)){
818      stepperZ.moveTo(500);
819      step  = 68;
820     }
821     else{
822      step = 69; 
823     }
824     break;
825     case 68:
826     if(digitalRead(home_switchZD)){
827      stepperZ.run();
828     }
829     else{
830      step = 69;
831     }
832     break;
833     case 69:
834     if(!digitalRead(home_switchZD)){
835      stepperZ.setCurrentPosition(stepperZ.currentPosition());
836      stepperY.moveTo(-250);
837      stepperA.moveTo(250);
838      stepperYB.moveTo(550);
839      step = 70;
840     }
841     break;
842     case 70:
843     if(stepperY.distanceToGo()  != 0){
844       stepperY.run();
845     }
846     if(stepperA.distanceToGo() !=  0){
847      stepperA.run();
848     }
849     if(stepperYB.distanceToGo() != 0){
850      stepperYB.run();
851     }
852     
853     if(stepperY.currentPosition()  == -250 && stepperA.currentPosition() == 250 && stepperYB.currentPosition() == 550){
854      step = 71;
855     }
856     break;
857     case 71:
858     if(stepperY.currentPosition()  == -250 && stepperA.currentPosition() == 250 && stepperYB.currentPosition() == 550){
859      stepperX.moveTo(1200);
860      stepperXB.moveTo(1200);
861      step = 72;
862     }
863     break;
864     case 72:
865     if(digitalRead(home_switchXBF) &&  digitalRead(home_switchX)){
866      stepperX.run();
867      stepperXB.run();
868     }
869     else {
870      step = 73;
871     }
872     break;
873     case  73:
874     if(digitalRead(home_switchX)){
875      stepperX.run();
876     }
877     if(digitalRead(home_switchXBF)){
878      stepperXB.run();
879     }
880     if(!digitalRead(home_switchXBF)  && !digitalRead(home_switchX)){
881       stepperXB.setCurrentPosition(stepperXB.currentPosition());
882       stepperX.setCurrentPosition(stepperX.currentPosition());
883      step =  74;
884     }
885     break;//
886     case 74:
887      if(!digitalRead(home_switchXBF)  && !digitalRead(home_switchX)){
888      stepperY.moveTo(250);
889      stepperA.moveTo(-250);
890      stepperYB.moveTo(0);
891      step = 75;
892     }
893     break;
894     case  75:
895     if(stepperY.distanceToGo() != 0){
896      stepperY.run();
897     }
898     if(stepperA.distanceToGo() != 0){
899      stepperA.run();
900     }
901     if(stepperYB.distanceToGo()  != 0){
902      stepperYB.run();
903     }
904     else{
905      step = 76;
906     }
907     break;
908     case 76:
909   
910     if(stepperY.currentPosition()  == 250 && stepperA.currentPosition() == -250 && stepperYB.currentPosition() == 0){
911      stepperX.moveTo(-100);
912      stepperXB.moveTo(-100);
913      step = 77;
914     }
915     break;
916    case 77:
917    if(digitalRead(home_switchXB)){
918      stepperX.run();
919    }
920    if(digitalRead(home_switchXBB)){
921      stepperXB.run();
922    }
923    if(!digitalRead(home_switchXB) && !digitalRead(home_switchXBB)){
924      stepperX.setCurrentPosition(0);
925      stepperXB.setCurrentPosition(0);
926      step = 78;
927    }
928    break;
929    case 78:
930    if(stepperX.currentPosition()  == 0 && stepperXB.currentPosition() == 0){
931      stepperZ.move(-200);
932      step  = 79;
933    }
934    break;
935    case 79:
936    if(stepperZ.distanceToGo() !=  0){
937      stepperZ.run();
938    }
939    else{
940      step = 80;
941    }
942    break;
943    case 80:
944    if(stepperZ.distanceToGo() == 0){
945       stepperR.moveTo(110);
946       step = 81;
947    }
948    break;
949    case 81:
950    if(stepperR.currentPosition()  != 110){
951      stepperR.run();
952    }
953    else{
954    step = 82;
955    }
956   break;
957   case 82:
958   if(stepperR.currentPosition() == 110){
959    stepperZ.move(220);
960    step = 83;
961   }
962   else{
963    step = 81;
964   }
965   break;
966   case  83:
967   if(digitalRead(home_switchZD)){
968    stepperZ.run();
969   }
970   else{
971    step = 84;
972     }
973   break;
974   case 84:
975   if(!digitalRead(home_switchZD)){
976      stepperZ.setCurrentPosition(stepperZ.currentPosition());
977      stepperY.moveTo(-250);
978      stepperA.moveTo(250);
979      stepperYB.moveTo(550);
980      step = 85;
981     }
982     break;
983     case 85:
984     if(stepperY.distanceToGo() != 0){
985       stepperY.run();
986     }
987     if(stepperA.distanceToGo() != 0){
988      stepperA.run();
989     }
990     if(stepperYB.distanceToGo() != 0){
991      stepperYB.run();
992     }
993     
994     if(stepperY.currentPosition() == -250 && stepperA.currentPosition()  == 250 && stepperYB.currentPosition() == 550){
995      step = 86;
996     }
997     break;
998     case 86:
999     if(stepperY.currentPosition() == -250 && stepperA.currentPosition()  == 250 && stepperYB.currentPosition() == 550){
1000      stepperX.moveTo(1200);
1001      stepperXB.moveTo(1200);
1002      step = 87;
1003     }
1004     break;
1005     case  87:
1006     if(digitalRead(home_switchXBF) && digitalRead(home_switchX)){
1007      stepperX.run();
1008      stepperXB.run();
1009     }
1010     else {
1011      step = 88;
1012     }
1013     break;
1014     case 88:
1015     if(digitalRead(home_switchX)){
1016      stepperX.run();
1017     }
1018     if(digitalRead(home_switchXBF)){
1019      stepperXB.run();
1020     }
1021     if(!digitalRead(home_switchXBF) && !digitalRead(home_switchX)){
1022       stepperXB.setCurrentPosition(stepperXB.currentPosition());
1023       stepperX.setCurrentPosition(stepperX.currentPosition());
1024      step =  89;
1025     }
1026     break;//
1027     case 89:
1028      if(!digitalRead(home_switchXBF)  && !digitalRead(home_switchX)){
1029      stepperY.moveTo(250);
1030      stepperA.moveTo(-250);
1031      stepperYB.moveTo(0);
1032      step = 90;
1033     }
1034     break;
1035     case  90:
1036     if(stepperY.distanceToGo() != 0){
1037      stepperY.run();
1038     }
1039     if(stepperA.distanceToGo() != 0){
1040      stepperA.run();
1041     }
1042     if(stepperYB.distanceToGo()  != 0){
1043      stepperYB.run();
1044     }
1045     else{
1046      step = 91;
1047     }
1048     break;
1049     case 91:
1050   
1051     if(stepperY.currentPosition()  == 250 && stepperA.currentPosition() == -250 && stepperYB.currentPosition() == 0){
1052      stepperX.moveTo(-100);
1053      stepperXB.moveTo(-100);
1054      step = 92;
1055     }
1056     break;
1057    case 92:
1058    if(digitalRead(home_switchXB)){
1059      stepperX.run();
1060    }
1061    if(digitalRead(home_switchXBB)){
1062      stepperXB.run();
1063    }
1064    if(!digitalRead(home_switchXB) && !digitalRead(home_switchXBB)){
1065      stepperX.setCurrentPosition(0);
1066      stepperXB.setCurrentPosition(0);
1067      step = 93;
1068    }
1069    break;
1070    case 93:
1071    if(stepperX.currentPosition()  == 0 && stepperXB.currentPosition() == 0){
1072      stepperZ.moveTo(-100);
1073      step  = 94;
1074    }
1075    break;
1076    case 94:
1077    if(digitalRead(home_switchZ)){
1078      stepperZ.run();
1079    }
1080    if(!digitalRead(home_switchZ)){
1081      stepperZ.setCurrentPosition(0);
1082      step = 95;
1083    }
1084    break;
1085    case 95:
1086    if(!digitalRead(home_switchZ)){
1087    stepperR.moveTo(0);
1088    step = 96;
1089    }
1090    break;
1091    case 96:
1092    if(stepperR.distanceToGo() != 0){
1093      stepperR.run();
1094    }
1095    if(stepperR.distanceToGo()  == 0){
1096      step = 62;
1097    }
1098    break;
1099
1100}// switch bracket
1101
1102
1103}//loop  bracket

#include <GyverButton.h>

#include <AccelStepper.h>
#include  <MultiStepper.h>


AccelStepper stepperX(1, 3, 2);   // 1 режим, 2 степ,  5 дир 
AccelStepper stepperZ(1, 9, 8);                                
AccelStepper  stepperA(1, 5, 4);
AccelStepper stepperY(1, 7, 6); 
AccelStepper stepperXB(1,  11, 10);
AccelStepper stepperYB(1, 13, 12);                               
AccelStepper  stepperR(1, 23, 25);
AccelStepper stepperP(1, 27, 29);

#define home_switchX  56 // дефайним пины концевиков
#define home_switchXB 57 // x back
#define  home_switchZ 64
#define home_switchZD 65
#define home_switchY 55
#define  home_switchA 54
#define home_switchXBB 62 // x back bottom
#define home_switchXBF  58 // x front bottom
#define home_switchYB 63 // y bottom
#define pedal 18  // дефайнми пин педали
#define relay 16 // пин реле
#define DEBOUNCE 100 //  антидребзг дебоунсер
#define TIMEOUT 500 // таймают парсера
#define buttonG  21 // init button
#define buttonR 20
#define buttonB 19
// перемешки хоминга
  GButton switchX(home_switchX, HIGH_PULL, NORM_OPEN); // назначаем входы концевиков  через библиотеку
  GButton switchXB(home_switchXB, HIGH_PULL, NORM_OPEN);
  GButton switchZ(home_switchZ, HIGH_PULL, NORM_OPEN);
  GButton switchZD(home_switchZD,  HIGH_PULL, NORM_OPEN); 
  GButton switchY(home_switchY, HIGH_PULL, NORM_OPEN);
  GButton switchA(home_switchA, HIGH_PULL, NORM_OPEN);
  GButton switchXBB(home_switchXBB,  HIGH_PULL, NORM_OPEN);
  GButton switchXBF(home_switchXBF, HIGH_PULL, NORM_OPEN);
  GButton switchYB(home_switchYB, HIGH_PULL, NORM_OPEN);

  GButton pedalsw(pedal,  HIGH_PULL, NORM_OPEN);  // пинчик педальки запускаем как входик и подтягиваем
  GButton greensw(buttonG, HIGH_PULL, NORM_OPEN);
  GButton blacksw(buttonB,  HIGH_PULL, NORM_OPEN);
  GButton redsw(buttonR, HIGH_PULL, NORM_OPEN);

int  step=0;  // глобальная закладка switch

// педаль
boolean pedal_state,  pedal_flag; // бульки педали
boolean buttonG_state, buttonG_flag, buttonR_state,  buttonR_flag, buttonB_state, buttonB_flag;
unsigned long debounceTimer; // шоб  работало без всяких дребезгав!! :)



void setup() {
  

  pinMode(relay,  OUTPUT);
  digitalWrite(relay, HIGH);


  switchX.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
  switchX.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
  switchXB.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
  switchXB.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
  switchZD.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
  switchZD.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
  switchZ.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
  switchZ.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
  switchY.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
  switchY.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
  switchA.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
  switchA.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
  switchXBB.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
  switchXBB.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
  switchXBF.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
  switchXBF.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
  switchYB.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
  switchYB.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
  pedalsw.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
  pedalsw.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
  greensw.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
  greensw.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
  blacksw.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
  blacksw.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)
  redsw.setDebounce(DEBOUNCE);        // настройка антидребезга (по умолчанию 80 мс)
  redsw.setTimeout(TIMEOUT);        // настройка таймаута на удержание (по умолчанию 500 мс)

  switchX.setTickMode(AUTO);
  switchXB.setTickMode(AUTO);
  switchY.setTickMode(AUTO);
  switchA.setTickMode(AUTO);
  switchXBB.setTickMode(AUTO);
  switchXBF.setTickMode(AUTO);
  switchYB.setTickMode(AUTO);
  pedalsw.setTickMode(AUTO);
  greensw.setTickMode(AUTO);
  blacksw.setTickMode(AUTO);
  redsw.setTickMode(AUTO);
  switchZ.setTickMode(AUTO);
  switchZD.setTickMode(AUTO);


  stepperX.setMaxSpeed(600);      // дефолтим скорость для хоминга
  stepperX.setAcceleration(600);
  stepperZ.setMaxSpeed(200);
  stepperZ.setAcceleration(500);
  stepperY.setMaxSpeed(4000);
  stepperY.setAcceleration(4000);
  stepperA.setMaxSpeed(4000);
  stepperA.setAcceleration(4000);
  stepperXB.setMaxSpeed(600);
  stepperXB.setAcceleration(600);
  stepperYB.setMaxSpeed(4000);  
  stepperYB.setAcceleration(4000); 
  stepperP.moveTo(7500);      
  
  Serial.begin(9600);
}

void loop() {
//Serial.print(digitalRead(18));  Serial.print(digitalRead(19)); Serial.print(digitalRead(20)); Serial.println(digitalRead(21));  
//Serial.print(stepperR.currentPosition()); Serial.print("  "); Serial.println(step);  
//Serial.println(step);
switch(step){
  //последовательность инициализации
  case 0:
  if(switchXB.isPress()){ // если замкнут концевик при старте, отходим
    stepperX.moveTo(200);
    step = 1;
  }
  else{
  step = 2;
  }
  break;
  case 1:
  if(switchXB.isPress()){
     stepperX.run();
  }
  else{
    step = 2;
  }
  break;
  case 2:
  if(switchXBB.isPress()){
    stepperXB.moveTo(200);
    step = 3;
  }
  else{
    step = 4;
  }
  break;
  case 3:
  if(switchXBB.isPress()){
    stepperXB.run();
  }
  else{
    step = 4;
  }
  break;
  case 4:
  if(switchY.isPress()){  // если замкнут концевик при старте, отходим
    stepperY.moveTo(200);
    step  = 5;
  }
  else{
  step = 6;
  }
  break;
  case 5:
  if(switchY.isPress()){
  stepperY.run();
  }
  else{
    step = 6;
  }
  break;
  case  6:
  if(switchA.isPress()){ // если замкнут концевик при старте, отходим
    stepperA.moveTo(200);
    step = 7;
  }
  else{
  step = 8;
  }
  break;
  case 7:
 
  if(switchA.isPress()){
     stepperA.run();
  }
  else{
    step = 8;
  }
  break;
  case 8:
  if(switchYB.isPress())){  // если замкнут концевик при старте, отходим
    stepperYB.moveTo(100);
    step  = 9;
  }
  else{
  step = 10;
  }
  break;
  case 9:
  if(switchYB.isPress()){
     stepperYB.run();
  }
  else{
    step = 10;
  }
  break;
  
  case 10:  // поиск нолей
  if(!switchXB.isPress()){
  stepperX.moveTo(-2000);
  step = 11;
  }
  else {
    step = 0;
  }
  break;
  case 11:
  if(!switchXB.isPress()){
    stepperX.run();
  }
  else{
    stepperX.setCurrentPosition(0);
    step = 12;
  }
  break;
  
   case 12:  // поиск нолей
  if(!switchXBB.isPress()){
  stepperXB.moveTo(-2000);
  step = 13;
  }
  else {
    step = 0;
  }
  break;
  case 13:
  if(!switchXBB.isPress()){
    stepperXB.run();
  }
  else{
    stepperXB.setCurrentPosition(0);
    step = 14;
  }
  break;
  case 14:  // поиск нолей
  if(!switchZ.isPress()){
  stepperZ.moveTo(-1000);
  step = 15;
  }
  else {
    step = 15;
  }
 
  break;
  case  15:
  if(!switchZ.isPress()){
    stepperZ.run();
  }
  else{
    stepperZ.setCurrentPosition(0);
    step = 16;
  }
  break;

  case 16:
  if(!switchY.isPress()){
    stepperY.moveTo(-600);
    step = 17;
    }
    else{
      step  = 0;
    }
    break;
    case 17:
    if(!switchY.isPress()){
      stepperY.run();
    }
    else{
      stepperY.setCurrentPosition(0);
      stepperY.moveTo(250);
      step = 18;
    }
    break;
    case 18:
    if(stepperY.currentPosition()  != 250){
      stepperY.run();
    }
    else{
      stepperY.setCurrentPosition(0);
      step = 19;
    }
    break;
    case 19:
    if(!switchA.isPress()){
    stepperA.moveTo(-600);
    step = 20;
    }
    else{
      step  = 0;
    }
    break;
    case 20:
    if(!switchA.isPress())){
      stepperA.run();
    }
    else{
      stepperA.setCurrentPosition(0);
      stepperA.moveTo(250);
      step = 21;
    }
    break;
    case  21:
    if(stepperA.currentPosition() != 250){
       stepperA.run();
    }
    else{
      stepperA.setCurrentPosition(0);
      step = 22;
    }
    break;
    case 22:
    if(!switchYB.isPress()){
    stepperYB.moveTo(-800);
    step = 23;
    }
    else{
      step = 0;
    }
    break;
    case 23:
    if(!switchYB.isPress()){
      stepperYB.run();
    }
    else{
      stepperYB.setCurrentPosition(0);
      stepperYB.moveTo(50);
      step = 24;
    }
    break;
    case 24:
    if(stepperYB.currentPosition()  != 50){
      stepperYB.run();
    }
    if(stepperYB.currentPosition()  == 50){
      stepperYB.setCurrentPosition(0);
      step = 25;
    }
    break;
    case 25:
  stepperX.setMaxSpeed(10000);      
  stepperX.setAcceleration(6000);
  stepperZ.setMaxSpeed(1000);
  stepperZ.setAcceleration(1000);
  stepperY.setSpeed(15000);
  stepperY.setAcceleration(15000);
  stepperA.setMaxSpeed(15000);
  stepperA.setAcceleration(15000);
  stepperXB.setMaxSpeed(10000);
  stepperXB.setAcceleration(6000);
  stepperYB.setMaxSpeed(15000);      
  stepperYB.setAcceleration(15000);
  stepperR.setMaxSpeed(5000);      
  stepperR.setAcceleration(5000);
  stepperP.setMaxSpeed(15000);      
  stepperP.setAcceleration(15000);
  step = 26;
  break;

    case 26: //ОБРАБОТЧИК КНОПОК
    
        //  обработчик педали
    if(pedalsw.isPress()) { //knopka pressed
    stepperP.moveTo(7500);
    step = 27;
    }
 // black button
    if(blacksw.isPress()) { //knopka  pressed
     step = 14;
    }
    // red button     
    if(redsw.isPress())  { //knopka pressed
    step = 44;
    }
   // green button
    if(greensw.isPress())  { //knopka pressed
    step = 62;
    }
 
break;
     case 27: //  два прохода две стороны
     
     if(stepperP.currentPosition() != 7500){
      stepperP.runToPosition();
     }
     else {
      step = 28;
     }
     break;
     case 28:
     if(stepperP.currentPosition() ==  7500){
      delay(500);
      stepperP.moveTo(0);
      step = 29;
     }
     break;
     case 29:
     if(stepperP.currentPosition() !=  0){
      stepperP.runToPosition();
     }
     else{
      step = 30;
     }
     break;
     case 30:
     digitalWrite(relay, LOW);
     delay(1300);
     digitalWrite(relay, HIGH);
     step = 31;
     
     break;
     case  31:
     if(!switchZD.isPress()){
      stepperZ.moveTo(500);
      step  = 32;
     }
     else{
      step = 33; 
     }
     break;
     case 32:
     if(!switchZD.isPress()){
      stepperZ.run();
     }
     else{
      step = 33;
     }
     break;
     case 33:
     if(switchZD.isPress()){
      stepperZ.setCurrentPosition(stepperZ.currentPosition());
      stepperY.moveTo(-250);
      stepperA.moveTo(250);
      stepperYB.moveTo(550);
      step = 34;
     }
     break;
     case 34:
     if(stepperY.distanceToGo() != 0){
       stepperY.run();
     }
     if(stepperA.distanceToGo() != 0){
      stepperA.run();
     }
     if(stepperYB.distanceToGo() != 0){
      stepperYB.run();
     }
     
     if(stepperY.currentPosition() == -250 && stepperA.currentPosition()  == 250 && stepperYB.currentPosition() == 550){
      step = 35;
     }
     break;
     case 35:
     if(stepperY.currentPosition() == -250 && stepperA.currentPosition()  == 250 && stepperYB.currentPosition() == 550){
      stepperX.moveTo(1200);
      stepperXB.moveTo(1200);
      step = 36;
     }
     break;
     case  36:
     if(!switchXBF.isPress() && !switchX.isPress()){
      stepperX.run();
      stepperXB.run();
     }
     else {
      step = 37;
     }
     break;
     case 37:
     if(!switchX.isPress()){
      stepperX.run();
     }
     if(!switchXBF.isPress()){
      stepperXB.run();
     }
     if(switchXBF.isHold()) && switchX.isHold()){
       stepperXB.setCurrentPosition(stepperXB.currentPosition());
       stepperX.setCurrentPosition(stepperX.currentPosition());
      step =  38;
     }
     break;//
     case 38:
      if(!digitalRead(home_switchXBF)  && !digitalRead(home_switchX)){
      stepperY.moveTo(250);
      stepperA.moveTo(-250);
      stepperYB.moveTo(0);
      step = 39;
     }
     break;
     case  39:
     if(stepperY.distanceToGo() != 0){
      stepperY.run();
     }
     if(stepperA.distanceToGo() != 0){
      stepperA.run();
     }
     if(stepperYB.distanceToGo()  != 0){
      stepperYB.run();
     }
     else{
      step = 40;
     }
     break;
     case 40:
   
     if(stepperY.currentPosition()  == 250 && stepperA.currentPosition() == -250 && stepperYB.currentPosition() == 0){
      stepperX.moveTo(-100);
      stepperXB.moveTo(-100);
      step = 41;
     }
     break;
    case 41:
    if(digitalRead(home_switchXB)){
      stepperX.run();
    }
    if(digitalRead(home_switchXBB)){
      stepperXB.run();
    }
    if(!digitalRead(home_switchXB) && !digitalRead(home_switchXBB)){
      stepperX.setCurrentPosition(0);
      stepperXB.setCurrentPosition(0);
      step = 42;
    }
    break;
    case 42:
    if(stepperX.currentPosition()  == 0 && stepperXB.currentPosition() == 0){
      stepperZ.moveTo(-50);
      step  = 43;
    }
    break;
    case 43:
    if(digitalRead(home_switchZ)){
      stepperZ.run();
    }
    if(!digitalRead(home_switchZ)){
      stepperZ.setCurrentPosition(0);
      step = 26;
    }
    break;
    case 44:
        pedal_state =  !digitalRead(pedal); // сетапим педаль
     buttonG_state = !digitalRead(buttonG);  // сетапим кнопарь
     buttonR_state = !digitalRead(buttonR);
     buttonB_state  = !digitalRead(buttonB);

     // обработчик педали
    if(pedal_state  && !pedal_flag && (millis() - debounceTimer > DEBOUNCE)) { //knopka pressed
    pedal_flag = true;
    debounceTimer = millis();
    stepperP.moveTo(7500);
    step = 45;
    }// if pedal state bracket
     if(!pedal_state && pedal_flag)  { //knopka released, debounce code
     pedal_flag = false;
     debounceTimer  = millis();
     }// if !pedal state bracket
// black button
    if(buttonB_state  && !buttonB_flag && (millis() - debounceTimer > DEBOUNCE)) { //knopka pressed
    buttonB_flag = true;
    debounceTimer = millis();
    step = 14;
    }
    if(!buttonB_state && buttonB_flag) { //knopka released, debounce code
     buttonB_flag = false;
     debounceTimer = millis();
     }
    break;
     case 45: // два прохода одна сторона
     
     if(stepperP.currentPosition()  != 7500){
      stepperP.runToPosition();
     }
     else {
      step  = 46;
     }
     break;
     case 46:
     if(stepperP.currentPosition()  == 7500){
      delay(500);
      stepperP.moveTo(0);
      step = 47;
     }
     break;
     case 47:
     if(stepperP.currentPosition() !=  0){
      stepperP.runToPosition();
     }
     else{
      step = 48;
     }
     break;
     case 48:
     digitalWrite(relay, LOW);
     delay(1300);
     digitalWrite(relay, HIGH);
     step = 49;
     
     break;
     case  49:
     if(digitalRead(home_switchZD)){
      stepperZ.moveTo(500);
      step  = 50;
     }
     else{
      step = 51; 
     }
     break;
     case 50:
     if(digitalRead(home_switchZD)){
      stepperZ.run();
     }
     else{
      step = 51;
     }
     break;
     case 51:
     if(!digitalRead(home_switchZD)){
      stepperZ.setCurrentPosition(stepperZ.currentPosition());
      stepperY.moveTo(-250);
      stepperA.moveTo(250);
     // stepperYB.moveTo(550);
      step = 52;
     }
     break;
     case 52:
     if(stepperY.distanceToGo()  != 0){
       stepperY.run();
     }
     if(stepperA.distanceToGo() !=  0){
      stepperA.run();
     }
    // if(stepperYB.distanceToGo() !=  0){
    //  stepperYB.run();
    // }
     
     if(stepperY.currentPosition()  == -250 && stepperA.currentPosition() == 250){
      step = 53;
     }
     break;
     case 53:
     if(stepperY.currentPosition() == -250 && stepperA.currentPosition()  == 250){
      stepperX.moveTo(1200);
      //stepperXB.moveTo(1200);
      step = 54;
     }
     break;
     case 54:
     if(digitalRead(home_switchX)){
      stepperX.run();
      //stepperXB.run();
     }
     else {
      step  = 55;
     }
     break;
     case 55:
     if(digitalRead(home_switchX)){
      stepperX.run();
     }
     //if(digitalRead(home_switchXBF)){
      //stepperXB.run();
     //}
     if(!digitalRead(home_switchX)){
      // stepperXB.setCurrentPosition(stepperXB.currentPosition());
       stepperX.setCurrentPosition(stepperX.currentPosition());
      step =  56;
     }
     break;//
     case 56:
      if(!digitalRead(home_switchX)){
      stepperY.moveTo(250);
      stepperA.moveTo(-250);
     // stepperYB.moveTo(0);
      step = 57;
     }
     break;
     case 57:
     if(stepperY.distanceToGo()  != 0){
      stepperY.run();
     }
     if(stepperA.distanceToGo() !=  0){
      stepperA.run();
     }
     //if(stepperYB.distanceToGo() !=  0){
     // stepperYB.run();
     //}
     else{
      step = 58;
     }
     break;
     case 58:
   
     if(stepperY.currentPosition()  == 250 && stepperA.currentPosition()){
      stepperX.moveTo(-100);
     //  stepperXB.moveTo(-100);
      step = 59;
     }
     break;
    case  59:
    if(digitalRead(home_switchXB)){
      stepperX.run();
    }
    //if(digitalRead(home_switchXBB)){
    //  stepperXB.run();
   // }
    if(!digitalRead(home_switchXB)){
      stepperX.setCurrentPosition(0);
     // stepperXB.setCurrentPosition(0);
      step = 60;
    }
    break;
    case 60:
    if(stepperX.currentPosition() == 0){
      stepperZ.moveTo(-50);
      step = 61;
    }
    break;
    case 61:
    if(digitalRead(home_switchZ)){
      stepperZ.run();
    }
    if(!digitalRead(home_switchZ)){
      stepperZ.setCurrentPosition(0);
      step = 44;
    }
    break;


    case 62:

     pedal_state  = !digitalRead(pedal); // сетапим педаль
     buttonG_state = !digitalRead(buttonG);  // сетапим кнопарь
     buttonR_state = !digitalRead(buttonR);
     buttonB_state  = !digitalRead(buttonB);

      if(pedal_state && !pedal_flag && (millis()  - debounceTimer > DEBOUNCE)) { //knopka pressed
    pedal_flag = true;
    debounceTimer  = millis();
    stepperP.moveTo(7500);
    step = 63;
    }// if pedal  state bracket
     if(!pedal_state && pedal_flag) { //knopka released, debounce  code
     pedal_flag = false;
     debounceTimer = millis();
     }// if  !pedal state bracket
// black button
    if(buttonB_state && !buttonB_flag  && (millis() - debounceTimer > DEBOUNCE)) { //knopka pressed
    buttonB_flag  = true;
    debounceTimer = millis();
    step = 14;
    }
    if(!buttonB_state  && buttonB_flag) { //knopka released, debounce code
     buttonB_flag = false;
     debounceTimer = millis();
     }
// red button     
    if(buttonR_state  && !buttonR_flag && (millis() - debounceTimer > DEBOUNCE)) { //knopka pressed
    buttonR_flag = true;
    debounceTimer = millis();
    step = 44;
    }
    if(!buttonR_state && buttonR_flag) { //knopka released, debounce code
     buttonR_flag = false;
     debounceTimer = millis();
     }
     break;

     case 63: // два прохода 4 стороны
     
     if(stepperP.currentPosition()  != 7500){
      stepperP.runToPosition();
     }
     else {
      step  = 64;
     }
     break;
     case 64:
     if(stepperP.currentPosition()  == 7500){
      delay(500);
      stepperP.moveTo(0);
      step = 65;
     }
     break;
     case 65:
     if(stepperP.currentPosition() !=  0){
      stepperP.runToPosition();
     }
     else{
      step = 66;
     }
     break;
     case 66:
     digitalWrite(relay, LOW);
     delay(1300);
     digitalWrite(relay, HIGH);
     step = 67;
     
     break;
     case  67:
     if(digitalRead(home_switchZD)){
      stepperZ.moveTo(500);
      step  = 68;
     }
     else{
      step = 69; 
     }
     break;
     case 68:
     if(digitalRead(home_switchZD)){
      stepperZ.run();
     }
     else{
      step = 69;
     }
     break;
     case 69:
     if(!digitalRead(home_switchZD)){
      stepperZ.setCurrentPosition(stepperZ.currentPosition());
      stepperY.moveTo(-250);
      stepperA.moveTo(250);
      stepperYB.moveTo(550);
      step = 70;
     }
     break;
     case 70:
     if(stepperY.distanceToGo()  != 0){
       stepperY.run();
     }
     if(stepperA.distanceToGo() !=  0){
      stepperA.run();
     }
     if(stepperYB.distanceToGo() != 0){
      stepperYB.run();
     }
     
     if(stepperY.currentPosition()  == -250 && stepperA.currentPosition() == 250 && stepperYB.currentPosition() == 550){
      step = 71;
     }
     break;
     case 71:
     if(stepperY.currentPosition()  == -250 && stepperA.currentPosition() == 250 && stepperYB.currentPosition() == 550){
      stepperX.moveTo(1200);
      stepperXB.moveTo(1200);
      step = 72;
     }
     break;
     case 72:
     if(digitalRead(home_switchXBF) &&  digitalRead(home_switchX)){
      stepperX.run();
      stepperXB.run();
     }
     else {
      step = 73;
     }
     break;
     case  73:
     if(digitalRead(home_switchX)){
      stepperX.run();
     }
     if(digitalRead(home_switchXBF)){
      stepperXB.run();
     }
     if(!digitalRead(home_switchXBF)  && !digitalRead(home_switchX)){
       stepperXB.setCurrentPosition(stepperXB.currentPosition());
       stepperX.setCurrentPosition(stepperX.currentPosition());
      step =  74;
     }
     break;//
     case 74:
      if(!digitalRead(home_switchXBF)  && !digitalRead(home_switchX)){
      stepperY.moveTo(250);
      stepperA.moveTo(-250);
      stepperYB.moveTo(0);
      step = 75;
     }
     break;
     case  75:
     if(stepperY.distanceToGo() != 0){
      stepperY.run();
     }
     if(stepperA.distanceToGo() != 0){
      stepperA.run();
     }
     if(stepperYB.distanceToGo()  != 0){
      stepperYB.run();
     }
     else{
      step = 76;
     }
     break;
     case 76:
   
     if(stepperY.currentPosition()  == 250 && stepperA.currentPosition() == -250 && stepperYB.currentPosition() == 0){
      stepperX.moveTo(-100);
      stepperXB.moveTo(-100);
      step = 77;
     }
     break;
    case 77:
    if(digitalRead(home_switchXB)){
      stepperX.run();
    }
    if(digitalRead(home_switchXBB)){
      stepperXB.run();
    }
    if(!digitalRead(home_switchXB) && !digitalRead(home_switchXBB)){
      stepperX.setCurrentPosition(0);
      stepperXB.setCurrentPosition(0);
      step = 78;
    }
    break;
    case 78:
    if(stepperX.currentPosition()  == 0 && stepperXB.currentPosition() == 0){
      stepperZ.move(-200);
      step  = 79;
    }
    break;
    case 79:
    if(stepperZ.distanceToGo() !=  0){
      stepperZ.run();
    }
    else{
      step = 80;
    }
    break;
    case 80:
    if(stepperZ.distanceToGo() == 0){
       stepperR.moveTo(110);
       step = 81;
    }
    break;
    case 81:
    if(stepperR.currentPosition()  != 110){
      stepperR.run();
    }
    else{
    step = 82;
    }
   break;
   case 82:
   if(stepperR.currentPosition() == 110){
    stepperZ.move(220);
    step = 83;
   }
   else{
    step = 81;
   }
   break;
   case  83:
   if(digitalRead(home_switchZD)){
    stepperZ.run();
   }
   else{
    step = 84;
     }
   break;
   case 84:
   if(!digitalRead(home_switchZD)){
      stepperZ.setCurrentPosition(stepperZ.currentPosition());
      stepperY.moveTo(-250);
      stepperA.moveTo(250);
      stepperYB.moveTo(550);
      step = 85;
     }
     break;
     case 85:
     if(stepperY.distanceToGo() != 0){
       stepperY.run();
     }
     if(stepperA.distanceToGo() != 0){
      stepperA.run();
     }
     if(stepperYB.distanceToGo() != 0){
      stepperYB.run();
     }
     
     if(stepperY.currentPosition() == -250 && stepperA.currentPosition()  == 250 && stepperYB.currentPosition() == 550){
      step = 86;
     }
     break;
     case 86:
     if(stepperY.currentPosition() == -250 && stepperA.currentPosition()  == 250 && stepperYB.currentPosition() == 550){
      stepperX.moveTo(1200);
      stepperXB.moveTo(1200);
      step = 87;
     }
     break;
     case  87:
     if(digitalRead(home_switchXBF) && digitalRead(home_switchX)){
      stepperX.run();
      stepperXB.run();
     }
     else {
      step = 88;
     }
     break;
     case 88:
     if(digitalRead(home_switchX)){
      stepperX.run();
     }
     if(digitalRead(home_switchXBF)){
      stepperXB.run();
     }
     if(!digitalRead(home_switchXBF) && !digitalRead(home_switchX)){
       stepperXB.setCurrentPosition(stepperXB.currentPosition());
       stepperX.setCurrentPosition(stepperX.currentPosition());
      step =  89;
     }
     break;//
     case 89:
      if(!digitalRead(home_switchXBF)  && !digitalRead(home_switchX)){
      stepperY.moveTo(250);
      stepperA.moveTo(-250);
      stepperYB.moveTo(0);
      step = 90;
     }
     break;
     case  90:
     if(stepperY.distanceToGo() != 0){
      stepperY.run();
     }
     if(stepperA.distanceToGo() != 0){
      stepperA.run();
     }
     if(stepperYB.distanceToGo()  != 0){
      stepperYB.run();
     }
     else{
      step = 91;
     }
     break;
     case 91:
   
     if(stepperY.currentPosition()  == 250 && stepperA.currentPosition() == -250 && stepperYB.currentPosition() == 0){
      stepperX.moveTo(-100);
      stepperXB.moveTo(-100);
      step = 92;
     }
     break;
    case 92:
    if(digitalRead(home_switchXB)){
      stepperX.run();
    }
    if(digitalRead(home_switchXBB)){
      stepperXB.run();
    }
    if(!digitalRead(home_switchXB) && !digitalRead(home_switchXBB)){
      stepperX.setCurrentPosition(0);
      stepperXB.setCurrentPosition(0);
      step = 93;
    }
    break;
    case 93:
    if(stepperX.currentPosition()  == 0 && stepperXB.currentPosition() == 0){
      stepperZ.moveTo(-100);
      step  = 94;
    }
    break;
    case 94:
    if(digitalRead(home_switchZ)){
      stepperZ.run();
    }
    if(!digitalRead(home_switchZ)){
      stepperZ.setCurrentPosition(0);
      step = 95;
    }
    break;
    case 95:
    if(!digitalRead(home_switchZ)){
    stepperR.moveTo(0);
    step = 96;
    }
    break;
    case 96:
    if(stepperR.distanceToGo() != 0){
      stepperR.run();
    }
    if(stepperR.distanceToGo()  == 0){
      step = 62;
    }
    break;

}// switch bracket


}//loop  bracket

Downloadable files

Typical driver connection

Comments

Only logged in users can leave comments

Moofasta

0 Followers

•

0 Projects

Intro