Schieberegister – Was ist das?

Schieberegister – Was ist das?

Ausdrucken Ausdrucken

74hc595Das Schieberegister erweitert zum Beispiel die Eingangs- und/oder die Ausgangspins eines Mikrocontrollers.

Hierbei gilt zu beachten, dass man für Eingangs- und Ausgangspins das jeweilig passende Schieberegister verwendet.

Das wohl bekannteste Schieberegister trägt die Bezeichnung „74HC595“ und ist ein Schieberegister des SIPO-Typs (SIPO steht für Serial in, Parallel out, was bedeutet, dass es ein Ausgaberegister ist).

Das Pendant hierzu – beispielsweise ein „74LS299“ – ist ein Schieberegister des Typs PISO (PISO steht für Parallel in, Serial out). Mit diesem kann man den Status eines Pins des Schieberegisters abfragen.

Diese beiden Schieberegister gehören zu der Klasse der 8Bit-Schieberegister. Das heißt, man kann mit diesem Baustein 8 Pins (jeweils Ein- oder Ausgang des verwendeten Typs) ansteuern.

Es gibt auch eine Mischform, den „74LS194A“. Dieser ist ein 4bit-Schieberegister und besitzt 4 Ein- und 4 Ausgabepins in einem Baustein.

Darüber hinaus gibt es auch ein 16Bit-Register mit der Bezeichnung „74LS673“. Aber das und größere Schieberegister sind schon eher exotischer Natur und auch relativ schwer zu bekommen, was sich dann auch auf dem Preis niederschlägt.

Die Funktionsweise eines Schieberegisters ist recht leicht zu verstehen. Stellt Euch eine Eimerkette, bestehend aus 8 Eimern vor.

Wir wollen nun unsere Acht-Eimerkette in unser „Eimerregister“ gießen …
Wir gießen den ersten rechten Eimer in den ersten linken Eimer unseres Registers.
Jetzt legt das Register los und im zweiten Arbeitstakt wird der erste Registereimer in den zweiten geleert.
Nun nehmen wir unseren nächsten Eimer und gießen ihn wieder in den ersten Registereimer.
Im dritten Arbeitstakt müssen dann schon die ersten beiden Registereimer nacheinander um eine Position nach rechts weiter gekippt werden und nach dem achten Arbeitstakt haben wir dann die gesamte Eimerkette 1:1 in das Eimerregister gekippt/gespeichert.

Unsere Eimerkette:

eimer_leer eimer_leer eimer_voll eimer_leer eimer_voll eimer_leer eimer_leer eimer_voll
0 0 1 0 1 0 0 1

 

 eimer_leereimer_leereimer_volleimer_leereimer_volleimer_leereimer_leereimer_voll_leeren
 1. Arbeitstakt eimer_voll eimer_leer eimer_leer eimer_leer eimer_leer eimer_leer eimer_leer eimer_leer
1 0 0 0 0 0 0 0
 eimer_leereimer_leereimer_volleimer_leereimer_volleimer_leereimer_leer_leeren
 2. Arbeitstakt eimer_leer eimer_voll eimer_leer eimer_leer eimer_leer eimer_leer eimer_leer eimer_leer
0jump 1 0 0 0 0 0 0
 eimer_leereimer_leereimer_volleimer_leereimer_volleimer_leer_leeren
 3. Arbeitstakt eimer_leer eimer_leer eimer_voll eimer_leer eimer_leer eimer_leer eimer_leer eimer_leer
0jump 0jump 1 0 0 0 0 0
 eimer_leereimer_leereimer_volleimer_leereimer_voll_leeren
 4. Arbeitstakt eimer_voll eimer_leer eimer_leer eimer_voll eimer_leer eimer_leer eimer_leer eimer_leer
1jump 0jump 0jump 1 0 0 0 0
 eimer_leereimer_leereimer_volleimer_leer_leeren
 5. Arbeitstakt eimer_leer eimer_voll eimer_leer eimer_leer eimer_voll eimer_leer eimer_leer eimer_leer
