Loop Stoppen

[Alexander86]

Hallo,

ich bin gerade neu hier im Forum und benötige Hilfe bei der Programmierung meiner "Weizenbier-Einschenk-Maschine". Leider hab ich im Forum über die Suchfunktion und über Google nichts passendes oder aber für mich nicht verständliches gefunden.

Es geht darum, dass ich das Programm über einen Taster (Taster heißt im Programm "Stopknopf") an jeder beliebigen Stelle anhalten möchte. Leider komme ich da mit meinen Kenntnissen über c++ an meine Grenzen. Es spielt dabei keine Rolle, ob das Programm nach dem der Taster gedrückt wurde, wieder von vorne anfängt oder aber an der gestoppten Stelle wieder gestartet werden kann. Hab mir schon diverse Seiten über Interrupts durchgelesen aber so gut wie gar nichts verstanden. Als Prozessor verwende ich den Atmega 2560.

Ich wäre euch sehr dankbar, wenn mir jemand dabei helfen könnte.

Das Programm:

#include <Stepper.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);

int SPU1 = 200;                                                                             // Schritte für eine Umdrehung Schrittmotor 1
int SPU2 = 200;                                                                             // Schritte für eine Umdrehung Schrittmotor 2
int SPU3 = 200;                                                                             // Schritte für eine Umdrehung Schrittmotor 3
int SPU4 = 200;                                                                             // Schritte für eine Umdrehung Schrittmotor 1
int SPU5 = 200;                                                                             // Schritte für eine Umdrehung Schrittmotor 2
int SPU6 = 200;                                                                             // Schritte für eine Umdrehung Schrittmotor 3
int SPU7 = 200;                                                                             // Schritte für eine Umdrehung Schrittmotor 1
int SPU8 = 200;                                                                             // Schritte für eine Umdrehung Schrittmotor 1

int run;
int Startknopf;
int Stopknopf;
int Resetknopf;
int Schalterflasche;
int Schalterglas;
int Bierzaehler=1;


Stepper Motor1(SPU1, 1,2,3,4);                                                              // Schrittmotor 1 / PIN-Auswahl
Stepper Motor2(SPU2, 5,6,7,8);                                                              // Schrittmotor 2 / PIN-Auswahl
Stepper Motor3(SPU3, 9,10,11,12);                                                           // Schrittmotor 3 / PIN-Auswahl
Stepper Motor4(SPU4, 1,2,3,4);                                                              // Schrittmotor 1 / PIN-Auswahl
Stepper Motor5(SPU5, 5,6,7,8);                                                              // Schrittmotor 2 / PIN-Auswahl
Stepper Motor6(SPU6, 9,10,11,12);                                                           // Schrittmotor 3 / PIN-Auswahl
Stepper Motor7(SPU7, 1,2,3,4);                                                              // Schrittmotor 1 / PIN-Auswahl
Stepper Motor8(SPU8, 1,2,3,4);                                                              // Schrittmotor 1 / PIN-Auswahl


void setup()

