Blinker und Lichtsteuerung

SN_GOODLiFE · June 16, 2024, 8:28pm

Hallo Zusammen,

ich bin bei meiner kleinen Elektronikzentrale etwas weitergekommen, aber nun glaube ich, habe ich einen Hund reinbekommen.
Es klappt alles so einigermaßen, dass die linke und rechte Seite zueinander gesperrt ist und dass man auch mit einem beliebigen Taster den Modus wieder beenden kann.
Wo ich aber leider echt nicht weiterkomme ist das Thema mit der Warnblinkanlage, ich hätte gerne, dass wenn ich einen Taster gedrückt halte und dann den anderen drücke, dass dann eine Warnblinkfunktion mit synchronisierten LED´s ist.
Hat jemand von euch eine Idee, oder Verbesserung?
Und ja, bevor Leute kommen und sagen es ist gefährlich sowas selber zu programmieren, ja ist mir auch bewusst, aber ich will es halt versuchen.

Vielen Dank vorab.

Code

const int buttonPinlinks = 2;  // Pin, an dem der Taster angeschlossen ist
const int buttonPinrechts = 3;
const int ledPinlinks = 10;  // Pin, an dem die LED angeschlossen ist
const int ledPinrechts = 11;


const int LichtTaster = 4;
const int Fernlicht = A1;
const int Abblendlicht = A2;

unsigned long startTimelicht = 0;

unsigned long startTimelinks = 0;  // Zeitstempel für Tastendruck
unsigned long startTimerechts = 0;

unsigned long currentTimelicht =0;
unsigned long durationlicht = 0;

unsigned long currentTimelinks = 0;  // Zeitstempel für Tastendruck
unsigned long currentTimerechts = 0;
unsigned long durationlinks = 0;  // Gemessene Zeitdauer
unsigned long durationrechts = 0;


int currentStatelight = 0;

int currentStateTasterlinks = 0;  // Der aktuelle Zustand der TasterZustandsmaschine
int currentStateTasterrechts = 0;
int currentStateTasterlicht = 0;
int currentStateBlinkerlinks = 0;  // Der aktuelle Zustand der TasterZustandsmaschine
int currentStateBlinkerrechts = 0;
int currentStateLicht = 0;
int currentStateBlinkerArtlinks = 0;  // Der aktuelle Zustand der TasterZustandsmaschine
int currentStateBlinkerArtrechts = 0;
unsigned long actionStartTimelinks = 0;  // Zeitstempel für den Start der aktuellen Aktion
unsigned long actionStartTimerechts = 0;
unsigned long actionStartTimelicht = 0;
unsigned long blinkStartTimelinks = 0;  // Zeitstempel für den Start der aktuellen Aktion
unsigned long blinkStartTimerechts = 0;
const unsigned long overtakeDuration = 3500;       // Dauer des Überholblinkens (5 Sekunden)
const unsigned long turnDuration = 30000;          // Dauer des Abbiegeblinkens (30 Sekunden)
const unsigned long blinkTime = 800;               // Intervall des Blinkens
const unsigned long ZeitkurzerTastendruck = 300;   //Zeit für kurzen Tasterdruck = wenn unterhalb der Zeit
const unsigned long ZeitlangerTastendruck = 1200;
const unsigned long ZeitkurzerTastendrucklicht = 400;
const unsigned long ZeitlangerTastendrucklicht = 1200;  // Zeit ab "langerTastendruck"

void setup() {
  pinMode(buttonPinlinks, INPUT_PULLUP);  // Taster-Pin als Eingang mit Pull-Up-Widerstand
  pinMode(buttonPinrechts, INPUT_PULLUP);
  pinMode(LichtTaster, INPUT_PULLUP);
  pinMode(ledPinlinks, OUTPUT);  // LED-Pin als Ausgang
  pinMode(ledPinrechts, OUTPUT);
  pinMode(Fernlicht, OUTPUT);
  pinMode(Abblendlicht, OUTPUT);
  digitalWrite(Fernlicht, LOW);
  digitalWrite(Abblendlicht, LOW);
  digitalWrite(ledPinlinks, LOW);  // LED ausschalten
  digitalWrite(ledPinrechts, LOW);
  Serial.begin(115200);  // Serielle Kommunikation starten (zur Debugging-Zwecken)
}