0jump 1jump 0jump 0jump 1 0 0 0
 eimer_leereimer_leereimer_voll_leeren
 6. Arbeitstakt eimer_voll eimer_leer eimer_voll eimer_leer eimer_leer eimer_voll eimer_leer eimer_leer
1jump 0jump 1jump 0jump 0jump 1 0 0
 eimer_leereimer_leer_leeren
 7. Arbeitstakt eimer_leer eimer_voll eimer_leer eimer_voll eimer_leer eimer_leer eimer_voll eimer_leer
0jump 1jump 0jump 1jump 0jump 0jump 1 0
 eimer_leer_leeren
 8. Arbeitstakt eimer_leer eimer_leer eimer_voll eimer_leer eimer_voll eimer_leer eimer_leer eimer_voll
0jump 0jump 1jump 0jump 1jump 0jump 0jump 1

 

Somit versteht man schon das Grundprinzip des Schieberegisters: FIFO. First in, First out. Bei unserem Schieberegister bedeutet das, dass man acht Positionen die entweder 0 oder 1 sind reinschieben muss, um das Register komplett zu füllen und das die erste Eingabe die letzte Stelle im Register ist.
Jetzt erst werden die 8Bit an die Outputpins des Bauteils weitergeleitet.

Durch die 8 Pins ergeben Sich 2^8 Möglichkeiten der Ausgabe.
Würden wir 8 LEDs anschließen, würden wir 256 verschiedene einmalige Ansteuerungsmöglichkeiten haben.

Da ein Schieberegister über einen speziellen Pin verfügt, das es ihm ermöglicht die bereits eingegebenen Daten weiterzuschieben – sollte die Länge von 8Bit überschritten werden – kann man weitere Schieberegister anschließen.

Nehmen wir an, wir haben vier Schieberegister verbunden, dann haben wir insgesamt 32Bit, was 32 Pins entspricht. Mit 32 Pins stehen uns somit 2^32 Möglichkeiten zur Ausgabe zur Verfügung. Das sind 4.294.967.296 verschiedene einmalige Möglichkeiten.

Übrigens nennt man das kaskadieren von mehreren Schieberegistern dann eine „Daisy Chain“-Verbindung, was so viel bedeutet wie eine bestimmte Anzahl  Elektronik-Komponenten, die in Serie (Reihe) miteinander verbunden sind/werden können.

Nebenbei, fällt Euch was auf bei den Zahlen 256 und 4.294.967.296?
Solltet Ihr Euch schon mit der Programmiersprache Eures Arduinos ein wenig beschäftigt haben, seid Ihr sicher schon über die „Datentypen“ (int, long, double, char, …) gestolpert.
256 Möglichkeiten bei einem Schieberegister (8Bit) entsprechen genau der Länge eines int-Typs (0-255).
4.294.967.296 Möglichkeiten bei vier Schieberegistern (32Bit) entsprechen genau der Länge eines unsigned long-Typs (0-4.294.967.295)

Da der Computer ja nur 0 und 1 kennt, kennt er nur die Binärsprache. Wie müsste man nun vorgehen, um eine andere Zahl, außer 0 oder 1 speichern zu können?
Wir müssen es in seiner Sprache sprechen. Nehmen wir mal die Zahl 143, die wir im Register speichern möchten. Binär geschrieben ist die Zahl 143 = 10001111, die Zahl 2 wäre 00000010. Beides geht in ein 8Bit-Register. Die Zahl 256 passt nicht mehr, denn binär hat sie schon neun Stellen (100000001).

Und eine Zahl wie beispielsweise 4294967200?
Binär wird sie ja so geschrieben: 11111111111111111111111110100000
Diese passt natürlich nur vollständig in ein 32Bit Register.

Anders herum geht aber auch die Zahl 2 in ein 32Bit-Register.
Hierzu ergänzen wir nun noch 24 Nullen vor den 8Bit-Wert um sie 32stellig zu machen: 00000000000000000000000000000010

