Anschluss vieler LEDs an wenige Ausgänge

Der Pragmatische Architekt  –  10 Kommentare

Bisher hatten wir die Grundlagen elektronischer Schaltungen im Schnellverfahren kennengelernt, bevor wir uns in der letzten Folge mit dem Selbstbau eines Arduino beschäftigt haben. Dieser und die darauf folgenden Blog-Beiträge zeigen Schaltungen und ihre Optimierung. Im vorliegenden Post geht es um das Shiftregister 74HC595, und wie es sich geschickt nutzen lässt, um Ports einzusparen.

Ein Genuino/Arduino Uno besitzt auf dem ersten Blick zahlreiche digitale und analoge Ports. Daher liegt es nahe, die Zahl der verfügbaren Ports zu überschätzen. Das möchte ich anhand eines trivialen Schaltkreises demonstrieren.

Aufgabe

Die Aufgabe besteht darin, acht LEDs an den Arduino anzuschließen und diese zu steuern.

Lösung

Dazu verwenden wir acht digitale Arduino-Ports, die acht LEDs ansteuern. Die LEDs befinden sich auf einem Steckbrett (Breadboard), wobei jede LED (kürzeres Beinchen) über einen 220-Ohm- (oder 330-Ohm-)Widerstand an Erde angeschlossen wird. Wir erinnern uns, dass LEDs maximal 25 mA Stromstärke vertragen, weshalb wir Widerstände zur Begrenzung des Stroms verwenden müssen.

Die digitalen Ausgänge des Arduino verbinden wir über Drähte mit den LEDs (längeres Beinchen). Das Ganze finden Sie in der nachfolgenden Abbildung illustriert.

Mehrere LEDs werden direkt an den Arduino angeschlossen

Ein entsprechendes Arduino-Programm, das auf Basis des Blink-Programms entstanden ist, und das sie für die Ansteuerung weiterer LEDs erweitern können, ist das Folgende:

const int LED1 = 8;         // LED1 liegt am digitalen Port 8, 
// LED2 an 9 ...
const int LED2 = 9;
void setup() {
pinMode(LED1, OUTPUT); // Der Port von LED1 bzw. LED 2 ist ein Ausgang
pinMode(LED2, OUTPUT);
}

void loop() {
digitalWrite(LED1, HIGH); // LED1 an
digitalWrite(LED2, HIGH); // LED2 an
delay(1000); // eine Sekunde warten
digitalWrite(LED1, LOW); // LED1 aus
digitalWrite(LED2, LOW); // LED2 aus
delay(1000); // eine Sekunde warten und dann von vorn
}

Problem

Dies funktioniert aber nur so lange, wie die Zahl der digitalen Ports des Arduino Uno ausreicht. Bei Anschluss zu vieler LEDs erweist sich die beschränkte Zahl der digitalen Ports als Problem. Sind es mehr LEDs als verfügbare Ports, ist diese Begrenzung sogar ein Show Blocker.

Natürlich könnten wir auf die Idee kommen, einen Arduino MEGA zu besorgen, der wesentlich mehr Ports besitzt als das Uno-Board, aber auch dort stößt der Entwickler irgendwann an die Grenzen.

Lösungsalternative

Es gibt eine elegante Lösung für das besagte Problem, die wir im dritten Teil des Elektronik-Crashkurses bereits kurz kennen gelernt haben. Das Stichwort lautet: 74HC595. Hierbei handelt es sich um ein sogenanntes Shiftregister, dem wir seriell Bytes übergeben können, wobei das Shiftregister das Byte als Bitfolge interpretiert und die einzelnen Bits an seinen acht Ausgängen Q0, Q1, ... Q7 anlegt. Aus 19 hex wird dann zum Beispiel binär 00010011. Jede 0 wird als LOW-Signal (0V) am entsprechenden Ausgang angelegt, jede 1 als HIGH-Signal (5V). Und damit können wir LEDs ein- und ausschalten (!!!)

Pinbelegung eines 74HC595

Das Shiftregister 74HC595 hat die folgende Pinbelegung:

Die drei wichtigsten Pins des Bausteins sind:

  • Pin 14: Data – zum Senden von Datenbytes ans Shiftregister
  • Pin 12: Latch – zum Ausgaben des gespeicherten Bytes an den Ausgängen
  • Pin 11: Clock – als Taktgeber für Aktivitäten

Wir demonstrieren

In unserer Schaltung verbinden wir den digitalen Port 8 des Arduino mit dem Latch (grüner Draht), den digitalen Port 12 mit Clock (violetter Draht), den Arduino-Digitalport 11 mit Data (gelber Draht):

