Bei Led Lauflicht delay ersetzen

[partizan0180]

Mit :

Code:

digitalWrite(i, !digitalRead(i));

bleiben die leds dauerhaft an.

[Thorsten Pferdekämper]

(10.02.2015 17:14)partizan0180 schrieb:  Mit :

Code:

digitalWrite(i, !digitalRead(i));

bleiben die leds dauerhaft an.

Hi,
zeig mal das komplette Coding.
Gruß,
Thorsten

[partizan0180]

Hi Thorsten
Der Code ist ja schon auf der erster Seite hier. Werde einfach nicht schlau da raus.

[partizan0180]

Hallo Thorsten,
Das ist mein ausgangs Code:

Code:

void setup() {
for (int i=4; i<10; i++)
  {  
  pinMode(i, OUTPUT);  
  }
}

void loop() {
for (int i=4; i<10; i++)
  {
  digitalWrite(i, HIGH);
  delay(350);          
  }  

delay(2500);  

  for (int i=11; i>4; i--)
  {
  delay(1000);          
  digitalWrite(i, LOW);  
  }
}

Ich möchte nun die delay raus haben und einstellmöglichkeit für die Geschwindigkeit für ein und aus und Wartezeit nech dem es angegangen ist bis es wieder aus geht.

[Thorsten Pferdekämper]

(11.02.2015 08:07)partizan0180 schrieb:  Hi Thorsten
Der Code ist ja schon auf der erster Seite hier. Werde einfach nicht schlau da raus.

Na wenn Du das digitalWrite in Deinem Code einfach durch meine Variante ersetzt, dann machst Du es 10mal schnell hintereinander. 10 Invertierungen heben sich gegenseitig auf.
Gruss,
Thorsten

[partizan0180]

Hallo Thorsten,
Ich habe heute noch eine Idee gehabt. Und das ist aus der Idee geworden:

Code:

/* Treppen Licht / Wegbeleuchtung */
#include <OneButton.h>

int buttonPin1 = 2;    // Taster an Pin 2
int buttonPin2 = 3;    // Taster an Pin 3

//Einen Taster mit externem Widerstand
OneButton button1 = OneButton(buttonPin1, false);
OneButton button2 = OneButton(buttonPin2, false);

// Einstellungen///////////////////////////////////////////

int warten = 2500;         // Wartezeit bis wieder AUS
int interval1 = 350;      // Schaltinterval für AN
int interval2 = 1000;    // Schaltinterval für AUS

// Einstellungen ende/////////////////////////////////////

void setup()
{
  // Pins als Ausgang deklarieren und im Bootmodus auf aus stellen
  for (int i=4; i<11; i++)
  {  
  pinMode(i, OUTPUT);
  digitalWrite(i, HIGH);
  }
  ///////////////////////////////////////////////////////
  Serial.begin(9600);
  while(!Serial); // nur bei Leonardo nötig
  Serial.println("Programm gestartet ..::.....::..");
  //Wenn Taster 1 gedrückt wird soll nach oben ausgeführt werden
  button1.attachClick(oben);
  //Wenn Taster 1 doppelt gedrückt wird soll Dauerlicht geschaltet werden
  button1.attachDoubleClick(dauer_licht1);
    //Wenn Taster 1 gehalten wird - wird noch entwickelt
// button1.attachPress(halten);
  //Angabe wie lange der Taster gedrückt werden soll bis eine Aktion ausgeführt wird
// button1.setPressTicks(3000); //3 Sekunden
  ///////////////////////////////////////////////////////////////////////
   //Wenn Taster 2 gedrückt wird soll nach unten ausgeführt werden
  button2.attachClick(unten);
  //Wenn Taster 2 doppelt gedrückt wird soll Dauerlicht geschaltet werden
  button2.attachDoubleClick(dauer_licht2);
  //Wenn Taster 2 gehalten wird - wird noch entwickelt
  //button2.attachPress(halten);
  //Angabe wie lange der Taster gedrückt werden soll bis eine Aktion ausgeführt wird
// button2.setPressTicks(3000); //3 Sekunden
  
}
void loop()
{
  //prüft ob eine Änderung am Schalter stattgefunden hat
  button1.tick();
  button2.tick();

  delay(10);
  
}

