Mehr Eingänge mit dem 74HC165 Schieberegister

In diesem Tutorial zeige ich dir, wie du mit dem 74HC165 Schieberegister mehr Eingänge zu deinem Arduino oder ESP8266/ESP32 hinzufügen kannst.

Der beliebte Arduino UNO hat 14 GPIO-Pins, die du zum Ein- oder Ausgeben von Daten nutzen kannst. Oft reicht das aus, aber manchmal brauchst du mehr. Du könntest ein teureres Arduino-Modell kaufen, wie ein Arduino Mega mit 54 GPIO-Pins oder ein GPIO expander board . Aber am günstigsten ist es, ein Schieberegister wie das 74HC165 . zu verwenden.

Der 74HC165 bietet 8 Eingänge, benötigt nur 3 Pins deines Arduino und kann in Reihe geschaltet werden, um beliebig viele Eingänge auszulesen. Der einzige Nachteil ist, dass er langsamer ist als die direkte Nutzung der Arduino-GPIO-Pins. Typische Anwendungen sind das Auslesen von Tastaturen oder wenn du viele digitale Sensoren hast.

Schauen wir uns zuerst die benötigten Bauteile an, bevor wir die Funktion des 74HC165 Schieberegisters im Detail betrachten.

überblick

Benötigte Bauteile

Ich habe für dieses Projekt einen Arduino Uno verwendet, aber jedes andere Arduino-Board oder ein ESP8266/ESP32 funktioniert genauso gut. Ich habe eine Reihe von Tastern aufgelistet, aber in meinem Aufbau habe ich einen DIP-Schalter verwendet, da dieser kompakter ist. Taster funktionieren aber genauso.

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 74HC165 Schieberegisters

Der 74HC165 ist ein 8-Bit Parallel-Load Schieberegister, das 8 digitale Eingänge parallel einliest und sie dann seriell über einen einzigen Pin ausgibt. Es benötigt einen Takteingang, um das Verschieben der 8 digitalen Eingänge zum seriellen Ausgang zu steuern, und ein weiteres Signal, um das Laden der Eingangsdaten zu kontrollieren.

Das bedeutet, dass du mit drei Pins und einem 74HC165 bis zu 8 digitale Eingänge auslesen kannst. Du kannst aber auch mehrere 74HC165 in Reihe schalten und dann praktisch unbegrenzt viele digitale Eingänge auslesen – immer noch mit nur drei Pins an deinem Mikrocontroller!

Funktionsblockdiagramm

Das Bild unten zeigt das Funktionsblockdiagramm des 74HC165 Schieberegisters. Oben siehst du die 8 parallelen digitalen Eingänge (A…H). Der serielle Ausgang Q _H und sein Komplement Q̅ _H befinden sich rechts. In der Mitte findest du die Latches ( flip-flops ), in die die Eingangsdaten geladen werden.

Functional Block Diagram of the 74HC165 Shift Register — Funktionsblockdiagramm des 74HC165 Schieberegisters ( source )

Die Steuereingänge sind links. SH/L̅D̅ aktiviert die 8 digitalen Eingänge, wenn es auf Low gezogen wird. CLK (oder CLK INH) verschiebt die Daten einzeln zum seriellen Ausgang Q _H . SER ist der serielle Eingang, der beim Verketten mehrerer 74HC165 Schieberegister verwendet wird.

Logikdiagramm

Das folgende Bild zeigt das Logikdiagramm des Ablaufs. Das CLK-Signal steuert das Verschieben der digitalen Eingänge (A…H) zum seriellen Ausgang Q _H und seinem Inversen Q̅ _H .

Logic diagram of the 74HC165 Shift Register — Logikdiagramm des 74HC165 Schieberegisters ( source )

Das Taktsignal ist deaktiviert, solange Clock-Inhibit (CLK INH) auf High ist. Zum Laden der digitalen Eingänge muss SH/L̅D̅ auf Low gesetzt werden. SER wird nur beim Verketten mehrerer Schieberegister verwendet.

Zusammengefasst: Um die 8 digitalen Eingänge A…H zum seriellen Ausgang Q _H zu verschieben, sind folgende Schritte nötig.

