Ein Taster - LED-Lauflicht starten/stoppen

[Georg (Gast)]

Hallo zusammen,

ich hänge an einem kleinen Lauflichtproblem mit dem Arduino Uno.

Ich möchte mittels eines Tasters das Lauflicht (5 LEDs) starten und mit 
einem erneuten Druck auf den Taster wieder stoppen. Und das Ganze immer 
wiederkehrend.
Dazu habe ich auf die Delay() verzichtet, da ja in der Zeit der delay 
"nichts als nur gewartet" wird, ich aber ja jederzeit einen Tastendruck 
abfangen muss.

Problem:
1) Nachdem ich auf den Taster drücke, leuchtet stetig nur LED-0. Es 
entsteht also kein Lauflicht.
2) Bei erneutem Druck auf den Taster passiert nichts.

Wo liegt mein Denkfehler? Es wird mit den ganzen logischen Operationen 
mittlerweile etwas unübersichtlich, ich vermute, irgendwo da wird der 
Wurm drin sein.

Hier der Code:

const int LED_Pins[5] = {8,9,10,11,12};
const int Button_Pin = 7;

unsigned long Start_Millis = 0;
unsigned long Current_Millis = 0;
int Blinkwartezeit = 1000;
int Button_Druckzaehler = 0;

void setup()
{
   pinMode(Button_Pin, INPUT_PULLUP);               // Button an Pin 7, als Eingang (Pullups) schalten

   pinMode(LED_Pins[0], OUTPUT);              // LEDs an den Pins 8-12 als Ausgang schalten
   pinMode(LED_Pins[1], OUTPUT);
   pinMode(LED_Pins[2], OUTPUT);
   pinMode(LED_Pins[3], OUTPUT);
   pinMode(LED_Pins[4], OUTPUT);

   Start_Millis = millis();
}


void loop()
{
  Current_Millis = millis();

   if((digitalRead(Button_Pin) == LOW) || ((Button_Druckzaehler == 0) || (Button_Druckzaehler == 1)))        // wenn Button zum Einschalten gedrückt und voher zum Einschalten noch nicht gedrückt wurde
   {
     Button_Druckzaehler = 1;                  // ... setue Zähler des Tastendrucks auf 1
    
         if((Current_Millis - Start_Millis) >= Blinkwartezeit)
         {
           digitalWrite(LED_Pins[4], LOW);
           digitalWrite(LED_Pins[0], HIGH);
           Start_Millis = Current_Millis;
         } 

         if(((Current_Millis - Start_Millis) >= (Blinkwartezeit + 1000)))   
         {
           digitalWrite(LED_Pins[0], LOW);
           digitalWrite(LED_Pins[1], HIGH);
           Start_Millis = Current_Millis;
         }

         if(((Current_Millis - Start_Millis) >= (Blinkwartezeit + 2000))) 
         {
           digitalWrite(LED_Pins[1], LOW);
           digitalWrite(LED_Pins[2], HIGH);
           Start_Millis = Current_Millis;
         }
     
         if(((Current_Millis - Start_Millis) >= (Blinkwartezeit + 3000)))
         {
           digitalWrite(LED_Pins[2], LOW);
           digitalWrite(LED_Pins[3], HIGH);
           Start_Millis = Current_Millis;
         }

         if(((Current_Millis - Start_Millis) >= (Blinkwartezeit + 4000)))
         {
           digitalWrite(LED_Pins[3], LOW);
           digitalWrite(LED_Pins[4], HIGH);
           Start_Millis = Current_Millis;
         }
        
         if((digitalRead(Button_Pin) == LOW) && (Button_Druckzaehler == 1))
         {
           Button_Druckzaehler = 2;
           digitalWrite(LED_Pins[0], LOW);
           digitalWrite(LED_Pins[1], LOW);
           digitalWrite(LED_Pins[2], LOW);
           digitalWrite(LED_Pins[3], LOW);
           digitalWrite(LED_Pins[4], LOW);
           Start_Millis = Current_Millis;
         }   
     
         if((digitalRead(Button_Pin) == LOW) && Button_Druckzaehler == 2)
         {
           Button_Druckzaehler = 1;
         }
         
  }
}

