Go Down

Topic: Frontblitzer ohne Delay (Read 1 time) previous topic - next topic

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;
}


Gruß Walter

agmue

Das ist die Abkürzung für dieses Stück Programm:
Danke für's Aufdröseln :)

Die Vorstellungskraft ist wichtiger als Wissen, denn Wissen ist begrenzt. (Albert Einstein)

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?
Gruß Walter

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.

Die Vorstellungskraft ist wichtiger als Wissen, denn Wissen ist begrenzt. (Albert Einstein)

combie

Quote
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.
Säge kein Sägemehl.

michael_x

Quote
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!

Die Vorstellungskraft ist wichtiger als Wissen, denn Wissen ist begrenzt. (Albert Einstein)

timschillert

#23
Nov 26, 2020, 04:07 pm Last Edit: Nov 26, 2020, 05:37 pm by 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

#25
Nov 30, 2020, 08:13 pm Last Edit: Dec 01, 2020, 10:35 am by 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.

Die Vorstellungskraft ist wichtiger als Wissen, denn Wissen ist begrenzt. (Albert Einstein)

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.
Gruß Dieter

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. 8)

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.

Die Vorstellungskraft ist wichtiger als Wissen, denn Wissen ist begrenzt. (Albert Einstein)

Go Up