zum Shop
Schieberegister – Am Arduino anschließen
Kategorien: Arduino
Gehen uns die Ausgabepins an unserem Arduino aus, können wir einfach und preisgünstig mit einem oder mehreren Schieberegistern die Pinanzahl erhöhen.
Pro Schieberegister können wir 8 weitere Pins hinzufügen.
Zum Anschließen von weiteren 8 Pins werden lediglich einmalig 3 freie Pins am Arduino benötigt.
Wie eine Schieberegister funktioniert, könnt Ihr unter “Schieberegister – Was ist das?” nachlesen.
In diesem Beitrag zeige ich Euch, wie Ihr ein Schieberegister über das SPI-Bussystem anschließen könnt und gehe auf den Schaltplan ein.
Danach erweitern wir noch unser Schieberegister um ein weiteres Register.
Zuerst einmal die Liste der Bauteile die wir benötigen:
- 1-2 Schieberegister Typ 74HC595
- 8-16 Widerstände 1kΩ
- 8-16 LEDs (rot, gelb, oder grün)
- Kabel
- Breadboard
Beginnen wir mit dem Schaltplan:
Fangen wir von hinten an. Pin QA – QH sind unsere 8 Ausgabepins, an die wir jeweils 8 Vorwiderstände und 8 LEDs anschließen.
Der Pin 9 “QH*” ist in diesem Schaltplan nicht belegt. Dieser Pin leitet den seriellen Input an ein weiteres vorhandenes Schieberegister.
Der Pin 14 “SER” (in einigen Datenblättern auch SI oder DS genannt) ist der serielle Input. An diesem Pin werden wir Bit für Bit den gewünschten Zustand in das Schieberegister übertragen.
Das Schieberegister verfügt über einen Zwischenspeicher und erst durch ein Freischalten werden alle Bits in einem Rutsch an die Ausgabepins weitergleitet.
Pin 11 “SCK” (alias SHCP, SRCLK) ist der ShiftRegisterClock-Pin, der dafür sorgt, dass durch eine LH-Flanke (Ein Zustandswechsel von Low nach High wird als Flanke bezeichnet) alle Bits im Register um jeweils eine Stelle verschoben werden und das am PIN 14 “SER” anliegende Bit in das Schieberegister aufgenommen werden kann. Das geschieht so lange, bis das oder die Register (bei mehreren) voll sind.
Die Flankenwechsel, so wie das Übertragen der einzelnen Bits werden wir von unserem Arduino aus übernehmen, genau so wie das Kopieren aller Bits des Zwischenspeichers an die Ausgabe, wofür ein weiterer LH-Flankenwechsel am Pin 12 “RCK” (alias STCP (StoreClockPin), RCLK) Register Clock ausgeführt wird, damit dies geschieht.
Pin 13 “G” (alias OE) Open enabled ist ein Low-Aktiver Pin. Dies erkennt man daran, dass im Datenblatt über dem G ein Strich ist. Low-Aktiv heißt, wenn wir die Ausgabepins des Bausteins nutzen wollen, müssen wir ihn aktivieren und somit den Pin mit GND verbinden.
Pin 10 “SCLR” (alias SRCLK, MR) ist der StoreClockPin-Reset oder auch MasterReset-Pin genannt. Dieser Pin ist ebenfalls Low-Aktiv und resettet das gesamte Register. Das wollen wir nicht, also müssen wir den Pin mit +5V verbinden.
Pin 8 “GND” und Pin 16 “VCC” sollten klar sein.
So, jetzt setzen wir den Schaltplan auf unserem Breadboard um, das sollte dann in Etwa so aussehen:
Beachtet, dass ich als Vorwiderstand 1kΩ gewählt habe. Der Grund ist, dass das Schieberegister auf allen Pins eigentlich nur insgesamt 70mA (8,75mA pro Pin) verträgt. Bei sehr vielen Seiten im Netz ignoriert man das.
Das Bauteil läuft auch wenn wir jede LED mit 18mA (insgesamt 144mA) pro Pin betreiben, aber damit liegen wir mit dem doppelten Wert weit drüber und auf Dauer ist das keine gute Idee.
Mit 1kΩ haben wir rund 3mA pro LED und bleiben deutlich im Rahmen.
Lösungen, um das Problem zu umgehen könnt Ihr auch unter “Schieberegister – Was ist das?” nachlesen.
Es gibt beispielsweise preisgünstige Darlington-Arrays in IC-Form, um höhere Lasten ordnungsgemäß betreiben zu können.
So, jetzt brauchen wir noch einen Arduino-Sketch, um unsere Schaltung endlich ausprobieren zu können.
Was genau geschieht, habe ich im Quellcode dokumentiert und wenn Ihr es richtig angeschlossen habt, sollte nach dem Hochladen des Sketches die erste LED aufleuchten und dann um eine Stelle nach vorne wandern, dann kommt eine zweite LED usw.
Es werden die Zahlen von 0-255 in binärer Schreibweise dargestellt. Alles was leuchtet ist 1 und die anderen 0.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
/* * 8 LEDs zeigen die Zahlen von 0-255 binär an. * (1 = 000000001 | 2 = 000000010 | 3 = 000000011 usw.) * LED aus = 0 * LED ein = 1 */ int shiftPin = 8; // Pin SCK an 74HC595 int storePin = 9; // PIN RCK an 74HC595 int dataPin = 10; // Pin SER an 74HC595 int counter = 0; // Counter initialisieren void setup() { pinMode(storePin, OUTPUT); // Pin auf Output setzen pinMode(shiftPin, OUTPUT); // Pin auf Output setzen pinMode(dataPin, OUTPUT); // Pin auf Output setzen } void loop () { digitalWrite(storePin, LOW); // Wir ziehen den RegisterClockPin auf Low shiftOut(dataPin, shiftPin, MSBFIRST, counter); // Jetzt koennen wir eine Zahl (counter) übertragen und // im selben Schritt wird auch das StoreClockPin auf High gezogen digitalWrite(storePin, HIGH); // Wir ziehen den RegisterClockPin auf High, somit wird das Register // an Output kopiert. delay(500); // Nach 500ms wird die naechste Zahl übertragen und der Vorgang beginnt von vorne ... counter ++; // ... aber erst, wenn der Counter um eine Stelle erhoeht wird ... if (counter > 255) { // ... und nur so lange, bis die Zahl groesser als 255 ist ... counter = 0; // ... dann setzen wir die Zahl auf 0 zurueck und es beginnt von Vorne. } } |
Statt mit dem Befehl “shiftOut” können wir auch mittels digitalWrite eine binäre Zahl ausgeben lassen.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
/* * 8 LEDs zeigen eine bestimmte binaere Zahl an. * LED aus = 0 * LED ein = 1 */ int shiftPin = 8; // Pin SCK an 74HC595 int storePin = 9; // PIN RCK an 74HC595 int dataPin = 10; // Pin SER an 74HC595 int binOutput[8] = {0,0,1,0,1,0,0,1}; // = Int "41" void setup() { pinMode(storePin, OUTPUT); // Pin auf Output setzen pinMode(shiftPin, OUTPUT); // Pin auf Output setzen pinMode(dataPin, OUTPUT); // Pin auf Output setzen digitalWrite(storePin, LOW); // Wir ziehen den RegisterClockPin auf Low for (int i=8; i>=0; i--) { // Da ja First in, first out gilt, muessen wir mit dem letzten Bit beginnen, damit dieses ... // ... nach dem gesamten Schleifendurchlauf auch am Ende des Registers steht. digitalWrite(shiftPin, LOW); // Wir ziehen den StoreClockPin auf Low und ... digitalWrite(dataPin, binOutput[i]); // ... aus unserem Int-Array uebergeben wir binOutput[i] an das Register und setzen ... digitalWrite(shiftPin, HIGH); // ... StoreClockPin auf HIGH, damit die vorhandenen Werte um eine Stelle wandern ... // ... koennen und binOutput[i] an der ersten Stelle im Register eingefuegt werden kann. } digitalWrite(storePin, HIGH); // Wir ziehen den RegisterClockPin auf High, somit wird das Register an Output kopiert ... // ... und die LEDs leuchten entsprechend unserem binOutput[]-Muster } void loop () { } |
Doch was machen wir, wenn wir mehr Pins brauchen? Ganz einfach, wir kaskadieren ein weiteres Schieberegister, oder auch zwei, drei, usw. und gehen fast genau so vor.
Einziger Unterschied ist, dass wir bei zwei Schieberegistern einen größeren Adressbereich haben. Bei einem Register waren das 8Bit, also 8Pins, bei zwei Registern haben wir schon 16Bit.
Zuerst wieder der Schaltplan:
Es hat sich nicht viel verändert. Lediglich benutzen wir nun den Pin 9 “QH*” des ersten Schieberegisters, der den seriellen Input zum zweiten Register weiterschleift.
Das zweite Register ist zusätzlich mit PIN 11 SCK und Pin 12 RCK mit dem Arduino und dem ersten Register verbunden. Klar, denn auch hier muss ja der Arbeitstakt synchron sein mit dem ersten Register, wenn nun 16Bits durch alle Registerfelder durchgereicht werden müssen.
Dasselbe gilt für die Übergabe der Kopie des Registers an den Output, damit jedes Register seine 8Bit auf einmal ausgeben kann.
Und das Ganze wiederholt sich, je mehr Schieberegister wir in Serie aneinanderhängen.
Für zwei Schieberegister nochmal die beiden oberen Sketches ein wenig abgeändert:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
/* * 8 LEDs zeigen die Zahlen von 0-255 binär an. * (1 = 000000001 | 2 = 000000010 | 3 = 000000011 usw.) * LED aus = 0 * LED ein = 1 */ int shiftPin = 8; // Pin SCK an 74HC595 int storePin = 9; // PIN RCK an 74HC595 int dataPin = 10; // Pin SER an 74HC595 unsigned short counter = 0; // Counter initialisieren void setup() { pinMode(storePin, OUTPUT); // Pin auf Output setzen pinMode(shiftPin, OUTPUT); // Pin auf Output setzen pinMode(dataPin, OUTPUT); // Pin auf Output setzen } void loop () { digitalWrite(storePin, LOW); // Wir ziehen den RegisterClockPin auf Low shiftOut(dataPin, shiftPin, MSBFIRST, counter); // Jetzt koennen wir eine Zahl (counter) übertragen und // im selben Schritt wird auch das StoreClockPin auf High gezogen digitalWrite(storePin, HIGH); // Wir ziehen den RegisterClockPin auf High, somit wird das Register // an Output kopiert. delay(100); // Nach 500ms wird die naechste Zahl übertragen und der Vorgang beginnt von vorne ... counter ++; // ... aber erst, wenn der Counter um eine Stelle erhoeht wird ... if (counter > 65535) { // ... und nur so lange, bis die Zahl groesser als 65535 ist ... counter = 0; // ... dann setzen wir die Zahl auf 0 zurueck und es beginnt von Vorne. } } |
Da wir ja nun statt 2^8 Möglichkeiten haben (2 ergibt sich aus 0 oder 1 hoch 8Bit) 2^16 Möglichkeiten haben, steht uns ein Zahlenbereich von 0-65535 zur Verfügung.
Für diesen Wert reicht der Datentyp int nicht mehr aus. Wir brauchen was größeres und initialisieren in Zeile 12 stattdessen mit unsigned short.
Damit es etwas schneller läuft habe ich das Delay auf 100ms in Zeile 26 gesetzt.
Unsere if-Bedingung in Zeile 29 hat sich entsprechend unserem 16Bit-Register auch geändert. Statt 255 benutzen wir 65535.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
/* * 8 LEDs zeigen eine bestimmte binaere Zahl an. * LED aus = 0 * LED ein = 1 */ int shiftPin = 8; // Pin SCK an 74HC595 int storePin = 9; // PIN RCK an 74HC595 int dataPin = 10; // Pin SER an 74HC595 unsigned short binOutput[16] = {0,1,0,1,0,1,0,0,1,1,1,1,0,1,0,1}; // = Int "21749" void setup() { pinMode(storePin, OUTPUT); // Pin auf Output setzen pinMode(shiftPin, OUTPUT); // Pin auf Output setzen pinMode(dataPin, OUTPUT); // Pin auf Output setzen digitalWrite(storePin, LOW); // Wir ziehen den RegisterClockPin auf Low for (int i=16; i>=0; i--) { // Da ja First in, first out gilt, muessen wir mit dem letzten Bit beginnen, damit dieses ... // ... nach dem gesamten Schleifendurchlauf auch am Ende des Registers steht. digitalWrite(shiftPin, LOW); // Wir ziehen den StoreClockPin auf Low und ... digitalWrite(dataPin, binOutput[i]); // ... aus unserem Int-Array uebergeben wir binOutput[i] an das Register und setzen ... digitalWrite(shiftPin, HIGH); // ... StoreClockPin auf HIGH, damit die vorhandenen Werte um eine Stelle wandern ... // ... koennen und binOutput[i] an der ersten Stelle im Register eingefuegt werden kann. } digitalWrite(storePin, HIGH); // Wir ziehen den RegisterClockPin auf High, somit wird das Register an Output kopiert ... // ... und die LEDs leuchten entsprechend unserem binOutput[]-Muster } void loop () { } |
Auch hier in Zeile 11 den Datentyp unsigned short und die Erweiterung des Arrays auf 16 Felder.
Entsprechend müssen wir noch in Zeile 20 die for-Schleife auf unsere 16Bit anpassen.
4 Comments
Johann
2. Juli 2020 at 10:02 amVielen Dank für dieses ausführliche Tutorial!
In einem Punkt stehe ich noch auf dem Schlauch:
Wenn man von der 5v Eingangsspannung die 2v, die die LED selber als Widerstand hat, abzieht, hat man noch 3v.
Wenn wir jetzt also auf 6mA kommen wollen, sollten wir doch 3 / 0,006 = 500 Ohm und nicht 1k Ohm als Widerstand benötigen?
Ronin
3. Juli 2020 at 12:25 pmHallo Johann,
Du hast natürlich Recht. Es verbleiben ja nur noch 3V nach Abzug der Betriebsspannung der LED.
Die entsprechende Zeile im Text habe ich entsprechend geändert.
Viele Grüße,
Michael
Plumps
31. Dezember 2018 at 2:17 pmSehr schön ausführlich erklärt, Danke.
Aber etwas ist komisch am Schaltplan. Ich dachte immer der 74hc595 zieht die LEDs auf Masse. Eigentlich müsste rechts unten die LED Versorgungsspannung sein und die LEDs im Schaltplan gedreht werden, oder? Zumindest ist das so in anderen Tuts erklärt.
Auf dem Breadboard ist es etwas schwer zu erkennen wo deine LEDs stecken.
Ronin
3. Januar 2019 at 7:03 pmHallo Plumps,
vielen Dank, Dein Lob freut mich.
Zu Deiner Frage … Ich hab nochmal nachgeschaut, aber es passt. Fritzing ist da leider etwas unübersichtlich, aber die flache Seite der LED (GND) liegt oben auf der Versorgungsschiene auf Blau, also GND.
Aber mal generell ist das eine interessante Frage von Dir, denn mit einem 74HC595 musst/kannst Du nicht nur die LEDs auf Masse ziehen.
Der 74HC595 ist ein CMOS Baustein mit komplementären Ausgängen, was heißt, dass die Ausgänge sowohl VCC als auch GND schalten.
Du kannst auch mischen. Somit lässt sich die Gesamtlast des Bausteins von 70mA reduzieren. Schau mal auf https://www.mikrocontroller.net/articles/AVR-Tutorial:_Schieberegister#Acht_LEDs_mit_je_20mA_pro_Schieberegister rein.
Viele Grüße,
Michael