Frage zu meinem Sketch

[JaimyS]

Guten morgen alle miteinander!

Anfang Dezember habe ich mich mit einer Art Blinkersystem und Leuchtsystem befasst.

Konnte die meisten Probleme und Ideen lösen doch habe ich ein Problem mit einem longbuttonpress und einem shortbuttonpress. Der shortbuttonpress soll 3 mal blinken, der longbuttonpress soll durchgehend blinken.

Ich poste mal meinen ganzen Sketch rein um die zusammenhänge zu zeigen.

Code:

int LEDrot = 3; //Farbe: rot
int LEDweiss = 4; //Farbe: weiss
int LEDrw = 5; //Farben: rot und weiß
int LEDrechts = 6; //Farbe: gruen auf der rechten Seite
int LEDlinks = 7; //Farbe: gruen auf der linken Seite

int Tasterrw = 11; //Taster für rot und weiß
int TasterRechts = 9; //Taster für rot
int TasterRechts2 = 12; //Taster für gruenr
int TasterLinks = 10; //Taser für weiss
int TasterLinks2 = 13; //Taster für gruenl

int Tasterstatusrw = 1;                 //Tasterstatusrw´s Maximalwert ist 1
int Tasterstatusr = 1;                  //Tasterstatusr´s Maximalwert ist 1
int Tasterstatusw = 1;                  //Tasterstatusw´s Maximalwert ist 1

int Tasterstatusaltrw = 1;              //Tasterstatusaltrw´s Maximalwert ist 1
int Tasterstatusaltr = 1;               //Tasterstatusaltr´s Maximalwert ist 1
int Tasterstatusaltw = 1;               //Tasterstatusaltw´s Maximalwert ist 1

int Zaehlerrw = 0;                      //Zaehlerrw Startwert ist 0
int Zaehlerr = 0;                       //Zaehlerr Startwert ist 0
int Zaehlerw = 0;                       //Zaehlerw Startwert ist 0

int blinken = 500;                      //500 steht für 0,5 Sekunden
int Minutetest = 6000;

#define INPUT_TYPE INPUT_PULLUP
#define ENTPRELLZEIT 5
boolean rechtsBlinken = true;
boolean linksBlinken = true;


const uint32_t prellIntervall = 10, kurzerIntervall = 250, langerIntervall = 750;
uint32_t aktMillis, prellMillis, ausgangMillis, aktMillis2, prellMillis2, ausgangMillis2;
bool aktTaster, altTaster, ausgangStatus, aktTaster2, altTaster2, ausgangStatus2;



void weisseLEDlang(){
  aktMillis2 = millis();

  altTaster2 = aktTaster2;
  if (aktMillis2 - prellMillis2 >= langerIntervall){
    prellMillis2 = aktMillis2;
    aktTaster2 = digitalRead(TasterLinks);
  }
  if (altTaster2 && !aktTaster2){
    if (ausgangStatus2){
      ausgangStatus2 = LOW;
      digitalWrite(LEDweiss, LOW);
    }
    else{
      ausgangMillis2 = aktMillis2;
      ausgangStatus2 = HIGH;
      digitalWrite(LEDweiss, HIGH);
    }
  }
}

void weisseLEDkurz(){
  aktMillis = millis();

  altTaster = aktTaster;
  if (aktMillis - prellMillis >= prellIntervall){
    prellMillis = aktMillis;
    aktTaster = digitalRead(TasterLinks);
  }
  if (altTaster && !aktTaster){
    if (ausgangStatus){
      ausgangStatus = LOW;
      digitalWrite(LEDweiss, LOW);
    }
    else{
      ausgangMillis = aktMillis;
      ausgangStatus = HIGH;
      digitalWrite(LEDweiss, HIGH);
    }
  }
  if (ausgangStatus && (aktMillis - ausgangMillis >= kurzerIntervall)){
    digitalWrite(LEDweiss, LOW);
    ausgangStatus = LOW;
  }
}