void loop() {

////////////////////LICHTTASTER/////////////////////////////////

  int lightButtonState = digitalRead(LichtTaster);

currentTimelicht = millis();
  switch (currentStateTasterlicht) {
    case 0:                                                                                                                                                                                    // Warten auf Tastendruck
      if ((lightButtonState == LOW)) {  // Taster wurde gedrückt
        startTimelicht = currentTimelicht;                                                                                                                                                     // Aktuelle Zeit speichern
        actionStartTimelicht = currentTimelicht;
        currentStateTasterlicht = 1;  // Zustand wechseln
        Serial.println("Taster licht gedrückt");
      }
      break;
    case 1:                                                 // Warten auf Loslassen des Tasters
      if (lightButtonState == HIGH) {                       // Taster wurde losgelassen
        durationlicht = currentTimelicht - startTimelicht;  // Zeitdauer berechnen
        currentStateTasterlicht = 0;                        // Zustand wechseln
        Serial.print("Taster losgelassen, Zeitdauer: ");
        Serial.println(durationlicht);
      }
      break;
  }


  /////////////////////////////////////////////////////////////////////LINKER KNOPF //////////////////////////////////////////////////

  int buttonStatelinks = digitalRead(buttonPinlinks);
  currentTimelinks = millis();
  switch (currentStateTasterlinks) {
    case 0:                                                                                                                                                                                    // Warten auf Tastendruck
      if ((buttonStatelinks == LOW) && (currentStateBlinkerArtlinks == 0) != (currentStateBlinkerArtrechts == 3 || currentStateBlinkerArtrechts == 4 || currentStateBlinkerArtrechts == 2)) {  // Taster wurde gedrückt
        startTimelinks = currentTimelinks;                                                                                                                                                     // Aktuelle Zeit speichern
        actionStartTimelinks = currentTimelinks;
        currentStateTasterlinks = 1;  // Zustand wechseln
        Serial.println("Taster links gedrückt");
      }
      break;
    case 1:                                                 // Warten auf Loslassen des Tasters
      if (buttonStatelinks == HIGH) {                       // Taster wurde losgelassen
        durationlinks = currentTimelinks - startTimelinks;  // Zeitdauer berechnen
        currentStateTasterlinks = 0;                        // Zustand wechseln
        Serial.print("Taster losgelassen, Zeitdauer: ");
        Serial.println(durationlinks);
      }
      break;
  }

  //////////////////////////////////////////////////////////////////RECHTER KNOPF////////////////////////////////////////////////////

  int buttonStaterechts = digitalRead(buttonPinrechts);
  currentTimerechts = millis();
  switch (currentStateTasterrechts) {
    case 0:                                                                                                                                                                                   // Warten auf Tastendruck
      if ((buttonStaterechts == LOW) && (currentStateBlinkerArtrechts == 0) != (currentStateBlinkerArtlinks == 3 || currentStateBlinkerArtlinks == 4 || currentStateBlinkerArtlinks == 2)) {  // Taster wurde gedrückt
        startTimerechts = currentTimerechts;                                                                                                                                                  // Aktuelle Zeit speichern
        actionStartTimerechts = currentTimerechts;
        currentStateTasterrechts = 1;  // Zustand wechseln
        Serial.println("Taster rechts gedrückt");
      }
      break;
    case 1:                                                    // Warten auf Loslassen des Tasters
      if (buttonStaterechts == HIGH) {                         // Taster wurde losgelassen
        durationrechts = currentTimerechts - startTimerechts;  // Zeitdauer berechnen
        currentStateTasterrechts = 0;                          // Zustand wechseln
        Serial.print("Taster losgelassen, Zeitdauer: ");
        Serial.println(durationrechts);
      }
      break;
  }

  /////////////////////////////////////////////////////////////////////BLINKER LINKS//////////////////////////////////////////////

  switch (currentStateBlinkerlinks) {
    case 0:                                                                                                                                                                                    // Warten auf Tastendruck
      if ((buttonStatelinks == LOW) && (currentStateBlinkerArtlinks == 0) != (currentStateBlinkerArtrechts == 3 || currentStateBlinkerArtrechts == 4 || currentStateBlinkerArtrechts == 2)) {  // Taster wurde gedrückt
        blinkStartTimelinks = currentTimelinks;                                                                                                                                                // Aktuelle Zeit speichern
        digitalWrite(ledPinlinks, HIGH);                                                                                                                                                       // LED einschalten
        currentStateBlinkerlinks = 1;                                                                                                                                                          // Zustand wechseln
        Serial.println("Taster gedrückt, LED eingeschaltet");
      }
      break;
    case 1:  // Dauerhaftes Blinken ON
      if (currentTimelinks - blinkStartTimelinks > blinkTime) {
        digitalWrite(ledPinlinks, LOW);  // LED einschalten
        blinkStartTimelinks = currentTimelinks;
        currentStateBlinkerlinks = 2;  // Zustand wechseln
      }
    case 2:  // Dauerhaftes Blinken OFF
      if (currentTimelinks - blinkStartTimelinks > blinkTime) {
        digitalWrite(ledPinlinks, HIGH);  // LED einschalten
        blinkStartTimelinks = currentTimelinks;
        currentStateBlinkerlinks = 1;  // Zustand wechseln
      }
  }

  ////////////////////////////////////////////////////////////////BLINKER RECHTS///////////////////////////////////////


  switch (currentStateBlinkerrechts) {
    case 0:                                                                                                                                                                                   // Warten auf Tastendruck
      if ((buttonStaterechts == LOW) && (currentStateBlinkerArtrechts == 0) != (currentStateBlinkerArtlinks == 3 || currentStateBlinkerArtlinks == 4 || currentStateBlinkerArtlinks == 2)) {  // Taster wurde gedrückt
        blinkStartTimerechts = currentTimerechts;                                                                                                                                             // Aktuelle Zeit speichern
        digitalWrite(ledPinrechts, HIGH);                                                                                                                                                     // LED einschalten
        currentStateBlinkerrechts = 1;                                                                                                                                                        // Zustand wechseln
        Serial.println("Taster gedrückt, LED eingeschaltet");
      }
      break;
    case 1:  // Dauerhaftes Blinken ON
      if (currentTimerechts - blinkStartTimerechts > blinkTime) {
        digitalWrite(ledPinrechts, LOW);  // LED einschalten
        blinkStartTimerechts = currentTimerechts;
        currentStateBlinkerrechts = 2;  // Zustand wechseln
      }
    case 2:  // Dauerhaftes Blinken OFF
      if (currentTimerechts - blinkStartTimerechts > blinkTime) {
        digitalWrite(ledPinrechts, HIGH);  // LED einschalten
        blinkStartTimerechts = currentTimerechts;
        currentStateBlinkerrechts = 1;  // Zustand wechseln
      }
  }

  ///////////////////////////////////////////////////////////////////Blinker Links ////////////////////////

  switch (currentStateBlinkerArtlinks) {
    case 0:  // Warten auf loslassen des Tasters
      if (durationlinks > 0 && durationlinks < ZeitkurzerTastendruck) {
        // Aktion für Überholblinken
        currentStateBlinkerArtlinks = 2;  // Zustand wechseln
        Serial.println("Überholblinken gestartet");
      } if (durationlinks >= ZeitkurzerTastendruck && durationlinks < ZeitlangerTastendruck) {
        // Aktion für Abbiegeblinken
        currentStateBlinkerArtlinks = 3;  // Zustand wechseln
        Serial.println("Abbiegeblinken gestartet");
      } if (durationlinks >= ZeitlangerTastendruck) {
        // Aktion für dauerhaftes Blinken
        currentStateBlinkerArtlinks = 4;  // Zustand wechseln
        Serial.println("Dauerhaftes Blinken gestartet");
      }
      break;
    case 2:  // Überholblinkenlinks
      if (currentTimelinks - actionStartTimelinks >= overtakeDuration || buttonStaterechts == LOW || buttonStatelinks == LOW) {
        linksblinkenBeenden();
        Serial.println("Überholblinken beendet");
      }
      break;
    case 3:  // Abbiegeblinkenlinks
      if (currentTimelinks - actionStartTimelinks >= turnDuration || buttonStaterechts == LOW || buttonStatelinks == LOW) {
        // Aktion für Abbiegeblinkenlinks beenden
        linksblinkenBeenden();
        currentStateBlinkerArtlinks = 5;
        Serial.println("Abbiegeblinken beendet");
      }
      break;
    case 4:                                                                                                    // Warten auf Tastendruck
      if (buttonStatelinks == LOW != (currentStateBlinkerrechts == 1 && currentStateBlinkerArtrechts == 2)) {  // Taster wurde gedrückt
        linksblinkenBeenden();
        currentStateBlinkerArtlinks = 5;
        Serial.println("Dauerhaftes Blinken beendet");
      }
    case 5:                            // Warten auf Loslassen des Tasters
      if (buttonStatelinks == HIGH) {  // Taster wurde losgelassen
        currentStateBlinkerArtlinks = 0;
        Serial.println("Taster losgelassen");
      }
  }

  //////////////////////////////////////////////////////////Blinker rechts ///////////////////////////////

  switch (currentStateBlinkerArtrechts) {
    case 0:  // Warten auf loslassen des Tasters
      if (durationrechts > 0 && durationrechts < ZeitkurzerTastendruck) {
        // Aktion für Überholblinken
        currentStateBlinkerArtrechts = 2;  // Zustand wechseln
        Serial.println("Überholblinken Rechts gestartet");
      } if (durationrechts >= ZeitkurzerTastendruck && durationrechts < ZeitlangerTastendruck) {
        // Aktion für Abbiegeblinken
        currentStateBlinkerArtrechts = 3;  // Zustand wechseln
        Serial.println("Abbiegeblinken Rechts gestartet");
      } if (durationrechts >= ZeitlangerTastendruck) {
        // Aktion für dauerhaftes Blinken
        currentStateBlinkerArtrechts = 4;  // Zustand wechseln
        Serial.println("Dauerhaftes Blinken rechts gestartet");
      }
      break;
    case 2:  // Überholblinkenrechts
      if (buttonStatelinks == LOW && currentStateBlinkerArtrechts || buttonStaterechts == LOW && currentStateBlinkerArtrechts || currentTimerechts - actionStartTimerechts >= overtakeDuration) {
        rechtsblinkenBeenden();
        Serial.println("Überholblinken Rechts beendet");
      }
      break;
    case 3:  // Abbiegeblinkenrechts
      if (currentTimerechts - actionStartTimerechts >= turnDuration || buttonStaterechts == LOW || buttonStatelinks == LOW) {
        // Aktion für Abbiegeblinkenrechts beenden
        rechtsblinkenBeenden();
        currentStateBlinkerArtrechts = 5;
        Serial.println("Abbiegeblinken Rechts beendet");
      }
      break;
    case 4:                                                                                                   // Warten auf Tastendruck
      if (buttonStaterechts == LOW != (currentStateBlinkerlinks == 1 || currentStateBlinkerArtlinks == 2)) {  // Taster wurde gedrückt
        rechtsblinkenBeenden();
        currentStateBlinkerArtrechts = 5;
        Serial.println("Dauerhaftes Blinken Rechts beendet");
      }
    case 5:                             // Warten auf Loslassen des Tasters
      if (buttonStaterechts == HIGH) {  // Taster wurde losgelassen
        currentStateBlinkerArtrechts = 0;
        Serial.println("Taster losgelassen");
      }

 
  }


  switch (currentStatelight) {
    case 0:  // Licht aus
      if (lightButtonState == LOW) {  // Licht-Taster wurde gedrückt
        startTimelicht = currentTimelicht;   // Aktuelle Zeit speichern
        currentStatelight = 1;    // Zustand wechseln
        Serial.println("Licht-Taster gedrückt");
      }
      break;
    case 1:  // Licht ein (kurzer Tastendruck)
      if (lightButtonState == HIGH) { // Licht-Taster wurde losgelassen
        durationlicht = currentTimelicht - startTimelicht;  // Zeitdauer berechnen
        if (durationlicht < ZeitkurzerTastendrucklicht) {
          if (digitalRead(Abblendlicht) == LOW) {  // Abblendlicht ist aus
            digitalWrite(Abblendlicht, HIGH);  // Abblendlicht einschalten
            Serial.println("Abblendlicht eingeschaltet");
          } else if (digitalRead(Fernlicht) == LOW) {  // Fernlicht ist aus
            digitalWrite(Fernlicht, HIGH);  // Fernlicht einschalten
            Serial.println("Fernlicht eingeschaltet");
          } else {  // Fernlicht ist an
            digitalWrite(Fernlicht, LOW);  // Fernlicht ausschalten
            Serial.println("Fernlicht ausgeschaltet");
          }
        } else if (durationlicht >= ZeitlangerTastendrucklicht) {
          digitalWrite(Abblendlicht, LOW);  // Abblendlicht ausschalten
          digitalWrite(Fernlicht, LOW); // Fernlicht ausschalten
          Serial.println("Abblendlicht und Fernlicht ausgeschaltet");
        }
        currentStatelight = 0;  // Zustand wechseln
      }
      break;
  }
}



