Blinkmuster per Taster auswählen

International Deutsch
1

Hallo liebe Mitglieder.

Ich bin auf dem Gebiet Prozessoren zu programmieren noch zimlich am Anfang und benötige jetzt erstmals eure Hilfe.

Ich möchte eine Sondersignalanlage mit unterschiedlichen Blinkmustern bauen, so wie sie bei Feuerwehr, Rettungswagen und Polizei zum Einsatz kommen. Die einzelnen Blinkmuster sollen immer wieder in Schleife laufen. Bei Betätigung eines Tasters soll das nächste Blinkmuster ausgewählt werden und in Schleife laufen. jetzt weiß ich nicht wie ich das hinbekomme. Die ganzen super erklärten Beispiele die ich im Internet gefunden habe kann ich so nicht nutzen, da die LEDs in unterschiedlichen Zeitabständen blinken.
Das Programm habe ich ein gutes Stück abgespeckt, insgesamt sind dort 14 Muster drin, bitte nicht wundern über die etwas eigenartige Formatierung des Quellcodes. Ich experimentiere damit auch noch etwas rum. Ich würde mich freuen, wenn ihr mir weiterhelfen könnt.

// BLINKMUSTERPROGRAMM Kurzversion


const int analogInPin = A0;
const int ledL = 10;
const int ledR = 9;

int sensorValue = 0;
int outputValue = 0;
float PWMlang = 10.23;