{
    
    Motor1.setSpeed(150);                                                                   // Geschwindigkeit Flasche Motor 1 / 150 Umdrehung pro Minute
    Motor2.setSpeed(150);                                                                   // Geschwindigkeit Glas Motor 2 / 150 Umdrehung pro Minute
    Motor3.setSpeed(140);                                                                   // Geschwindigkeit Topf Motor 3 / 140 Umdrehung pro Minute
    Motor4.setSpeed(130);                                                                   // Geschwindigkeit Flasche Motor 1 / 130 Umdrehung pro Minute
    Motor5.setSpeed(55);                                                                   // Geschwindigkeit Glas Motor 2 / 100 Umdrehung pro Minute
    Motor6.setSpeed(60);                                                                    // Geschwindigkeit Topf Motor 3 / 60 Umdrehung pro Minute
    Motor7.setSpeed(100);                                                                   // Geschwindigkeit Flasche Motor 1 / 90 Umdrehung pro Minute
    Motor8.setSpeed(55);                                                                    // Geschwindigkeit Flasche Motor 1 / 55 Umdrehung pro Minute

                                                                              
    Startknopf = A8;                                                                        // Startknopf PIN Belegung
    Resetknopf = A9;
    Stopknopf = A10;
    Schalterglas = A12;
    Schalterflasche = A13;
    pinMode(Startknopf, INPUT);
    pinMode(Stopknopf, INPUT);
    pinMode(Resetknopf, INPUT);
    pinMode(Schalterglas, INPUT);
    pinMode(Schalterflasche, INPUT);
    pinMode(A0, OUTPUT);                                                                    // Fest verbauter Impulszähler (Tür)
    pinMode(A1, OUTPUT);                                                                    // Statusanzeige "Maschine bereit"
    pinMode(A2, OUTPUT);                                                                    // Statusanzeige "Hochfahren + Einschenken"
    pinMode(A3, OUTPUT);                                                                    // Statusanzeige "Resthefe rausschwenken"
    pinMode(A4, OUTPUT);                                                                    // Statusanzeige "Rest einschenken"
    pinMode(A5, OUTPUT);                                                                    // Statusanzeige "Programm läuft" (Blinken mit lastunabhängigem Blinkrelais)
    pinMode(A6, OUTPUT);                                                                    // AUSGANG MOMENTAN NOCH NICHT BELEGT
    
    digitalWrite(A1, LOW);                                                                  // Statusanzeige Maschine Betriebsbereit (AN / Dauersignal)
    
    lcd.begin(16, 2);

    for(int i = 0; i< 4; i++)
   {
    lcd.backlight();
    delay(250);
    lcd.noBacklight();
    delay(250);
   }

    lcd.backlight();

    lcd.setCursor(6,0);
    lcd.print("DER");
    lcd.setCursor(3,1);
    lcd.print("-WEIZOMAT-");

    delay(2000); 

    lcd.clear();

}  

void loop() 