void linksblinkenBeenden() {
  digitalWrite(ledPinlinks, LOW);   // LED ausschalten
  currentStateBlinkerArtlinks = 0;  // Zurück zum Anfangszustand
  currentStateBlinkerlinks = 0;
  durationlinks = 0;
}
void rechtsblinkenBeenden() {
  digitalWrite(ledPinrechts, LOW);   // LED ausschalten
  currentStateBlinkerArtrechts = 0;  // Zurück zum Anfangszustand
  currentStateBlinkerrechts = 0;
  durationrechts = 0;
}

kolaha · June 16, 2024, 8:52pm

höre zum ersten Mal.

kolaha · June 16, 2024, 9:27pm

was heißt das?

welchen Modus?

wozu brauchst du (Licht)Zeitdauer berechnen ?

kolaha · June 16, 2024, 11:21pm

const int buttonPinlinks = 2;  // Pin, an dem der Taster angeschlossen ist
const int buttonPinrechts = 3;
const int ledPinlinks = 10;  // Pin, an dem die LED angeschlossen ist
const int ledPinrechts = 11;


const int LichtTaster = 4;
const int Fernlicht = A1;
const int Abblendlicht = A2;

unsigned long startTimelicht = 0;

unsigned long startTimelinks = 0;  // Zeitstempel für Tastendruck
unsigned long startTimerechts = 0;

