Mit einem Schalter eine LED-Reihenfolge Programieren

Moin,
Ich Verwende einen Arduino Nano (mit dem ATmega328P) und ich würde gerne LEDs in Reihenfolge, zb die LEDs von rechts nach links blinken lassen, mit einem Schalter bestimmen.

Ich habe 3 Schalter und 10 LEDs zur verfügung und mein Plan war es, wenn ich den Ersten Schalter umlege blinken die LEDs in einer Reihenfolge und wenn ich den zweiten Schalter umlege (und der ersten schalter wieder auf aus) in einer anderen Reihenfolge.

Was ich bisher im Forum gefunden habe hat mir nicht wirklich weitergeholfen, ich hoffe jemand von euch kann mir Helfen

Gruß Matze

Hier noch ein Bild von meiner Platine

so:

if (digitalRead(schalterPin[0]) == LOW)
  blinkInEinerReihenfolge();
else if (digitalRead(schalterPin[1]) == LOW)
  blinkInAndererReihenfolge();
1 Like

Dann wäre es doch schön und hilfreich, wenn du uns zeigst, was du bisher programmiert hast.
Poste deinen Sketch in Code-Tags.? Dazu in der IDE mit rechter Maustaste auf "Für Forum kopieren" klicken und hier einfügen.

Hallo,
das geht gut mit einer Switch/Case Anweisung, einem Timer und dem LED Programm in einem zweidimensionalen Array abgelegt.

ledSwitch [switch] [OnOff];

Was soll ich bei 'Blink in einer Reihenfolge' einfügen? Direkt das digitalWrite und delay oder was muss ich machen?

Bin erst neu beim Programmieren mit dem Arduino und verstehe noch relativ wenig davon.
Bisher habe ich nur zwei Blinkreihenfolgen programmiert.

Und wieso machst du nicht, worum wir dich gebeten haben ?
So ist eine Hilfe sehr schwer.

Je mehr ich darüber nachdenke desto weniger brauch ich die Switch/Case Anweisung.
Eigentlich sollte ein Timer und die Matrix langen, grübel.

Hier ist mein Code für meine Platine (In diesem Code verwende ich allerdings 20 LEDs)

void setup() {
//Alle Outputs
  pinMode(13,OUTPUT); // Pin 14 auf der Platine
  pinMode(12,OUTPUT); // Pin 1 auf der Platine
  pinMode(11,OUTPUT); // Pin 2 auf der Platine
  pinMode(10,OUTPUT); // Pin 3 auf der Platine
  pinMode(9,OUTPUT);  // Pin 4 auf der Platine
  pinMode(8,OUTPUT);  // Pin 5 auf der Platine
  pinMode(7,OUTPUT);  // Pin 6 auf der Platine
  pinMode(6,OUTPUT);  // Pin 7 auf der Platine
  pinMode(5,OUTPUT);  // Pin 8 auf der Platine
  pinMode(4,OUTPUT);  // Pin 9, 10, 11 auf der Platine
  pinMode(3,OUTPUT);  // Pin 13 auf der Platine
  pinMode(2,OUTPUT);  // Pin 12 auf der Platine
  pinMode(A0,OUTPUT); // Pin 15 auf der Platine
  pinMode(A1,OUTPUT); // Pin 16 auf der Platine
  pinMode(A4,OUTPUT); // Pin 17 auf der Platine
  pinMode(A5,OUTPUT); // Pin 18 auf der Platine
                      // Pin 19 und 20 sind nicht besetzt

//Alle Inputs
  pinMode(A2,INPUT); //Input vom LDR
  pinMode(A3,INPUT); //Input von S2
  pinMode(A6,INPUT); //Input von S3
  pinMode(A7,INPUT); //Input von S4
}