Vielleicht könnt ihr mir helfen, ich wäre euch sehr dankbar.

Vielen Dank,
Georg

[Stefan F. (Gast)]

> ( (Button_Druckzaehler == 0) || (Button_Druckzaehler == 1) )
> // wenn Button zum Einschalten gedrückt
> // und voher zum Einschalten noch nicht gedrückt wurde

Da stimmt der Code überhaupt nicht mit dem Kommentar überein. In welcher 
variable hast du den "vorher" Status?

> if((digitalRead(Button_Pin) == LOW) && (Button_Druckzaehler == 1))
Diese Bedingung ist immer wahr, weil du weiter oben
> Button_Druckzaehler = 1;
geschrieben hast.

In Folge dessen ist auch dies immer wahr
> if((digitalRead(Button_Pin) == LOW) && Button_Druckzaehler == 2)
weil du in dem if darüber
> Button_Druckzaehler = 2;
geschrieben hast

Der eigentliche Knackpunkt ist, dass du nirgendwo den vorherigen Zustand 
des Tasters speicherst. Und nimm dazu bitte boolean Variablen, keine 
Integer wo nicht so richtig klar ist, welche Werte erlaubt sind und was 
sie bedeuten.

Als nächstes wird dir dann auffallen, dass der Taster prellt. Informiere 
dich zum Thema Entprellung, dazu gibt es einen Artikel in der 
Artikelsammlung.

[Adam P. (adamap)]

Stefan ⛄ F. schrieb:
> Und nimm dazu bitte boolean Variablen, keine
> Integer wo nicht so richtig klar ist, welche Werte erlaubt sind und was
> sie bedeuten.

Weiterhin hättest du ihm noch den Tipp geben können,
die Lauflichtlogik zu komprimieren - er hat ja schon ein LED Array, 
diese ganzen Abfragen machen es auch nicht leichter.

Und evtl. noch ein paar Zeilen hinzufügen bzgl. Taster-Entprellung.

[quotendepp (Gast)]

FSM

oder wie prof middeldorp sagte "let's build an automaton..."

[Georg (Gast)]

Danke für die Antworten!

In der Var. Button_Druckzaehler ist im Urzustand nach dem Einschalten 
eine null gespeichert. Also alle LEDs sollen "aus" sein.
Wird das erste mal nach dem Einschalten der Taster betätigt, wird diese 
Variable auf "1" gesetzt. So sollte das Lauflicht dann so lange laufen, 
bis erneut die Taste gedrückt wird, worauf der Wert auf "2" gesetzt 
wird.
Die erste If-Anweisung fragt ab, ob eine Taste gedrückt wurde ODER der 
Wert der Var. "1" ist, wenn ja, soll weiterhin das Lauflicht laufen. 
(was es nicht tut)

Wird dann irgendwann erneut der Taster gedrückt, sollen alle LEDs 
erlöschen.
Wird wieder die Taste gedrückt, soll die Var. auf "1" gesetzt werden und 
erneut das Lauflicht gestartet werden.

Hier nochmals der leicht veränderte Code anhand der Vorgaben:

const int LED_Pins[5] = {8,9,10,11,12};
const int Button_Pin = 7;
unsigned long Start_Millis = 0;
unsigned long Current_Millis = 0;
int Blinkwartezeit = 1000;
int Button_Druckzaehler = 0;
void setup()
{
   pinMode(Button_Pin, INPUT_PULLUP);               // Button an Pin 7, als Eingang (Pullups) schalten
   pinMode(LED_Pins[0], OUTPUT);              // LEDs an den Pins 8-12 als Ausgang schalten
   pinMode(LED_Pins[1], OUTPUT);
   pinMode(LED_Pins[2], OUTPUT);
   pinMode(LED_Pins[3], OUTPUT);
   pinMode(LED_Pins[4], OUTPUT);
   Start_Millis = millis();
}
void loop()
{
  Current_Millis = millis();
   if((digitalRead(Button_Pin) == LOW) || (Button_Druckzaehler == 1))       
   {
     Button_Druckzaehler = 1;                  // ... setue Zähler des Tastendrucks auf 1    
         if((Current_Millis - Start_Millis) >= Blinkwartezeit)
         {
           digitalWrite(LED_Pins[4], LOW);
           digitalWrite(LED_Pins[0], HIGH);
           Start_Millis = Current_Millis;
         } 
         if(((Current_Millis - Start_Millis) >= (Blinkwartezeit + 1000)))   
         {
           digitalWrite(LED_Pins[0], LOW);
           digitalWrite(LED_Pins[1], HIGH);
           Start_Millis = Current_Millis;
         }
         if(((Current_Millis - Start_Millis) >= (Blinkwartezeit + 2000))) 
         {
           digitalWrite(LED_Pins[1], LOW);
           digitalWrite(LED_Pins[2], HIGH);
           Start_Millis = Current_Millis;
         }
     
         if(((Current_Millis - Start_Millis) >= (Blinkwartezeit + 3000)))
         {
           digitalWrite(LED_Pins[2], LOW);
           digitalWrite(LED_Pins[3], HIGH);
           Start_Millis = Current_Millis;
         }
         if(((Current_Millis - Start_Millis) >= (Blinkwartezeit + 4000)))
         {
           digitalWrite(LED_Pins[3], LOW);
           digitalWrite(LED_Pins[4], HIGH);
           Start_Millis = Current_Millis;
         }
        
         if((digitalRead(Button_Pin) == LOW) || (Button_Druckzaehler == 1))
         {
           Button_Druckzaehler = 2;
           digitalWrite(LED_Pins[0], LOW);
           digitalWrite(LED_Pins[1], LOW);
           digitalWrite(LED_Pins[2], LOW);
           digitalWrite(LED_Pins[3], LOW);
           digitalWrite(LED_Pins[4], LOW);
           Start_Millis = Current_Millis;
         }   
     
         if((digitalRead(Button_Pin) == LOW) && Button_Druckzaehler == 2)
         {
           Button_Druckzaehler = 1;
         }
         
  }
}

[versuchmachtklug (Gast)]

Hallo,

Stefan hat dir ja Tipps gegeben.

Hab dir mal was Angehangen, ist zwar nicht der eleganteste Weg, aber ich 
glaub du wolltest eher sowas in der Richtung programmieren ;)

Gruß

[MaWin (Gast)]

Georg schrieb:
> Wo liegt mein Denkfehler

Du baust dein Lauflicht in die Tastererkennung ein.

Im grossen und ganzen muss man das Programm komplett neu schreiben.

loop()
{


  button=digitalRead(Button_Pin);
  if(button&&!oldbutton) // Taster wurde runtergedrückt
  {
   run=!run;
  }
oldbutton=button;


  if(run)
  {
    Current_Millis = millis();
    if(Current_Millis>Start_Millis+Blinkwartezeit)
    {
        digitalWrite(LED_Pins[pos], LOW);
        pos=(pos+1)%5;
        digitalWrite(LED_Pins[pos], HIGH);
        Start_Millis = Current_Millis;
    }
  }

  else digitalWrite(LED_Pins[pos], LOW); 


}

[Georg (Gast)]

versuchmachtklug schrieb:
> Hab dir mal was Angehangen

Hi, Danke, aber da rührt sich garnichts, wenn ich das (derzeit nur) 
simuliere.

[Adam P. (adamap)]

MaWin schrieb:
> Im grossen und ganzen muss man das Programm komplett neu schreiben.

MaWin hat es ja bereits erwähnt, ich hatte durch Zufall auch den Ansatz 
wie er, kannst ja mal ausprobieren.

[versuchmachtklug (Gast)]

Georg schrieb:
> Hi, Danke, aber da rührt sich garnichts, wenn ich das (derzeit nur)
> simuliere.

oh ja hab pinMode(Button_Pin, INPUT_PULLUP); übersehen ...sry

die beiden Zeilen mussten geändert werden.

    if(!digitalRead(Button_Pin)){
        start = start^1;              // toggled Varianble

habs abgeändert und mal eben auf ein NANO spielt.. jetzt funktioniert es 
:)

[Peter D. (peda)]

Beitrag "AVR Sleep Mode / Knight Rider"

[Falk B. (falk)]