unsigned long currentTimelicht =0;
unsigned long durationlicht = 0;

unsigned long currentTimelinks = 0;  // Zeitstempel für Tastendruck
unsigned long currentTimerechts = 0;
unsigned long durationlinks = 0;  // Gemessene Zeitdauer
unsigned long durationrechts = 0;


int currentStatelight = 0;

int currentStateTasterlinks = 0;  // Der aktuelle Zustand der TasterZustandsmaschine
int currentStateTasterrechts = 0;
int currentStateTasterlicht = 0;
int currentStateBlinkerlinks = 0;  // Der aktuelle Zustand der TasterZustandsmaschine
int currentStateBlinkerrechts = 0;
int currentStateLicht = 0;
int currentStateBlinkerArtlinks = 0;  // Der aktuelle Zustand der TasterZustandsmaschine
int currentStateBlinkerArtrechts = 0;
unsigned long actionStartTimelinks = 0;  // Zeitstempel für den Start der aktuellen Aktion
unsigned long actionStartTimerechts = 0;
unsigned long actionStartTimelicht = 0;
unsigned long blinkStartTimelinks = 0;  // Zeitstempel für den Start der aktuellen Aktion
unsigned long blinkStartTimerechts = 0;
const unsigned long overtakeDuration = 3500;       // Dauer des Überholblinkens (5 Sekunden)
const unsigned long turnDuration = 30000;          // Dauer des Abbiegeblinkens (30 Sekunden)
const unsigned long blinkTime = 800;               // Intervall des Blinkens
const unsigned long ZeitkurzerTastendruck = 300;   //Zeit für kurzen Tasterdruck = wenn unterhalb der Zeit
const unsigned long ZeitlangerTastendruck = 1200;
const unsigned long ZeitkurzerTastendrucklicht = 400;
const unsigned long ZeitlangerTastendrucklicht = 1200;  // Zeit ab "langerTastendruck"

void setup() {
  pinMode(buttonPinlinks, INPUT_PULLUP);  // Taster-Pin als Eingang mit Pull-Up-Widerstand
  pinMode(buttonPinrechts, INPUT_PULLUP);
  pinMode(LichtTaster, INPUT_PULLUP);
  pinMode(ledPinlinks, OUTPUT);  // LED-Pin als Ausgang
  pinMode(ledPinrechts, OUTPUT);
  pinMode(Fernlicht, OUTPUT);
  pinMode(Abblendlicht, OUTPUT);
  digitalWrite(Fernlicht, LOW);
  digitalWrite(Abblendlicht, LOW);
  digitalWrite(ledPinlinks, LOW);  // LED ausschalten
  digitalWrite(ledPinrechts, LOW);
  Serial.begin(115200);  // Serielle Kommunikation starten (zur Debugging-Zwecken)
}

void Warnblinker(){
  currentStateBlinkerlinks=!currentStateBlinkerlinks;
  currentStateBlinkerrechts=currentStateBlinkerlinks;
}