void loop() {
//Erster Test --> Alle LED´s ein und ausschalten in abständen von 50ms

digitalWrite(12,HIGH);
delay(50);
digitalWrite(12,LOW);
delay(50);
digitalWrite(11,HIGH);
delay(50);
digitalWrite(11,LOW);
delay(50);
digitalWrite(10,HIGH);
delay(50);
digitalWrite(10,LOW);
delay(50);
digitalWrite(9,HIGH);
delay(50);
digitalWrite(9,LOW);
delay(50);
digitalWrite(8,HIGH);
delay(50);
digitalWrite(8,LOW);
delay(50);
digitalWrite(7,HIGH);
delay(50);
digitalWrite(7,LOW);
delay(50);
digitalWrite(6,HIGH);
delay(50);
digitalWrite(6,LOW);
delay(50);
digitalWrite(5,HIGH);
delay(50);
digitalWrite(5,LOW);
delay(50);
digitalWrite(4,HIGH);
delay(50);
digitalWrite(4,LOW);
delay(50);           //Erste Hälfte

digitalWrite(2,HIGH);
delay(50);
digitalWrite(2,LOW);
delay(50);
digitalWrite(3,HIGH);
delay(50);
digitalWrite(3,LOW);
delay(50);
digitalWrite(13,HIGH);
delay(50);
digitalWrite(13,LOW);
delay(50);
digitalWrite(A0,HIGH);
delay(50);
digitalWrite(A0,LOW);
delay(50);
digitalWrite(A1,HIGH);
delay(50);
digitalWrite(A1,LOW);
delay(50);
digitalWrite(A4,HIGH);
delay(50);
digitalWrite(A4,LOW);
delay(50);
digitalWrite(A5,HIGH);
delay(50);
digitalWrite(A5,LOW);
delay(50);


}

Sorry
Ich haben meinen bisherigen Code nun gepostet.

hast du dir schon die Beispiele durchgesehen, wie man einen Schalte/Taster ausliest?
Außerdem fehlt noch dein Schaltplan.
Ohne Schaltplan von dir sehen wir nicht, wie deine Schalter/Taster angeschlossen sind.

sonst halt weiterhin rumgerate

void setup() {
  //Alle Outputs
  pinMode(13, OUTPUT); // Pin 14 auf der Platine
  pinMode(12, OUTPUT); // Pin 1 auf der Platine
  pinMode(11, OUTPUT); // Pin 2 auf der Platine
  pinMode(10, OUTPUT); // Pin 3 auf der Platine
  pinMode(9, OUTPUT); // Pin 4 auf der Platine
  pinMode(8, OUTPUT); // Pin 5 auf der Platine
  pinMode(7, OUTPUT); // Pin 6 auf der Platine
  pinMode(6, OUTPUT); // Pin 7 auf der Platine
  pinMode(5, OUTPUT); // Pin 8 auf der Platine
  pinMode(4, OUTPUT); // Pin 9, 10, 11 auf der Platine
  pinMode(3, OUTPUT); // Pin 13 auf der Platine
  pinMode(2, OUTPUT); // Pin 12 auf der Platine
  pinMode(A0, OUTPUT); // Pin 15 auf der Platine
  pinMode(A1, OUTPUT); // Pin 16 auf der Platine
  pinMode(A4, OUTPUT); // Pin 17 auf der Platine
  pinMode(A5, OUTPUT); // Pin 18 auf der Platine
  // Pin 19 und 20 sind nicht besetzt

  //Alle Inputs
  pinMode(A2, INPUT); //Input vom LDR
  pinMode(A3, INPUT); //Input von S2
  pinMode(A6, INPUT); //Input von S3
  pinMode(A7, INPUT); //Input von S4
}

void loop() {

  if (digitalRead(A3) == HIGH)   // wenn der Taster mit einem externen Pulldown Widerstand angeschlossen ist und bei Tastendruck gegen 5V schließt.
  {
    einAblauf();
  }


}

