LED zum blinken bringen mit einem Knopf und wieder ausmachen

Hallo ich habe mir vor einigen Tagen ein Arduino gekauft. Jetzt will ich ein LED mit einem Knopf anmachen so das sie die ganze zeit durchgehend blinkt. Wenn ich dann ein 2 mal auf den Knopf drücke, soll das blinken aufhören und die LED ausgehen, aber ich weiß nicht wie ich das machen soll.

Ich bin führ jede Hilfe dankbar.

Hi,

lies dir mal den Artikel über Interrupts Arduino Playground - Interrupts durch.

Du kannst dir in der ISR ein Flag setzen, dass dir zeigt ob grade blinken angesagt ist oder nicht.

Vergiss nicht den Taster zu entprellen!

Liebe Grüße
Patrick

P_Will:
lies dir mal den Artikel über Interrupts Arduino Playground - Interrupts durch.

Du kannst dir in der ISR ein Flag setzen, dass dir zeigt ob grade blinken angesagt ist oder nicht.

Vergiss nicht den Taster zu entprellen!

Und was soll der Interrupt hier bewirken ?
Da braucht es keinen Interrupt, das geht alles sehr gut ohne und der Interrupt ist hier Quatsch.

@Peter_M
Sieh dir die Beispiele der IDE an, da ist sehr viel (Led, blinken und Taster) schon beschrieben.

P_Will:
lies dir mal den Artikel über Interrupts https://playground.arduino.cc/Code/Interrupts durch.

Für eine solch einfache Sache empfiehlst Du einem Anfänger die Verwendung von Interrupts?! Gib’s zu, Du machst Witze.

@Peter_M: Sieh Dir die Beispiele in der IDE an. Wenn Du die dort beschriebenen Dinge kombinierst, bist Du ratz-fatz am Ziel.

Gruß

Gregor

Und für ein einfaches ein/ausschalten muss der Taster nicht aufwändig entprellt werden.
Da reicht schon ein kurzes delay im Code.

Wenn du mit deinem Sketch nicht weiter kommst, da helfen wir gerne.

Ich habe sowas geschrieben, aber das blinken hört auf. Ich will aber das es die ganze zeit weiter blinkt bis ich noch ein mal auf den Knopf drücke erst dann soll es aufhören.

const int button = 7;

int merke = 0;

int buttonState = 0;



void setup() {
  // put your setup code here, to run once:
    pinMode(2,OUTPUT);
    pinMode(button,INPUT);
}

void loop() {
  // put your main code here, to run repeatedly:

     buttonState = digitalRead(button);

     if((buttonState == HIGH) && (merke == 0)){
      digitalWrite(2,HIGH);
      delay(500);
      digitalWrite(2,LOW);
      delay(1000);
      digitalWrite(2,HIGH);
      delay(500);
      digitalWrite(2,LOW);
      merke = 1;
     }
     if((buttonState == LOW) && (merke == 1)){
      merke = 2;
     }
     if((buttonState == HIGH) && (merke == 2)){
      digitalWrite(2,LOW);
      merke = 3;
     }
     if((buttonState == LOW) && (merke == 3)){
      merke = 0;     
     }
}

Das geht leider auch nicht so.

Du musst die Led "immer" blinken lassen und das ohne delays.
Dazu sieh dir BlinkWithoutDelay (in den Beispielen) an.
Das Beispiel kannst du direkt verwenden und per Taster steuern.

Den Taster verwendest du dann, um das Blinken an bzw. auszuschalten.

@HotSystems könntest du oder jemand anderes mal ein beispiel Code schreiben da ich es ganze zeit versuche, aber es nicht hin bekomme. Wäre sehr nett.

Nimm doch erst mal das Beispiel "BlinkWithoutDelay" und steuere das durch eine Taste.

Peter_M:
@HotSystems könntest du oder jemand anderes mal ein beispiel Code schreiben da ich es ganze zeit versuche, aber es nicht hin bekomme. Wäre sehr nett.

Ich habe genau so einen “Tastenblinker” im Nähkästchen.
Befürchte aber, dass ich dann wieder Haue von den anderen bekomme, wenn ich das zeige.
Und auch, dass du danach noch verwirrter bist, als jetzt schon.

Aber was solls, kannste ja einfach ignorieren, wenn es dir nicht gefällt!

#include <TaskMacro.h>
// https://forum.arduino.cc/index.php?topic=415229.0

/*
 * Tastenblinker
 * Blinken wird mit Tastendruck gestartet und gestoppt
*/




