Arduino Grundlagen Teil 9: Mehrere LEDs dimmen

Im Beispiel >> Eine LED dimmen haben wir jede LED einzeln aufgeführt, als Ausgang festgelegt und angesprochen. Wir mussten also dieselbe Zeile jeweils vier Mal kopieren und leicht verändern. Bei vier LEDs mag das vielleicht noch funktionieren, aber praktikabel ist es irgendwann nicht mehr. Wie wir mehrere LEDs dimmen können beschäftigt uns heute!

Ein Arduino LED Lauflicht programmieren mittels Array

Komponenten-Liste

Für die Umsetzung brauchen wir folgende Komponenten:

Um uns solche Aufgaben zu vereinfachen, kann man auch Arrays nutzen. Ein Array ist ein so genanntes Feld von Daten. Man kann also einer Variablen gleichzeitig mehrere Werte zuweisen und auf die einzelnen Werte wieder zugreifen.

Wir schauen uns das am besten direkt an dem Programm an.

// Dem Array out_LEDs[] die Nummern 
// der vier Pins zuweisen.
const uint8_t out_LEDs[] = {3, 5, 6, 9}

// Das Setup
void setup() {
  // In einer Schleife von 0 bis 3 zählen.
  for (uint8_t i = 0 ; i <= 3 ; i++ ){
    // Den vier Pins sagen, dass sie Ausgänge sind.
    pinMode(out_LEDs[i], OUTPUT);	
  }
}

// Die Haupt-Schleife (Main-Loop)
void loop() {
  // In einer Schleife von 0 bis 255 zählen.
  for (uint8_t i = 0 ; i <= 255 ; i++ ){ 
    // In einer Schleife von 0 bis 3 zählen.
    for (uint8_t j = 0 ; j <= 3 ; j++ ){
      // Den vier Ausgängen nacheinander 
      // den Wert  von i zuweisen.
      analogWrite(out_LEDs[j], i);
    }
    delay(10); // 10ms warten.
  }
  // In einer Schleife von 255 bis 0 zählen.
  for (uint8_t i = 255 ; i >= 0 ; i-- ){
    // In einer Schleife von 0 bis 3 zählen.
    for (uint8_t j = 0 ; j <= 3 ; j++ ){
      // Dem aktuellen Ausgang einen Wert zuweisen.
      analogWrite(out_LEDs[j], i);
    }
    delay(10); // 10ms warten.
  }
}

 

Verwendete Datentypen

Wir nutzen hier den Datentyp uint8_t. Dies ist eine Variante des Integer Datentyps, welcher ganzzahlige Werte/Zahlen annehmen kann. Oftmals wird einfach int genommen, das hat aber einen kleinen Nachteil. Ein Integer kann verschiedene Längen bzw. Größen haben. Es ist also sinnvoll bei der Deklaration anzugeben, um was für einen Integer es sich handelt.

Die von mir am häufigsten verwendeten Integer sind:

Datentyp Anzahl Bits Minimum Maximum
int8_t 8 -128 127
uint8_t 8 0 255
int16_t 16 -32768 32767
uint16_t 16 0 65535

Anhand dieser Auflistung erkennt man auch gut, was das vorgestellte u bewirkt. Das u steht für unsigned, also „ohne Vorzeichen“. Man muss sich also vor der Deklaration überlegen, wie groß der Zahlenwert werden und ob er negative Werte annehmen kann.

Da Speicherplatz in den letzten Jahren billig geworden ist, wird oftmals nicht auf platzsparende Variablen-Deklaration geachtet. Bei einem Mikro-Controller ist der Speicherplatz allerdings begrenzt, weswegen wir uns von Anfang an eine platzsparende Programmierung angewöhnen sollten.

Die Ein-/Ausgänge eines Arduinos beginnen beim Pin 0 und gehen nicht über 100 (das ist schon eine übertrieben hohe Zahl) hinaus. Es werden also nicht mehr als 8Bit benötigt, um alle Ein-/Ausgänge des Arduinos zuweisen zu können. Ein sinnvoller Datentyp wäre also uint8_t.

TIPP
Manchmal möchte man zur Fehleranalyse (Debugging) einen Ein-/Ausgang „stumm schalten“. Eine praktikable Möglichkeit ist, die Variable des besagten Ein-/Ausgangs auf den Wert -1 zu setzen. Die Befehle/Zugriffe/… werden dadurch ins Nirwana geschoben. Möchte man dies machen, muss man anstatt uint8_t den Datentyp int8_t verwenden, um an die negativen Zahlen ranzukommen.

Deklaration des Arrays

Durch die Zeile

const uint8_t out_LEDs[] = {3, 5, 6, 9}

weisen wir dem Array out_LEDs[] die Werte 3, 5, 6 und 9 zu. Dies sind unsere Ausgänge, an denen wir die LEDs angeschlossen haben. Wir haben also ein Array (ein Feld) mit vier Stellen.

Was anfangs meist etwas verwirrend ist, ist der Zugriff auf die vier Werte. Die erste Stelle unseres Arrays ist nicht bei

out_LEDs[1]

sondern bei

out_LEDs[0]

Ein Array beginnt also immer an der Stelle 0.

Zugriff auf die einzelnen Stellen des Arrays

In der Schleife

