STM32: LED 3 x blinken lassen ohne blocking Code zu verwenden

[Nick (Gast)]

Es geht darum, dass wenn man auf einen Button drückt, dann soll eine LED 
dreimal blinken.
Wenn man während dem Blinken erneut auf den Button drückt, dann muss die 
LED wieder 3x blinken.
Das ganze soll ohne blocking Code implementiert werden.

Wie man eine LED ohne blocking Code zum blinken bringt, habe ich bereits 
gefunden.
https://www.arduino.cc/en/Tutorial/BuiltInExamples/BlinkWithoutDelay

Die LED soll aber dreimal blinken. Jetzt könnte man eine Schleife 
verwenden, damit die LED 3x blinkt, aber dann hätte ich wieder implizit 
blocking Code drin.

Wie kann man das ohne blocking Code implementieren?

[Sozialarbeiter (Gast)]

Nick schrieb:
> Wie kann man das ohne blocking Code implementieren?

Ganz einfach keinen blocking Code verwenden.

[Peter D. (peda)]

Z.B. mit einem Scheduler:

Beitrag "Wartezeiten effektiv (Scheduler)"

[Sebastian W. (wangnick)]

Die einfachste Lösung ist eine Zustandsmaschine (state machine). Also 
sich einfach global merken, ob die LED gerade nicht blinkt, das erste 
Mal blinkt, das zweite Mal blinkt oder das dritte Mal blinkt. Und dann 
bei Ablauf der Wartezeit (millis() überprüfen wie in deinem Beispiel) 
die LED bedienen und den Zustand weiterschalten.

LG, Sebastian

[Thomas W. (goaty)]

Alles asynchron programmieren mit Statemachine.
Jegliches delay/wait/etc braucht man damit fast nie mehr.

Pseudocode:

enum State{
  INIT,
  ....
}

State currentState = INIT;

while(true) {
  

  switch(currentState){
    case INIT:
      if(someEvent or some time passed or..) { 
        currentState = LEDONSTATE
        SwitchLEDON  
        remember millis()
      }
    case LEDONSTATE:
      if(timePassed) {
        currentState = NEXTSTATE
        SwitchLEDOFF
      }
    
    case...
  }

}

(Mod: C-Tags eingefügt)

[Nick (Gast)]

Vielen Dank für eure bisherigen Antworten. Das hat mir weiter geholfen.
Eine Frage hätte ich noch. Wie realisiere ich den untenstehenden Punkt?

Wenn man während dem Blinken erneut auf den Button drückt, dann muss die
LED wieder von vorne 3x blinken.

[Thomas W. (goaty)]

...
if(buttonpressed) {
  currentState = INIT
  SwitchLEDOFF
}
...

[Nick (Gast)]

Wo soll überall die Überprüfung rein,ob der Button gedrückt wurde?
In jedem case?

[Thomas W. (goaty)]

Wie sagt der Meister: "Du sollst doch deinen Kopf benutzen".

Schau dir das Prinzip an, versuch es zu verstehen, dann kannst du es 
selbst optimal umsetzen. Nicht einfach abschreiben....

Zur Frage:
Ist dir überlassen, wo du den Event "Button Pressed" verarbeitest.
Entweder du sagst, nur in einem bestimmten Zustand (z.B. LEDONSTATE) 
wird der Button berücksichtigt, oder du machst es außerhalb des Switch, 
dann setzt du einfach den Zustand/State zurück.

Du kannst auch sehr schön mehrere Switch-Blöcke ineinander verschachteln 
um Sub-Statemachines zu machen.

(Das ist alles super-primitiv-Variante ich weiß)

[Sebastian W. (wangnick)]

Noch eine Anmerkung:

while(true) {

Bei Arduino-Code kann diese Schleife entfallen. Stattdessen würde der 
enthaltene Code innerhalb der loop()-Funktion landen ...

LG, Sebastian

[Guido K. (Firma: Code Mercenaries GmbH) (thebug)]

Das Tolle an so einer Statemachine: Sie hat immer einen definierten 
Zustand. Kommt ein externer Stimulus, der zu einer Zustandsänderung 
führen soll, dann kann man einfach in einen anderen Zusatnd springen.

Im Fall von "auf Knopfdruck von vorne blinken" halt in den Zustand, mit 
dem das Blinken beginnt.

Optimal ist es übrigens, wenn man so eine Statemachine im 
Systick-Interrupt laufen lässt, dann hat man immer eine Zeitreferenz und 
das Ding nimmt kaum Rechenzeit in Anspruch.

[A. S. (Gast)]

Nick schrieb:
> Wenn man während dem Blinken erneut auf den Button drückt, dann muss die
> LED wieder von vorne 3x blinken.

Das ist schlecht definiert.

Was genau soll passieren?

Das aktuelle blinken abbrechen?

Das aktuelle erst beenden?

Sagen wir Mal, du blinkt 1s an, 1s aus. Kurz vor Ende der ersten Sekunde 
erkennst Du einen Tastendruck. Soll dann insgesamt

A) 6x geblinkt werden
B) 4x geblinkt werden
C) 3x geblinkt werden mit 2s an beim ersten mal

[foobar (Gast)]

Sowas geht über einen regelmäßigen Timer-Interrupt sehr einfach (hier 
z.B. mit einem 100Hz Timer):

static volatile uint8_t button_led;
#define LED_MSK 0x10
#define LED_PORT PORTA

static void timer100hz(void)
{
   ...
   // button led blinking
   static uint8_t frac;
   if ((frac += 3) >= 100)  // 3Hz
   {
      frac -= 100;
      if (button_led & 1)
         LED_PORT |= LED_MASK;
      else
         LED_PORT &= ~LED_MASK;
      button_led >>= 1;
   }
   ...
}

  ...
  button_led = 0b10101;  // start/restart 3 blinks
  ...
  button_led = 0b101;  // start/restart 2 blinks
  ...
  button_led = 0b1111;  // start/restart long blink
  ...
  button_led = 0;   // turn off