{
            
            digitalWrite(1, LOW);                                                           // Phasen ausschalten (Netzteilüberlastung)
            digitalWrite(2, LOW);                                                           // Phasen ausschalten (Netzteilüberlastung)
            digitalWrite(3, LOW);                                                           // Phasen ausschalten (Netzteilüberlastung)
            digitalWrite(4, LOW);                                                           // Phasen ausschalten (Netzteilüberlastung)
            digitalWrite(5, LOW);                                                           // Phasen ausschalten (Netzteilüberlastung)
            digitalWrite(6, LOW);                                                           // Phasen ausschalten (Netzteilüberlastung)
            digitalWrite(7, LOW);                                                           // Phasen ausschalten (Netzteilüberlastung)
            digitalWrite(8, LOW);                                                           // Phasen ausschalten (Netzteilüberlastung)
            digitalWrite(9, LOW);                                                           // Phasen ausschalten (Netzteilüberlastung)
            digitalWrite(10, LOW);                                                          // Phasen ausschalten (Netzteilüberlastung)
            digitalWrite(11, LOW);                                                          // Phasen ausschalten (Netzteilüberlastung)
            digitalWrite(12, LOW);                                                          // Phasen ausschalten (Netzteilüberlastung)



if ((digitalRead(Schalterflasche) == LOW) or (digitalRead(Schalterglas) == LOW))
{
lcd.setCursor(4,0);
lcd.print("RESTART");
lcd.setCursor(4,1);
lcd.print("Druecken");

if (digitalRead(Resetknopf) == HIGH)
{
lcd.clear();
lcd.setCursor(4,0);
lcd.print("Endlagen");
lcd.setCursor(4,1);
lcd.print("Anfahren");
}


if (digitalRead(Resetknopf) == HIGH)
{
{
for(int i = 0; i< 20000; i++)                                                                // Zeitgleiches Ansteuern Arm Flasche + Glas / 150 U/min 
{
if (digitalRead(Schalterflasche) == LOW) 
{                                                                          
Motor1.step(1); 
}
}
}
{
for(int i = 0; i< 20000; i++)                                                                // Zeitgleiches Ansteuern Arm Flasche + Glas / 150 U/min 
{
if (digitalRead(Schalterglas) == LOW)                                                                            
{
Motor2.step(1); 
}
}
}

if ((digitalRead(Schalterflasche) == HIGH) and (digitalRead(Schalterglas) == HIGH))
{
lcd.clear();
lcd.setCursor(4,0);
lcd.print("Endlagen");
lcd.setCursor(4,1);
lcd.print("Erreicht");
}

delay(1500);
  
}
}

            digitalWrite(1, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(2, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(3, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(4, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(5, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(6, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(7, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(8, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)

  
    if((digitalRead(Startknopf) == LOW) and (digitalRead(Schalterflasche) == HIGH) and (digitalRead(Schalterglas) == HIGH))
    {
    digitalWrite(A1, HIGH);
    lcd.setCursor(0,0);
    lcd.print("Status Maschine:");
    lcd.setCursor(1,1);
    lcd.print("Betriebsbereit");
    }
    
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------//

       {
 
         if((digitalRead(Startknopf) == HIGH) and (digitalRead(Schalterflasche) == HIGH) and (digitalRead(Schalterglas) == HIGH))     // Abfrage Startknopf

       {


            
            digitalWrite(A1, LOW);                                                          // Statusanzeige Maschinen Betriebsbereit (AUS / LED Blinkt)
           
            digitalWrite(A2, HIGH);                                                         // Statusanzeige Programm läuft (AN)

            digitalWrite(A3, HIGH);                                                         // Statusanzeige Einschenken (AN)


            lcd.clear();
    
            lcd.setCursor(0,0);
            lcd.print("Status Maschine:");
            lcd.setCursor(1,1);
            lcd.print("Programm aktiv");

            delay(1000);

            lcd.clear();
    
            lcd.setCursor(0,0);
            lcd.print("Status Maschine:");
            lcd.setCursor(2,1);
            lcd.print("Einschenken");
  

for(int i = 0; i< 8000; i++)                                                               // Zeitgleiches Ansteuern Arm Flasche + Glas / 150 U/min 
{
Motor1.step(-1);                                                                            
Motor2.step(-1);
}


            digitalWrite(5, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(6, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(7, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(8, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)


Motor1.step(-4800);                                                                         // Hochfahren Flasche / 150 U/min


Motor8.step(-600);                                                                         // Hochfahren Flasche / 55 U/min

            digitalWrite(1, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(2, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(3, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(4, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)

for(int i = 0; i< 600; i++)                                                                 // Zeitgleiches Ansteuern Arm Flasche + Glas / 55 U/min 
{
Motor8.step(-1);
Motor5.step(1);
}

            digitalWrite(1, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(2, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(3, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(4, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)

Motor2.step(1800);                                                                          // Glas runtenfahren / 150 U/min

delay(3500);

            digitalWrite(5, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(6, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(7, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(8, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)

//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------//


Motor1.step(4100);   



for(int i = 0; i< 2700; i++)                                                                 // Zeitgleiches Ansteuern Arm Flasche + Glas / 55 U/min 
{
Motor1.step(1);
Motor2.step(1);                                                                             // Zeitgleiches Ansteuern Arm Flasche + Glas / 150 U/min 
}

                                                                          

            digitalWrite(1, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(2, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(3, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(4, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(5, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(6, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(7, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(8, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)


            digitalWrite(A3, LOW);                                                          // Statusanzeige Einschenken (AUS)


            digitalWrite(A4, HIGH);                                                         // Statusanzeige Resthefe (AN)


    lcd.clear();
    
    lcd.setCursor(0,0);
    lcd.print("Status Maschine:");
    lcd.setCursor(1,1);
    lcd.print("Hefe schwenken");
    

delay(250);


Motor3.step(2000);                                                                          //Flasche Schwenken / 140 U/min

delay(250);

Motor3.step(-2000);                                                                         //Flasche Schwenken / 140 U/min


            digitalWrite(9, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(10, LOW);                                                          // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(11, LOW);                                                          // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(12, LOW);                                                          // Phasen abschalten (Netzteilüberlastung)


            digitalWrite(A4, LOW);                                                          // Statusanzeige Resthefe (AUS)


            digitalWrite(A5, HIGH);                                                         // Statusanzeige Rest einschenken (AN)


    lcd.clear();
    
    lcd.setCursor(0,0);
    lcd.print("Status Maschine:");
    lcd.setCursor(2,1);
    lcd.print("Schaumkrone");
    

Motor1.step(-7000);                                                                         // Hochfahren Flasche / 150 U/min

for(int i = 0; i< 1400; i++)                                                                 // Zeitgleiches Ansteuern Arm Flasche + Glas / 55 U/min 
{
Motor7.step(-1);
Motor2.step(1);
}


            digitalWrite(1, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(2, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(3, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(4, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)


for(int i = 0; i< 20000; i++)                                                               // Endlage Glas anfahren
{
if (digitalRead(Schalterglas) == LOW)
{
Motor2.step(1);                                                                             // Endlage Glas / 150 U/min
}
}

            digitalWrite(5, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(6, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(7, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(8, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)


for(int i = 0; i< 20000; i++)                                                               // Endlage Flasche anfahren                                                     
{
if (digitalRead(Schalterflasche) == LOW)  
{
Motor1.step(1);                                                                             // Endlage Flasche / 150 U/min
}
}
            digitalWrite(1, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(2, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(3, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)
            digitalWrite(4, LOW);                                                           // Phasen abschalten (Netzteilüberlastung)


            digitalWrite(A1, HIGH);                                                         // Statusanzeige Maschine Betriebsbereit (AN)
            digitalWrite(A2, LOW);                                                          // Statusanzeige Programm läuft (AUS)
            digitalWrite(A5, LOW);                                                          // Statusanzeige Rest einschenken (AUS)

    digitalWrite(A0, HIGH);

    delay(100);

    digitalWrite(A0, LOW);
    
    lcd.clear();


    if((digitalRead(Schalterflasche) == HIGH) and (digitalRead(Schalterglas) == HIGH))
    {
    lcd.setCursor(2,0);
    lcd.print("BIER FERTIG");
    lcd.setCursor(5,1);
    lcd.print("PROST!");
    }
    
    delay(2500);

    lcd.clear();

    if((digitalRead(Schalterflasche) == HIGH) and (digitalRead(Schalterglas) == HIGH))       // Zählt die Anzahl der eingeschenkten Biere (keine dauerhafte Speicherung der Daten)
    {
    lcd.setCursor(2,0);
    lcd.print("Anzahl Bier");
    lcd.setCursor(7,1);
    lcd.print(Bierzaehler++);
    }

    delay(2500);

    lcd.clear();
                  
    }
  
  }

}

[oberallgeier]

.. Programm über einen Taster .. an jeder beliebigen Stelle anhalten .. spielt dabei keine Rolle, ob das Programm .. wieder von vorne anfängt oder ..

Vielleicht ne Mitternachts-Schnaps-Idee - aber wie wärs diese Aktion mit dem Reset-Taster zu erledigen? Ok, etwas grob - aber das dürfte gut gehen ?!?!?!

[i_make_it]

Um Code zu posten, hat es extra Code Tags dann wird der Post keinen halben Kilometer lang.
Einfach unter [Erweitert].

An sonsten, könnte es hier eventuell um Aruino C++ und als Board um einen ArduinoMega 2560 gehen?

void loop() lässt sich übrigens nicht stoppen (außer man dreht den Saft ab)

Aber Tastendruck per IRQ erkennen ist der richtige Weg.
Und in der ISR dann eine Variabel setzen oder toggeln.
Danach kommt einfach eine Auswertung auf den Status dieser Variable (IF variable == 1) und entsprechende Verzweigung die verhindert das der gesammte Rest der Befehle ausgeführt wird.
Sei es überspringen der entsprechenden Bereiche, oder eine While schleife die solange durchlaufen wird wie die Merkervariable gesetzt (WHILE variable==1) ist. in der Schleife kann mann dann noch einen delay von z.B. 100ms ausführen.
Wenn also die Variable wieder zurückgenommen wird, würde das System nach spätestens 0,1s wieder reagieren.

ERGÄNZUNG

So, habe mal einen Code, für einen Arduino Nano mit IRQ Auswertung einer Taste, von mir gefunden.

//int f_tast = 2;
int a_rot = 3;
int a_gelb = 4;
int a_gruen = 5;
int f_rot = 8;
int f_gruen = 9;
int f_lamp_tast = 13;
int s_licht = A0;
byte f_press = HIGH;

void setup() {
pinMode(f_tast, INPUT);
pinMode(a_rot, OUTPUT);
pinMode(a_gelb, OUTPUT);
pinMode(a_gruen, OUTPUT);
pinMode(f_rot, OUTPUT);
pinMode(f_gruen, OUTPUT);
attachInterrupt(0, button, LOW);
//Serial.begin(9600);
}

void loop() {
  int sensorValue = analogRead(s_licht);
  //Serial.println(sensorValue);
  // Blinker code zum Prüfen ob Programm läuft 
  digitalWrite(f_lamp_tast, HIGH); //Blinker an Taste fuer Fussgaenger
  delay(500);
  digitalWrite(f_lamp_tast, LOW);
  delay(500);
  
  if (sensorValue > 500){ //Dämmerungswert für Nachtschaltung
  digitalWrite(a_rot, LOW);
  digitalWrite(a_gelb, HIGH); //Autos Gelb für Blinker
  digitalWrite(a_gruen, LOW);
  digitalWrite(f_rot, LOW);
  digitalWrite(f_gruen, LOW);
  delay(500);
  digitalWrite(a_gelb, LOW);
  }
  else {
  digitalWrite(a_rot, LOW);
  digitalWrite(a_gelb, LOW);
  digitalWrite(a_gruen, HIGH); //Autos gruen
  digitalWrite(f_rot, HIGH); //Fussgaenger rot
  digitalWrite(f_gruen, LOW);
  }

  // if (digitalRead(f_tast) == LOW){ //Taste Fussgaenger abfragen
  if (f_press == LOW){ //Statusvariable Taste Fussgaenger abfragen
  delay(500);
  digitalWrite(13, HIGH); //Taste Fussgaenger ist gedrueckt worden
  digitalWrite(f_rot, HIGH); //Fussgaenger rot
  digitalWrite(a_gruen, LOW);
  digitalWrite(a_gelb, HIGH); //Autos gelb
  delay(1000); // Autos Gelbphase
  digitalWrite(a_gelb, LOW);
  digitalWrite(a_rot, HIGH); //Autos rot
  delay(1000); // Fussgaenger Wartezeit damit kein Auto mehr fährt
  digitalWrite(13, LOW);
  digitalWrite(f_rot, LOW);
  digitalWrite(f_gruen, HIGH); //Fussgaenger gruen
  delay (6000); //Fussgaenger gruenphase
  digitalWrite(f_rot, HIGH); //Fussgaenger rot
  digitalWrite(f_gruen, LOW);
  delay(1000); //Autos Wartezeit damit kein Fussgaenger mehr laeuft
  digitalWrite(a_gelb, HIGH); //Autos gelb
  delay(1000); // Autos Gelbphase
  f_press = HIGH;
  }
}
void button(){
f_press = LOW;
}

void Button() ist die ISR die nichts anderes macht wie die Variable f_press auf Low zu setzen.

attachInterrupt(0, button, LOW)
Ordnet den Interrupt dem Eingang 0 und die ISR Button zu.

if (f_press == LOW) ist dann die Abfrage der Variablen und löst den entsprechenden Programmteil aus.
(in dem ich dann auch dafür sorgen muß das die Variable wieder zurückgesetzt wird: f_press = HIGH).

f_tast ist auskommentiert, wenn das anstelle der IRQ Variante genutzt wird, wird genau einmal pro Zyklus die Taste abgefragt (die liegt dann an Eingang 2).
Das ganze ist bewust mit delay() ausgeführt, da es genau die Problematik der Tastenauswertung ohne IRQ, bei längeren Zykluszeiten, verdeutlichen soll.