void loop() {

////////////////////LICHTTASTER/////////////////////////////////

  int lightButtonState = digitalRead(LichtTaster);

currentTimelicht = millis();
  switch (currentStateTasterlicht) {
    case 0:                                                                                                                                                                                    // Warten auf Tastendruck
      if ((lightButtonState == LOW)) {  // Taster wurde gedrückt
        startTimelicht = currentTimelicht;                                                                                                                                                     // Aktuelle Zeit speichern
        actionStartTimelicht = currentTimelicht;
        currentStateTasterlicht = 1;  // Zustand wechseln
        Serial.println("Taster licht gedrückt");
      }
      break;
    case 1:                                                 // Warten auf Loslassen des Tasters
      if (lightButtonState == HIGH) {                       // Taster wurde losgelassen
        durationlicht = currentTimelicht - startTimelicht;  // Zeitdauer berechnen
        currentStateTasterlicht = 0;                        // Zustand wechseln
        Serial.print("Taster losgelassen, Zeitdauer: ");
        Serial.println(durationlicht);
      }
      break;
  }


  /////////////////////////////////////////////////////////////////////LINKER KNOPF //////////////////////////////////////////////////

  int buttonStatelinks = digitalRead(buttonPinlinks);
  currentTimelinks = millis();
  switch (currentStateTasterlinks) {
    case 0:                                                                                                                                                                                    // Warten auf Tastendruck
      if ((buttonStatelinks == LOW) && (currentStateBlinkerArtlinks == 0) != (currentStateBlinkerArtrechts == 3 || currentStateBlinkerArtrechts == 4 || currentStateBlinkerArtrechts == 2)) {  // Taster wurde gedrückt
        startTimelinks = currentTimelinks;                                                                                                                                                     // Aktuelle Zeit speichern
        actionStartTimelinks = currentTimelinks;
        currentStateTasterlinks = 1;  // Zustand wechseln
        Serial.println("Taster links gedrückt");
      }
      break;
    case 1:                                                 // Warten auf Loslassen des Tasters
      if (buttonStatelinks == HIGH) {                       // Taster wurde losgelassen
        durationlinks = currentTimelinks - startTimelinks;  // Zeitdauer berechnen
        currentStateTasterlinks = 0;                        // Zustand wechseln
        Serial.print("Taster losgelassen, Zeitdauer: ");
        Serial.println(durationlinks);
      }
      else if(!digitalRead(buttonPinrechts))Warnblinker();
      break;
  }

  //////////////////////////////////////////////////////////////////RECHTER KNOPF////////////////////////////////////////////////////

  int buttonStaterechts = digitalRead(buttonPinrechts);
  currentTimerechts = millis();
  switch (currentStateTasterrechts) {
    case 0:                                                                                                                                                                                   // Warten auf Tastendruck
      if ((buttonStaterechts == LOW) && (currentStateBlinkerArtrechts == 0) != (currentStateBlinkerArtlinks == 3 || currentStateBlinkerArtlinks == 4 || currentStateBlinkerArtlinks == 2)) {  // Taster wurde gedrückt
        startTimerechts = currentTimerechts;                                                                                                                                                  // Aktuelle Zeit speichern
        actionStartTimerechts = currentTimerechts;
        currentStateTasterrechts = 1;  // Zustand wechseln
        Serial.println("Taster rechts gedrückt");
      }
      break;
    case 1:                                                    // Warten auf Loslassen des Tasters
      if (buttonStaterechts == HIGH) {                         // Taster wurde losgelassen
        durationrechts = currentTimerechts - startTimerechts;  // Zeitdauer berechnen
        currentStateTasterrechts = 0;                          // Zustand wechseln
        Serial.print("Taster losgelassen, Zeitdauer: ");
        Serial.println(durationrechts);
      }
      
      else if(!digitalRead(buttonPinlinks))Warnblinker();
      break;
  }

  /////////////////////////////////////////////////////////////////////BLINKER LINKS//////////////////////////////////////////////

  switch (currentStateBlinkerlinks) {
    case 0:                                                                                                                                                                                    // Warten auf Tastendruck
      if ((buttonStatelinks == LOW) && (currentStateBlinkerArtlinks == 0) != (currentStateBlinkerArtrechts == 3 || currentStateBlinkerArtrechts == 4 || currentStateBlinkerArtrechts == 2)) {  // Taster wurde gedrückt
        blinkStartTimelinks = currentTimelinks;                                                                                                                                                // Aktuelle Zeit speichern
        digitalWrite(ledPinlinks, HIGH);                                                                                                                                                       // LED einschalten
        currentStateBlinkerlinks = 1;                                                                                                                                                          // Zustand wechseln
        Serial.println("Taster gedrückt, LED eingeschaltet");
      }
      break;
    case 1:  // Dauerhaftes Blinken ON
      if (currentTimelinks - blinkStartTimelinks > blinkTime) {
        digitalWrite(ledPinlinks, LOW);  // LED einschalten
        blinkStartTimelinks = currentTimelinks;
        currentStateBlinkerlinks = 2;  // Zustand wechseln
      }
    case 2:  // Dauerhaftes Blinken OFF
      if (currentTimelinks - blinkStartTimelinks > blinkTime) {
        digitalWrite(ledPinlinks, HIGH);  // LED einschalten
        blinkStartTimelinks = currentTimelinks;
        currentStateBlinkerlinks = 1;  // Zustand wechseln
      }
  }

  ////////////////////////////////////////////////////////////////BLINKER RECHTS///////////////////////////////////////


  switch (currentStateBlinkerrechts) {
    case 0:                                                                                                                                                                                   // Warten auf Tastendruck
      if ((buttonStaterechts == LOW) && (currentStateBlinkerArtrechts == 0) != (currentStateBlinkerArtlinks == 3 || currentStateBlinkerArtlinks == 4 || currentStateBlinkerArtlinks == 2)) {  // Taster wurde gedrückt
        blinkStartTimerechts = currentTimerechts;                                                                                                                                             // Aktuelle Zeit speichern
        digitalWrite(ledPinrechts, HIGH);                                                                                                                                                     // LED einschalten
        currentStateBlinkerrechts = 1;                                                                                                                                                        // Zustand wechseln
        Serial.println("Taster gedrückt, LED eingeschaltet");
      }
      break;
    case 1:  // Dauerhaftes Blinken ON
      if (currentTimerechts - blinkStartTimerechts > blinkTime) {
        digitalWrite(ledPinrechts, LOW);  // LED einschalten
        blinkStartTimerechts = currentTimerechts;
        currentStateBlinkerrechts = 2;  // Zustand wechseln
      }
    case 2:  // Dauerhaftes Blinken OFF
      if (currentTimerechts - blinkStartTimerechts > blinkTime) {
        digitalWrite(ledPinrechts, HIGH);  // LED einschalten
        blinkStartTimerechts = currentTimerechts;
        currentStateBlinkerrechts = 1;  // Zustand wechseln
      }
  }

  ///////////////////////////////////////////////////////////////////Blinker Links ////////////////////////

  switch (currentStateBlinkerArtlinks) {
    case 0:  // Warten auf loslassen des Tasters
      if (durationlinks > 0 && durationlinks < ZeitkurzerTastendruck) {
        // Aktion für Überholblinken
        currentStateBlinkerArtlinks = 2;  // Zustand wechseln
        Serial.println("Überholblinken gestartet");
      } if (durationlinks >= ZeitkurzerTastendruck && durationlinks < ZeitlangerTastendruck) {
        // Aktion für Abbiegeblinken
        currentStateBlinkerArtlinks = 3;  // Zustand wechseln
        Serial.println("Abbiegeblinken gestartet");
      } if (durationlinks >= ZeitlangerTastendruck) {
        // Aktion für dauerhaftes Blinken
        currentStateBlinkerArtlinks = 4;  // Zustand wechseln
        Serial.println("Dauerhaftes Blinken gestartet");
      }
      break;
    case 2:  // Überholblinkenlinks
      if (currentTimelinks - actionStartTimelinks >= overtakeDuration || buttonStaterechts == LOW || buttonStatelinks == LOW) {
        linksblinkenBeenden();
        Serial.println("Überholblinken beendet");
      }
      break;
    case 3:  // Abbiegeblinkenlinks
      if (currentTimelinks - actionStartTimelinks >= turnDuration || buttonStaterechts == LOW || buttonStatelinks == LOW) {
        // Aktion für Abbiegeblinkenlinks beenden
        linksblinkenBeenden();
        currentStateBlinkerArtlinks = 5;
        Serial.println("Abbiegeblinken beendet");
      }
      break;
    case 4:                                                                                                    // Warten auf Tastendruck
      if (buttonStatelinks == LOW != (currentStateBlinkerrechts == 1 && currentStateBlinkerArtrechts == 2)) {  // Taster wurde gedrückt
        linksblinkenBeenden();
        currentStateBlinkerArtlinks = 5;
        Serial.println("Dauerhaftes Blinken beendet");
      }
    case 5:                            // Warten auf Loslassen des Tasters
      if (buttonStatelinks == HIGH) {  // Taster wurde losgelassen
        currentStateBlinkerArtlinks = 0;
        Serial.println("Taster losgelassen");
      }
  }

  //////////////////////////////////////////////////////////Blinker rechts ///////////////////////////////

  switch (currentStateBlinkerArtrechts) {
    case 0:  // Warten auf loslassen des Tasters
      if (durationrechts > 0 && durationrechts < ZeitkurzerTastendruck) {
        // Aktion für Überholblinken
        currentStateBlinkerArtrechts = 2;  // Zustand wechseln
        Serial.println("Überholblinken Rechts gestartet");
      } if (durationrechts >= ZeitkurzerTastendruck && durationrechts < ZeitlangerTastendruck) {
        // Aktion für Abbiegeblinken
        currentStateBlinkerArtrechts = 3;  // Zustand wechseln
        Serial.println("Abbiegeblinken Rechts gestartet");
      } if (durationrechts >= ZeitlangerTastendruck) {
        // Aktion für dauerhaftes Blinken
        currentStateBlinkerArtrechts = 4;  // Zustand wechseln
        Serial.println("Dauerhaftes Blinken rechts gestartet");
      }
      break;
    case 2:  // Überholblinkenrechts
      if (buttonStatelinks == LOW && currentStateBlinkerArtrechts || buttonStaterechts == LOW && currentStateBlinkerArtrechts || currentTimerechts - actionStartTimerechts >= overtakeDuration) {
        rechtsblinkenBeenden();
        Serial.println("Überholblinken Rechts beendet");
      }
      break;
    case 3:  // Abbiegeblinkenrechts
      if (currentTimerechts - actionStartTimerechts >= turnDuration || buttonStaterechts == LOW || buttonStatelinks == LOW) {
        // Aktion für Abbiegeblinkenrechts beenden
        rechtsblinkenBeenden();
        currentStateBlinkerArtrechts = 5;
        Serial.println("Abbiegeblinken Rechts beendet");
      }
      break;
    case 4:                                                                                                   // Warten auf Tastendruck
      if (buttonStaterechts == LOW != (currentStateBlinkerlinks == 1 || currentStateBlinkerArtlinks == 2)) {  // Taster wurde gedrückt
        rechtsblinkenBeenden();
        currentStateBlinkerArtrechts = 5;
        Serial.println("Dauerhaftes Blinken Rechts beendet");
      }
    case 5:                             // Warten auf Loslassen des Tasters
      if (buttonStaterechts == HIGH) {  // Taster wurde losgelassen
        currentStateBlinkerArtrechts = 0;
        Serial.println("Taster losgelassen");
      }

 
  }


  switch (currentStatelight) {
    case 0:  // Licht aus
      if (lightButtonState == LOW) {  // Licht-Taster wurde gedrückt
        startTimelicht = currentTimelicht;   // Aktuelle Zeit speichern
        currentStatelight = 1;    // Zustand wechseln
        Serial.println("Licht-Taster gedrückt");
      }
      break;
    case 1:  // Licht ein (kurzer Tastendruck)
      if (lightButtonState == HIGH) { // Licht-Taster wurde losgelassen
        durationlicht = currentTimelicht - startTimelicht;  // Zeitdauer berechnen
        if (durationlicht < ZeitkurzerTastendrucklicht) {
          if (digitalRead(Abblendlicht) == LOW) {  // Abblendlicht ist aus
            digitalWrite(Abblendlicht, HIGH);  // Abblendlicht einschalten
            Serial.println("Abblendlicht eingeschaltet");
          } else if (digitalRead(Fernlicht) == LOW) {  // Fernlicht ist aus
            digitalWrite(Fernlicht, HIGH);  // Fernlicht einschalten
            Serial.println("Fernlicht eingeschaltet");
          } else {  // Fernlicht ist an
            digitalWrite(Fernlicht, LOW);  // Fernlicht ausschalten
            Serial.println("Fernlicht ausgeschaltet");
          }
        } else if (durationlicht >= ZeitlangerTastendrucklicht) {
          digitalWrite(Abblendlicht, LOW);  // Abblendlicht ausschalten
          digitalWrite(Fernlicht, LOW); // Fernlicht ausschalten
          Serial.println("Abblendlicht und Fernlicht ausgeschaltet");
        }
        currentStatelight = 0;  // Zustand wechseln
      }
      break;
  }
}