void blinkEingabe()
{
  static unsigned long lastMillis = 0;
  static boolean altTasteL = false;
  static boolean altTasteR = false;
  if (millis() - lastMillis < ENTPRELLZEIT) return;
  lastMillis = millis();
  boolean neuTasteL = digitalRead (TasterLinks2);
  boolean neuTasteR = digitalRead (TasterRechts2);
  if (INPUT_TYPE == INPUT_PULLUP)
  {
    neuTasteL =! neuTasteL;
    neuTasteR =! neuTasteR;
  }
  if (neuTasteL == HIGH && altTasteL == LOW)
  {
    linksBlinken =! linksBlinken;
  }
  if (neuTasteR == HIGH && altTasteR == LOW)
  {
    rechtsBlinken =! rechtsBlinken;
  }


  altTasteL = neuTasteL;
  altTasteR = neuTasteR;
}

void blinkAusgabe(){
  static unsigned long lastMillis = 0;
  static boolean onTakt = false;
  static unsigned long diffMillis = 0;
  unsigned long nowMillis = millis();
  diffMillis += nowMillis - lastMillis;
  if (diffMillis >= blinken){
   diffMillis = 0;
   onTakt=!onTakt;
  
      if (onTakt && linksBlinken){
        digitalWrite(LEDlinks, HIGH);
        }
      else {
        digitalWrite(LEDlinks, LOW);
        }
      if (onTakt && rechtsBlinken){
        digitalWrite(LEDrechts, HIGH);
        }
      else{
        digitalWrite(LEDrechts, LOW);
        }

   Serial.print(digitalRead(LEDlinks));
   Serial.print(digitalRead(LEDrechts));
   Serial.println();
  }
    lastMillis = nowMillis;
}

void setup() {
  // Setup
    Serial.begin (9600);
    pinMode (LEDrw, OUTPUT);            //LED rot und weiß output
    pinMode (LEDrot, OUTPUT);
    pinMode (LEDrechts, OUTPUT);        //LED gruen(gelb) rechts output
    pinMode (LEDweiss, OUTPUT);
    pinMode (LEDlinks, OUTPUT);         //LED gruen(gelb) links output
    pinMode (Tasterrw, INPUT);          //Taster für rot und weiß input
    pinMode (TasterRechts, INPUT);
    pinMode (TasterLinks, INPUT);
    pinMode (TasterRechts2, INPUT_TYPE);           //Taster für gruen(gelb) rechts input
    //digitalWrite (Tasterr, HIGH);       //Benötigter Status des rechten Tasters
    pinMode (TasterLinks2, INPUT_TYPE);           //Taster für gruen(gelb) links input
    //digitalWrite (Tasterl, HIGH);       //Benötigter Status des linken Tasters
  
    digitalWrite (LEDrw, LOW);          //Start-Status für rote und weiße LED
    //digitalWrite (LEDgruenr, LOW);      //Start-Status für gruen(gelb) rechts
    //digitalWrite (LEDgruenl, LOW);      //Start-Status für gruen(gelb) links
  }

void loop(){

  blinkAusgabe();
  blinkEingabe();
  weisseLEDkurz();
  weisseLEDlang();

    //Rote und Weiße LED Startbedingung
    Tasterstatusrw = digitalRead (Tasterrw);       //Von welchem Tasterstatus der Status gelesen wird

  if (Tasterstatusaltrw != Tasterstatusrw)         //Trifft nur zu wenn Tasterstatusaltrw ungleich Tasterstatusrw ist
  {  
    if (Tasterstatusrw == HIGH)                    //Trifft nur zu wenn Tasterstatusrw HIGH ist
    {
      if (Zaehlerrw == 1)                           //Wenn Zaehlerrw gleich 1 ist, also 1 mal betätigt ist
      {
        Zaehlerrw = 0;                              //dann soll er sich beim weiteren betätigen auf 0 setzen
      }
      else
      {
        Zaehlerrw++;                                //Sonst wird weiter hoch gezählt
      }
    }
  }
  
      //Rote und Weiße LED Schaltbedingung
  Tasterstatusaltrw = Tasterstatusrw;

  if (Zaehlerrw == 1)                               //Wenn Zaehlerrw gleich 1 ist
  {
    digitalWrite (LEDrw, HIGH);                     //werden die LED rot und weiß leuchten
  }

  if (Zaehlerrw == 0)                               //Wenn Zaehlerrw gleich 0 ist
  {
    digitalWrite (LEDrw, LOW);                      //sollen die LEDs nicht leuchten
  }



//Rote LED
  Tasterstatusr = digitalRead (TasterRechts);        //Von welchem Tasterstatus der Status gelesen wird
    if (Tasterstatusr == HIGH) {                    
     digitalWrite(LEDrot, HIGH);
     }
    else{
     digitalWrite(LEDrot, LOW);                              
     }
}