void einAblauf()
{
  digitalWrite(12, HIGH);
  delay(50);
  digitalWrite(12, LOW);
  delay(50);
  digitalWrite(11, HIGH);
  delay(50);
  digitalWrite(11, LOW);
  delay(50);
  digitalWrite(10, HIGH);
  delay(50);
  digitalWrite(10, LOW);
  delay(50);
  digitalWrite(9, HIGH);
  delay(50);
  digitalWrite(9, LOW);
  delay(50);
  digitalWrite(8, HIGH);
  delay(50);
  digitalWrite(8, LOW);
  delay(50);
  digitalWrite(7, HIGH);
  delay(50);
  digitalWrite(7, LOW);
  delay(50);
  digitalWrite(6, HIGH);
  delay(50);
  digitalWrite(6, LOW);
  delay(50);
  digitalWrite(5, HIGH);
  delay(50);
  digitalWrite(5, LOW);
  delay(50);
  digitalWrite(4, HIGH);
  delay(50);
  digitalWrite(4, LOW);
  delay(50);           //Erste Hälfte

  digitalWrite(2, HIGH);
  delay(50);
  digitalWrite(2, LOW);
  delay(50);
  digitalWrite(3, HIGH);
  delay(50);
  digitalWrite(3, LOW);
  delay(50);
  digitalWrite(13, HIGH);
  delay(50);
  digitalWrite(13, LOW);
  delay(50);
  digitalWrite(A0, HIGH);
  delay(50);
  digitalWrite(A0, LOW);
  delay(50);
  digitalWrite(A1, HIGH);
  delay(50);
  digitalWrite(A1, LOW);
  delay(50);
  digitalWrite(A4, HIGH);
  delay(50);
  digitalWrite(A4, LOW);
  delay(50);
  digitalWrite(A5, HIGH);
  delay(50);
  digitalWrite(A5, LOW);
  delay(50);
}

Nein ich habe mich noch nicht damit beschäftigt.
Hier der Schaltplan.

Das was du geschrieben hast funktioniert schonmal! Danke!

Pin A6 und A7 können nicht als digitale Pins verwendet werden!

Sketch von #11 in Wokwi simulation:

Ihre Sketch mit ein wenig modernem 'C++' geändert.
Die beiden Tasten und das Potentiometer machen etwas:

Hallo,
Möglichkeiten gibts wie immer viele. Stell Dir einfach mal vor wenn der erste Schalter ein ist lässt Du einen Zähler mit einem festen Zeittakt von 0 an hochlaufen. Den Zeittakt machst Du am besten mit millis(). Kommt er bei 10 an setzt Du Ihn sofort wieder auf 0 . Dann hat er die Zustände von 0-9. Bei dem anderen Schalter geht das dann rückwärts von 9 bis 0 . Bei jedem Zustand schaltest Du eine LED ein und die vorhergehende und nachfolgende aus.

 if (count==0){
  digitalWrite(ledpin0,HIGH);
  digitalWrite(ledpin1,LOW); // nexte aus 
  digitalWrite(ledpin9,LOW); // vorhergehend aus 
 }

Jetzt hast Du eigentlich schon eine Ablaufsteuerung oder Schrittkette gebaut.
Wenn Du dann die Ausgänge der LED noch geschickt in Array packst kannst Du mit dem Zählerstand direkt die entsprechende LED ansteuern.

const byte LEDpin[]={2,3,4,5,6...} // Eingänge in einem Array zuorden
.
.
digitalWrite(LEDpin[count],HIGH); // LED einschalten

Das ist jetzt ein bisschen viel auf einmal gehe also schrittweise vor

Zeittakt mit millis() erzeugen
Zähler bauen der auf 0-9 und ab 9-0 zählt
mittels if.. oder switch case die LEDs ansteuern
Lerne wie man Array verwendet und die auf Eingänge und Ausgänge anwendet

Heinz

