Arduino Lektion #100: Schieberegister 74HC595N N2B5

In diesem Beitrag möchte ich das Schieberegister 74HC595N N2B5 vorstellen.

Mit diesem Schieberegister kann man seine vorhandenen digitalen Pins um ein vielfaches erweitern.

Bezug

Es gibt die Schieberegister in größeren Verpackungseinheiten (5,10 usw.) mit diesen Packungen spart man auf ebay.de deutlich gegenüber dem kauf eines einzelnen Chips.

Auf ebay.de* kann man zbsp. das Schieberegister im 10er-Pack für ca. 4 € aus China bestellen.

Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Technische Daten des Schieberegisters 74HC595N N2B5

• 8bit,
• Sockel 16 DIP,
• Betriebsspannung 2VDC bis 6VDC
• Ausgangsstrom 35mA
• Betriebstemperatur -40 °C bis 85 °C

Aufbau

Der Chip verfügt über 16 Pins welche wie folgt belegt sind.

Pin	Beschreibung
Q0 … Q7	Ausgangspins 0 bis 7
GND	Ground
VCC	5V Anschluss
DS	Serieller Eingang
OE	Ein -/ Ausschalten der Ausgangspins
STCP	Shift Register, beim Wechsel von LOW auf HIGH wird das an DS anliegende Bit um eine Stelle weiter geschoben
SHCP	Storage Register, beim Wechsel von LOW auf HIGH werden die Daten des Schieberegisters in das Speicherregister übertragen.
MR	Zurücksetzen des Speicher & Schieberegisters
Q7S	Pin für den Anschluss eines weiteren Schieberegisters

Aufbau & Anschluss am Arduino

Für den Anschluss des Schieberegisters am Arduino benötigt man nur ein paar Breadboardkabel (6 Stück) und natürlich für die Ausgänge (pro Schieberegister 8 Stück).

In meinem Beispiel verwende ich einen Arduino Nano V3.0 und ein 720 Pin Breadboard. Dieses Breadboard bietet genügend Platz für den Microcontroller, das Schieberegister sowie 8, 5mm LEDs.

Aufbau der Schaltung

Nachfolgend möchte ich zeigen wie du das Schieberegister am Arduino Nano V3.0 mit 8 LEDs anschließen kannst.

Arduino	Schieberegister
digitaler Pin D8	SHCP
digitaler Pin D9	STCP
digitaler Pin D10	DS

schreiben eines Wertes in das Schieberegister

Das Schieberegister 74HC595 verfügt über 8 digitale Ausgänge, d.h. wir können mit einem solchen Element 8 Aktoren betreiben. Im nachfolgenden Beispiel möchte ich 8 LEDs im Zustand verändern.

int shiftPin = 8; //SHCP
int storePin = 9; //STCP
int dataPin = 10; //DS

//Status der einzelnen LEDs
int led1 = 1;
int led2 = 1;
int led3 = 1;
int led4 = 1;
int led5 = 1;
int led6 = 1;
int led7 = 1;
int led8 = 1;

//maximale Anzahl der LEDs
//(Wenn ein weiteres Schieberegister angeschlossen wird
//muss diese Zahl ensprechend erhöht werden.)
const int ANZAHL_LEDS = 8;

//Array mit Daten für das Schieberegister.
int muster[ANZAHL_LEDS] = {
    led1,led2,led3,led4,
    led5,led6,led7,led8
    };
 
void setup() {
 //setzen der Pins als Ausgang
 pinMode(storePin, OUTPUT);
 pinMode(shiftPin, OUTPUT);
 pinMode(dataPin, OUTPUT);

 //setzen des Pins am digitalen Pin D8
 //auf LOW quasi Status "AUS"
 digitalWrite(storePin, LOW); 

 //Schleife über das Muster welches
 //auf das Schieberegister geschrieben
 //werden soll.
 for (int i=0; i<ANZAHL_LEDS; i++) {
  digitalWrite(shiftPin, LOW);
  digitalWrite(dataPin, muster[i]);
  digitalWrite(shiftPin, HIGH);
 }

  //aktivieren des Musters
 digitalWrite(storePin, HIGH);
}
 