Mehr zu Datentypen und deren Länge kann man nachlesen unter https://de.wikibooks.org/wiki/C-Programmierung:_Datentypen und wie Ihr Zahlensysteme umrechnen könnt, findet Ihr unter http://www.arndt-bruenner.de/mathe/scripts/Zahlensysteme.htm. Bequemer geht es nicht. Ohne Internet musste ich damals noch selbst auf Papier von Dezimal nach Binär usw. umrechnen. 🙂

Zusammenfassend gesagt haben wir hier einen Speicherbaustein und nichts anderes ist ein Schieberegister. Es besteht intern aus 8 in Reihe geschalteten FlipFlops (Artikel folgt später) die jeweils zwei Zustände, 0 (aus/LOW) oder 1 (an/HIGH), speichern können.

Wir können dort eine beliebige 8stellige Binärzahl ablegen und an jeder Stelle, an der eine 1 im Speicher liegt wird der entsprechende Pin auf HIGH geschaltet und eine LED fängt beispielsweise an zu leuchten, ein Relais schaltet, usw.

Wir können mit einem oder mehreren Schieberegistern einfach und kostengünstig unseren Mikrocontroller um x-beliebe Pins erweitern und der Preis, den wir dafür zahlen müssen, sind ledglich drei Pins die wir an an unserem Controller belegen müssen.

Es ist auch möglich, Eingabe- (PISO) und Ausgabeschieberegister (SIPO) miteinander verbinden zu können. Wir können somit nicht nur Ein- oder Ausgabepins beliebig erweitern, nein, wir können Ein- UND Ausgabepins beliebig erweitern.

Wie wir ein oder mehrere Schieberegister an den Arduino anschließen können, könnt ihr unter „Schieberegister – Am Arduino anschließen“ nachlesen.

Dasselbe können wir natürlich auch mit einem RaspberryPi machen. Das könnt Ihr unter „Schieberegister – Am RaspberryPi anschließen“ nachlesen.

Achtung, zum Schluss noch etwas, was auf vielen Seiten keine Erwähnung findet. Man kann zwar an jedem Pin eine LED anschließen und das Schieberegister macht das auch brav mit, aber laut Datenblatt ist das viel zu viel, denn das IC kann nur maximal 70mA über VCC bzw. GND ableiten. Das gilt für alle 8 Pins zusammen. Somit würden nur 8,75mA pro Pin bei Vollbelegung zur Verfügung stehen. Etwas dunkel für eine LED.
Aber auf Dauer zerstört man dann das Bauteil, wenn man es hoffnungslos mit 20-30mA pro Pin überlastet.

Eine Möglichkeit wie es doch geht, habe ich auf mikrokontroller.net gefunden, in dem man mit einem Trick arbeitet. Dort findet Ihr auch die genaue Beschreibung zum Schaltplan:

8x20ma_led_mit_74xx595

Alternativ kann man auch mit Darlington-Transistoren arbeiten um das Ausgabesignal zu verstärken. Hierfür gibt es auch ein äußerst preisgünstiges IC mit einem Darlington-Array, was aus 8 Darlington-Schaltungen besteht.
Mit diesem Baustein, beispielsweise dem ULN2803, kann man Lasten bis rund 500mA an einem Mikrocontroller betreiben.
Will man statt einem NPN-Array ein PNP-Array verwenden, sollte man auf den UDN2981 zurückgreifen. Dieser ist etwas teurer, ist aber auch ein NPN/PNP-Array.

Diese Bausteine haben auch schon für induktive Lasten wie beipielsweise Relais Freilaufdioden integriert.

Der Anschluss ist leicht, denn die 8 Input-Pins werden direkt an die Output-Pins des Schieberegisters angeschlossen.
Induktive Lasten benötigen den Pin 10, kann aber generell immer angeschlossen werden.

uln2803a_74hc595

Euer Schieberegister wird Euch die Entlastung danken. 🙂


Schreibe einen Kommentar