"Bobbycar LED" - 2 Fragen (Mehrere Taster: Unterprog. Abbrechen / Einfacher "Code" ?)

[KlausGuenther]

Guten Abend Zusammen,

es handelt sich insgesamt um mein zweites Projekt. Also bitte nicht direkt empört reagieren wenn der Code an der ein oder anderen stelle "einfach" ist und das der Profi vermutlich einfacher gelöst hätte. Vielleicht sollte ich auch noch dazu sagen, dass das ganze auf einem ESP32 läuft und erstmal "nur" auf ein Holzbrett geschraubt ist. Soweit läuft auch alles, ich hätte bis hier her mit wesentlich mehr Problemen gerechnet.
Wenn die Software vom Grundaufbau her auch läuft, werde ich danach erst an die Programmierung der einzelnen Lichtszenen gehen, unter anderem ist geplant aus 2 Strips 4 zu machen (für jede Ecke einen), aber das dürfte ja eher nicht das Problem sein.


Genrell habe ich 2 Fragen zu meinem Code:
- Im Moment ist es ja so, dass nach Tastendruck das Unterprogramm erst mal durchläuft. Kann man das irgendwie so anpassen (wenn ja wie) dass man Beispielsweise aus dem Warnblick-Programm in den Blinkmodus kommt ohne warten zu müssen das das Programm beendet ist ?
- Vermutlich kann man das ein oder andere vereinfachen, wenn jemand Tipps dazu hat, wäre ich für den ein oder anderen Hinweis dankbar

Und hier der Code:

Code:

#include "ClickButton.h"
#include <Adafruit_NeoPixel.h>

#define PIN_Strip_a 15              //Strip Vorne
#define PIN_Strip_b 17              //Strip Hinten
#define NUMPIXEL_a 8
#define NUMPIXEL_b 8
#define Delay_Bluelight 80
#define Count_Bluelight 150
#define Delay_Warn_Lights 250
#define Count_Warn_Lights 50
#define Delay_Blinkers 250
#define Count_Blinkers 100

const int buttonPin1 = 26;  //Lighthorn
const int buttonPin2 = 25;  //Blinker Links
const int buttonPin3 = 33;  //Blinker Rechts
const int buttonPin4 = 32;  //WarnblinkLight




ClickButton button1(buttonPin1, LOW, CLICKBTN_PULLUP);  //Licht/Lichthupe
ClickButton button2(buttonPin2, LOW, CLICKBTN_PULLUP);  //Blinker Links
ClickButton button3(buttonPin3, LOW, CLICKBTN_PULLUP);  //Blinker Rechts
ClickButton button4(buttonPin4, LOW, CLICKBTN_PULLUP);  //WarnblinkLight