void loop () {
 //bleibt leer
}

Der Code bewirkt das alle LEDs aktiviert werden. (led1 … led8 steht auf 1)

Wenn man nun eine LED deaktivieren möchte so kann man den Wert auf 0 setzen.

Lauflicht mit dem Schieberegister realisieren

Nachdem wir im ersten Beispiel ein einfaches Muster ausgegeben haben, wollen wir nun ein Lauflicht erstellen.

int shiftPin = 8; //SHCP
int storePin = 9; //STCP
int dataPin = 10; //DS

//globale Variable 
//dient als Index für die aktive LED
//im Lauflicht
int activeIndex = -1;

void setup() {
  //setzen der Pins als Ausgang
  pinMode(storePin, OUTPUT);
  pinMode(shiftPin, OUTPUT);
  pinMode(dataPin, OUTPUT);

  //setzen des Pins am digitalen Pin D8
  //auf LOW quasi Status "AUS"
  digitalWrite(storePin, LOW);
}

void loop () {
  writeMuster();
  //eine kleine Pause von 150ms.
  delay(150); 
}

void writeMuster() {
  //den aktiven Index um 1 erhöhen
  ++activeIndex;
  //Das "Ausgangsmuster" wo alle LEDs 
  //deaktivert sind.
  int muster[8] = {0, 0, 0, 0, 0, 0, 0};

  //Wenn der aktive Index größer als die
  //maximale Anzahl der LEDs ist, dann...
  if (activeIndex > 7) {
    activeIndex = 0; //den activen Index auf 0 setzen.
    //Dieses sorgt dafür dass, das Lauflicht wieder von vorne beginnt.
  }

  //den Wert im Array manipulieren
  //es wird an der Stelle "x" im Array eine 1 gesetzt
  muster[activeIndex] = 1;

  //Von 0 bis 8 mache...
  for (int i = 0; i < 8; i++) {
    digitalWrite(shiftPin, LOW);
    digitalWrite(dataPin, muster[i]);
    digitalWrite(shiftPin, HIGH);
    Serial.print(muster[i]);
  }
  //schreiben der Daten
  digitalWrite(storePin, HIGH);
  delay(20); //eine kleine Pause
  //zurücksetzen 
  digitalWrite(storePin, LOW);
}

Video

Lauflicht vorwärts & rückwärts laufen lassen

Nachfolgend der Code um das Lauflicht vorwärts & rückwärts laufen zu lassen.

// Definition der Pins für das Shift-Register (74HC595)
int shiftPin = 8;  // SHCP (Schieberegister-Takt)
int storePin = 9;  // STCP (Latching, Speichern der Daten)
int dataPin = 10;  // DS (Dateninput für das Register)

// Bitmuster für das Lauflicht (Indexwerte für aktive LEDs)
int lauflicht[14] = { 1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1 };

// Globale Variable zum Speichern der aktuell aktiven LED-Position
int activeIndex = -1;  // Start bei -1, wird in writeMuster() inkrementiert

bool forward = true;  // Gibt an, ob das Licht vorwärts oder rückwärts läuft

void setup() {
  Serial.begin(9600);  // Serielle Kommunikation starten (9600 Baud)

  // Setzen der Pins als Ausgang
  pinMode(storePin, OUTPUT);
  pinMode(shiftPin, OUTPUT);
  pinMode(dataPin, OUTPUT);

  // Initialisieren des Store-Pins auf LOW (keine Daten gespeichert)
  digitalWrite(storePin, LOW);
}

void loop() {
  writeMuster();  // Bitmuster an das Shift-Register senden
  delay(150);     // Kleine Pause von 150 ms für das Lauflicht
}