[Thomas W. (goaty)]

Voll der overkill:

struct Button {
  Button(int p) : pin(p) {};
  enum {
    NOTPRESSED,
    PRESSED_,
    RELEASE_
  } state;

  void update() {
    unsigned now = millis();
    if (initialized) {
      bool s = digitalRead(pin);
      switch (state) {
        case NOTPRESSED:
          if (s == LOW) {
            state = PRESSED_;
            lastTime = now;
          }
          break;
        case PRESSED_:
          if (s == LOW && now - lastTime > 50) {
            state = RELEASE_;
            lastTime = now;
            Serial.println("Pressed");
          }
          else if (s == HIGH) state = NOTPRESSED;
          break;
        case RELEASE_:
          if (s == HIGH && now - lastTime > 50) {
            state = NOTPRESSED;
            event = true;
            Serial.println("Released");
          }
          break;  
      }
    }
    else {
      state = (digitalRead(pin) == LOW ? PRESSED_ : NOTPRESSED);
      initialized = true;
      Serial.println("Button Init");
    }
  }

  bool hasBeenPressed() {
    bool event_ = event;
    event = false;
    return event_;
  };

  int pin;
  bool initialized = false;
  unsigned lastTime = millis();

  bool event = false;
};
Button button(6);

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);

  pinMode(7, OUTPUT);
  digitalWrite(7, LOW);
  pinMode(6, INPUT_PULLUP);

  Serial.begin(9600);
}

enum State {
  INIT,
  IDLE_,
  BLINK
};
State state = INIT;

enum BlinkState {
  LEDON,
  WAIT,
  LEDOFF,
  WAIT2
};
BlinkState blinkState = LEDOFF;

int lastTime;
int blinkCount = 0;
void loop() {

  button.update();

  int now = millis();
  switch (state) {
    case INIT:
      lastTime = millis();
      Serial.println("Init");
      state = IDLE_;
      break;

    case IDLE_:
      if (button.hasBeenPressed()) {
        Serial.println("Blink !");
        state = BLINK;
        blinkCount = 0;
        blinkState = LEDON;
      }
      break;

    case BLINK:
      switch (blinkState) {
        case LEDON:
          Serial.println("ON");
          digitalWrite(LED_BUILTIN, HIGH);
          lastTime = millis();
          blinkState = WAIT;
          blinkCount++;
          break;
        case WAIT:
          if (now - lastTime > 1000) {
            blinkState = LEDOFF;
          }
          break;
        case LEDOFF:
          Serial.println("OFF");
          digitalWrite(LED_BUILTIN, LOW);
          lastTime = millis();
          if (blinkCount == 3) state = IDLE_;
          else blinkState = WAIT2;
          break;
        case WAIT2:
          if (now - lastTime > 1000) {
            blinkState = LEDON;
          }
          break;
      }

      // Retrigger if button pressed again
      if (button.hasBeenPressed()) {
        Serial.println("Retrigger");
        state = BLINK;
        blinkCount = 0;
        blinkState = LEDON;
      }
      
      break;
  }
}

[Stefan F. (Gast)]

Thomas W. schrieb:
> Voll der overkill:

Wieso overkill? Ich würde es vielleicht in mehre Prozeduren aufteilen, 
aber ansonsten gefällt mir der Code so. Er ist übersichtlich, 
nachvollziehbar und vor allem ausbaufähig.

[Uwe G. (scd)]

Immer wieder schön, wie hier Hausaufgaben gemacht werden.

[Thomas W. (goaty)]

Da hat Uwe natürlich recht, das hab ich nicht bedacht.
Vielleicht doch besser löschen ?

[W.S. (Gast)]

Nick schrieb:
> Wie kann man das ohne blocking Code implementieren?

#define tEvent  unsigned char
#define dword   unsigned long

extern void   Event_Init        (void);
extern bool   Event_avail       (void);
extern tEvent Get_Event         (void);
extern void   Add_Event         (tEvent aEvent);
extern bool   Add_Delayed_Event (dword millisec, tEvent aEvent);

extern void LED_einaus (bool ObLedEinschalten);

#define tBlink 0x10

main(..)
{ tEvent E; 
  int    Blink;
 ...
elleweil:
 // Knopf auslesen und ggf. Blinken beginnen
 if (KnopfNeuGedrueckt()) 
   { Add_Delayed_Event(100,tBlink); // Event nach 100 ms auslösen
     Blink = 5;  
   }

 if (Event_avail())
 { E = Get_Event();
   if (E==tBlink)
   { LED_einaus(E & 1);  // Bit 0 = Blinkbit
     E--;
     if (E) Add_Delayed_Event(300,tBlink);
   }

   ... hier ggf. anderweitige Events auswerten
 }
 ... hier ggf. anderes Zeugs erledigen
goto elleweil;

So, jetzt brauchst du bloß noch eine Systemuhr in deiner Firmware und 
eine kleine Event-Verwaltung. Sowas habe ich schon vor ewig hier mal 
gepostet.

W.S.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Übrigens: Solange man an der Priorität von Systick nichts verändert, 
nicht in ISRs aufrufen - they never come back...

[W.S. (Gast)]

Nachtrag: Mit E zu rechnen, ist falsch, dafür war Blink gedacht, hab's 
aber aus dem Stegreif geschrieben und verwechselt.

W.S.

[Moko (Gast)]

P.S. https://forum.arduino.cc/index.php?topic=725015.0