Schaltung mit Stiftregister 74HC595

Der Kopf des ICs ist auf dem Schaltbild nach rechts gerichtet. Die rechte Seite des IC (d.h. dessen Pins 9 bis 16) liegt also direkt gegenüber dem abgebildeten Arduino. Die linke Seite (Pins 1 bis 8) ist den LEDs zugewandt. Wir benötigen demzufolge nur noch die genannten drei Ports des Arduino, um acht LEDs anzusteuern.

Die Ausgangspins des Shiftregisters an den IC-Ports 1 (Q1) bis 7 (Q7) und 15 (Q0) repräsentieren die Bits des gespeicherten Bytes. Diese Ausgänge werden mit den Spannungsversorgungs-Polen der LEDs verbunden (längeres Beinchen). Die LEDs und Widerstände befinden sich in der abgebildeten Schaltung auf dem oberen Breadboard. Zudem sind zu verbinden:

  • Pin 16 des IC (=Vcc) mit Spannung
  • Pin 10 des IC (= MR) ebenfalls mit Spannung
  • Pin 13 des IC (= OE) mit GND
  • Pin 8 des IC (= GND) mit GND
  • Die rote, horizontale Leitung des Breadboards verbinden wir mit dem 5V-Ausgang des Arduino.
  • Die blaue, horizontale Leitung des Breadboards verbinden wir mit dem GND-Dasgang des Arduino

Da in der oben dargestellten Schaltung zwei Breadboards im Einsatz sind, müssen deren roten (Spannung) und blauen horizontalen Leitungen (Erdung) jeweils miteinander verbunden werden. Das Ganze kann aber auch problemlos mit nur einem Breadboard bewerkstelligt werden.

Zum Vermeiden von Fluktuationen verbinden wir den Latch des ICs (Pin 12) über einen Keramikkondensator 1 yF mit dem blauen Terminalstrip. Zum Testen der Schaltung eignet sich folgendes Programm (Arduino-Sketch):

int pinLatch = 8;  // verbunden mit ST_CP => latch
int pinClock = 12; // verbunden mit SH_CP => clock
int pinData = 11; // verbunden mit DS => data

void setup() {
pinMode(pinLatch, OUTPUT); // Alle Arduino-Pina dienen zur digitalen Ausgabe
pinMode(pinClock, OUTPUT);
pinMode(pinData, OUTPUT);
}

void loop() {
for (int byteVal = 0; byteVal < 256; byteVal++) {
// latch pin ST_CP auf low => Zahl wird noch nicht am Ausgang angelegt
digitalWrite(pinLatch, LOW);

// nun speichern wir die Zahl byteVal im Datenregister:
shiftOut(pinData, pinClock, MSBFIRST, byteVal);

// latch pin auf High => 74HC595 Ports Q0,..,Q7 geben die Bits aus
digitalWrite(pinLatch, HIGH);

// Kleine Verschnaufpause für uns als Beobachter
delay(200);
}
}

Serienweise Shiftregister

Natürlich könnte man jetzt argumentieren, dass wir zwar 5 Ports einsparen, aber die Zahl der LEDs immer noch begrenzt ist. Dem ist entgegenzuhalten, dass sich zum einen über Pin 9 des 74HC595 ein weiteres Shiftregister anschließen lässt. Zum anderen gibt es Shiftregister mit 16 Bits, etwa den 74HC165. Auch diese Bausteine lassen sich in Reihe schalten. Wir können also eine ganze Menge LEDs steuern. In einer späteren Folge dieser Reihe lernen Sie allerdings eine noch bequemere Variante kennen, die NeoPixel von Adafruit.

Weitere Informationen

Wer weitere Experimente durchführen will, der sei auf ein exzellentes Tutorial (ShiftOut Tutorial) von Carly Maw und Tom Igoe verwiesen. Ich habe mich bei meiner eigenen Schaltung an dem genannten Tutorial orientiert, damit Sie die dortigen Beispiele nutzen können, ohne das Programm oder die Schaltung refaktorisieren zu müssen.

Letzte Worte

IoT-Geräte auf Basis von Mikrocontrollern haben physikalische Einschränkungen. In diesem Post haben wir eine solche Einschränkung kennengelernt. In den nächsten Posts gehe ich auf ein paar weitere Beispiele ein, wie wir Einschränkungen umgehen können, und welche Möglichkeiten es gibt, Sensoren & Aktoren anzuschließen. Außerdem tasten wir uns Schritt für Schritt zur seriellen Kommunikation vom PC zum Arduino vor.