Falls es so noch fragen gibt, hier runterschreiben und ich werde mein bestes geben um diese zu beantworten.

[MicroBahner]

Und was funktioniert jetzt nicht?

[JaimyS]

(15.01.2020 10:32)MicroBahner schrieb:  Und was funktioniert jetzt nicht?

Der longbuttonpress und shortbuttonpress funktioniert nicht. Ist in der blinkAusgabe.

[MicroBahner]

(15.01.2020 10:37)JaimyS schrieb:  Der longbuttonpress und shortbuttonpress funktioniert nicht. Ist in der blinkAusgabe.

Und wo stellst Du überhaupt fest, ob kurz oder lang gedrückt wurde? Leider fehlen genau an den relevanten Stellen sämtliche Kommentare, da ist das schlecht nachzuvollziehen.
Du kannst auch mal zum Debuggen serielle Ausgaben einfügen.

Edit: wie soll das eigentlich genau funktionieren? So wie bei vielen Blinkern im Auto? D.h. er blinkt mindestens 3x, wenn der Schalter vor dem 3. Blinken wieder abgeschaltet wurde, ansonstgen solange wie der Taster betätigt wurde? Das ist dann aber ein bisschen anders als der typische 'longbutton' und 'shortbutton' press.

[JaimyS]

(15.01.2020 10:57)MicroBahner schrieb:  Edit: wie soll das eigentlich genau funktionieren? So wie bei vielen Blinkern im Auto? D.h. er blinkt mindestens 3x, wenn der Schalter vor dem 3. Blinken wieder abgeschaltet wurde, ansonstgen solange wie der Taster betätigt wurde? Das ist dann aber ein bisschen anders als der typische 'longbutton' und 'shortbutton' press.

Es sollte halt so funktionieren wie für meine weisseLEDkurz/lang Funktion, nur mein Problem war, dass sich die BlinkerLED, die 3x Blinken soll, bei der Dauerblinkfunktion auch nur 3x blinkt und dann "aus" geht bzw eher nur die LED auf LOW geht und 2x gedrückt werden muss bis die dann wieder 3x blinkt. Problem war also, dass ich keine 2 Blinkfunktionen auf den selbigen Taster legen konnte.


Edit: Ich merke grade, dass ich den original Sketch nicht mehr habe und ausversehen den "falschen" geposted habe. Ich hoffe aber dass du durch die obrige Erklärung mein Idee etwas besser verstehst.

[MicroBahner]

(15.01.2020 15:15)JaimyS schrieb:  Ich hoffe aber dass du durch die obrige Erklärung mein Idee etwas besser verstehst.

Ehrlich gesagt - nicht wirklich.

Wenn Du den Sketch, in dem das Problem auftritt garnicht mehr hast, ist es allerdings schwer zu helfen.
Wäre noch die Frage was ist bei dir 'kurz' und was ist 'lang'. Ist 'lang' kürzer als die 3x Blinken?

[JaimyS]

(15.01.2020 15:26)MicroBahner schrieb:  [quote='JaimyS' pid='66354' dateline='1579097724']
Ich hoffe aber dass du durch die obrige Erklärung mein Idee etwas besser verstehst.
[quote/]Ehrlich gesagt - nicht wirklich.
[quote/]
Prinzipiell wie hier:

Code:

void weisseLEDlang(){
  aktMillis2 = millis();

  altTaster2 = aktTaster2;
  if (aktMillis2 - prellMillis2 >= langerIntervall){
    prellMillis2 = aktMillis2;
    aktTaster2 = digitalRead(TasterLinks);
  }
  if (altTaster2 && !aktTaster2){
    if (ausgangStatus2){
      ausgangStatus2 = LOW;
      digitalWrite(LEDweiss, LOW);
    }
    else{
      ausgangMillis2 = aktMillis2;
      ausgangStatus2 = HIGH;
      digitalWrite(LEDweiss, HIGH);
    }
  }
}

void weisseLEDkurz(){
  aktMillis = millis();

  altTaster = aktTaster;
  if (aktMillis - prellMillis >= prellIntervall){
    prellMillis = aktMillis;
    aktTaster = digitalRead(TasterLinks);
  }
  if (altTaster && !aktTaster){
    if (ausgangStatus){
      ausgangStatus = LOW;
      digitalWrite(LEDweiss, LOW);
    }
    else{
      ausgangMillis = aktMillis;
      ausgangStatus = HIGH;
      digitalWrite(LEDweiss, HIGH);
    }
  }
  if (ausgangStatus && (aktMillis - ausgangMillis >= kurzerIntervall)){
    digitalWrite(LEDweiss, LOW);
    ausgangStatus = LOW;
  }
}