Setze SH/L̅D̅ auf Low, um die Daten zu laden
Setze SH/L̅D̅ wieder auf High
Wiederhole die folgenden Schritte 8-mal
- Setze CLK auf High, um die Daten zu verschieben
- Setze CLK wieder auf Low

CLK INH wird nicht benötigt und kann die ganze Zeit auf Low bleiben. Wenn du nur ein einziges 74HC165 Schieberegister verwendest, wird der SER-Eingang nicht genutzt.

Pinout

Im Bild unten findest du das Pinout des 74HC165 Schieberegisters. Die Stromversorgung erfolgt über V _CC und GND. Die Versorgungsspannung V _CC kann zwischen 2V und 6V liegen, und die Ausgangsspannung am Q _H -Pin wird durch V _CC bestimmt.

Die Funktion der anderen Pins haben wir oben bereits besprochen, aber die folgende Tabelle fasst die Funktionen aller Pins zusammen. Weitere Details findest du im Datasheet for the 74HC165 Shift Register .

Pin functions of the 74HC165 Shift Register — Pin-Funktionen des 74HC165 Schieberegisters ( source )

Im nächsten Abschnitt verbinden wir das 74HC165 Schieberegister mit einem Arduino.

Anschluss des 74HC165 Schieberegisters an Arduino

Um es einfach zu halten, verbinden wir das 74HC165 zunächst ohne Signale an den Dateneingängen A…H mit dem Arduino. Das Bild unten zeigt die Verdrahtung dieses ersten Schritts.

Connecting the 74HC165 Shift Register to Arduino — Anschluss des 74HC165 Schieberegisters an Arduino

Fangen wir mit der Stromversorgung an. Verbinde ein schwarzes Kabel vom GND-Pin des Arduino zur negativen Stromschiene des Breadboards. Dann verbinde ein rotes Kabel vom 5V-Pin des Arduino zur positiven Stromschiene. Als nächstes verbindest du die beiden negativen Stromschienen des Breadboards mit einem schwarzen Kabel. Die zweite positive Schiene wird nicht verwendet, daher ist dort keine Verbindung nötig.

Jetzt schließen wir die Stromversorgung für den 74HC165 an. Verbinde Pin 8 (GND) des 74HC165 mit der negativen Stromschiene (schwarzes Kabel) und Pin 16 (V _CC ) mit der positiven Stromschiene (rotes Kabel).

Zum Schluss die Signalkabel. Wir verwenden CLK INH an Pin 15 nicht und verbinden ihn daher direkt mit der negativen Stromschiene (schwarzes Kabel). SH/L̅D̅ an Pin 1 wird mit Pin 3 des Arduino verbunden (grünes Kabel). Das CLK-Signal an Pin 2 wird mit Pin 2 des Arduino verbunden (oranges Kabel). Und der serielle Ausgang Q _H an Pin 9 wird mit Pin 4 verbunden (gelbes Kabel).

Das sind alle Verbindungen, die du brauchst, um den 74HC165 zu steuern und Daten auszulesen. Im nächsten Abschnitt schließen wir einige Taster als digitale Eingänge an die Eingangspins an.

Anschluss von Tastern an das 74HC165 Schieberegister

Du könntest jede Art von Digitalsignal an die Eingänge (A…H) des 74HC165 anschließen. Zum Ausprobieren verbinden wir aber ein paar Taster. Wir fangen mit einem einzelnen Taster an. Das Schaltbild unten zeigt die gleiche Schaltung wie oben, plus die Verdrahtung für einen einzelnen Taster.

Connecting a button to the 74HC165 Shift Register — Anschluss eines Tasters an das 74HC165 Schieberegister

Der Taster ist in einer pull-down configuration -Schaltung mit einem 10KΩ Widerstand angeschlossen. Das bedeutet, wenn der Taster gedrückt wird, wird das Signal auf Masse gezogen. Dafür verbinden wir einen Pin des Tasters mit der positiven Stromschiene (rotes Kabel) und den gegenüberliegenden Pin über den 10KΩ Widerstand mit der negativen Stromschiene.

Der Ausgang des Tasters ist mit dem digitalen Eingang A an Pin 11 des 74HC165 verbunden (lila Kabel). Beachte, dass das andere Ende des lila Kabels am gleichen Pin wie der Widerstand angeschlossen ist, da die interne Verdrahtung des Tasters wie folgt aussieht:

Internal wiring of Push Button — Interne Verdrahtung des Tasters

Achte darauf, den Taster in der richtigen Orientierung ins Breadboard zu stecken. Wenn du mehr Infos zu Tastern brauchst, schau dir unser Tutorial How to use a Push Button with Arduino.

Beachte, dass du den Taster auch als Pull-Up verschalten könntest, aber der Ausgang an Q _H wäre dann invertiert. Um das auszugleichen, könntest du den komplementären Ausgang Q̅ _H verwenden oder die Invertierung im Code behandeln.

Anschluss mehrerer Taster

Das Schaltbild unten zeigt, wie du 7 weitere Taster anschließt, um Signale für alle 8 digitalen Eingänge A…H des 74HC165 zu erzeugen. Sie sind alle genauso wie der einzelne Taster oben verschaltet, nur dass die Ausgänge an die anderen Eingänge B…H des 74HC165 gehen (lila Kabel).

Connecting multiple buttons to the 74HC165 Shift Register — Anschluss mehrerer Taster an das 74HC165 Schieberegister

Wie du siehst, sind das eine Menge Kabel ; ) Schauen wir uns an, was wir tun müssen, um die Zustände dieser Taster auszulesen.

Code zum Auslesen von Tastern mit dem 74HC165 Schieberegister

In diesem Abschnitt lesen wir den Zustand der an den 74HC165 angeschlossenen Taster aus. Der Code ist einfach und folgt den Schritten aus dem Logikdiagramm des 74HC165:

Setze SH/L̅D̅ auf Low, um die Daten zu laden
Setze SH/L̅D̅ wieder auf High
Wiederhole die folgenden Schritte 8-mal
- Setze CLK auf High, um die Daten zu verschieben
- Setze CLK wieder auf Low

Schau dir zuerst den vollständigen Code unten an, danach besprechen wir die Details.

const int dataPin = 4;   // QH
const int clockPin = 2;  // CLK
const int latchPin = 3;  // SH/LD
  