/////////////////////////////////
// Schalter Funktion für unten//
///////////////////////////////
void unten() {
  Serial.println("Auto Licht");
  for (int i=0; i<11; i++)
  {
  delay(interval1);
  digitalWrite(i, LOW);
              
  }
  
  delay(warten % 4);
  
  for (int i=0; i<11; i++)
  {
  delay(interval2);
  digitalWrite(i, HIGH);
        
  }
}
/////////////////////////////////
// Schalter Funktion für oben //
///////////////////////////////
void oben() {
  Serial.println("Auto Licht");
  for (int i=10; i>0; i--)
  {
    delay(interval1);
   digitalWrite(i, LOW);        
  }
   delay(warten);
    
    for (int i=10; i>0; i--)
  {
    delay(interval2);
  digitalWrite(i, HIGH);    
  }  
}

///////////////////////////
// Dauerlicht von unten //
/////////////////////////
void dauer_licht1()
{
  Serial.println("Dauerlicht");
  for (int i=10; i>0; i--)
  {
  delay(200);
  digitalWrite(i, LOW);
  }
}
  ////////////////////////
//Dauerlicht von oben //
////////////////////////
void dauer_licht2()
{
  Serial.println("Dauerlicht");
  for (int i=0; i<11; i++)
  {
    delay(200);
  digitalWrite(i, LOW);
              
  }
}

/*void halten()
{
  Serial.println("gehalten");
  
}
*/

Ist der Code so ok ? Oder ist es noch verbesserungswürdig oder würdest du es anders machen ? Wenn man da noch die delay wegbekäme. Aber genau da scheitere ich

[Thorsten Pferdekämper]

Hi,
mit der OneButton-Lib habe ich noch nichts gemacht. Ich mache sowas normalerweise direkt, aber so geht's wohl auch.
Um die delays wegzubekommen wuerde ich so vorgehen:
- Das delay(10) in loop() muesste man einfach ersatzlos loeschen koennen. Was macht das da?
- Alle anderen delays kannst Du dadurch ersetzen, dass Du Dir ueberlegst, wie Du den Zustand des Systems beim Aufruf von delay "sichern" und nachher wieder herstellen kannst

Fuer letzteres solltest Du Dir einen neuen Sketch schreiben, der erstmal nichts mit den Buttons macht. Das irritiert sonst nur. Dann Stueck fuer Stueck arbeiten. Hier mal ein Beispiel, wie man eine Schleife mit delay loswird:
Das Ausgangs-Coding:

Code:

void oben() {
  // eins nach dem Anderen einschalten
  for (int i= 0; i < 11 0; i++)
  {
      delay(interval1);
      digitalWrite(i, LOW);        
  }
  delay(warten);
  // und alle wieder aus
  for (int i= 0; i < 11 0; i++)
  {
    digitalWrite(i, HIGH);        
  }
}

Zum Ersetzen der delays ueberlegt man sich erst einmal, was zum Zeitpunkt der delays den Zustand des Systems charakterisiert. Das ist hier einzig und allein das i. D.h., wir muessen das i "statisch" machen. Das ist so wie global, nur eleganter, da es weiterhin nur von der Routine selbst "gesehen" wird.
In der zweiten Schleife ist das i ein "anderes" i, da wir da ueberhaupt kein delay haben.
Statt dem delay() springt man aus der Routine raus, um dem Rest des Programms eine Chance zu geben. Aus loop() heraus wird unsere Routine zyklisch aufgerufen. Dann muss das Programm wieder an der Stelle weitermachen, wo es das letzte Mal aufgehoert hat. Das sieht dann etwa so aus:

Code:

void handleOben() {

  static int i = 0;   // wie oben beschrieben

  // eins nach dem Anderen einschalten
  // i sagt uns, wie weit wir das letzte mal gekommen sind
  if(i < 11) {  // die letzte ist noch nicht an
     delay(interval1);
     digitalWrite(i, LOW);        
     i++;   // damit das naechste Mal die naechste angeht
     return;  // das war's fuer diese Runde
  };  // oben ist ein return, da brauchen wir kein else

  // hier wissen wir, dass i >= 11 ist, also das letzte Mal ist die letzte angegangen
  delay(warten);
  // und alle wieder aus
  for (int j = 0; j < 11; j++)
  {
    digitalWrite(j, HIGH);        
  }
  // Jetzt sind alle wieder aus. i muss jetzt zurueck gesetzt werden,
  // damit es das naechste Mal wieder von vorne anfaengt
  i = 0;
}

Wenn man diese Routine aus loop() heraus immer wieder aufruft, dann macht das System pro Aufruf "einen Schritt", also entweder nur eine LED an oder alle aus. Zwischendurch kann man dann was anderes machen. Die delays sind zwar noch drin, aber insgesamt muss man nicht mehr auf die komplette Routine warten.
Die delays wird man jetzt los, indem man nur was macht, wenn seit dem letzten Aufruf die gewuenschte Zeit vergangen ist. Also so:

Code:

void handleOben() {

  static int i = 0;   // wie oben beschrieben
  static unsigned long lastTime = 0;  // da wurde das letzte Mal was gemacht

  unsigned long now = millis();  // "jetzt"

  // eins nach dem Anderen einschalten
  // i sagt uns, wie weit wir das letzte mal gekommen sind
  if(i < 11) {  // die letzte ist noch nicht an
     if(now - lastTime < interval1)
           return;   // die Zeit ist noch nicht vergangen, also nichts tun
     lastTime = now;   // wir werden _jetzt_ was tun
     digitalWrite(i, LOW);        
     i++;   // damit das naechste Mal die naechste angeht
     return;  // das war's fuer diese Runde
  };  // oben ist ein return, da brauchen wir kein else

  // hier wissen wir, dass i >= 11 ist, also das letzte Mal ist die letzte angegangen
       if(now - lastTime < warten)
           return;   // die Zeit ist noch nicht vergangen, also nichts tun
     lastTime = now;   // wir werden _jetzt_ was tun
  // und alle wieder aus
  for (int j = 0; j < 11; j++)
  {
    digitalWrite(j, HIGH);        
  }
  // Jetzt sind alle wieder aus. i muss jetzt zurueck gesetzt werden,
  // damit es das naechste Mal wieder von vorne anfaengt
  i = 0;
}

So, die delays sind jetzt weg. Man muss nur die Routine zyklisch aus loop() aufrufen und es sollte so aussehen wie vorher. Wenn man das ganze jetzt noch von irgendwelchen Ereignissen abhaengig machen will, dann packt man den Aufruf in loop in ein entsprechendes "if".
Gruss,
Thorsten

[partizan0180]

Mensch Thorsten danke für deine Geduld und die Mühe. Die beiden Varianten funzen perfekt. In der erste Variante habe ich delay(2500) hinzugefügt und die LEDs gehen auch wieder nach einander aus und nicht alle gleichzeitig.
Das Muester wollte ich so realisieren:

void oben(){
pin4 -- > pin10 nacheinander an und nach kurzer Pause wieder von
pin4 -- > pin10 nacheinander wieder aus.
}

und

void unten(){
pin10 -- > pin4 nacheinander an und nach kurzer Pause wieder von
pin10 -- > pin4 nacheinander wieder aus.
}


Die zweite Variante von dir die LEDs gehen nacheinander an gehen aber alle gleichzeitig aus. Wie muss ich es verändern damit die LEDs auch nacheinander ausgehen?

(12.02.2015 10:02)Thorsten Pferdekämper schrieb:  

Code:

void handleOben() {

  static int i = 0;   // wie oben beschrieben
  static unsigned long lastTime = 0;  // da wurde das letzte Mal was gemacht

  unsigned long now = millis();  // "jetzt"

  // eins nach dem Anderen einschalten
  // i sagt uns, wie weit wir das letzte mal gekommen sind
  if(i < 11) {  // die letzte ist noch nicht an
     if(now - lastTime < interval1)
           return;   // die Zeit ist noch nicht vergangen, also nichts tun
     lastTime = now;   // wir werden _jetzt_ was tun
     digitalWrite(i, LOW);        
     i++;   // damit das naechste Mal die naechste angeht
     return;  // das war's fuer diese Runde
  };  // oben ist ein return, da brauchen wir kein else

  // hier wissen wir, dass i >= 11 ist, also das letzte Mal ist die letzte angegangen
       if(now - lastTime < warten)
           return;   // die Zeit ist noch nicht vergangen, also nichts tun
     lastTime = now;   // wir werden _jetzt_ was tun
  // und alle wieder aus
  for (int j = 0; j < 11; j++)
  {
    digitalWrite(j, HIGH);        
  }
  // Jetzt sind alle wieder aus. i muss jetzt zurueck gesetzt werden,
  // damit es das naechste Mal wieder von vorne anfaengt
  i = 0;
}

So, die delays sind jetzt weg. Man muss nur die Routine zyklisch aus loop() aufrufen und es sollte so aussehen wie vorher. Wenn man das ganze jetzt noch von irgendwelchen Ereignissen abhaengig machen will, dann packt man den Aufruf in loop in ein entsprechendes "if".
Gruss,
Thorsten