void writeMuster() {
  activeIndex++;  // Erhöht den Index für das nächste Bitmuster

  // Falls der Index größer als 13 wird, auf 0 zurücksetzen (Restart des Musters)
  if (activeIndex > 13) {
    activeIndex = 0;
  }

  // Schieberegister mit neuen Werten befüllen
  for (int i = 0; i < 8; i++) {  // 8-Bit-Schieberegister durchlaufen
    digitalWrite(shiftPin, LOW);  // Schiebetakt-Pin auf LOW setzen

    // Prüfen, ob das aktuelle Bit dem Muster entspricht, falls ja, HIGH setzen
    digitalWrite(dataPin, (lauflicht[activeIndex] == i ? 1 : 0));

    // Schiebetakt-Pin auf HIGH setzen, damit das Bit ins Register geladen wird
    digitalWrite(shiftPin, HIGH);

    // Debug-Ausgabe in die serielle Konsole (zeigt den aktuellen Zustand)
    Serial.println("IDX" + String(activeIndex) + ">>" + String(lauflicht[activeIndex] == i ? 1 : 0));
  }

  // Speichern der neuen Werte im Schieberegister (Daten auf Ausgänge übernehmen)
  digitalWrite(storePin, HIGH);
  delay(20);  // Kurze Pause für Stabilität
  digitalWrite(storePin, LOW);  // Zurücksetzen des Store-Pins
}

mehrere Schieberegister mit einander verbinden

Bisher habe ich nur ein Schieberegister an den Arduino Nano V3.0 angeschlossen. Eigentlich bräuchte man für die bisherigen Aufgaben kein Schieberegister denn der Arduino Nano verfügt über 13 digitale Pins welche frei programmiert werden können. Somit könnte man also auch 13 LEDs anschließen und ein Lauflicht etc. aufbauen. 

Nun möchte ich jedoch 16 LEDs an dem Microcontroller betreiben und somit werden min. 2 Schieberegister benötigt.

Aufbau mit zwei Schieberegister

Das erste Schieberegister wird wie aus dem ersten Beispiel angeschlossen.

Arduino	Schieberegister #1	Schieberegister #2
digitaler Pin D8	SHCP	SHCP
digitaler Pin D9	STCP	STCP
digitaler Pin D10	Q7S	DS

Die Pins für die 16 LEDs sind mit blauen Drähten „markiert“.

Text „XMAS“ mit 16 LEDs

Da dieser Beitrag zum 09.12.2019 veröffentlicht wird, möchte ich nun ein ein Beispiel passend zur Weihnachtszeit präsentieren.

Der Schriftzug verfügt über 6 Löcher, mit einem Durchmesser von 5mm für die Aufnahme von LEDs. Erstellt habe ich die Buchstaben mit dem Onlinetool TinkerCad.com und gedruckt wurden diese mit dem 3D Drucker Creality Ender2.

3D Druck Modelle

Hier findest du diese Modelle zum bequemen Download.

Vorbereitung

Für den betrieb müssen wir zunächst die 16 LEDs mit entsprechende Vorwiderstände und einer Platine verbinden.

Wir benötigen dazu:

• 16x LED, 5mm, rot,
• 16x Vorwiderstand, 220 Ohm,
• 16 Stiftleisten, Rastermaß 2,54mm
• 1x Lochrasterplatine,
• 1x ca.1m, 0,20mm Kupferdraht (jeweils weiß & lila)

Sowie

• Lötkolben, Lötzinn, hitzebeständige Unterlage
• Seitenschneider

Quellcode

Video

Quellenangabe

Für dieses Tutorial habe ich mir zuvor die Informationen des Beitrages „Das Schieberegister 74HC595 am Arduino“ vom Makerblog.at durchgelesen und durchgearbeitet, daher werden sich sicherlich einige Elemente in diesem Beitrag wiederfinden.