//                1 bi| 2 bi |3 bi| 5 bi|8 bi
//                  0    1    2    3    4
int blinktimes[] = {40, 80, 120, 200, 320};
// the setup routine runs once when you press reset:
void setup() {
// initialize serial communications at 9600 bps:
Serial.begin(9600);
pinMode(ledL, OUTPUT);
pinMode(ledR, OUTPUT);
}
// the loop routine runs over and over again forever:
void loop() {
// read the analog in value:
sensorValue = analogRead(analogInPin);             // map it to the range of the analog out:
outputValue = map(sensorValue, 0, 1023, 0, 255);  // change the analog out value:


// print the results to the serial monitor:
Serial.print("sensor = ");
Serial.print(sensorValue);
Serial.print("\t LED Helligkeitsstufe in Prozent: ");
Serial.print(sensorValue / PWMlang);
Serial.print("\t output = ");
Serial.println(outputValue);

// wait 2 milliseconds before the next loop
// for the analog-to-digital converter to settle
// after the last reading:
delay(2);

// 1. Blinkmuster  ************************* HELA FWL synchron **********


analogWrite(ledL, outputValue);   // turn the ledL on (HIGH is the voltage level)
analogWrite(ledR, outputValue);  // turn the ledL on (HIGH is the voltage level)
delay(blinktimes[3]);                // wait for blinktimes[] miRiseconds

analogWrite(ledL, 0);    // turn the ledL off by making the voltage 0
analogWrite(ledR, 0);     // turn the ledL off by making the voltage LOW
delay(blinktimes[2]);


analogWrite(ledL, outputValue);   // turn the ledL on (HIGH is the voltage level)
analogWrite(ledR, outputValue);   // turn the ledL on (HIGH is the voltage level)
delay(blinktimes[0]);                // wait for blinktimes[] miRiseconds

analogWrite(ledL, 0);    // turn the ledL off by making the voltage 0
analogWrite(ledR, 0);   // turn the ledL on (HIGH is the voltage level)
delay(blinktimes[0]);

//  2. Blinkmuster *********************************** DREIFACHBLITZ  *******


// 1. Block
analogWrite(ledL, outputValue);   // turn the ledL on (HIGH is the voltage level)
analogWrite(ledR, outputValue);   // turn the ledL on (HIGH is the voltage level)
delay(blinktimes[0]);

// 2. Block
analogWrite(ledL, 0);    // turn the ledL off by making the voltage 0
analogWrite(ledR, 0);    // turn the ledL off by making the voltage LOW
delay(blinktimes[0]);


// 3. Block
analogWrite(ledL, outputValue);   // turn the ledL on (HIGH is the voltage level)
analogWrite(ledR, outputValue);   // turn the ledL on (HIGH is the voltage level)
delay(blinktimes[0]);

// 4. Block
analogWrite(ledL, 0);    // turn the ledL off by making the voltage LOW
analogWrite(ledR, 0);   // turn the ledL on (HIGH is the voltage level)
delay(blinktimes[0]);


// 3. Blinkmuster ************************************ VIERFACHBLITZ ********


// 1. Block
analogWrite(ledL, outputValue);  // turn the ledL on (HIGH is the voltage level)
analogWrite(ledR, outputValue);  // turn the ledL on (HIGH is the voltage level)
delay(blinktimes[0]);

// 2. Block
analogWrite(ledL, 0);    // turn the ledL off by making the voltage LOW
analogWrite(ledR, 0);    // turn the ledL off by making the voltage LOW
delay(blinktimes[0]);


// 3. Block
analogWrite(ledL, outputValue);  // turn the ledL on (HIGH is the voltage level)
analogWrite(ledR, outputValue);  // turn the ledL on (HIGH is the voltage level)
delay(blinktimes[0]);

// 4. Block
analogWrite(ledL, 0);    // turn the ledL off by making the voltage LOW
analogWrite(ledR, 0);   // turn the ledL on (HIGH is the voltage level)
delay(blinktimes[0]);

// 4. Blinkmuster **********  2 x  BLINKEN SYNCHRON     2xBLINKEN ALTERNIEREND********

// 1. BEIDE LED AN
analogWrite(ledL, outputValue);  // turn the ledL on (HIGH is the voltage level)
analogWrite(ledR, outputValue);  // turn the ledL on (HIGH is the voltage level)
delay(blinktimes[2]);

// 2. BEIDE LED AUS
analogWrite(ledL, 0);    // turn the ledL off by making the voltage LOW
analogWrite(ledR, 0);    // turn the ledL off by making the voltage LOW
delay(blinktimes[2]);

// 3. BEIDE LED AN
analogWrite(ledL, outputValue);  // turn the ledL on (HIGH is the voltage level)
analogWrite(ledR, outputValue);  // turn the ledL on (HIGH is the voltage level)
delay(blinktimes[2]);

// 4. BEIDE LED AUS
analogWrite(ledL, 0);    // turn the ledL off by making the voltage LOW
analogWrite(ledR, 0);    // turn the ledL off by making the voltage LOW
delay(blinktimes[2]);

// 5. NUR Links AN
analogWrite(ledL, outputValue);  // turn the ledL on (HIGH is the voltage level)
delay(blinktimes[2]);

// 6.NUR Links AUS
analogWrite(ledL, 0);    // turn the ledL off by making the voltage LOW
delay(blinktimes[2]);

// 7. NUR Rechts AN
analogWrite(ledR, outputValue);  // turn the ledL on (HIGH is the voltage level)
delay(blinktimes[2]);

// 8. NUR Rechts AUS
analogWrite(ledR, 0);    // turn the ledL off by making the voltage LOW
delay(blinktimes[2]);

// 5. Blinkmuster ************************  ALTERNIERENDER DOPPELBLITZ********

// 1. Linke LED AN
analogWrite(ledL, outputValue);  // turn the ledL on (HIGH is the voltage level)
delay(blinktimes[0]);


// 2. Linke LED AUS
analogWrite(ledL, 0);    // turn the ledL off by making the voltage LOW
delay(blinktimes[0]);

// 3. Linke LED AN
analogWrite(ledL, outputValue);  // turn the ledL on (HIGH is the voltage level)
delay(blinktimes[0]);


// 4. Linke LED AUS
analogWrite(ledL, 0);    // turn the ledL off by making the voltage LOW
delay(blinktimes[2]);

// 5. Rechte LED AN
analogWrite(ledR, outputValue);  // turn the ledL on (HIGH is the voltage level)
delay(blinktimes[0]);

// 6. Rechte LED AUS
analogWrite(ledR, 0);    // turn the ledL off by making the voltage LOW
delay(blinktimes[0]);

// 7. Rechte LED AN
analogWrite(ledR, outputValue);  // turn the ledL on (HIGH is the voltage level)
delay(blinktimes[0]);

// 8. Rechte LED AUS
analogWrite(ledR, 0);    // turn the ledL off by making the voltage LOW
delay(blinktimes[2]);

}
2

