LEDs mit dem Schie­be­re­gis­ter 74HC595 steu­ern

Lese­zeit: 8 Minu­ten
Navi­ga­ti­on

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 not­wen­dig.

Bei­spie­le Bits set­zen

gesetz­te Bitsgeschal­te­te LEDs
11111111alle LEDs ein­schal­ten
00000000alle LEDs aus­schal­ten
10101010jede zwei­te LED ein­schal­ten
10000001nur die bei­den äuße­ren LEDs ein­schal­ten

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 gescho­ben.

Das Schie­be­re­gis­ter besteht aus zwei Tei­len:

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 wer­den

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 über­nom­men.

Die Pin­be­le­gung:

Die Anord­nung der LEDs:

Benö­tig­te Bau­tei­le:

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

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.

Ver­schie­ben von Bits nach rechts:

B mar­kiert eine Binär­zahl
LED = B11111111;
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 ein­ge­fü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;
  }

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 ein­ge­fü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 umkeh­ren:

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 Moni­tor

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 setup-Teil wer­den die Aus­gän­ge defi­niert:

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

Der loop-Teil. Beach­te die Kom­men­ta­re.

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.



Ver­wand­te Auf­ga­ben:


Letzte Aktualisierung: 23. Aug 2020 @ 13:38