Danke für den neuen Code, ich habe aber das Problem das ich den Arduino Festgelötet habe und keinen Potentiometer einbauen kann.
Wenn ich die Pins A6 und A7 nicht als Digital Eingang verwenden kann gibt es noch eine andere Möglichkeit das Projekt laufen zu lassen? (Also nur am Code zu arbeiten)

Hallo Heinz,
Mein Problem ist nicht die Reihenfolge in welche meine LEDs blinken sollen, das habe ich jetzt schon verstanden und auch umgesetzt (mit einem if command)
Jetzt ist mein Problem, das ich nicht verstehe wie ich A6 und A7 welche kein Digital Read ausführen oder erfassen können trotzdem so hinbekomme das es doch funktioniert (Möglicherweise mit einen Anolog Read aber da muss ich mich erstmal schlau machen)

Allerdings hab ich mich über die Array Sache gerade informiert und fand das extrem Kompliziert trotzdem vielen dank für die Hilfe!

Bei A6 und A7 brauchst du einen externen Widerstand und dann:

if( analogRead( A6) > 512)
{
  ...
}

Wokwi simuliert jedoch keine analogen Signale, daher konnte ich das in Wokwi nicht tun. Deshalb habe ich statt des LDR auch ein Potmeter verwendet.

1 Like

Ich weiss nicht warum und wieso, aber Deine andauernde Werbung für ein - zumal hier nicht mal funktionierendes - Irgendwas, gibt mir Rätsel.

Zumal Du offensichtlich den Code und die Voraussetzungen weder gelesen noch verstanden hast.

Sprichst du von meiner unverblümten Werbung für Wokwi? Und das stört Sie? Hahaha.

Manchmal kann es für andere hilfreich sein, zu sehen, was die Sketch tatsächlich tut. Ich habe keine Lösung angegeben. Ich habe nur versucht, ein wenig Unterstützung zu geben.

Ja und dann??

Ich hab den Thread gelesen und verstehe nicht, wo das alles hinführen soll.

Das, was Du suchst ist doch recht einfach.
3 Schalter - 3 BIT.
Daraus machst Du ein Byte.
Das ist sogar noch einfacher, weil Du nur und ausschliesslich auf einen Schalterpin reagieren willst.

Ja, das mit den AnalogPin's, die nicht digital ausgewertet werden können, muss man tricksen. - Wobei mir nicht klar ist, warum man nicht einfach einen Pin-Tausch machen kann und die nicht digital auswertbaren Pins als Outputs benutzt. (Ja, Du hast eine Leiterplatte - aber die ist doch noch umbaubar)

Und dazu Deine Initialisierung und den ganzen Teil drum rum.
Warum machst Du Dir das so mühselig?

Das ist der Ansatz(!)
Du darfst gerne daraus weiter entwickeln.
Gerne auch fragen, was daraus und wie geht.

const byte ledPin[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
const byte switchPin[] = {A3, A6, A7};
void setup()
{
  Serial.begin(115200);
  Serial.println(F("Start..."));
  for (uint8_t i = 0; i < sizeof(ledPin); i++)
  {
    pinMode(ledPin[i], OUTPUT);
  }
  for (uint8_t i = 0; i < sizeof(switchPin); i++)
  {
    pinMode(switchPin[i], INPUT);
  }
}

void loop() {
  Serial.println(giveMeBitMuster());
  delay(1000);
}

byte giveMeBitMuster()
{
  byte myVar = 0;
  for (uint8_t i = 0; i < sizeof(switchPin); i++)
  {
    if (analogRead(switchPin[i]) < 10)
    {
      myVar = 1 << i;
    }
  }
  return myVar;
}

Spiele den Code ein, setze Deine Schalterstellungen so, wie Du willst.
Beobachte den Seriellen Monitor.
Ist es das, was Du willst?
Wenn ja - > daraus entwickel Deine LED-Blinker

Wenn Nein, dann schreib was Du erwartest.