LEDs mit dem Schie­be­re­gis­ter 74HC595 steuern

Lese­zeit: 8 Minu­ten

Lösung
Seite als PDF

Schieberegister

Das Schie­be­re­gis­ter 74HC595 ver­fügt über acht Aus­gän­ge, die mit nur drei Daten­lei­tun­gen ange­steu­ert wer­den.
Für jeden Aus­gang wird ein Signal in Form einer „0“ = LOW, oder „1“ = HIGH gesen­det.
Ins­ge­samt sind acht Bits notwendig.

Eine Rei­he von 8 LEDs sol­len als Lauf­licht funk­tio­nie­ren und abwech­selnd blinken. 

Bei­spie­le Bits setzen

gesetz­te Bitsgeschal­te­te LEDs
11111111alle LEDs einschalten
00000000alle LEDs ausschalten
10101010jede zwei­te LED einschalten
10000001nur die bei­den äuße­ren LEDs einschalten

Der ers­te Wert wird in den Spei­cher geschrie­ben. Sobald der nächs­te Wert geschrie­ben wird, wer­den alle vor­he­ri­gen Wer­te eine Posi­ti­on wei­ter geschoben.

Das Schie­be­re­gis­ter besteht aus zwei Teilen:

dem Schie­be­re­gis­ter:
die ein­zel­nen Bits wer­den durch den Seri­el­len Ein­gang Pin 14 zuerst hier hin­ein gescho­ben, es wird noch kein Signal an die Aus­gangs­pins geschickt, mit MSBFIRST (links begin­nen) LSBFIRST (rechts begin­nen) kann der Start des „Schie­be­vor­gangs“ bestimmt werden

dem Aus­gangs­re­gis­ter:
erst wenn alle Bits an ihren Platz gescho­ben wur­den, wer­den durch das Schrei­ben von HIGH auf den Pin 12 die Daten in das Aus­gangs­re­gis­ter übernommen.

Die Pinbelegung:

Pinbelegung Schieberegister

Die Anord­nung der LEDs:

Benö­tig­te Bauteile:

  • 8 LEDs
  • Schie­be­re­gis­ter 74HC595
  • 8 Wider­stän­de 220 Ω
  • Lei­tungs­dräh­te

Beach­te die ➨Vor­wi­der­stän­de ver­schie­de­ner LEDs

Für die Pro­gram­mie­rung brauchst du noch Infor­ma­tio­nen über ver­schie­de­ne Mani­pu­la­tio­nen von Bits.

Bits nach rechts schieben

Ver­schie­ben von Bits nach rechts:

LED = LED >> 1;

Alle Bits wer­den um eine Posi­ti­on nach rechts ver­scho­ben. Das letz­te Bit auf der rech­ten Sei­te fällt her­aus, auf der lin­ken Sei­te wird jeweils eine 0 eingefügt.

Im Pro­gramm sieht das so aus:

  // LSBFIRST -> Bits von rechts in das Register schieben
  LED = B11111111;

  /*
    8-mal schieben
    bis alle Bits herausgeschoben sind
    und eine 0 vorne hinzufügt wurde
    Stand am Ende:
    B00000000
  */
  for (int i = 0; i <= 7; i++)
  {
    // Ausgaberegister ausschalten
    digitalWrite(AusgabePin, 0);

    // Bits in das Schiebregister schieben
    shiftOut(EingangPin, BitsSchieben, LSBFIRST, LED);

    // Ausgaberegister einschalten
    digitalWrite(AusgabePin, 1);
    delay(200);

    // 1 Bit nach rechts schieben
    LED = LED >> 1;
  }
Bits nach links schieben

Ver­schie­ben von Bits nach links:

LED = LED << 1;

Alle Bits wer­den um eine Posi­ti­on nach links ver­scho­ben. Das letz­te Bit auf der lin­ken Sei­te fällt her­aus, auf der rech­ten Sei­te wird jeweils eine 0 eingefügt.

