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.