In diesem Tutorial lernst du, wie du den 74HC595 Shift Register verwendest, um die Anzahl der Ausgänge deines Arduino zu erweitern.
Der beliebte Arduino UNO verfügt über 14 GPIO-Pins, die du zum Ausgeben (oder Eingeben) von Daten nutzen kannst. Für viele Anwendungen ist diese Anzahl ausreichend, aber manchmal reicht sie nicht aus. Du könntest einen teureren, größeren Arduino kaufen, z.B. Arduino Mega mit 54 GPIO-Pins oder einen GPIO expander board. Aber der günstigste Weg ist die Verwendung eines Shift Registers wie dem 74HC595.
Der 74HC595 bietet 8 Ausgänge, benötigt nur 3 Pins deines Arduino und kann kaskadiert werden, um beliebig viele Ausgänge zu erzeugen. Die einzigen Nachteile sind, dass er langsamer ist als die direkte Nutzung der Arduino-GPIO-Pins und nur für Ausgänge verwendet werden kann.
Wenn du viele Ausgänge brauchst und hohe Geschwindigkeit keine Rolle spielt, ist der 74HC595 Shift Register fantastisch. Lass uns mit den benötigten Bauteilen beginnen, bevor wir die Funktion eines Shift Registers genauer betrachten.
Benötigte Bauteile
Hier die Liste der benötigten Bauteile. Ich habe für dieses Projekt einen Arduino Uno verwendet, aber jedes andere Arduino-Board oder ESP8266/ESP32 Board funktioniert ebenso gut. Außerdem verwenden wir den 74HC595 Shift Register, es gibt aber auch Alternativen wie den 74LS595, 74HC164 und MCP23017.
Arduino Uno
Dupont-Kabel-Set
Breadboard
USB-Kabel für Arduino UNO
74HC595 Shift Register
Widerstands- & LED-Kit
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Funktion des 74HC595 Shift Registers
Der 74HC595 Shift Register ist ein integrierter Schaltkreis (IC), der einen seriellen Datenstrom in parallele Daten umwandelt. So kannst du mit nur drei Pins deines Arduino viele zusätzliche Ausgänge steuern.
Ein Shift Register hat drei Hauptkomponenten: den seriellen Eingang (SER), den seriellen Takt (SRCLK) und den Latch-Takt (RCLK). Der serielle Eingang wird verwendet, um die Daten bitweise einzuspeisen. Der serielle Takt verschiebt die Daten mit jedem Taktimpuls durch die Register. Schließlich aktualisiert der Latch-Takt die Ausgänge mit den verschobenen Daten.
Funktionales Blockdiagramm
Das Bild unten zeigt das funktionale Blockdiagramm mit den 8 internen Registern des 74HC595. Du siehst die Steuereingänge (OE, RCLK, SRCLR, SRCLK, SER) und die 8 Ausgänge (Q A … Q H ).
Umwandlung serieller Daten in parallele Ausgänge
Wenn du ein Byte an den Shift Register sendest, speichert er die Bits in seinen internen Registern. Sobald alle Bits eingelesen sind, kannst du die Ausgänge durch Umschalten des Latch-Takts aktualisieren. Dadurch werden die gespeicherten Daten auf die 8 Ausgangspins übertragen.
Wir wandeln also einen seriellen Bitstrom in einen parallelen 8-Bit-Ausgang um. Unten siehst du eine anschauliche Animation von Last Minute ENGINEERS, die den Prozess zeigt. Beachte die Änderung der roten Ausgangsbits, wenn das Daten-Latch-Signal auf HIGH geht.
Steuerung des 74HC595
Die genauen Schritte zur Steuerung des 74HC595 über die Pins RCLK, SER und SRCLK sind wie folgt:
- Setze den Latch-Pin (RCLK) auf LOW, damit die Ausgänge während des Datenverschiebens nicht aktualisiert werden.
- Sende die Daten bitweise an den seriellen Eingang (SER).
- Für jedes Bit pulsiere den Takt-Pin (SRCLK), um die Daten in das Shift Register zu schieben.
- Wiederhole die Schritte 2 und 3, bis alle Bits im Shift Register sind.
- Nachdem alle Bits verschoben wurden, pulsiere den Latch-Pin (RCLK), um die Daten vom Shift Register in das Ausgangsregister zu übertragen.
- Die parallelen Daten sind nun an den Ausgangspins (Q A , …, Q H ) des 74HC595 verfügbar, die mit externen Geräten wie LEDs, Relais oder anderen digitalen Komponenten verbunden werden können.
Das Bild unten zeigt das Zeitdiagramm dieser Schritte:
Neben den Pins RCLK, SER und SRCLK kannst du den OE-Pin verwenden, um die Ausgänge zu aktivieren oder zu deaktivieren. Das ist praktisch, wenn du ein PWM-Signal senden möchtest. Dazu später mehr. Die folgende Tabelle listet die Funktionsmodi des 74HC595 basierend auf den Steuersignalen auf.
Spezifikation des 74HC595
In diesem Abschnitt werfen wir einen kurzen Blick auf die Spezifikationen des 74HC595. Sieh das 74HC595 Datasheet für mehr Informationen.
Pinbelegung
Das Bild unten zeigt die Pinbelegung des 74HC595. Beachte, dass in manchen Datenblättern die Pins anders benannt sind, z.B. Q0, …, Q7 statt Q A , …, Q H für die 8 Ausgangspins. Die Anordnung und Funktion der Pins bleibt jedoch gleich.
Neben den Ausgangspins gibt es Masse (GND), die Steuereingänge (RCLK, SER, SRCLK, SRCLR, OE) und den Q H‘ , der das Kaskadieren mehrerer 74HC595 ermöglicht. Die folgende Tabelle listet alle Pins und ihre Funktionen auf.
| Pin | Name | Funktion |
|---|---|---|
| 1 | Q B | Ausgang: B |
| 2 | Q C | Ausgang: C |
| 3 | Q D | Ausgang: D |
| 4 | Q E | Ausgang: E |
| 5 | Q F | Ausgang: F |
| 6 | Q G | Ausgang: G |
| 7 | Q H | Ausgang: H |
| 8 | GND | Masse |
| 9 | Q H‘ | Ausgang: Kaskadierung |
| 10 | SRCLR | Eingang: Shift Register Clear |
| 11 | SRCLK | Eingang: Shift Register Clock |
| 12 | RCLK | Eingang: Reset Clock, Latch-Ausgang |
| 13 | OE | Eingang: Output Enable |
| 14 | SER | Eingang: Serial, serielle Daten senden |
| 15 | Q A | Ausgang: A |
| 16 | V CC | Stromversorgung (2V…6V) |
Spannungen und Ströme
Der 74HC595 arbeitet mit einer Versorgungsspannung (V CC ) von 2V bis 6V und benötigt nur 80μA Betriebsstrom. Die Gesamtlast am 74HC595 darf 70mA nicht überschreiten.
Du kannst den 74HC595 mit 5V oder 3,3V Logik (und Versorgung) betreiben. Daher ist er auch einfach mit einem ESP8266 oder ESP32 zu verwenden.
Obwohl die Ausgänge bis zu 35mA treiben können, fällt die Ausgangsspannung ab etwa 6mA ab. Selbst für LEDs mit geringem Strombedarf ist daher ein Vorwiderstand nötig. Typischerweise wählt man mindestens 470Ω, besser 560Ω.
Typisches Anwendungsschema
Das folgende Bild zeigt ein typisches Anwendungsschema für den 74HC595. Ein Mikrocontroller schaltet 8 LEDs mit 560Ω Vorwiderständen. Ein kleiner 0,1µF Kondensator dient zur Störschutzmaßnahme.
Im nächsten Abschnitt zeige ich dir, wie du diese Schaltung mit einem Arduino aufbaust.
Verdrahtung des 74HC595 Shift Registers
Das Bild unten zeigt die komplette Verdrahtung des 74HC595 Shift Registers mit einem Arduino zur Steuerung von 8 LEDs. Es folgt im Wesentlichen dem vorher gezeigten typischen Anwendungsschema, mit der Ausnahme, dass ich 470Ω Widerstände für die LEDs verwende und den 0,1µF Kondensator weglasse. Füge den Kondensator hinzu, wenn du instabiles Verhalten beobachtest.
Die Verdrahtung wirkt etwas komplex, ist aber eigentlich einfach. Beginne damit, 5V und GND des Arduino mit den positiven und negativen Stromschienen des Breadboards zu verbinden (rote und schwarze Kabel).
Füge dann die 8 LEDs hinzu und achte darauf, dass der kürzere Pin der LEDs mit der negativen (blauen) Stromschiene verbunden ist. Für jede LED steckst du einen 470Ω (oder 560Ω) Widerstand ins Breadboard. Achte darauf, dass jeder Widerstand mit dem längeren LED-Pin verbunden ist und die Lücke im Breadboard überbrückt.
Verbinde nun alle Widerstände mit den Ausgangspins Q A , …, Q H des 74HC595 (lila Kabel). Achte auf die ungewöhnliche Verbindung zum Pin Q A , der sich auf der gegenüberliegenden Seite des ICs (Pin 15) befindet.
Als nächstes verbindest du die positive Versorgung mit Pin 16 (rotes Kabel) und Masse mit Pin 8 (schwarzes Kabel) des 74HC595. Die Steuereingänge OE (Pin 13) wird auf Masse gelegt (schwarzes Kabel) und SRCLR (Pin 10) an die positive Versorgung (rotes Kabel).
Schließlich verbindest du SER (Pin 14) des 74HC595 mit Pin 4 des Arduino (grünes Kabel). RCLK (Pin 12) kommt an Pin 5 des Arduino (gelbes Kabel). Und SRCLK (Pin 11) wird mit Pin 6 des Arduino verbunden (oranges Kabel). Unten ist ein Bild der kompletten Schaltung auf einem echten Breadboard.
Damit ist die Verdrahtung abgeschlossen. Im nächsten Abschnitt schreiben wir einfachen Code, um die Verdrahtung zu testen.
Code zur Steuerung von LEDs mit dem 74HC595 Shift Register
Der folgende Code nutzt den 74HC595, um die 8 angeschlossenen LEDs nacheinander aufleuchten zu lassen. Schau dir zuerst den kompletten Code an, bevor wir ins Detail gehen.
// Light up LEDs in sequence using Shift Register
const int dataPin = 4; // SER
const int latchPin = 5; // RCLK
const int clockPin = 6; // SRCLK
void setRegister(byte val) {
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, val);
digitalWrite(latchPin, HIGH);
delay(1000);
}
void setup() {
pinMode(latchPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
}
void loop() {
byte leds = 0b00000000;
setRegister(leds);
for (int i = 0; i < 8; i++) {
bitSet(leds, i);
setRegister(leds);
}
}
Konstanten und Variablen
Wir beginnen mit der Definition der Konstanten dataPin, latchPin und clockPin. Diese Pins sind mit den entsprechenden Pins des Shift Registers verbunden. Der dataPin wird verwendet, um Daten an das Shift Register zu senden, der latchPin dient zum Latchen der Daten an die Ausgangspins, und der clockPin schiebt die Daten in das Register.
const int dataPin = 4; // SER const int latchPin = 5; // RCLK const int clockPin = 6; // SRCLK
Register-Set-Funktion
Die setRegister() Funktion setzt den Wert des Shift Registers. Sie nimmt ein Byte als Eingabe, das den Zustand der 8 LEDs repräsentiert. Innerhalb der Funktion setzen wir zuerst den latchPin auf LOW, um das Verschieben der Daten vorzubereiten. Dann verwenden wir die shiftOut() Funktion, um die Daten an das Shift Register zu senden. Schließlich setzen wir den latchPin auf HIGH, um die Daten zu latchen und die Ausgänge zu aktualisieren. Zusätzlich fügen wir eine Verzögerung von 1000 ms ein, um das sequentielle Aufleuchten der LEDs zu verlangsamen.
void setRegister(byte val) {
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, val);
digitalWrite(latchPin, HIGH);
delay(1000);
}
Du kannst die Reihenfolge, in der die Bits des Bytes gesendet werden, umkehren, indem du den bitOrder Parameter von MSBFIRST (Most Significant Bit FIRST) auf LSBFIRST (Least Significant Bit FIRST) änderst. Die LEDs leuchten dann in umgekehrter Reihenfolge auf.
Setup-Funktion
In der setup() Funktion setzen wir die Pins latchPin, dataPin und clockPin als Ausgänge mit der pinMode() Funktion. Das ist notwendig, damit diese Pins Daten an das Shift Register ausgeben können.
void setup() {
pinMode(latchPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
}
Loop-Funktion
In der loop() Funktion initialisieren wir zuerst eine Byte-Variable leds mit dem Wert 0b00000000. Das repräsentiert den Anfangszustand der LEDs, bei dem alle LEDs aus sind. Dann rufen wir die setRegister() Funktion auf, um den Anfangszustand des Shift Registers zu setzen.
Anschließend starten wir eine for Schleife, die von 0 bis 7 läuft. In jeder Iteration setzen wir mit der bitSet() Funktion ein bestimmtes Bit in der leds Byte-Variable, das die LED repräsentiert, die wir einschalten wollen.
Dann rufen wir erneut die setRegister() Funktion auf, um den Zustand des Shift Registers zu aktualisieren und die entsprechende LED einzuschalten. Durch Wiederholung dieses Prozesses in der Schleife können wir alle LEDs nacheinander einschalten. Wenn die Schleife von vorne beginnt, werden alle LEDs wieder ausgeschaltet.
void loop() {
byte leds = 0b00000000;
setRegister(leds);
for (int i = 0; i < 8; i++) {
bitSet(leds, i);
setRegister(leds);
}
}
Wenn du diese Schaltung aufbaust und den Code ausführst, solltest du die folgende Lichtsequenz sehen.
Statt 8 einzelnen LEDs kannst du auch eine LED-Leiste verwenden. Schau dir unser Tutorial an: LED Bar Graph With Arduino UNO. Und wenn du generell Probleme mit der LED-Steuerung hast, lies How To Blink An LED Using Arduino (4 Different Ways) und Control Multiple LEDs With Different Delays with Arduino.
Hinweise
Du kannst ganz einfach (Licht-)Muster als Binärzahlen senden, um die LEDs zu aktivieren. Da ein Byte 8 Bits hat, kannst du ein Byte verwenden, um den Zustand aller 8 LEDs zu beschreiben (1 = an, 0 = aus). Um z.B. jede zweite LED zu aktivieren, kannst du den folgenden Binärwert 0b10101010 senden und über setRegister übertragen.
void loop() {
setRegister(0b10101010);
}
Oder wenn du eine ganze Folge von Mustern senden möchtest, ist das ebenfalls einfach möglich:
byte patterns[] = { 0b00000000,
0b10101010,
0b11111111 };
void loop() {
for (int i = 0; i < 3; i++) {
setRegister(patterns[i]);
}
}
Anstatt die Muster fest zu codieren, kannst du auch Muster erstellen, die einen Balkengraphen simulieren und diese über ein Potentiometer steuern, siehe How use Arduino to control an LED with a Potentiometer.
Schließlich gibt es die bitClear() Funktion, die das Gegenteil zur bitSet() Funktion ist und Bits auf Null setzen kann. Damit kannst du Lauflichter und andere Effekte realisieren.
void loop() {
uint8_t leds = 0b00000000;
for (int i = 0; i < 8; i++) {
bitSet(leds, i);
setRegister(leds);
}
for (int i = 7; i >=0; i--) {
bitClear(leds, i);
setRegister(leds);
}
}
Für weitere Musterideen oder Anwendungen schau dir unser Spin the Wheel Game Tutorial an.
Im obigen Code schalten wir die LEDs komplett an oder aus. Einzelne LEDs dimmen können wir nicht, aber alle aktiven LEDs lassen sich über das OE-Signal dimmen. Wie das funktioniert, ist Thema des nächsten Abschnitts.
PWM-Signal zur Steuerung des 74HC595 Shift Registers
Der OE (Output Enable) Pin des 74HC595 ermöglicht es, alle Ausgänge Q A , …, Q H zu aktivieren oder zu deaktivieren. Im vorherigen Schaltkreis haben wir OE auf Masse gelegt, wodurch alle Ausgänge aktiviert sind. Beachte den Überstrich über OE in der Pinbelegung, der anzeigt, dass die Logik invertiert ist. OE auf LOW aktiviert die Ausgänge, OE auf HIGH deaktiviert sie.
Anstatt die Ausgänge komplett ein- oder auszuschalten, können wir ein PWM-Signal an den OE-Pin senden, um alle Ausgänge zu „dimmen“. Beachte, dass dies immer alle Ausgänge Q A , …, Q H betrifft, also keine individuelle Dimmung einzelner LEDs möglich ist.
Verdrahtung
Das folgende Bild zeigt die geänderte Verdrahtung. Statt den OE-Pin des 74HC595 an Masse (schwarzes Kabel) zu legen, verbinden wir ihn mit einem PWM-Pin des Arduino. Hier wähle ich Pin ~3. Alle anderen Verbindungen bleiben gleich.
Code
Im Code können wir nun Pin 3 des Arduino verwenden, um ein PWM-Signal an den OE-Pin des 74HC595 zu senden und so alle Ausgänge zu dimmen. Unten ein Beispielcode, der im Wesentlichen wie der vorherige funktioniert, aber am Ende des Zyklus alle LEDs von voller Helligkeit auf 0 dimmt, bevor der Zyklus neu startet.
int dataPin = 4; // SER
int latchPin = 5; // RCLK
int clockPin = 6; // SRCLK
int enablePin = 3; // OE
void setRegister(uint8_t val) {
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST, val); // LSBFIRST
digitalWrite(latchPin, HIGH);
delay(100);
}
void setBrightness(byte brightness) {
analogWrite(enablePin, 255 - brightness);
}
void setup() {
pinMode(latchPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(enablePin, OUTPUT);
}
void loop() {
uint8_t leds = 0b00000000;
setRegister(leds);
setBrightness(255);
for (int i = 0; i < 8; i++) {
bitSet(leds, i);
setRegister(leds);
}
for (byte b = 255; b > 0; b--) {
setBrightness(b);
delay(2);
}
}
Das einzige neue Element ist die setBrightness() Funktion, die das PWM-Signal mit der enablePin Funktion an den analogWrite() schreibt. Normalerweise wäre volle Helligkeit bei 255 erreicht. Da die Logik des OE-Pins invertiert ist, müssen wir den gewünschten brightness Wert von 255 subtrahieren, um die Inversion auszugleichen.
Wir verwenden die setBrightness() Funktion in der zweiten Schleife, um die Helligkeit b von 255 auf 0 mit einer kurzen Verzögerung von 2 ms zu reduzieren.
for (byte b = 255; b > 0; b--) {
setBrightness(b);
delay(2);
}
Wenn du diesen Code auf deinen Arduino lädst und ausführst, siehst du den Effekt: Die LEDs leuchten nacheinander auf, und wenn alle an sind, dimmen sie langsam auf Null, bevor der Zyklus von vorne beginnt.
Im nächsten Abschnitt besprechen wir, wie man mehr als 8 Ausgänge erzeugt, indem man mehrere 74HC595 kaskadiert.
Kaskadierung von 74HC595 Shift Registern
Ein einzelner 74HC595 hat 8 Ausgänge Q A , …, Q H und benötigt drei Steuerleitungen. Das Gute ist, dass du mehrere 74HC595 Shift Register kaskadieren kannst, um beliebig viele Ausgänge zu erhalten (innerhalb vernünftiger Grenzen) und trotzdem nur drei Steuerleitungen benötigst.
Das Kaskadieren von 74HC595 ist sehr einfach. Wenn du z.B. zwei 74HC595 kaskadieren möchtest, verbinde einfach den Q H ‚ Pin des ersten 74HC595 mit dem SER-Pin des zweiten. Siehe Bild unten.
Verdrahtung
Alle anderen Verbindungen bleiben gleich und werden für den zweiten 74HC595 dupliziert. Das Bild unten zeigt die komplette Verdrahtung von zwei kaskadierten 74HC595, mit denen du 16 LEDs steuern kannst.
Code
Um die 16 LEDs zu steuern, kannst du folgenden Code verwenden. Wie zuvor leuchtet er alle LEDs nacheinander auf, setzt sie zurück und startet den Zyklus neu.
// Light up 16 LEDs in sequence using two Shift Registers
const int dataPin = 4; // SER
const int latchPin = 5; // RCLK
const int clockPin = 6; // SRCLK
const int nRegister = 2;
const int nOutput = nRegister * 8;
void setRegister(byte vals[]) {
digitalWrite(latchPin, LOW);
for (int i = nOutput - 1; i >= 0; i--) {
digitalWrite(clockPin, LOW);
digitalWrite(dataPin, vals[i]);
digitalWrite(clockPin, HIGH);
}
digitalWrite(latchPin, HIGH);
delay(100);
}
void setup() {
pinMode(latchPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
}
void loop() {
byte leds[nOutput];
for (int i = 0; i < nOutput; i++) {
leds[i] = HIGH;
setRegister(leds);
}
for (int i = 0; i < nOutput; i++) {
leds[i] = LOW;
}
setRegister(leds);
}
Anstatt die Bits eines Bytes zu setzen, das den Zustand von 8 LEDs repräsentiert, verwenden wir hier ein Byte-Array leds[]. Es speichert die Zustände aller 16 LEDs einzeln. Das verbraucht etwas mehr Speicher, ist aber einfacher zu handhaben und funktioniert für eine beliebige Anzahl kaskadierter Shift Register. Setze einfach die Konstante nRegister auf die Anzahl der verbundenen Register.
Dadurch müssen wir die setRegister() Funktion etwas anpassen. Sie nimmt jetzt ein Byte-Array und schreibt die Werte iterativ in das dataPin. Beachte, dass die Schleife in umgekehrter Reihenfolge läuft, um die Reihenfolge des MSBFIRST aus dem anderen Code zu imitieren.
void setRegister(byte vals[]) {
digitalWrite(latchPin, LOW);
for (int i = nOutput - 1; i >= 0; i--) {
digitalWrite(clockPin, LOW);
digitalWrite(dataPin, vals[i]);
digitalWrite(clockPin, HIGH);
}
digitalWrite(latchPin, HIGH);
delay(100);
}
Schließlich setzen wir den Zustand im leds[] Array iterativ auf HIGH oder LOW, je nachdem, ob die LED an- oder ausgeschaltet werden soll. Die erste Schleife schaltet alle LEDs nacheinander ein, die zweite schaltet sie alle gleichzeitig aus. Beachte, dass setRegister innerhalb der ersten Schleife, aber nach der zweiten Schleife aufgerufen wird.
for (int i = 0; i < nOutput; i++) {
leds[i] = HIGH;
setRegister(leds);
}
for (int i = 0; i < nOutput; i++) {
leds[i] = LOW;
}
setRegister(leds);
Und das war’s. Jetzt weißt du so ziemlich alles, was du über den 74HC595 Shift Register wissen musst, und kannst ihn nutzen, um Ausgänge an deinem Arduino zu erweitern.
Zusammenfassung
In diesem Blogbeitrag haben wir gelernt, wie man die Anzahl der Ausgänge eines Arduino-Boards mit einem 74HC595 Shift Register erweitert. Mit diesem Shift Register können wir die Anzahl der steuerbaren Geräte oder Komponenten deutlich erhöhen.
Wir haben mit den benötigten Bauteilen begonnen, darunter ein Arduino-Board, ein 74HC595 Shift Register, Widerstände, LEDs und Jumper-Kabel.
Dann haben wir die Funktion des 74HC595 Shift Registers erklärt. Dieser integrierte Schaltkreis wandelt ein serielles Eingangssignal in ein paralleles Ausgangssignal um und vervielfacht so die verfügbaren Ausgänge. Er arbeitet, indem er die Datenbits durch interne Register schiebt.
Anschließend haben wir die Verdrahtung des 74HC595 Shift Registers behandelt. Wir haben ein detailliertes Schaltbild gezeigt und erklärt, wie man das Shift Register mit dem Arduino, LEDs und Widerständen verbindet.
Nach der Verdrahtung haben wir den Code zur Steuerung des 74HC595 implementiert. Wir haben ein Beispiel gezeigt, das demonstriert, wie man Daten in das Shift Register schiebt und die Ausgangspins entsprechend steuert. Der Code wurde Schritt für Schritt erklärt, sodass du ihn leicht verstehen und anpassen kannst.
Außerdem haben wir gezeigt, wie man Pulsweitenmodulation (PWM) verwendet, um die Helligkeit der LEDs am Ausgang des Shift Registers zu steuern. Wir haben ein Beispiel gezeigt und erklärt, wie man das PWM-Signal anpasst, um den gewünschten Effekt zu erzielen.
Zusätzlich haben wir die Möglichkeit besprochen, mehrere 74HC595 Shift Register zu kaskadieren, um die Anzahl der Ausgänge weiter zu erhöhen.
Wenn du weitere Fragen hast, schau dir bitte den Abschnitt Häufig gestellte Fragen unten an oder hinterlasse einen Kommentar.
Viel Spaß beim Tüfteln 😉
Häufig gestellte Fragen
Hier sind einige häufig gestellte Fragen zur Verwendung des 74HC595 Shift Registers, um mehr Ausgänge an deinem Arduino hinzuzufügen:
F: Was ist ein Shift Register?
A: Ein Shift Register ist eine digitale Schaltung, die Daten speichern und verschieben kann. Es wird häufig verwendet, um die Anzahl der Ausgänge eines Mikrocontrollers wie Arduino zu erweitern. Der 74HC595 ist ein beliebter Shift Register IC, der bis zu 8 Ausgänge mit nur 3 Arduino-Pins steuern kann.
F: Wie funktioniert der 74HC595 Shift Register?
A: Der 74HC595 arbeitet, indem er serielle Daten in seine internen Speicherregister lädt. Die Daten können dann bitweise an die Ausgangspins ausgegeben werden. Durch das Kaskadieren mehrerer Shift Register kannst du noch mehr Ausgänge mit derselben Anzahl Arduino-Pins steuern.
F: Welche Vorteile hat die Verwendung eines Shift Registers?
A: Ein Shift Register wie der 74HC595 hat mehrere Vorteile. Erstens kannst du viele Ausgänge mit nur wenigen Arduino-Pins steuern, was besonders bei begrenzten Pins nützlich ist. Zweitens reduziert es den Verkabelungsaufwand, was dein Projekt übersichtlicher und einfacher macht. Drittens werden Arduino-Pins für andere Zwecke frei, sodass du mehr Funktionalität hinzufügen kannst.
F: Kann ich die Helligkeit von LEDs mit dem 74HC595 steuern?
A: Ja, du kannst die Helligkeit von LEDs mit dem 74HC595 steuern. Mit Pulsweitenmodulation (PWM) kannst du den Tastgrad der Ausgangspins variieren, die an die LEDs angeschlossen sind. So kannst du Helligkeitsstufen einstellen und Effekte wie Ein- und Ausblenden erzeugen.
F: Kann ich mehrere 74HC595 Shift Register kaskadieren?
A: Ja, du kannst mehrere 74HC595 kaskadieren, um noch mehr Ausgänge zu steuern. Indem du den seriellen Ausgang (Q7′) eines Registers mit dem seriellen Eingang (SER) des nächsten verbindest, entsteht eine Kaskaden-Schaltung. So kannst du viele Ausgänge mit wenigen Arduino-Pins steuern.
F: Gibt es Einschränkungen bei der Verwendung des 74HC595?
A: Der 74HC595 ist vielseitig, hat aber einige Einschränkungen. Er steuert nur digitale Ausgänge, ist also nicht für analoge Geräte geeignet. Die Strombelastbarkeit ist begrenzt, für stromstarke Geräte wie Motoren oder Relais benötigst du zusätzliche Schaltungen. Außerdem erfordert er etwas Einrichtung, weshalb er für sehr einfache Projekte eventuell nicht ideal ist.
F: Kann ich den 74HC595 mit anderen Mikrocontrollern als Arduino verwenden?
A: Ja, der 74HC595 kann mit anderen Mikrocontrollern verwendet werden, solange diese digitale Signale senden können und die nötigen Pins verfügbar sind. So kannst du die Ausgänge auch bei anderen Plattformen erweitern.
F: Wie verbinde ich den 74HC595 mit meinem Arduino?
A: Verbinde SER (serieller Eingang) mit einem digitalen Arduino-Pin, SRCLK (Shift Register Clock) mit einem weiteren digitalen Pin, RCLK (Register Clock) mit einem dritten digitalen Pin und OE (Output Enable) mit Masse. Wenn du mehrere Register kaskadierst, verbinde den seriellen Ausgang QH‘ eines Registers mit dem SER-Eingang des nächsten.
F: Kann ich den 74HC595 auch zum Einlesen von Eingängen verwenden?
A: Nein, der 74HC595 ist nur für Ausgänge ausgelegt und kann keine Eingänge lesen. Für Eingänge benötigst du andere Bauteile, z.B. Shift Register mit Eingangs-Funktion oder andere Mikrocontroller-Pins.
F: Kann ich den 74HC595 mit anderen digitalen Bauteilen als LEDs verwenden?
A: Ja, der 74HC595 kann jede digitale Komponente steuern, die ein digitales Signal zum Ein- oder Ausschalten benötigt, z.B. Transistoren, Relais oder andere ICs.
F: Kann ich den 74HC595 mit anderen Shift Register ICs kombinieren?
A: Ja, du kannst den 74HC595 mit anderen Shift Register ICs verwenden, sofern die Pinbelegung und Spannungsanforderungen kompatibel sind. Beachte jedoch, dass verschiedene ICs unterschiedliche Funktionen haben können, daher solltest du die Datenblätter prüfen und deinen Code anpassen.
F: Kann ich den 74HC595 mit anderen Programmiersprachen als der Arduino IDE verwenden?
A: Ja, der 74HC595 ist ein Hardware-Bauteil, das mit jeder Programmiersprache gesteuert werden kann, die mit dem Mikrocontroller kommuniziert. Du musst deinen Code jedoch an die Syntax und Bibliotheken der jeweiligen Sprache anpassen.
F: Kann ich den 74HC595 mit Mikrocontrollern verwenden, die mit anderen Spannungen arbeiten?
A: Ja, das ist möglich, solange die Spannungspegel kompatibel sind. Wenn der Mikrocontroller mit höherer Spannung arbeitet als der Shift Register, benötigst du eventuell Pegelwandler oder Spannungsteiler, um eine korrekte Kommunikation sicherzustellen.
F: Wie viele Shift Register kann ich kaskadieren?
A: Die Anzahl der kaskadierbaren Shift Register hängt von verschiedenen Faktoren ab, z.B. den verfügbaren Pins deines Mikrocontrollers und der gewünschten Funktionalität. Theoretisch kannst du unbegrenzt viele kaskadieren. Mit zunehmender Anzahl steigt jedoch die Komplexität und die Zeit für das Verschieben der Daten. Teste dein Design, um eine zuverlässige Funktion sicherzustellen.
F: Kann ich den 74HC595 mit anderen Shift Register Typen wie dem 74HC164 verwenden?
A: Ja, du kannst den 74HC595 mit anderen Shift Register Typen wie dem 74HC164 verwenden. Beachte jedoch, dass unterschiedliche Register unterschiedliche Pinbelegungen und Funktionen haben können. Prüfe die Datenblätter beider ICs und passe deine Schaltung und deinen Code entsprechend an.
F: Kann ich den 74HC595 zur Steuerung anderer digitaler Anzeigen wie 7-Segment-Anzeigen oder LCDs verwenden?
A: Ja, der 74HC595 kann zur Steuerung von 7-Segment-Anzeigen oder LCDs verwendet werden. Du benötigst jedoch zusätzliche Schaltungen und Code, z.B. Multiplexing für 7-Segment-Anzeigen oder spezielle LCD-Bibliotheken.
F: Kann ich den 74HC595 zur Steuerung von Servos oder Schrittmotoren verwenden?
A: Nein, der 74HC595 ist nicht geeignet, um Servos oder Schrittmotoren direkt zu steuern. Diese benötigen präzise Steuerungssignale. Verwende dafür spezielle Motor-Treiber-Module oder Servo-Controller, die für diese Anforderungen ausgelegt sind.
F: Kann ich den 74HC595 in batteriebetriebenen Projekten verwenden?
A: Ja, der 74HC595 verbraucht sehr wenig Strom und beeinflusst die Batterielaufzeit kaum. Beachte jedoch den Stromverbrauch der angeschlossenen Komponenten wie LEDs oder andere digitale Geräte, die einen größeren Einfluss auf die Batterielaufzeit haben können.
Das sind einige der häufig gestellten Fragen zur Verwendung des 74HC595 Shift Registers, um mehr Ausgänge an deinem Arduino hinzuzufügen. Wenn du weitere Fragen hast, stelle sie gerne in den Kommentaren.