Im Pro­gramm sieht das so aus:

  LED = B11111111;

  for (int i = 0; i <= 7; i++)
  {
    // Ausgaberegister ausschalten
    digitalWrite(AusgabePin, 0);

    // Bits von rechts in das Register schieben
    shiftOut(EingangPin, BitsSchieben, LSBFIRST, LED);

    // Ausgaberegister einschalten
    digitalWrite(AusgabePin, 1);
    delay(200);

    // 1 Bit nach links schieben
    LED = LED << 1;
  } 

Wert der Bits umkehren:

Wert von Bits umkehren

LED = B10101010;
LED = ~ LED;
aus 0 wird 1, aus 1 wird 0

Im Pro­gramm sieht das so aus:

  LED = B10101010;

  for (int i = 0; i <= 6; i++)
  {
    digitalWrite(AusgabePin, 0);
    shiftOut(EingangPin, BitsSchieben, MSBFIRST, LED);
    digitalWrite(AusgabePin, 1);
    delay(200);
    LED = ~ LED;
  }

Bit­ma­ni­pu­la­ti­on im Seri­el­len Monitor

Defi­nie­re die Varia­blen für das Schie­be­re­gis­ter und das ➨Array für das LED-Muster.

int BitsSchieben = 8;
int AusgabePin = 9;
int EingangPin = 10;

// Array LEDs leuchten von außen nach innen und zurück
byte AussenNachInnen[] =
{
  B10000001, B01000010, B00100100, B00011000,
  B00100100, B01000010, B10000001
};

Im set­up-Teil wer­den die Aus­gän­ge definiert:

void setup()
{
  pinMode(BitsSchieben, OUTPUT);
  pinMode(AusgabePin, OUTPUT);
  pinMode(EingangPin, OUTPUT);
}
Download

Der loop-Teil. Beach­te die Kommentare.

