- LiFePO4 Speicher Test         
Ergebnis 1 bis 3 von 3

Thema: Loop Stoppen

Baum-Darstellung

Vorheriger Beitrag Vorheriger Beitrag   Nächster Beitrag Nächster Beitrag
  1. #1

    Loop Stoppen

    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:

    Code:
    #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();
                      
        }
      
      }
    
    }
    Geändert von radbruch (26.06.2017 um 07:47 Uhr)

Ähnliche Themen

  1. LOOP bleibt stehen??
    Von fredyxx im Forum Arduino -Plattform
    Antworten: 1
    Letzter Beitrag: 15.01.2017, 07:27
  2. Loop unterbrechen
    Von bomberman_z im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 2
    Letzter Beitrag: 02.11.2008, 21:29
  3. Starten|Stoppen (C)
    Von BlackDevil im Forum C - Programmierung (GCC u.a.)
    Antworten: 7
    Letzter Beitrag: 03.07.2008, 10:07
  4. loop problem
    Von pinoccio im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 12
    Letzter Beitrag: 01.05.2006, 19:22
  5. Do Loop
    Von christian87 im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 6
    Letzter Beitrag: 28.01.2005, 11:32

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •  

Labornetzteil AliExpress