Nur halt BlinkerLEDlang unendlich lang blinkt und BlinkerLEDkurz 3x aufblinkt und sich dann ausschaltet.


[quote='MicroBahner' pid='66355' dateline='1579098391']
Wenn Du den Sketch, in dem das Problem auftritt garnicht mehr hast, ist es allerdings schwer zu helfen.
Wäre noch die Frage was ist bei dir 'kurz' und was ist 'lang'. Ist 'lang' kürzer als die 3x Blinken?

Lang Blinken wäre in dem Falle nach sag ich mal 1sek drücken würde die LED so lange blinken bis der Taster wieder gedrückt wird um diese auszuschalten. Kurz drücken wäre bis 0.5sek drücken und dann sollte die LED 3 mal aufblinken.

[MicroBahner]

Ok, hab' mal einen reduzierten Sketch geschrieben, der das für eine Led so macht.
In deinen Sketch einbauen musst Du das dann selbst.

Code:

const byte LEDrot = 3; //Farbe: rot
const byte TasterRechts = 9; //Taster für rot

enum ledStatus_t:byte { BLNK_AUS, BLNK_3, BLNK_AN };
ledStatus_t ledStatus;  // Status der Led ( aus, 3xblinken, dauerblinken )

byte tasterStatusR = HIGH;           //tasterStatusR LOW=gedrückt

const uint32_t prellIntervall = 10, blinkIntervall = 500, langerIntervall = 750;
uint32_t prellMillis, tasterMillis;

void blinkAusgabe(){
  static byte blnkCnt = 0;          // Zählt die Blinkintervall ( das UMschalten der Led )
  static uint32_t blinkMillis;
  
  switch ( ledStatus ) {
    case BLNK_AUS:                  // Status: die Led ist aus
      digitalWrite( LEDrot, LOW );
      blnkCnt = 0;
      break;
    case BLNK_AN:                   // Status Dauerblinken, der Blinkzäher wird immer wieder zu 0 gesetzt
      blnkCnt = 0;
    case BLNK_3:                    // Status 3x blinekn.
      if ( blnkCnt > 6 ) {          // Wenn Zähler 6 Umschaltvorgänge gezählt hat, wieder auf AUS
        ledStatus = BLNK_AUS;
      } else {
        if ( millis() - blinkMillis  > blinkIntervall ) {
          blinkMillis = millis();
          blnkCnt++;
          digitalWrite( LEDrot, !digitalRead( LEDrot ) );
        }
      }
      break;
    default:
      ;
  }  
}

void setup() {
  // Setup
    Serial.begin (9600);
    pinMode (LEDrot, OUTPUT);
    pinMode (TasterRechts, INPUT_PULLUP);
  }

void loop(){
  blinkAusgabe();
  if ( millis() - prellMillis  > prellIntervall ) {
    // Taster im Prell-Intervall abfragen
    prellMillis = millis();
    if ( digitalRead( TasterRechts ) != tasterStatusR ) {
      // Taste wurde gedrückt oder losgelassen
      tasterStatusR = digitalRead( TasterRechts );        // neuen Status merken
      tasterMillis = millis();
      if ( tasterStatusR == LOW ) {
        // Taste wurde gedrückt
        if ( ledStatus == BLNK_AUS ) {
          // derzeit Ruhezustand, einschalten auf 3x und Taster-Timer starten
          ledStatus = BLNK_3;
        } else {
          // die Led blinkt, ausschalten
          ledStatus = BLNK_AUS;
        }
      } else {
        // Loslassen des Tasters hat keine Bedeutung
      }
    } // Ende Tasterabfrage nach Ablauf der Prellzeit
    
    if ( tasterStatusR == LOW && millis() - tasterMillis > langerIntervall ) {
      // es wurde lang gedrückt -> auf Dauerblinken umschalten
      ledStatus = BLNK_AN;
    }
  }
}

Edit: hab' gerade entdeckt, dass da noch ein kleiner Fehler drin ist - aber den findest Du sicher selbst raus