const byte taster            = 4;   // Taster zwischen Pin und GND
const byte led               = 13;  // Led zwischen Pin und GND
const unsigned long interval = 500; // ms Blinkinterval


bool blinkAnforderung        = false; // Merker für Blink Anforderung


void tasterBehandlung() // Task
{
    static byte i = 0;
    taskBegin();
    while(1)
    {
        taskStepName(WarteAufTaster);
        taskWaitFor(!digitalRead(taster));
        for(i=0;i<20;i++) // entprellen
        {
          taskPause(10);
          if(digitalRead(taster)) taskJumpTo(WarteAufTaster);
        }
        
        blinkAnforderung = ! blinkAnforderung; // Anforderungsmerker toggle
    
        
        taskStepName(WarteAufLosLassen);
        taskWaitFor(digitalRead(taster));
        for(i=0;i<20;i++)  // entprellen
        {
          taskPause(10);
          if(!digitalRead(taster)) taskJumpTo(WarteAufLosLassen);
        }
        taskJumpTo(WarteAufTaster);
    }
    taskEnd();
}


void blink() // Task
{
  taskBegin();
  while(1)
  {
      taskWaitFor(blinkAnforderung);
      digitalWrite(led, HIGH); // leuchte an
      taskPause(interval);
      digitalWrite(led, LOW); // leuchte aus
      taskPause(interval);
  }
  taskEnd();
}


void setup()
{
  pinMode(led, OUTPUT);
  pinMode(taster,INPUT_PULLUP);
}

void loop()
{  
  blink();
  tasterBehandlung();
}

Viele Wege führen nach Rom:

#define EIN 7
uint32_t aktMillis, tasterMillis, blinkMillis, intervall;
const uint32_t intervalle[] = {500, 100, 100, 100};
const byte anzahlIntervalle = sizeof(intervalle) / sizeof(intervalle[0]);
byte index;
bool aktTaster, altTaster, blinken;

void setup() {
  pinMode(EIN, INPUT_PULLUP);
  pinMode(LED_BUILTIN, OUTPUT);
  intervall = intervalle[index];
}

void loop() {
  aktMillis = millis();
  altTaster = aktTaster;
  if (aktMillis - tasterMillis >= 30) {
    tasterMillis = aktMillis;
    aktTaster = digitalRead(EIN);
  }
  if (aktTaster && !altTaster) {
    blinken = !blinken;
  }
  if (blinken) {
    if (aktMillis - blinkMillis >= intervall) {
      blinkMillis = aktMillis;
      digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
      index++;
      index = index % anzahlIntervalle;
      intervall = intervalle[index];
    }
  } else {
    digitalWrite(LED_BUILTIN, LOW);
    index = 0;
  }
}

agmue:
Viele Wege führen nach Rom

Und wie es aussieht, sogar über Moskau und Tokyo :slight_smile:

Hier noch eine "simple" Lösung mit der von mir beschriebenen "BlinkWithoutDelay"-Funktion.

int ledState = LOW;                       // Led-Status 
uint8_t TasterValue = 0;                  // Taster-Status
uint8_t BlinkValue = 0;                   // Blink-Status    
uint8_t status = 0;
unsigned long previousMillis = 0;        

const byte TasterPin = 2;                 // Taster an Pin 2 und GND
const long interval = 1000;               // Blinkintervall


void setup() {
  pinMode(LED_BUILTIN, OUTPUT);           // Led Pin13
  pinMode (TasterPin, INPUT_PULLUP);      // Taster mit Pullup
}

void loop() {
  // BlinkWithoutDelay....
  unsigned long currentMillis = millis();
  if (BlinkValue == HIGH) {                   
    if (currentMillis - previousMillis >= interval) {
      previousMillis = currentMillis; 
      if (ledState == LOW)
        ledState = HIGH;
      else
        ledState = LOW;
      digitalWrite(LED_BUILTIN, ledState);
    }
  }
  else
    digitalWrite(LED_BUILTIN, LOW);            
  // Ende BlinkWithoutDelay....
    
  TasterValue = digitalRead (TasterPin);        // Tasterstatus einlesen
  if (status != TasterValue) {                  // Aenderung des Taster ?
    if (TasterValue) {                          // geschaltet
      BlinkValue = !BlinkValue;                 // ...und wird gewechselt.
    }
    status = TasterValue;                       // Status merken
    delay (200);
  }
}
// Ende Loop --------------------------------------------------------------------------