Georg schrieb:
> Hier nochmals der leicht veränderte Code anhand der Vorgaben:

Immen noch ziemlich schlechter Ansatz. Das kann man deutlich besser und 
einfacher machen, siehe Multitasking. Der "Trick" ist die Trennung 
der Aufgaben "Taste erkennen und auswerten" sowie Lauflicht.
Eher so.

const int LED_Pins[5] = {8,9,10,11,12};
const int Button_Pin = 7;
unsigned long Last_Millis;
int Blinkwartezeit = 10;
uint8_t mode;

void setup() {
  pinMode(Button_Pin, INPUT_PULLUP);         // Button an Pin 7, als Eingang (Pullups) schalten
  pinMode(LED_Pins[0], OUTPUT);              // LEDs an den Pins 8-12 als Ausgang schalten
  pinMode(LED_Pins[1], OUTPUT);
  pinMode(LED_Pins[2], OUTPUT);
  pinMode(LED_Pins[3], OUTPUT);
  pinMode(LED_Pins[4], OUTPUT);
  Last_Millis = millis();
}

void lauflicht(void) {
  static uint8_t licht=1;
  static uint8_t cnt;
    
  cnt++;
  if (cnt == Blinkwartezeit) {
    cnt = 0;
    licht <<= 1;
    if (licht > 16 || licht == 0)  licht = 1;
    if (!mode) licht = 0;
      for (i=0; i<5; i++) {
        digitalWrite(LED_Pins[i], (licht & 1<<i) );
      }
   } 
}

void taste(void) {
  uint8_t Button_new;
  static uint8_t Button_old;
 
  Button_new = digitalRead(Button_Pin);
  if( (Button_new == LOW) && (Button_old == HIGH) ) {   // Flankenerkennung
    mode = !mode;                                       // mode umschalten
  }
  Button_old = Button_new;
}

void loop() {

  if ( ( millis() - Last_Millis) >= 100 )          // 100ms Zeitraster
    Last_Millis += 100;
    taste();
    lauflicht();
  }
}

[Stefan F. (Gast)]

Georg schrieb:
> In der Var. Button_Druckzaehler ist im Urzustand nach dem Einschalten
> eine null gespeichert. Also alle LEDs sollen "aus" sein.
> Wird das erste mal nach dem Einschalten der Taster betätigt, wird diese
> Variable auf "1" gesetzt. So sollte das Lauflicht dann so lange laufen,
> bis erneut die Taste gedrückt wird, worauf der Wert auf "2" gesetzt
> wird.

Danke für die Erklärung, so ist wenigstens klar wie du es geplant 
hattest. Umgesetzt hast du aber immer noch was anderes.

if((digitalRead(Button_Pin) == LOW) || (Button_Druckzaehler == 1)

Weil Button_Druckzaehler vorher auf 1 gesetzt wurde, ist diese bedinung 
immer wahr. Dann kommt:

> Button_Druckzaehler = 2;

Und dann:

> if((digitalRead(Button_Pin) == LOW) && Button_Druckzaehler == 2)


Button_Druckzaehler ist also immer =2. Zudem kannst du den Taster nicht 
schnell genug loslassen (er ist immer noch gedrückt). Also ist die 
Bedingung immer wahr.

Es fehlt immer noch der vorher/nachher Vergleich des Tasten-Zustandes.

[Stefan F. (Gast)]

Vernünf-Tiger schrieb im Beitrag #6820378:
> Eine vernünftige Programmiersprache kennt den "Toggle" -Befehl, der
> solche Sachen extrem erleichtert.

Der Toggle Befehl schaltet einen Ausgang um. Hier geht es um das 
Gegenteil: Die Abfrage eines Eingangs.

> Eine vernünftige, wohlgemerkt.

Welche "vernünftige" Programmiersprache hat denn (ohne zusätzliche 
Bibliothek) so einen Befehl? Mir fällt gerade keine ein.

Im Fall von AVR braucht man dazu nicht einmal einen extra Befehl, weil 
jeder Port ein Register zum Toggeln hat. Den Ausgang PD4 toggelt man 
z.B. mit

> PIND = (1<<PD4)

Das geht so in jeder Programmiersprache.