for (int i = 0 ; i <= 3 ; i++ ){

zählen wir von 0 bis 3. Das entspricht den ersten vier Stellen des Arrays.

Die Variable i wird daraufhin in folgender Zeile genutzt

pinMode(out_LEDs[i], OUTPUT);

um auf die jeweiligen Stellen des Arrays zuzugreifen. Die einzelnen Stellen haben folgende Werte:

  • out_LEDs[0] = 3
  • out_LEDs[1] = 5
  • out_LEDs[2] = 6
  • out_LEDs[3] = 9

In diesem Beispiel mag es vielleicht nicht als sinnvoll erscheinen, die einzeln aufgeführten Ausgänge und Variablen gegen ein Array zu tauschen. Im nun folgenden Artikel “LED Lauflicht” wird aber ersichtlich, warum solch ein Array sehr praktisch sein kann.

LED Lauflicht mit vier LEDs

Dieses Beispiel-Programm erzeugt ein Lauflicht mit vier LEDs. Es ist sicher nicht die effektivste Methode ein Lauflicht zu erzeugen, aber anhand von diesem Beispiel können wir uns ein paar praktische Vorgehensweisen anschauen.

Du kannst das Programm direkt kopieren und auf Deinen Arduino laden. Achte aber darauf, dass die LEDs so angeschlossen sind, wie wir es im Artikel >> Mehrere LEDs ansteuern & blinken lassen gemacht haben.

// Dem Array out_LEDs[] die Nummern
// der vier Pins zuweisen.
const uint8_t out_LEDs[] = {3, 5, 6, 9};

// Das Setup
void setup() {
  // In einer Schleife von 0 bis 3 zählen.
  for (int8_t i = 0 ; i <= 3 ; i++ ) {
    // Den vier Pins sagen, dass sie Ausgänge sind.
    pinMode(out_LEDs[i], OUTPUT);
  }
}

// Die Haupt-Schleife (Main-Loop)
void loop() {
  // In einer Schleife alle Ausgänge abarbeiten.
  for (int8_t j = 0 ; j <= 3 ; j++ ) {
    // Von 0 bis 255 zählen zum Hochfaden.
    for (int16_t i = 0 ; i <= 255 ; i = i + 5 ) {
      // Dem aktuellen Ausgang den Wert zuweisen.
      analogWrite(out_LEDs[j], i);
      delay(5); // Diesen Wert kannst Du verändern.
    }
    delay(100); // Diesen Wert kannst Du verändern
    // Von 255 bis 0 zählen zum Runterfaden.
    for (int16_t i = 255 ; i >= 0 ; i = i - 5 ) {
      // Dem aktuellen Ausgang den Wert zuweisen.
      analogWrite(out_LEDs[j], i);
      delay(5); // Diesen Wert kannst Du verändern.
    }
  }
}

Listing 2: Ein Beispiel-Programm für ein LED Lauflicht

Wie gehabt, musst Du in der Arduino IDE Dein Board und den passenden Port auswählen. Danach kannst Du das Programm hochladen und das LED Lauflicht sollte starten.

Erklärung: Mehrere LEDs dimmen

Dieses Programm ist vielleicht nicht unbedingt elegant gelöst, aber dafür einfach verständlich. Wir haben eine äußere Schleife, in der wir von 0 bis 3 zählen.

// In einer Schleife alle Ausgänge abarbeiten.
for (int8_t j = 0 ; j <= 3 ; j++ ) {

Die erste Stelle eines Arrays ist die Stelle 0. Da wir vier Werte in das Array geschrieben haben, geht das Array also von 0 bis 3.

Währenddessen zählen wir von 0 bis 255, was die möglichen Werte sind, mit denen wir die LEDs ansteuern können.

// Von 0 bis 255 zählen zum Hochfaden.
for (int16_t i = 0 ; i <= 255 ; i = i + 5 ) {

Während in 5er Schritte von 0 bis 255 gezählt wird, weisen wir dem aktuellen Ausgang (z.B. Array[0], also Pin 3) den jeweiligen Wert zu.

Möchtest Du, dass das Hochfaden schneller oder langsamer geht, kannst du den Wert der Zeile

delay(5); // Diesen Wert kannst Du verändern.

verändern. Der Wert wird in Millisekunden (ms) angegeben.

Danach ist das Hochfaden abgeschlossen und wir warten 100ms. Diesen Wert kannst Du ebenfalls anpassen.

delay(100); // Diesen Wert kannst Du verändern

Nun kommt das Runterfaden. Es funktioniert genauso wie das Hochfaden, nur mit dem kleinen Unterschied, dass von 255 bis 0 runter gezählt wird.

// Von 255 bis 0 zählen zum Runterfaden.
for (int16_t i = 255 ; i >= 0 ; i = i – 5 ) {

// Dem aktuellen Ausgang den Wert zuweisen.
analogWrite(out_LEDs[j], i);
delay(5); // Diesen Wert kannst Du verändern.

}

Damit ist der erste Durchgang der äußeren Schleife

for (int8_t j = 0 ; j <= 3 ; j++ ) {

abgearbeitet und es wird für die zweite, dritte und vierte LED wiederholt.

Hier wieder ein kurzes Beispiel-Video (ohne Ton!):


Arduino Grundlagen Kurs im Überblick:

>> Teil 1: Der Arduino im Detail
>> Teil 2: Die Bauteile des Arduino
>>Teil 3: Ein Programm auf einen Arduino laden
>> Teil 4: Eine LED blinken lassen!
>> Teil 5: Eine externe LED blinken lassen
>> Teil 6: Die LED Schaltung im Detail
>> Teil 7: Mehrere LEDs ansteuern & blinken lassen
>> Teil 8: Eine LED dimmen
>> Teil 9: Mehrere LEDs dimmen
>> Teil 10: Taster an Arduino anschließen
>> Teil 11: Serielle Schnittstelle
>> Teil 12: Softwareserial Library

Kommentar hinterlassen zu "Arduino Grundlagen Teil 9: Mehrere LEDs dimmen"

Hinterlasse einen Kommentar

E-Mail Adresse wird nicht veröffentlicht.


*


*