Adafruit_NeoPixel strip_a = Adafruit_NeoPixel(NUMPIXEL_a, PIN_Strip_a, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel strip_b = Adafruit_NeoPixel(NUMPIXEL_b, PIN_Strip_b, NEO_GRB + NEO_KHZ800);

//Farben Strip Vorne
uint32_t blue_a = strip_a.Color(0, 0, 255);  
uint32_t red_a = strip_a.Color(255, 0, 0);  
uint32_t orange_a = strip_a.Color(255, 155, 0);
uint32_t white_a = strip_a.Color(0, 0, 0, 255);
uint32_t yellow_a = strip_a.Color(255, 255, 0);
uint32_t off_a = strip_a.Color(0, 0, 0); //off

//Farben Strip Hinten
uint32_t blue_b = strip_b.Color(0, 0, 255);
uint32_t red_b = strip_b.Color(255, 0, 0);  
uint32_t orange_b = strip_b.Color(255, 155, 0);
uint32_t yellow_b = strip_b.Color(255, 255, 0);
uint32_t off_b = strip_a.Color(0, 0, 0);

    
void setup()
{

Serial.begin(9600);
  pinMode(buttonPin1, INPUT_PULLUP);
  pinMode(buttonPin2, INPUT_PULLUP);
  pinMode(buttonPin3, INPUT_PULLUP);
  pinMode(buttonPin4, INPUT_PULLUP);
  strip_a.begin(); // This initializes the NeoPixel library.
  strip_a.show(); // Initialize all pixels to 'off'
  strip_b.begin(); // This initializes the NeoPixel library.
  strip_b.show(); // Initialize all pixels to 'off'
  button1.debounceTime   = 100;  // Debounce timer in ms
  button1.multiclickTime = 250;  // Time limit for multi clicks
  button1.longClickTime  = 2000; // time until "held-down clicks" register
  button2.debounceTime   = 100;  // Debounce timer in ms
  button2.multiclickTime = 250;  // Time limit for multi clicks
  button2.longClickTime  = 2000; // time until "held-down clicks" register
  button3.debounceTime   = 100;  // Debounce timer in ms
  button3.multiclickTime = 250;  // Time limit for multi clicks
  button3.longClickTime  = 2000; // time until "held-down clicks" register
  button4.debounceTime   = 100;  // Debounce timer in ms
  button4.multiclickTime = 250;  // Time limit for multi clicks
  button4.longClickTime  = 2000; // time until "held-down clicks" register

}


void loop() {
  // Update button state
  
  button1.Update();
    if(button1.clicks == 1){
      Serial.println("Taster 1 - 1 mal gedrückt");
      Lichthupe();
      }
   else if(button1.clicks == 2 ) {  
      Serial.println("Taster 1 - 2 mal gedrückt");
      Light();  
      }
    
  button2.Update();
    if(button2.clicks == 1){
      Serial.println("Taster 2 - 1 mal gedrückt");
      BlinkerLinks();
      }
   else if(button2.clicks == 2 ) {  
      Serial.println("Taster 2 - 2 mal gedrückt");
      Light();  
      }
  else if(button2.clicks == 3 ) {  
      Serial.println("Taster 2 - 3 mal gedrückt");
      Rainbow();
      }

          

  button3.Update();
    if(button3.clicks == 1){
      Serial.println("Taster 3 - 1 mal gedrückt");
      BlinkerRechts();
      }
   else if(button3.clicks == 2 ) {  
      Serial.println("Taster 3 - 2 mal gedrückt");
      Light();  
      }

  button4.Update();
    if(button4.clicks == 1){
      Serial.println("Taster 4 - 1 mal gedrückt");
      WarnblinkLight();
      }
   else if(button4.clicks == 2 ) {  
      Serial.println("Taster 4 - 2 mal gedrückt");
      blueLight();  
      }

  
}


//**************** Unterprogramm Light ******************************

void Light(){
strip_a.fill(yellow_a, 0, 8);    //Vorne white/yellow
strip_a.setBrightness(20);   //0-255
strip_a.show();       //Daten an Strip schicken
strip_b.fill(red_b, 0, 8);    //Hinten red
strip_b.setBrightness(20);   //0-255
strip_b.show();       //Daten an Strip schicken

}
//**************** Ende Unterprogramm ******************************


//**************** Unterprogramm Lighthorn ******************************

void Lichthupe(){
strip_b.fill(red_b, 0, 8);    
strip_b.setBrightness(20);
strip_a.fill(yellow_a, 0, 8);    
strip_a.setBrightness(255);  
strip_b.show();      
strip_a.show();      
delay(150);
strip_a.setBrightness(20);
strip_a.show();    
delay(150);
strip_a.setBrightness(255);
strip_a.show();  
delay(450);
Light();
}
//**************** Ende Unterprogramm ******************************


//**************** Unterprogramm BLINKER LINKS ******************************
void BlinkerLinks(){
strip_a.fill(off_a, 0, 8);
strip_b.fill(off_b, 0, 8);
strip_a.show();
strip_b.show();  
strip_a.fill(yellow_a, 0, 4);
strip_b.fill(yellow_b, 0, 4);  
strip_a.setBrightness(128);
strip_b.setBrightness(128);
strip_a.show();
strip_b.show();    
delay(5000);
Light();      
}
//**************** Ende Unterprogramm ******************************


//**************** Unterprogramm BLINKER RECHTS ******************************
void BlinkerRechts(){
strip_a.fill(off_a, 0, 8);
strip_b.fill(off_b, 0, 8);  
strip_a.show();
strip_b.show();  
strip_a.fill(yellow_a, 4, 4);
strip_b.fill(yellow_b, 4, 4);  
strip_a.setBrightness(128);
strip_b.setBrightness(128);
strip_a.show();
strip_b.show();    
delay(5000);
Light();  
}
//**************** Ende Unterprogramm ******************************


//**************** Unterprogramm WARNBLINKER ******************************

void WarnblinkLight(){

for (int c = 0; c < Count_Warn_Lights; c++) {
    strip_a.fill(orange_a, 0, 4);    
    strip_b.fill(orange_a, 0, 4);  
    strip_a.fill(off_a, 4, 4);    
    strip_b.fill(off_a, 4, 4);
    strip_a.setBrightness(100);
    strip_b.setBrightness(100);
    strip_a.show();      
    strip_b.show();
    delay(Delay_Warn_Lights);
    strip_a.fill(orange_a, 4, 4);    
    strip_b.fill(orange_a, 4, 4);  
    strip_a.fill(off_a, 0, 4);    
    strip_b.fill(off_a, 0, 4);
    strip_a.setBrightness(100);
    strip_b.setBrightness(100);
    strip_a.show();      
    strip_b.show();
    delay(Delay_Warn_Lights);
    }
    Light();
}
//**************** Ende Unterprogramm ******************************


//**************** Unterprogramm blueLight ******************************
void blueLight(){

for (int c = 0; c < Count_Bluelight; c++) {
    strip_a.fill(blue_a, 0, 4);    
    strip_b.fill(blue_a, 0, 4);  
    strip_a.fill(off_a, 4, 4);    
    strip_b.fill(off_a, 4, 4);
    strip_a.setBrightness(255);
    strip_b.setBrightness(255);
    strip_a.show();      
    strip_b.show();
    delay(Delay_Bluelight);
    strip_a.fill(blue_a, 4, 4);    
    strip_b.fill(blue_a, 4, 4);  
    strip_a.fill(off_a, 0, 4);    
    strip_b.fill(off_a, 0, 4);
    strip_a.setBrightness(255);
    strip_b.setBrightness(255);
    strip_a.show();      
    strip_b.show();
    delay(Delay_Bluelight);
    }
    Light();
}
    
//**************** Ende Unterprogramm ******************************


//**************** Unterprogramm Rainbow ******************************
void Rainbow(){

  Light();
}


//**************** Ende Unterprogramm ******************************

[Tommy56]

Das geht nur, wenn Du nichtblockierend programmierst.

Schaue Dir in der IDE das Beispiel BlinkWithoutDelay an und verstehe es.

Dabei kann Dir die Nachtwächtererklärung helfen oder das Tutorial von Rentner oder die Erklärung von Arne oder das Beispiel von Franz.

Gruß Tommy

Edit: Du kannst Dir natürlich auch den objektorientierten Code anschauen, den ich hier in #28 veröffentlicht habe.

[KlausGuenther]

Das heißt ich bleibe bei meinen Unterprogrammen / Funktionen, ändere diese einfach von "delay" in "millis" und schon kann ich in der Hauptschleife (loop) von Funktion zu Funktion springen auch wenn diese noch nicht vollständig durchgelaufen sind ?

[hotsystems]

(06.03.2020 13:27)KlausGuenther schrieb:  Das heißt ich bleibe bei meinen Unterprogrammen / Funktionen, ändere diese einfach von "delay" in "millis" und schon kann ich in der Hauptschleife (loop) von Funktion zu Funktion springen auch wenn diese noch nicht vollständig durchgelaufen sind ?

Wenn es dann so einfach wäre.
Millis() ist eine Funktion die du nicht einfach statt der Funktion "delay()" verwenden kannst. Sieh dir dazu das schon genannte Beispiel BlinkWithoutDelay an, da siehst du, wie millis verwendet wird.

[KlausGuenther]

(06.03.2020 16:13)hotsystems schrieb:  Millis() ist eine Funktion die du nicht einfach statt der Funktion "delay()" verwenden kannst. Sieh dir dazu das schon genannte Beispiel BlinkWithoutDelay an, da siehst du, wie millis verwendet wird.

Habe ich. Soweit habe ich das auch verstanden und finde ja ganz in Ordnung das der Nachtwächter auf Rundgeht geht uns ausser gucken nix zu tun hat.

Ich wollte nur sicher sein, dass ich mir jetzt nicht mit viel Mühe etwas anlese, ausprobiere, alles umprogrammiere und dann feststelle, dass ich dann trotzdem nicht von einem "Unterprogramm"/Funktion in die andere komme ohne warten zu müssen
das die erst mal zu ende läuft.
Anhand eine Beispiels von Adafruit habe ich jetzt die Unterfunktion auch noch mit leben gefüllt und auch da komme ich trotz eines "delay(3) nicht raus.

[hotsystems]

(06.03.2020 18:51)KlausGuenther schrieb:  Ich wollte nur sicher sein, dass ich mir jetzt nicht mit viel Mühe etwas anlese, ausprobiere, alles umprogrammiere und dann feststelle, dass ich dann trotzdem nicht von einem "Unterprogramm"/Funktion in die andere komme ohne warten zu müssen
das die erst mal zu ende läuft.
Anhand eine Beispiels von Adafruit habe ich jetzt die Unterfunktion auch noch mit leben gefüllt und auch da komme ich trotz eines "delay(3) nicht raus.

Unterfunktionen gibt es nicht.
Ich vermute du meinst die reinen Funktionen.
Was du damit meinst, das du nicht mehr aus de Funktion rauskommst, verstehe ich nicht. Das geht normal immer am Ende der Funktion. Vorrausgesetzt, alles ist richtig programmiert.

[KlausGuenther]

Also die Funktionen beenden und gehen dann die die Loop Funktion zurück. Soweit alles gut.
Nur jetzt wäre ja Denkbar, z.B. die Funktion für das Warnblinken sehr sehr lange zu machen und aber die Möglichkeit zu haben, dann durch einen Tastendruck in eine andere Funktion zu wechseln. Und daran hapert es im Moment. Also im Prinzip dem Nachtwächter auf seiner Runde sagen: schön das Du immer bei Lampe A vorbei gehst, jetzt machen wir Lampe C.

[hotsystems]

(07.03.2020 09:44)KlausGuenther schrieb:  Also die Funktionen beenden und gehen dann die die Loop Funktion zurück. Soweit alles gut.

Nicht zwangsläufig. Die Funktion geht immer dahin zurück, wo sie gestartet wurde.

Zitat:Nur jetzt wäre ja Denkbar, z.B. die Funktion für das Warnblinken sehr sehr lange zu machen und aber die Möglichkeit zu haben, dann durch einen Tastendruck in eine andere Funktion zu wechseln. Und daran hapert es im Moment. Also im Prinzip dem Nachtwächter auf seiner Runde sagen: schön das Du immer bei Lampe A vorbei gehst, jetzt machen wir Lampe C.

Auch das kann funktionieren.
Nur dazu darf keine Funktion blockierend geschrieben sein und du musst immer (möglichst in der loop) die Tasten abfragen können.
Ob das mit den verwendeten Libraries tatsächlich so umsetzbar ist, kann ich allerdings nicht sagen. Ich habe die bisher noch nicht verwendet.