Frontblitzer ohne Delay

[timschillert]

Da bin ich nicht so gut drin, aber ich probier's:

jetzt ist die aktuelle Zeit in Millisekunden seit Reset.

vorhin ist die Zeit beim letzten Wechsel in Millisekunden seit Reset.

Statische Variablen behalten am Ende der Funktion ihren Wert.

Die Intervalle, die Du bei delay verwendest hast, wandern in ein Feld. Die Anzahl der Feldelemente steckt in sizeof(Blitzintervalle) / sizeof(Blitzintervalle[0]). Der intervallindex durchläuft 0 bis 5.

Das ist es, oder?

Code: [Select]

const uint16_t

uint32_t

 if (jetzt - vorhin >= Blitzintervalle[intervallindex]) {
    vorhin = jetzt;
    digitalWrite(Blitzer, !digitalRead(Blitzer));
    intervallindex = ++intervallindex < (sizeof(Blitzintervalle) / sizeof(Blitzintervalle[0])) ? intervallindex : 0;

kannst du mir diese Sachen oben erklären? Steht ja einmal vor dem Feld "Blitzintervalle" und einmal vor "jetzt"

bzw. einmal die ganze if-Schleife.  Der erste Teil jetzt-vorhin ist ja klar, nur halt der Teil danach wäre noch interessant

[wno158]

Ich habe da mal was vorbereitet, was diese Zeile hier angeht:

Code: [Select]

intervallindex = ++intervallindex < (sizeof(Blitzintervalle) / sizeof(Blitzintervalle[0])) ? intervallindex : 0;

Das ist die Abkürzung für dieses Stück Programm:

Code: [Select]

// nächster (kommender) Wert ist eins höher als der aktuelle
intervallindexNeu = intervallindex + 1;

// Größe des ganzen Arrays / Größe des ersten Elements = Anzahl Elemente
anzahlBlitzintervalle = (sizeof(Blitzintervalle) / sizeof(Blitzintervalle[0]); 

// Kurzform: <bedingung> ? <wenn wahr> : <wenn falsch>
// Begrenzung auf die Anzahl der definierten Intervalle
if (intervallindexNeu < anzahlBlitzintervalle)
{
  // nächster - da es den gibt
  intervallindex = intervallindexNeu;
}
else
{
  // erster, wenn wir am Ende angekommen waren
  intervallindex = 0;
}

[agmue]

Das ist die Abkürzung für dieses Stück Programm:

Danke für's Aufdröseln

[wno158]

@agmue: Entschuldige, dass ich mich da eingemischt habe. Hatte das die Tage schon mal geschrieben, war aber nicht sicher, ob es benötigt wird.

@tim:
Fehlt ja dann nur noch das hier:

Code: [Select]

digitalWrite(Blitzer, !digitalRead(Blitzer));

Was passiert da eigentlich?
Man muss das von innen nach außen auflösen:
1. digitalRead(Blitzer) kann LOW oder HIGH liefern - je nachdem, ob das Ding gerade aus- oder eingeschaltet ist.
2. ! --> invertiert das Ergebnis vom read: aus (LOW) --> ein (HIGH) bzw. ein (HIGH) --> aus (LOW)
3. das kannst Du selbst.
Am Ende wird also einfach der Pinstatus invertiert.

Pfiffig, oder?

[agmue]

agmue: Entschuldige, ...

Nö, ich bin Dir dankbar

Sonst habe ich

Code: [Select]

intervallindex = (1 + intervallindex) % anzahlBlitzintervalle;
genutzt, aber Modulo soll, wie ich las, rechenaufwendig sein, mit der Bedingung geht es schneller. In diesem Thema ist die anfängerfreundliche aufgedröselte Variante aber vermutlich die verständlichere, so hoffe ich.

[combie]

aber Modulo soll, wie ich las, rechenaufwendig sein

Nicht nur das...
Im Überlauf fängst du dir noch einen Jitter ein, wenn der Divisor keine 2er Potenz ist.

[michael_x]

Pfiffig, oder?

Das Blinklicht ist immer 50% an, 50% aus. Blitzen ist was anderes.

Code: [Select]

//Blitzen: alle CYCLE ms für FLASH ms HIGH setzen.
static unsigned long last;
const unsigned int CYCLE=500;
const unsigned int FLASH=70;
if (millis() - last >= CYCLE) last = millis ();
digitalWrite (flashPin, millis()- last < FLASH);

[agmue]

Das Blinklicht ist immer 50% an, 50% aus. Blitzen ist was anderes.

Code: [Select]

const uint16_t Blitzintervalle[] = {50, 50, 50, 50, 50, 300};

Da muß ich widersprechen, denn "pfiffig" bezieht sich auf das Umschalten des Ausgangs durch Lesen desselben. Und bei mir blitzt es!

Genau dafür habe ich ja das Feld vorgeschlagen, da kann man die Zeiten variieren, bis das Blitzen mit der Vorstellung übereinstimmt. Auch die Anzahl der Elemente könnte man vergrößern, da sie berechnet wird.

Danke für das Lob, das "pfiffig" lasse ich mir nicht nehmen!

[timschillert]

Ok super danke schonmal.
Ich werde mit der ganzen Geschichte mal experimentieren. Sollte ich noch Fragen haben , würde ich hier nochmal darauf  zurück kommen  .

[timschillert]

Guten Abend,

ich hätte nochmal eine Frage.

Ich habe mein Programm jetzt so erweitert, das mein Blaulicht aufm dem Dach jetzt entgegengesetzt zu den Frontblitzern blinken.

Jetzt möchte ich das ganze per Taster steuern. Im Anhang mein momentanter Code. Der Taster mit dem Blitzer funktioniert soweit, beim Blaulicht funktioniert es noch nicht.

Ich vermute, das der Fehler in dem Punkt "!digitalRead(Blitzer)" liegt?

Code: [Select]



void blitzen() {
 if (digitalRead(Taster1)==HIGH)
  {
    static byte intervallindex = 0;
  static uint32_t vorhin;
  if (jetzt - vorhin >= Blitzintervalle[intervallindex]) {
    vorhin = jetzt;
    digitalWrite(Blitzer, !digitalRead(Blitzer));
    intervallindex = ++intervallindex < (sizeof(Blitzintervalle) / sizeof(Blitzintervalle[0])) ? intervallindex : 0;
  }
}
}
void blinken() {
  if (digitalRead(Taster2)==HIGH)
  {
  static byte intervallindex = 0;
  static uint32_t vorhin;
     if (jetzt - vorhin >= Blinkintervalle[intervallindex]) {
    vorhin = jetzt;
    digitalWrite(Blaulicht, !digitalRead(Blitzer));
    intervallindex = ++intervallindex < (sizeof(Blinkintervalle) / sizeof(Blinkintervalle[0])) ? intervallindex : 0;
  }
  }
}


[agmue]

Eher hier:

Code: [Select]

digitalWrite(Blaulicht, !digitalRead(Blitzer));

besser:

Code: [Select]

digitalWrite(Blaulicht, !digitalRead(Blaulicht));

Ich habe mein Programm jetzt so erweitert, das mein Blaulicht aufm dem Dach jetzt entgegengesetzt zu den Frontblitzern blinken.

Dann so in setup:

Code: [Select]

 digitalWrite(Blitzer, HIGH);
  digitalWrite(Blaulicht, LOW);


Wobei ich blitzen() und blinken() zusammenfassen würde, wenn es nur eine Invertierung sein soll.

[timschillert]

Eher hier:

Code: [Select]

digitalWrite(Blaulicht, !digitalRead(Blitzer));
 Ja den Teil meinte ich ,genau.
besser:

Code: [Select]

digitalWrite(Blaulicht, !digitalRead(Blaulicht));
Dann so in setup:

Code: [Select]

  digitalWrite(Blitzer, HIGH);
  digitalWrite(Blaulicht, LOW);

Werde ich mal probieren.


Wobei ich blitzen() und blinken() zusammenfassen würde, wenn es nur eine Invertierung sein soll.

Ich gehe von aus, beide Teile jetzt als eins zu schreiben? Einmal mit dem blinken Werten und einmal mit dem blitzen ? Die Intervalle müsste ich nur einmal schreiben , da ja die Zeiten gleich sind ?

[HotSystems]

Dein Post wäre deutlich besser zu lesen, wenn du nicht alles in den Zitierenblock rein packst.

[timschillert]

sorry, das war am Ipad geschrieben, war dort etwas umständlich um die Uhrzeit

Habe jetzt mein Programm angepasst. Jetzt leuchten die LEDs entgegengesetzt und sind zusammengefasst.

Wenn ich dort jetzt einen Taster einbauen möchte, zum Schalten, könnte ich das ja einfach mit einem Pullup-Eingang machen oder?

Code: [Select]

void Alarm() {
 
    static byte intervallindex = 0;
  static uint32_t vorhin;
  if (jetzt - vorhin >= Blinkintervalle[intervallindex]) {
    vorhin = jetzt;
    digitalWrite(Blitzer, !digitalRead(Blitzer));
    digitalWrite(Blaulicht, !digitalRead(Blaulicht));
    intervallindex = ++intervallindex < (sizeof(Blinkintervalle) / sizeof(Blinkintervalle[0])) ? intervallindex : 0;
  }

[agmue]

Wenn ich dort jetzt einen Taster einbauen möchte, zum Schalten, könnte ich das ja einfach mit einem Pullup-Eingang machen oder?

Das könnte funktionieren.