Auch wenn dein Sketch gekürzt ist, solltestdu den in Code-Tags setzen.
Du kannst den noch bearbeiten und komplett markieren.
Danach die Schaltfläche </> oben links im Editorfenster klicken.

Dann ist der Sketch auch im Smartphone und Tablett vernünftig lesbar.

3

Mit deinen delays() verhinderst du, dass der Taster permanent erfasst wird.
Wenn das ok ist (musst den Taster halt solange drücken, bis eine Reaktion erfolgt), packst du am besten die Blinkmuster in separate Funktionen damit loop() etwas übersichtlicher wird:

const byte ANZAHL_MUSTER=14;
byte aktuelles Muster;

byte outputValue; // 0 .. 255 für LED-PWM
void loop () {
   outputValue = analogRead(A0) / 4; 

   if (digitalRead(Taster) == HIGH)  { // = gedrückt, evtl. andersrum bei INPUT_PULLUP
      if (++aktuellesMuster > ANZAHL_MUSTER) aktuellesMuster=0;
   }
   switch (aktuellesMuster) {
   case 1 : HELA_FWL(); return;
   case 2 : DREIFACHBLITZ(); return;
   // ...
   default : ALLES_AUS(); return;
   }
}
void ALLES_AUS() {
   digitalWrite (ledL, LOW);
   digitalWrite (ledR, LOW);
   delay(100); // das spart Entprellen und Flankenerkennung beim Taster 
}

Wenn du den Taster zu lange (permanent) drückst, werden die Blinkmuster der Reihe nach abgespielt,
wenn du den Taster zu kurz drückst, passiert garnichts.

Wenn dir das nicht gefällt, musst du dich mit "endlichen Automaten" beschäftigen und die delays rausschmeissen.

4

Parax:
Hallo liebe Mitglieder.

Im Prinzip ist das sehr einfach

Programmlogik in etwa:

int muster=0; // das Muster festlegen, mit dem das Programm starten soll

void loop()
{
if(buttonPressed())
{
  muster++; // nächstes Muster auswählen
  if (muster>=14) muster=0; // nach 14 Tastendrücken wieder zurück zum anfänglichen Muster
}
blink(muster); // Ablaufsteuerung für das Blinkmuster aufrufen
}

Du brauchst nur zwei nicht-blockierende Funktionen schreiben (buttonPressed() und blink(), die im kooperativen Multitasking laufen können, ohne dabei die jeweils andere Funktion im Ablauf zu blockieren. Also "delay()" ist für sowas eine VERBOTENE Funktion, weil delay() den Ablauf unterbricht und blockiert.

Voraussetzung für das Schreiben der blink() Funktion wäre außerdem, dass Du eine geeignete Datenstruktur (array oder struct) findest, in der Du die verschiedenen Blinkmuster deklarieren kannst.

Kannst Du den zeitlichen Ablauf der einzelnen Blinkmuster auf Deutsch beschreiben?

Wenn ja, mache mal eine Tabelle mit 14 Zeilen bzw. Einträgen, welches Blinkmuster welchen Zeitlichen Ablauf haben soll!
Dann schaue ich gerne mal rüber, wie man die Daten praktischwerweise als Konstanten in einem array, struct oder array-of-struct) einem Algorithmus für eine r Ablaufsteuerung zugänglich machen kann.

5

Vielen Dank für eure Lösungsvorschläge. Ich werde mich in dem Bereich die Tage mal Schlau machen. Sonst frag ich nochmal nach wenn ich nicht weiterkomme. Danke