void linksblinkenBeenden() {
  digitalWrite(ledPinlinks, LOW);   // LED ausschalten
  currentStateBlinkerArtlinks = 0;  // Zurück zum Anfangszustand
  currentStateBlinkerlinks = 0;
  durationlinks = 0;
}
void rechtsblinkenBeenden() {
  digitalWrite(ledPinrechts, LOW);   // LED ausschalten
  currentStateBlinkerArtrechts = 0;  // Zurück zum Anfangszustand
  currentStateBlinkerrechts = 0;
  durationrechts = 0;
}

uwefed · June 17, 2024, 2:20pm

Hängt immer von der Definition von gefährlich ab. Wenn es nicht gefährlich ist, daß eine Versicherung nicht zahlt auch wenn man nicht schuld hat, und man selbst zahlen muß, dann ist es nicht gefährlich.

Erlaube mir aber daß mir meine Haut wichtig ist und ich nicht beitrage.

Grüße Uwe

SN_GOODLiFE · June 17, 2024, 2:42pm

Das ist für mich vollkommen in Ordnung, dass du diese Meinung vertrittst, die Frage ist nur, wenn ich einfach reingeschrieben hätte ich habe 4 LED und 3 Taster und dann meine Frage, wäre es das gleiche gewesen, aber ich will das nicht für den Straßenverkehr machen, sondern für ein Custombike für Shows und da gibt es keinen TÜV, aber wie gesagt, verstehe deine Meinung zu 100%.