void setup() {
  Serial.begin(9600);
  pinMode(dataPin, INPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(latchPin, OUTPUT);
}
 
void loop() {
  // Load input bits into latches
  digitalWrite(latchPin, LOW);
  digitalWrite(latchPin, HIGH);
 
  for (int i = 0; i < 8; i++) {
    int bit = digitalRead(dataPin);
    Serial.print(bit ? "1" : "0");

    // Shift out the next bit to QH
    digitalWrite(clockPin, HIGH); 
    digitalWrite(clockPin, LOW);
  }
 
  Serial.println();
  delay(1000);
}

Im obigen Codebeispiel lesen wir 8 digitale Eingangsbits vom 74HC165 Schieberegister und geben sie jede Sekunde aus.

Konstanten und Variablen

Wir beginnen mit der Definition der Konstanten dataPin , clockPin und latchPin , die die Pins repräsentieren, die mit den Daten- (QH), Takt- (CLK) und Latch- (SH/LD) Pins des 74HC165 Schieberegisters verbunden sind. Du kannst auch andere Arduino-Pins verwenden. Wichtig ist nur, dass Verdrahtung und Code zusammenpassen.

const int dataPin = 4;   // QH
const int clockPin = 2;  // CLK
const int latchPin = 3;  // SH/LD

Setup-Funktion

In der setup() -Funktion initialisieren wir die serielle Kommunikation mit 9600 Baud. Außerdem setzen wir den dataPin als INPUT und die clockPin und latchPin als OUTPUT, da wir Daten vom Datenpin lesen und die Takt- und Latch-Pins steuern.

void setup() {
  Serial.begin(9600);
  pinMode(dataPin, INPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(latchPin, OUTPUT);
}

Loop-Funktion

In der loop() -Funktion laden wir zuerst die Eingangsbits in die Latches des Schieberegisters, indem wir den Latch-Pin umschalten.

void loop() {
  digitalWrite(latchPin, LOW);
  digitalWrite(latchPin, HIGH);

  ...
}

Dann gehen wir jedes der 8 Bits durch, lesen deren Wert vom Datenpin, geben sie (als ‚1‘ oder ‚0‘) aus und schieben das nächste Bit durch Umschalten des Taktpins heraus. Am Ende fügen wir eine Verzögerung von 1 Sekunde zwischen den Lesezyklen ein.

void loop() {
  digitalWrite(latchPin, LOW);
  digitalWrite(latchPin, HIGH);

  for (int i = 0; i < 8; i++) {
    int bit = digitalRead(dataPin);
    Serial.print(bit ? "1" : "0");

    digitalWrite(clockPin, HIGH); 
    digitalWrite(clockPin, LOW);
  }

  Serial.println();
  delay(1000);
}

Mit diesem Code und der Schaltung kannst du jetzt 8 digitale Eingänge mit nur drei Pins deines Arduino auslesen. Das funktioniert natürlich genauso mit einem ESP8266 oder ESP32. Wenn du den Code ausführst, solltest du eine Ausgabe wie diese im Seriellen Monitor sehen.

Output on Serial Monitor — Ausgabe im Seriellen Monitor

Das tatsächliche Bitmuster hängt davon ab, welche Taster du während des Programmlaufs drückst. Wie erwähnt, habe ich tatsächlich einen DIP-Schalter verwendet und nur die ersten vier Schalter zum Testen der Schaltung und des Codes angeschlossen. Das Bild unten zeigt mein Breadboard mit der Schaltung.

Arduino with 74HC165 Shift Register and DIP switch — Arduino mit 74HC165 Schieberegister und DIP-Schalter

Mit der oben gezeigten Schaltung und dem Code kannst du bis zu 8 digitale Eingänge auslesen. Wenn du noch mehr Eingänge brauchst, kannst du mehrere 74HC165 Schieberegister in Reihe schalten. Wie das geht, ist Thema des nächsten Abschnitts.

Verkettung von 74HC165 Schieberegistern

Du kannst den seriellen Ausgang Q _H eines 74HC165 Schieberegisters mit dem seriellen Eingang SER eines weiteren 74HC165 verbinden, um sie zu verketten. So kannst du statt 8 gleich 16 digitale Eingänge auslesen.

Chaining two 74HC165 via QH and SER — Verkettung von zwei 74HC165 über Q _H und SER

Und du musst dort nicht aufhören. Du kannst beliebig viele in Reihe schalten und so praktisch beliebig viele digitale Eingänge auslesen. Das Beste: Alle 74HC165 Schieberegister werden über die gleichen drei Pins gesteuert.

Das Schaltbild unten zeigt, wie du 16 Taster als Eingänge an einen Arduino mit zwei 74HC165 Schieberegistern anschließt. Es sieht kompliziert aus, ist aber nur eine Verdopplung der obigen Verdrahtung.

Chaining two 74HC165 two read 16 Buttons — Verkettung von zwei 74HC165 zum Auslesen von 16 Tastern

Beachte, dass CLK und SH/LD der 74HC165 parallel geschaltet sind und der einzige Unterschied zur Verdrahtung eines einzelnen 74HC165 die Verkettung über Q _H und die SER-Pins ist.

Code zum Auslesen von verketteten 74HC165 Schieberegistern

Der Code zum Auslesen von zwei verketteten 74HC165 Schieberegistern ist eine einfache Erweiterung des Codes für ein einzelnes 74HC165. Siehe unten:

const int dataPin = 4;   // QH
const int clockPin = 2;  // CLK
const int latchPin = 3;  // SH/LD

const byte numBits = 16;  
  
void setup() {
  Serial.begin(9600);
  pinMode(dataPin, INPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(latchPin, OUTPUT);
}
 
void loop() {
  digitalWrite(latchPin, LOW);
  digitalWrite(latchPin, HIGH);
 
  for (int i = 0; i < numBits; i++) {
    int bit = digitalRead(dataPin);
    Serial.print(bit ? "1" : "0");

    digitalWrite(clockPin, HIGH); 
    digitalWrite(clockPin, LOW);
  }
 
  Serial.println();
  delay(1000);
}

Wir fügen einfach eine Konstante numBits hinzu, mit der wir festlegen, wie viele Bits wir auslesen wollen. Bei einem einzelnen 74HC165 wären das 8 Bits. Wenn wir zwei Schieberegister verwenden, können wir 8 * 2 = 16 Bits auslesen, und so weiter.

Mit ArduinoShiftIn vom 74HC165 Schieberegister auslesen

Wenn du nicht selbst Code schreiben möchtest, um den 74HC165 zu steuern, gibt es eine praktische kleine Bibliothek dafür. Sie heißt ArduinoShiftIn und sollte auch auf einem ESP32 oder ESP8266 funktionieren. Besonders praktisch ist sie, wenn du mehrere 74HC165 Schieberegister in Reihe schaltest und die Eingangsdaten in eine einzige Variable einlesen möchtest.

Um die ArduinoShiftIn-Bibliothek zu installieren, gehe in den ArduinoShiftIn github repo , lade die Zip file herunter und füge sie dann deiner Arduino IDE hinzu über: Sketch > Include Library > Add .ZIP > wähle die ZIP-Datei aus.

Das folgende Codebeispiel stammt aus einem der ArduinoShiftIn-Beispiele und zeigt, wie man von zwei 74HC165 Schieberegistern liest:

#include "ShiftIn.h"

ShiftIn<2> shift;  // 2 = two 74HC165 

void setup() {
  Serial.begin(9600);
  // pLoadPin, clockEnablePin, dataPin, clockPin
  shift.begin(8, 9, 11, 12);
}

void displayValues() {
  for(int i = 0; i < shift.getDataWidth(); i++)
    Serial.print(shift.state(i));
  Serial.println();
}

void loop() {
  if(shift.update()) 
    displayValues();
  delay(1);
}

Du musst beim Deklarieren des shift -Objekts angeben, wie viele 74HC165 Schieberegister verkettet sind:

ShiftIn<2> shift;

In der Setup-Funktion stellen wir die serielle Kommunikation her und definieren die Pins zur Steuerung des 74HC165 Schieberegisters.

void setup() {
  Serial.begin(9600);
  // pLoadPin, clockEnablePin, dataPin, clockPin
  shift.begin(8, 9, 11, 12);
}

Beachte, dass die ArduinoShiftIn-Bibliothek alle vier Pins verwendet, während wir in den Code- und Schaltungsbeispielen CLK INH auf Masse gelegt und nicht genutzt haben. Hier musst du den clockEnablePin (= CLK INH) definieren und anschließen.

Die Funktion displayValues() zeigt, wie der Name schon sagt, die gelesenen Eingabewerte an.

void displayValues() {
  for(int i = 0; i < shift.getDataWidth(); i++)
    Serial.print(shift.state(i));
  Serial.println();
}

Die Funktion shift.getDataWidth() bekommt die Anzahl der zu lesenden Bits. Du musst die Anzahl der Schieberegister also nicht selbst mit 8 multiplizieren. Und shift.state() gibt den Status des i -ten Eingangs zurück.

Zum Schluss die Loop-Funktion. Sie ruft displayValues() auf, aber nur, wenn sich der Zustand eines Eingangs geändert hat, was durch die shift.update() -Funktion signalisiert wird.

void loop() {
  if(shift.update()) 
    displayValues();
  delay(1);
}

Beachte jedoch, dass shift.update() nicht ereignisgesteuert ist, sondern den Zustand der 74HC165 Schieberegister einfach mit der Geschwindigkeit der Loop abfragt – in diesem Beispiel mit einer Verzögerung von 1 Mikrosekunde.

Die Verdrahtung ist im Wesentlichen wie zuvor, mit dem Unterschied, dass andere Steuerpins verwendet werden und dass du CLK INH mit dem Arduino verbinden musst.

Wiring of two 74HC165 for the ArduinoShiftIn library — Verdrahtung von zwei 74HC165 für die ArduinoShiftIn-Bibliothek

Zusammengefasst vereinfacht die ArduinoShiftIn-Bibliothek den Code zum Auslesen von Eingängen aus verketteten 74HC165 Schieberegistern, hat aber den kleinen Nachteil, dass sie einen weiteren GPIO-Pin (CLK INH) belegt. Wenn du aber viele (bis zu 8) Schieberegister kaskadierst, ist das meist kein Problem, da du ohnehin viele zusätzliche Eingänge hast.

Fazit

In diesem Tutorial hast du gelernt, wie du mit dem 74HC165 Schieberegister eine beliebige Anzahl digitaler Eingänge zu deinem Mikrocontroller hinzufügen kannst. Die gezeigte Schaltung und der Code basieren auf einem Arduino, funktionieren aber genauso mit einem ESP32 oder ESP8266.

Im Gegensatz zu GPIO expanders , der analoge Ein- und Ausgänge lesen und schreiben kann, ist der 74HC165 Schieberegister auf das Auslesen digitaler Eingänge beschränkt. Allerdings ist der 74HC165 in der Regel deutlich günstiger als ein GPIO-Expander-Board.

Wenn du auch viele Ausgänge ansteuern möchtest, schau dir unser Tutorial More Arduino Outputs With 74HC595 Shift Register an, das einen anderen Typ Schieberegister verwendet, um Daten auszugeben statt einzulesen.

Wenn du analoge Ein- und Ausgänge benötigst, ist ein GPIO-Expander wie der MCP23017 zum Beispiel die bessere Wahl. Mehr Infos dazu findest du in unserem Tutorial Using GPIO Expander MCP23017 With Arduino .

Und jetzt: Viel Spaß beim Bauen von Projekten mit massenhaft Ein- und Ausgängen ; )

Häufig gestellte Fragen

Hier findest du einige häufig gestellte Fragen zur Verwendung des 74HC165 Schieberegisters.

F: Was ist ein 74HC165 Schieberegister?

A: Der 74HC165 ist ein Parallel-in/Serial-out Schieberegister, mit dem du die Anzahl der digitalen Eingänge deines Arduino mit nur drei Pins erweitern kannst.

F: Wie viele Eingänge kann das 74HC165 Schieberegister verarbeiten?

A: Das 74HC165 Schieberegister kann bis zu 8 digitale Eingänge verarbeiten, was für Projekte mit mehreren Eingabegeräten nützlich ist.

F: Wie schließe ich das 74HC165 Schieberegister an meinen Arduino an?

A: Du kannst das 74HC165 Schieberegister an deinen Arduino anschließen, indem du die parallelen Eingänge mit deinen Eingabegeräten verbindest und den seriellen Ausgangspin mit einem digitalen Pin des Arduino verbindest.

F: Kann ich mehrere 74HC165 Schieberegister in Reihe schalten?

A: Ja, du kannst mehrere 74HC165 Schieberegister in Reihe schalten, um die Anzahl der Eingänge weiter zu erhöhen und so mehr Eingabegeräte an deinen Arduino anschließen.

F: Was sind die wichtigsten Vorteile der Verwendung des 74HC165 Schieberegisters in Arduino-Projekten?

A: Die wichtigsten Vorteile des 74HC165 Schieberegisters sind, dass du die Anzahl der Eingänge erweitern kannst, ohne alle Pins deines Arduino zu belegen, die Verdrahtung vereinfachst, da weniger Verbindungen nötig sind, und effizient mit mehreren Eingabegeräten arbeiten kannst.

F: Kann das 74HC165 Schieberegister auch mit anderen Mikrocontrollern als Arduino verwendet werden?

A: Ja, das 74HC165 Schieberegister kann mit anderen Mikrocontrollern verwendet werden, die digitale Ein- und Ausgänge unterstützen.

F: Kann ich das 74HC165 Schieberegister für Projekte mit Echtzeit-Eingabeüberwachung verwenden?

A: Ja, das 74HC165 Schieberegister eignet sich für Projekte, die eine Echtzeitüberwachung von Eingaben erfordern, da es ein schnelles Auslesen mehrerer digitaler Eingänge ermöglicht.

F: Gibt es häufige Tipps zur Fehlersuche beim Arbeiten mit dem 74HC165 Schieberegister?

A: Häufige Tipps zur Fehlersuche beim 74HC165 Schieberegister sind: Überprüfe die Verdrahtung, stelle sicher, dass die richtigen Takt- und Latch-Signale anliegen, und prüfe, ob das Eingabedatenformat im Code zur Konfiguration des Schieberegisters passt.

Stefan Maetschke