void loop()
{
  /*
    Lauflicht vorwärts
    LSBFIRST Bits von rechts ins Register schieben
    dann jeweils 1 Bit nach rechts schieben
    Startpunkt hängt davon ab, an welchen Pins die
    1. Led und die weiteren LEDs gesteckt sind
  */
  byte LED = B10000000;

  // die letzte LED bleibt an
  for (int i = 0; i <= 6; i++)
  {
    // Ausgaberegister ausschalten
    digitalWrite(AusgabePin, 0);

    // Bits von rechts in das Register schieben
    shiftOut(EingangPin, BitsSchieben, LSBFIRST, LED);

    // Ausgaberegister einschalten
    digitalWrite(AusgabePin, 1);
    delay(200);

    // 1 Bit nach rechts schieben
    LED = LED >> 1;
  }

  /*
    durch die Verschiebung ist der aktuelle Stand:
    LED = B00000001
    Lauflicht rückwärts -> 1 Bit nach links schieben
  */
  for (int i = 0; i <= 7; i++)
  {
    // Ausgaberegister ausschalten
    digitalWrite(AusgabePin, 0);

    // Bits von rechts in das Register schieben
    shiftOut(EingangPin, BitsSchieben, LSBFIRST, LED);

    // Ausgaberegister einschalten
    digitalWrite(AusgabePin, 1);
    delay(200);

    // 1 Bit nach links schieben
    LED = LED << 1;
  }

  // Lauflicht 2 LEDs vorwärts
  LED = B11000000;

  for (int i = 0; i <= 2; i++)
  {
    // Ausgaberegister ausschalten
    digitalWrite(AusgabePin, 0);

    // LSBFIRST -> Bits von rechts in das Register schieben
    shiftOut(EingangPin, BitsSchieben, LSBFIRST, LED);

    // Ausgaberegister einschalten
    digitalWrite(AusgabePin, 1);
    delay(200);

    // 2 Bits nach rechts schieben
    LED = LED >> 2;
  }

  // Lauflicht 2 LEDs rückwärts
  for (int i = 0; i <= 3; i++)
  {
    // Ausgaberegister ausschalten
    digitalWrite(AusgabePin, 0);

    // Bits von links in das Register schieben
    shiftOut(EingangPin, BitsSchieben, LSBFIRST, LED);

    // Ausgaberegister einschalten
    digitalWrite(AusgabePin, 1);
    delay(200);

    // 2 Bits nach links schieben
    LED = LED << 2;
  }

  // Lauflicht -> LEDs gehen nach und nach aus
  // LSBFIRST -> Bits von rechts in das Register schieben
  LED = B11111111;

  for (int i = 0; i <= 7; i++)
  {
    // Ausgaberegister ausschalten
    digitalWrite(AusgabePin, 0);

    // Bits in das Schiebregister schieben
    shiftOut(EingangPin, BitsSchieben, LSBFIRST, LED);

    // Ausgaberegister einschalten
    digitalWrite(AusgabePin, 1);
    delay(200);

    // 1 Bit nach rechts schieben
    LED = LED >> 1;
  }

  // LSBFIRST -> Bits von rechts in das Register schieben
  LED = B11111111;
  for (int i = 0; i <= 7; i++)
  {
    // Ausgaberegister ausschalten
    digitalWrite(AusgabePin, 0);

    // Bits in das Schiebregister schieben
    shiftOut(EingangPin, BitsSchieben, LSBFIRST, LED);

    // Ausgaberegister einschalten
    digitalWrite(AusgabePin, 1);
    delay(200);

    // 1 Bit nach links schieben
    LED = LED << 1;
  }

  // LEDS leuchten von außen nach innen und zurück
  // Array AussenNachInnen
  for (int i = 0; i <= 6; i++)
  {
    digitalWrite(AusgabePin, 0);
    shiftOut(EingangPin, BitsSchieben, MSBFIRST, AussenNachInnen[i]);
    digitalWrite(AusgabePin, 1);
    delay(200);
  }

  // alle LEDs blinken
  for (int i = 0; i <= 6; i++)
  {
    digitalWrite(AusgabePin, 0);
    shiftOut(EingangPin, BitsSchieben, MSBFIRST, LED);
    digitalWrite(AusgabePin, 1);
    delay(200);

    // alle Werte umkehren
    LED = ~ LED;
  }

  // MSBFIRST -> Bits von links in das Register schieben
  // jede zweite LED im Wechsel
  LED = B10101010;

  for (int i = 0; i <= 6; i++)
  {
    digitalWrite(AusgabePin, 0);
    shiftOut(EingangPin, BitsSchieben, MSBFIRST, LED);
    digitalWrite(AusgabePin, 1);
    delay(200);

    // alle Werte umkehren
    LED = ~ LED;
  }

  // jeweils 2 LEDs im Wechsel
  LED = B11001100;

  for (int i = 0; i <= 6; i++)
  {
    digitalWrite(AusgabePin, 0);
    shiftOut(EingangPin, BitsSchieben, MSBFIRST, LED);
    digitalWrite(AusgabePin, 1);
    delay(200);

    // alle Werte umkehren
    LED = ~ LED;
  }

  // äußere LEDs/innere LEDs im Wechsel
  LED = B11000011;

  for (int i = 0; i <= 6; i++)
  {
    digitalWrite(AusgabePin, 0);
    shiftOut(EingangPin, BitsSchieben, MSBFIRST, LED);
    digitalWrite(AusgabePin, 1);
    delay(200);

    // alle Werte umkehren
    LED = ~ LED;
  }
}

Ände­re die Rich­tung der Lauf­lich­ter durch Set­zen des Start­bits.
Erstel­le eige­ne Mus­ter von blin­ken­den LEDs.

Download

Für das Schie­be­re­gis­ter ist auch eine ➨Biblio­thek verfügbar.


Startseite
Aufgaben A-Z
Suchen
Downloads
Fehlermeldungen
Seite als PDF

Ver­wand­te Aufgaben:


Letzte Aktualisierung: 29. Nov 2023 @ 11:44