my_xy_projekt · June 17, 2024, 4:30pm

Ich glaube Du hast da viel zu viel drumrum gebaut.
Gib mal in Worten wieder, was da passieren soll.

Und erkläre:

Hat der Blinker eine "Tipp"Funktion?
Wie willst Du den Warnblinker auslösen?

kolaha · June 17, 2024, 5:29pm

wenn du akzeptierst Pin 11 auf 9 verlegen so könnte man PWM Frequenz so einstellen dass sie ungefähr 800ms Periode hat. Ein Pin wird dann linker Blinker, andere Pin den nicht linker. so fällt die Notwendigkeit ab es hin und her schalten, einfach digitalWrite(links, LOW) zum dauerhaft aus schalten (analogWrite(links,0) für aus geht auch) und analogWrite(links,127) für unendlich blinken .

    bitSet(DDRB, 1) ; // Set digital pin 9 (PB1) to an output ;
    bitSet(DDRB, 2) ; // Set digital pin 10 (PB2) to an output ;
    TCCR1A = _BV(COM1A1) | _BV(WGM11); // Enable the PWM output OC1A on digital pins 9/10
    TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS12); // Set fast PWM and prescaler of 256 on timer 1
    ICR1 = 62499; // Set the PWM frequency to 1Hz: 16MHz/(256 * 1Hz) - 1 = 62499
    OCR1A = 625; // Set the duty-cycle to 10%: 62499 / 10 = 6249

wwerner · June 17, 2024, 5:33pm

currentStateBlinkerArtrechts == 3

Vermeide magische Nummern. Was ist 3? Vergebe mit enum den Zuständen Werte, die für sich selbst sprechen.

digitalWrite(ledPinlinks, LOW); // LED einschalten
digitalWrite(ledPinlinks, HIGH); // LED einschalten

Was den jetzt?

SN_GOODLiFE · June 17, 2024, 8:21pm

Also Plan ist folgender:

Es sollen Taster benutzt werden und je nachdem wie lange dieser Tastendruck dauert soll eine Aktion ausgelöst werden also z.B.
Überholblinken ist Taster drücken unter 300ms dann blinkt der Blinker 4 mal und soll ausgehen. Abbiegeblinken soll aktiviert werden, wenn der Taster zwischen 300 und 1200ms gehalten wird und wird der Taster über diese 1200ms gehalten, dann blinkt er dauerhaft.
Es soll mit erneutem Tastendruck jeder Modus sofort beendet werden können, auch wenn links blinkt soll der rechte Taster das beenden können. Die Modi zueinander soll „gesperrt“ werden, was so viel bedeutet das die LED nicht gleichzeitig blinken können.
Der Modus Warnblinker soll aktiviert werden, wenn ich den Linken oder rechten Taster halte z.B größer gleich 1200ms und zusätzlich den jeweils anderen Taster antippe, sollen die Beiden LEDs im gleichen Takt zusammen leuchten. Beenden dann wieder über linken oder rechten Taster.
So der Plan

SN_GOODLiFE · June 17, 2024, 8:23pm

Ich bin aktuell nicht zuhause, aber ich werde das mal testen, vielen Dank.

my_xy_projekt · June 19, 2024, 3:48pm

Sowas hatte ich doch schon mal in ähnlicher Form...
Nur nicht mit dem langen und kombinierten Tastendruck.

ABER: Ich überleg mir was.
Das ist nicht so schwer, wenn man das irgendwie in einen Ablaufplan bekommt.

PS: Nein, Du darfst die Funktionen nicht gegenseitig sperren, dann würde das umschalten nicht funktionieren. Das was Du meinst, ist das aufheben einer Funktion, wenn eine andere ausgelöst wird.
Da bin ich mir sehr sicher.

SN_GOODLiFE · June 21, 2024, 6:19pm

Da hast du absolut Recht, es soll die Funktion nur beenden, nicht sperren

my_xy_projekt · June 22, 2024, 5:16pm

So, ich hab mal nachgedacht.
Das was Du willst, geht nicht.
Die lange Erklärung:

Du drückst den Blinker-Links-Taster (BLT).
Wenn Du den sehr früh wieder loslässt, soll das blinken kurz laufen.
Wenn Du den lange drückst, soll es auch lange blinken.

Während des kurzen blinken auf der rechten Seite die Taste (BRT) gedrückt, wechselt die Blinkrichtung.
Soweit so gut.
Hast Du den Taster lange gedrückt und wieder losgelassen, passiert beim drücken BRT genau das selbe.

Du willst aber zusätzlich noch das Warnblinklicht WBL mit dieser Funktion auslösen.
Dazu sagst Du Dir BLT gedrückt gehalten und BRT auslösen, macht Warnblinklicht.

Das geht nur, wenn beim auslösen von BLT der linke Blinker nicht blinkt.
Und das ginge nur, wenn der Blinker beginnt zu blinken, wenn Du die Taste loslässt.
Das ist aber falsch und führt auch die Logik ad absurdum.
Denn wenn Du BLT loslässt muss der Blinker bereits blinken.
Damit ist aber immer bereits der Blinker an, welcher auf einer Seite ausgelöst ist und erst dann kannst Du (bei weiterhin gedrückter Taste) das Warnblinklicht auslösen.

Wenn das so gewollt ist, ginge das. Aber es ist "ungewöhnlich" und macht es für spätere Erweiterungen ungleich aufwendig, wenn an der Logik was geändert werden muss.

Überleg Dir, ob Du für das Warnblinklicht nicht eine zusätzliche Taste nutzen kannst.
Das würde vieles vereinfachen, da es keine Abhängigkeiten, sondern nur Vorrang gibt.

SN_GOODLiFE · June 22, 2024, 5:33pm

Vielen Dank für die Rückmeldung. Wäre es möglich, wenn man einen Knopf z.B. 3 mal schnell hintereinander drückt das man WB aktiviert?

my_xy_projekt · June 22, 2024, 5:35pm

Das ginge, hat aber den selben Effekt wie wenn Du eine Taste gedrückt hälst und dann die andere Taste auslöst.

Mit dem auslösen der ersten Taste muss der Blinker der entsprechenden Seite anfangen zu blinken.

SN_GOODLiFE · June 22, 2024, 5:51pm

Ach ja stimmt. Hm das ist echt blöd.

my_xy_projekt · June 22, 2024, 6:05pm

Wenn Du keinen anderen Taster / Auslöser hast, müsste ich mal drüber nachdenken. Aber egal was es dann wird, es wird eine sehr spezielle Konfiguration....

noiasca · June 23, 2024, 9:19am

imho WB ohne einer dedizierten WB Taste ist ein NoGo.

Wie schauts aus - kannst dir vorstellen den WB mit "gleichzeitigem" Druck auf links und rechts auszulösen oder geht das mechanisch nicht?

SN_GOODLiFE · June 23, 2024, 9:46am

Doch, das wäre kein Thema, nur wie mach ich das?

Topic		Replies	Views
Push Button LED Blinken Deutsch	11	3004	May 6, 2021
Soweit, so gut.. Deutsch	43	2879	May 6, 2021
Tastenbetätigungen während einer bestimmten Zeit auslesen, LED Blinken Deutsch	21	1092	February 17, 2023
Lösung für das Problem in meinem Code Deutsch	40	402	June 10, 2024
2 LED´s mit 2 Tastern wie schaffe ich es einen aktion zu beenden Deutsch	11	2820	May 6, 2021

Blinker und Lichtsteuerung

Related Topics