Bemerkung

Hallo, willkommen in der SunFounder Raspberry Pi & Arduino & ESP32 Enthusiasten-Community auf Facebook! Tauche tiefer ein in die Welt von Raspberry Pi, Arduino und ESP32 mit Gleichgesinnten.

Warum mitmachen?

• Expertenunterstützung: Löse nach dem Kauf auftretende Probleme und technische Herausforderungen mit Hilfe unserer Community und unseres Teams.

• Lernen & Teilen: Tausche Tipps und Tutorials aus, um deine Fähigkeiten zu verbessern.

• Exklusive Vorschauen: Erhalte frühzeitigen Zugang zu neuen Produktankündigungen und Einblicken.

• Spezielle Rabatte: Genieße exklusive Rabatte auf unsere neuesten Produkte.

• Festliche Aktionen und Gewinnspiele: Nimm an Gewinnspielen und festlichen Sonderaktionen teil.

👉 Bereit, mit uns zu erkunden und zu erschaffen? Klicke auf [hier] und tritt noch heute bei!

25. Nummern anzeigen mit dem 74HC595

In der vorherigen Lektion hast du möglicherweise bemerkt, dass der 74HC595 und das 7-Segment-Display ein perfektes Paar bilden. Der 74HC595 kann gleichzeitig 8-Bit-Signale ausgeben, während das 7-Segment-Display durch 8 elektrische Signale gesteuert wird (einschließlich des Dezimalpunkt-LED-Segments, d.h. des dp-Segments).

Kann der 74HC595 also zur Steuerung des 7-Segment-Displays verwendet werden? Die Antwort lautet ja.

In dieser Lektion werden wir den 74HC595 verwenden, um das 7-Segment-Display zu steuern und verschiedene Zahlen anzuzeigen.

In dieser Lektion wirst du lernen:

• Wie man das Schieberegister 74HC595 verwendet, um ein 7-Segment-Display anzutreiben.

• Die Binärdarstellungen der Ziffern 0 bis 9 zu verstehen und wie man sie in Dezimal- und Hexadezimalformate umwandelt.

• Wie man den seriellen Monitor verwendet, um Daten einzugeben und auf dem 7-Segment-Display anzuzeigen.

Aufbau der Schaltung

Benötigte Komponenten

1 * Arduino Uno R3	1 * 7-Segment-Display	1 * 220Ω-Widerstand	1 * 74HC595
1 * Steckbrett	Jumperkabel	1 * USB-Kabel

Schritt-für-Schritt-Aufbau

Folge dem Verdrahtungsdiagramm oder den untenstehenden Schritten, um deine Schaltung aufzubauen.

1. Setze das 7-Segment-Display in das Steckbrett ein, wobei der Dezimalpunkt in der unteren rechten Ecke ist.

2. Verbinde den negativen (-) Anschluss des 7-Segment-Displays mit der Masse-Schiene des Steckbretts mittels eines Jumperkabels.

3. Finde den 74HC595-Chip und setze ihn in das Steckbrett ein. Achte darauf, dass der Chip die mittlere Lücke überbrückt.

4. Verbinde die VCC- und MR-Pins des 74HC595 mit der Plus-Schiene des Steckbretts.

5. Verbinde die CE- und GND-Pins des 74HC595 mit der Minus-Schiene des Steckbretts.

6. Verbinde Q0 des 74HC595 mit dem ‚a‘-Pin des 7-Segment-Displays, Q1 mit dem ‚b‘-Pin, Q2 mit dem ‚c‘-Pin, Q3 mit dem ‚d‘-Pin und Q4 mit dem ‚e‘-Pin.

7. Verbinde Q5 des 74HC595 mit dem ‚f‘-Pin des 7-Segment-Displays, Q6 mit dem ‚g‘-Pin und Q7 mit dem ‚dp‘-Pin.

8. Verbinde den DS-Pin des 74HC595 mit Pin 11 des Arduino Uno R3.

9. Verbinde den ST_CP-Pin des 74HC595 mit Pin 12 des Arduino Uno R3.

10. Verbinde den SH_CP-Pin des 74HC595 mit Pin 8 des Arduino Uno R3.

11. Verbinde schließlich die GND- und 5V-Pins des Arduino Uno R3 mit der Minus- und Plus-Schiene des Steckbretts.

12. Die folgende Tabelle zeigt die Pin-Verbindungen zwischen dem 74HC595, dem Arduino Uno R3 und dem 7-Segment-Display.

74HC595	Arduino UNO R3
VCC	5V
DS	11
CE	GND
ST_CP	12
SH_CP	8
MR	5V
GND	GND

74HC595	7-Segment-Display
Q0	a
Q1	b
Q2	c
Q3	d
Q4	e
Q5	f
Q6	g
Q7	dp

Binärzahlen für die Ziffern 0 bis 9

In diesem Projekt verwenden wir das 74HC595-Schieberegister, um das 7-Segment-Display zu steuern und verschiedene Ziffern anzuzeigen. Das 74HC595 empfängt jedoch Binärzahlen. Daher müssen wir vor dem Programmieren die entsprechenden Binärzahlen für die Ziffern 0 bis 9 kennen.

Angenommen, wir möchten die Ziffer 2 auf dem 7-Segment-Display anzeigen. Dafür müssen die Segmente f und c ausgeschaltet und die übrigen Segmente eingeschaltet werden.

Laut dem Verdrahtungsdiagramm entsprechen die Ausgangspins Q0 bis Q7 des 74HC595 den jeweiligen Pins des 7-Segment-Displays, wie in der Abbildung gezeigt. Im Binärsystem steht 0 für aus (geschlossen) und 1 für ein (offen). Um die Ziffer 2 anzuzeigen, müssen dp, f und c 0 sein, während die anderen Segmente 1 sind. Dies ergibt die Binärzahl B01011011.

Bemerkung

Wenn nur ein 7-Segment-Display vorhanden ist, wird der DP-Pin immer auf 0 gesetzt. Wenn mehrere 7-Segment-Displays in einer Daisy-Chain-Konfiguration verwendet werden, kann der DP-Pin zur Anzeige des Dezimalpunkts verwendet werden.

Um die Ziffer 0 anzuzeigen, müssen dp und g 0 sein und alle anderen Segmente 1, was die Binärzahl B00111111 ergibt.

Frage

Da wir jetzt die Binärdarstellungen für die Ziffern 0 und 2 kennen, füllen Sie bitte die Binärzahlen für die verbleibenden Ziffern in der folgenden Tabelle aus.

Zahl	Binär
0	B00111111
1
2	B01011011
3
4
5
6
7
8
9

Code-Erstellung - Zahlen anzeigen

1. Öffne das zuvor gespeicherte Sketch Lesson24_Flowing_Light.

2. Wähle im Menü „Speichern unter…“ und benenne es in Lesson25_Show_Number_Binary um. Klicke auf „Speichern“.

3. Ändere das datArray[], um die Binärzahlen anzuzeigen, die den Ziffern 0 bis 9 entsprechen.

const int STcp = 12;  //Pin verbunden mit ST_CP des 74HC595
const int SHcp = 8;   //Pin verbunden mit SH_CP des 74HC595
const int DS = 11;    //Pin verbunden mit DS des 74HC595
//zeige 0,1,2,3,4,5,6,7,8,9 an
int datArray[] = { B00111111, B00000110, B01011011, B01001111, B01100110, B01101101, B01111101, B00000111, B01111111, B01101111 };

4. Da das Array datArray[] 10 Elemente enthält, ändere den Bereich der Variablen num auf num <= 9.

void loop() {
    for (int num = 0; num <= 9; num++) {
        digitalWrite(STcp, LOW);                      // Setze ST_CP auf LOW und halte es während der Übertragung
        shiftOut(DS, SHcp, MSBFIRST, datArray[num]);  // Sende die Daten, MSB zuerst
        digitalWrite(STcp, HIGH);                     // Setze ST_CP auf HIGH, um die Daten zu speichern
        delay(1000);                                  // Warte eine Sekunde
    }
}

5. Dein vollständiger Code sollte folgendermaßen aussehen. Jetzt kannst du den Code auf den Arduino Uno R3 hochladen, und du wirst sehen, wie das 7-Segment-Display die Ziffern von 0 bis 9 durchläuft.

const int STcp = 12;  //Pin verbunden mit ST_CP des 74HC595
const int SHcp = 8;   //Pin verbunden mit SH_CP des 74HC595
const int DS = 11;    //Pin verbunden mit DS des 74HC595
//zeige 0,1,2,3,4,5,6,7,8,9 an
int datArray[] = { B00111111, B00000110, B01011011, B01001111, B01100110, B01101101, B01111101, B00000111, B01111111, B01101111 };

void setup() {
    //Pins als Ausgang setzen
    pinMode(STcp, OUTPUT);
    pinMode(SHcp, OUTPUT);
    pinMode(DS, OUTPUT);
}

void loop() {
    for (int num = 0; num <= 9; num++) {
        digitalWrite(STcp, LOW);                      // Setze ST_CP auf LOW und halte es während der Übertragung
        shiftOut(DS, SHcp, MSBFIRST, datArray[num]);  // Sende die Daten, MSB zuerst
        digitalWrite(STcp, HIGH);                     // Setze ST_CP auf HIGH, um die Daten zu speichern
        delay(1000);                                  // Warte eine Sekunde
    }
}

Binärumrechnung

In praktischen Anwendungen ermöglicht das Schreiben von Binärzahlen eine klarere Darstellung des Zustands jedes Bits in den Daten. Für die allgemeine Zahlendarstellung ist das Schreiben von Dezimalzahlen jedoch bequemer.

Bemerkung

Das Schreiben von Binär-, Dezimal- oder sogar Hexadezimalzahlen beeinflusst nicht das Ergebnis des Programms, sondern nur die Lesbarkeit des Codes. Zum Beispiel wird die Dezimalzahl 91 intern in die Binärform B01011011 umgewandelt.

Schauen wir uns an, wie Binärzahlen in Dezimalzahlen umgewandelt werden.

Umrechnung in Dezimal

Im Binärsystem repräsentiert jedes Bit einen entsprechenden Stellenwert. Der Stellenwert ist eine Potenz von 2, wie z. B. 2^0, 2^1, 2^2 usw. Durch Multiplikation jedes Bits mit seinem entsprechenden Stellenwert und Addition der Ergebnisse erhalten wir die Dezimalzahl.

Beispielsweise wird die Binärzahl B01011011 in die Dezimalzahl 91 umgewandelt.

Verwendung eines Taschenrechners

In praktischen Anwendungen kannst du den Rechner auf deinem Computer verwenden. Schalte in den Programmierermodus, und du kannst ganz einfach zwischen Binär-, Dezimal- und Hexadezimalzahlen umrechnen.

Suche auf deinem Computer nach „Rechner“ und schalte dann in den Programmierer-Modus.

2. Wenn du die Binärzahl bereits kennst und sie in ein anderes Zahlensystem umrechnen möchtest, wähle BIN.

3. Jetzt kannst du die Binärzahl eingeben.

• Die effektiven Bits in Binär beziehen sich auf den Bereich vom höchstwertigen Bit (linkes, nicht null Bit) bis zum niedrigstwertigen Bit (rechtes, nicht null Bit).

• Für die Binärzahl B00111111 sind die effektiven Bits 111111.

• Gib nun 111111 in den Taschenrechner ein, um die entsprechende Dezimal- und Hexadezimalzahl zu erhalten.

Frage

Bitte konvertiere die Binärzahlen, die die Ziffern 0 bis 9 darstellen, in Dezimal- und Hexadezimalzahlen mit einem Taschenrechner und fülle die Tabelle aus. Dies wird dir einen schnellen Überblick über die Basisumrechnungen verschaffen.

Zahl	Binär	Dezimal	Hexadezimal
0	B00111111	63	0x3F
1	B00000110
2	B01011011
3	B01001111
4	B01100110
5	B01101101
6	B01111101
7	B00000111
8	B01111111
9	B01101111

Sketch modifizieren

Öffne nun dein Lesson25_Show_Number_Binary Sketch in der Arduino IDE. Klicke auf „Datei“ -> „Speichern unter…“, benenne die Datei in Lesson25_Show_Number_Decimal um und klicke auf „Speichern“.

Ändere alle Elemente des datArray[] in Dezimalzahlen, wie im folgenden Code gezeigt. Sobald die Änderungen vorgenommen wurden, kannst du den Code auf den Arduino Uno R3 hochladen, um den Effekt zu sehen.

const int STcp = 12;  //Pin verbunden mit ST_CP des 74HC595
const int SHcp = 8;   //Pin verbunden mit SH_CP des 74HC595
const int DS = 11;    //Pin verbunden mit DS des 74HC595
//zeige 0,1,2,3,4,5,6,7,8,9 an
int datArray[] = { 63, 6, 91, 79, 102, 109, 125, 7, 127, 111 };

void setup() {
    //setze Pins als Ausgang
    pinMode(STcp, OUTPUT);
    pinMode(SHcp, OUTPUT);
    pinMode(DS, OUTPUT);
}

void loop() {
    for (int num = 0; num <= 9; num++) {
        digitalWrite(STcp, LOW);                      // Setze ST_CP auf LOW und halte es während der Übertragung
        shiftOut(DS, SHcp, MSBFIRST, datArray[num]);  // Sende die Daten, MSB zuerst
        digitalWrite(STcp, HIGH);                     // Setze ST_CP auf HIGH, um die Daten zu speichern
        delay(1000);                                  // Warte eine Sekunde
    }
}

Code-Erstellung - Serielle Eingabe

Der serielle Monitor ist ein leistungsfähiges Werkzeug der Arduino IDE zur Kommunikation mit dem Arduino-Board. Wir haben ihn verwendet, um Daten wie analoge Werte von einem Fotowiderstand zu überwachen. Er kann auch genutzt werden, um Daten an das Arduino zu senden, wodurch Aktionen basierend auf empfangenen Daten ausgeführt werden können.

In dieser Aktivität geben wir eine Zahl zwischen 0 und 9 in den seriellen Monitor ein, um sie auf dem 7-Segment-Display anzuzeigen.

1. Öffne dein Lesson25_Show_Number_Decimal Sketch in der Arduino IDE. Klicke auf „Datei“ -> „Speichern unter…“, benenne die Datei in Lesson25_Show_Number_Serial um. Klicke auf „Speichern“.

2. Starte im void setup() den seriellen Monitor und setze dessen Baudrate auf 9600.

void setup() {
    //setze Pins als Ausgang
    pinMode(STcp, OUTPUT);
    pinMode(SHcp, OUTPUT);
    pinMode(DS, OUTPUT);
    Serial.begin(9600);  // Serielle Kommunikation auf 9600 Baud einrichten
}

3. Beim Verwenden des seriellen Monitors kannst du die eingegebenen Daten über den Arduino-Code auslesen. Hier sind zwei Funktionen wichtig:

• Serial.available(): Gibt die Anzahl der Bytes (Zeichen) zurück, die vom seriellen Port zum Lesen bereitstehen. Dies sind Daten, die bereits eingetroffen und im Empfangspuffer gespeichert sind (dieser kann 64 Bytes halten).

• Serial.read(): Gibt den ASCII-Code des über den seriellen Eingang empfangenen Zeichens zurück.

Verwende nun eine if-Anweisung in der Funktion loop(), um zu überprüfen, ob Daten vom Port gelesen wurden, und drucke sie dann aus.

Bemerkung

Kommentiere vorübergehend die for-Schleife in void loop() aus, die die Ziffern auf dem 7-Segment-Display anzeigt, um den Druckvorgang nicht zu stören.

void loop() {
    if (Serial.available() > 0) {
        //Gibt das vom seriellen Port empfangene Zeichen aus
        Serial.println(Serial.read());
    }

    // for (int num = 0; num <= 9; num++) {
    //   digitalWrite(STcp, LOW);                      // Setze ST_CP auf LOW und halte es während der Übertragung
    //   shiftOut(DS, SHcp, MSBFIRST, datArray[num]);  // Sende die Daten, MSB zuerst
    //   digitalWrite(STcp, HIGH);                     // Setze ST_CP auf HIGH, um die Daten zu speichern
    //   delay(1000);                                  // Warte eine Sekunde
    // }
}

4. Dein vollständiger Code sieht folgendermaßen aus. Jetzt kannst du den Code auf den Arduino Uno R3 hochladen.

const int STcp = 12;  //Pin verbunden mit ST_CP des 74HC595
const int SHcp = 8;   //Pin verbunden mit SH_CP des 74HC595
const int DS = 11;    //Pin verbunden mit DS des 74HC595
//zeige 0,1,2,3,4,5,6,7,8,9 an
int datArray[] = { 63, 6, 91, 79, 102, 109, 125, 7, 127, 111 };

void setup() {
    //setze Pins als Ausgang
    pinMode(STcp, OUTPUT);
    pinMode(SHcp, OUTPUT);
    pinMode(DS, OUTPUT);
    Serial.begin(9600);  // Serielle Kommunikation auf 9600 Baud einrichten
}

void loop() {
    if (Serial.available() > 0) {
        //Gibt das vom seriellen Port empfangene Zeichen aus
        Serial.println(Serial.read());
    }

    // for (int num = 0; num <= 9; num++) {
    //   digitalWrite(STcp, LOW);                      // Setze ST_CP auf LOW und halte es während der Übertragung
    //   shiftOut(DS, SHcp, MSBFIRST, datArray[num]);  // Sende die Daten, MSB zuerst
    //   digitalWrite(STcp, HIGH);                     // Setze ST_CP auf HIGH, um die Daten zu speichern
    //   delay(1000);                                  // Warte eine Sekunde
    // }
}

5. Nach dem Hochladen öffne den seriellen Monitor. Gib in das Eingabefeld die Zahl 0 (oder eine beliebige Ziffer zwischen 0 und 9) ein und drücke Enter. In diesem Moment wirst du feststellen, dass die serielle Ausgabe die Zahl 48 anzeigt.

Bemerkung

• Wenn im seriellen Monitor die Option „Newline“ ausgewählt ist, kannst du auch eine 10 sehen.

• 10 ist der ASCII-Code für ein Zeilenumbruchzeichen (auch als LF - Line Feed bezeichnet).

Wo ist unser eingegebenes 0 hin? Woher kommt die 48? Kann es sein, dass 0 gleich 48 ist?

Das liegt daran, dass das 0, das wir in den seriellen Monitor eingegeben haben, als „Zeichen“ und nicht als „Zahl“ betrachtet wird.

Die Zeichenübertragung folgt einem Codierungsstandard, der als ASCII (American Standard Code for Information Interchange) bekannt ist.

ASCII enthält gängige Zeichen wie Großbuchstaben (A-Z), Kleinbuchstaben (a-z), Ziffern (0-9) und Satzzeichen (Punkte, Kommas, Ausrufezeichen usw.). Es definiert auch Steuerzeichen, die zur Steuerung von Geräten und Kommunikationsprotokollen verwendet werden. Diese Steuerzeichen werden normalerweise nicht auf dem Bildschirm angezeigt, steuern aber das Verhalten von Geräten wie Druckern, Terminals usw., wie z. B. Zeilenumbruch, Rücktaste, Wagenrücklauf usw.

Hier ist eine ASCII-Tabelle:

Wenn du das Zeichen 0 im seriellen Monitor eingibst, wird der ASCII-Code für das Zeichen 0 an das Arduino gesendet. Im ASCII-Code entspricht das Zeichen 0 dem Dezimalwert 48.

6. Bevor du mit der Programmierung fortfährst, solltest du den vorherigen Code, der den ASCII-Code ausgibt, auskommentieren, um Konflikte mit dem nachfolgenden Code zu vermeiden.

void loop() {
    if (Serial.available() > 0) {
        // Den vom seriellen Port empfangenen Zeichen drucken
        // Serial.println(Serial.read());
    }

    // for (int num = 0; num <= 9; num++) {
    //   digitalWrite(STcp, LOW);                      // ST_CP auf LOW setzen und während der Übertragung halten
    //   shiftOut(DS, SHcp, MSBFIRST, datArray[num]);  // Daten übertragen, MSB zuerst
    //   digitalWrite(STcp, HIGH);                     // ST_CP auf HIGH setzen, um die Daten zu speichern
    //   delay(1000);                                  // Eine Sekunde warten
    // }
}

7. Du musst eine neue char-Variable erstellen, um das Zeichen zu speichern, das vom seriellen Monitor gelesen wird.

void loop() {
    if (Serial.available() > 0) {
        // Den vom seriellen Port empfangenen Zeichen drucken
        // Serial.println(Serial.read());

        // Das vom seriellen Port empfangene Zeichen lesen
        char receivedChar = Serial.read();
    }
}

8. Nun musst du das Zeichen in eine Zahl umwandeln. Im ASCII-Code entspricht das Zeichen '0' dem Wert 48, '1' dem Wert 49 und so weiter. Durch das Subtrahieren des ASCII-Codes für '0' kannst du den entsprechenden numerischen Wert erhalten.

void loop() {
    if (Serial.available() > 0) {
        //Den vom seriellen Port empfangenen Zeichen drucken
        Serial.println(Serial.read());

        // Das vom seriellen Port empfangene Zeichen lesen
        char receivedChar = Serial.read();
        // Das Zeichen in eine Ziffer umwandeln
        int digit = receivedChar - '0';
    }
}

9. In diesem Beispiel gehen wir davon aus, dass die Eingabe numerische Zeichen '0' bis '9' sind. Daher interessieren uns nur Zeichen in diesem Bereich. Du musst also überprüfen, ob die Zahl im gültigen Bereich liegt:

• Wähle die zuvor auskommentierte for-Schleife aus und drücke Ctrl + /, um sie zu entkommentieren.

• Ändere dann die for-Anweisung in eine if-Anweisung, um zu überprüfen, ob das Eingabezeichen im Bereich '0' bis '9' liegt. Wenn dies der Fall ist, lasse die entsprechende Zahl auf dem 7-Segment-Display anzeigen.

void loop() {
    if (Serial.available() > 0) {
        // Den vom seriellen Port empfangenen Zeichen drucken
        // Serial.println(Serial.read());

        // Das vom seriellen Port empfangene Zeichen lesen
        char receivedChar = Serial.read();
        // Das Zeichen in eine Ziffer umwandeln
        int digit = receivedChar - '0';

        if (digit >= 0 && digit <= 9) {
            digitalWrite(STcp, LOW);                        // ST_CP auf LOW setzen und während der Übertragung halten
            shiftOut(DS, SHcp, MSBFIRST, datArray[digit]);  // Daten übertragen, MSB zuerst
            digitalWrite(STcp, HIGH);                       // ST_CP auf HIGH setzen, um die Daten zu speichern
            delay(1000);                                    // Eine Sekunde warten
        }
    }
}

10. Dein vollständiger Code sollte wie folgt aussehen. Du kannst den Code nun auf den Arduino Uno R3 hochladen und den seriellen Monitor öffnen. Gib eine beliebige Zahl zwischen 0 und 9 ein, um zu überprüfen, ob das 7-Segment-Display die entsprechende Zahl anzeigt.

const int STcp = 12;  //Pin verbunden mit ST_CP des 74HC595
const int SHcp = 8;   //Pin verbunden mit SH_CP des 74HC595
const int DS = 11;    //Pin verbunden mit DS des 74HC595
//zeige 0,1,2,3,4,5,6,7,8,9 an
int datArray[] = { 63, 6, 91, 79, 102, 109, 125, 7, 127, 111 };

void setup() {
    //setze Pins als Ausgang
    pinMode(STcp, OUTPUT);
    pinMode(SHcp, OUTPUT);
    pinMode(DS, OUTPUT);
    Serial.begin(9600);  // Serielle Kommunikation auf 9600 Baud einrichten
}

void loop() {
    if (Serial.available() > 0) {
        // Den vom seriellen Port empfangenen Zeichen drucken
        // Serial.println(Serial.read());

        // Das vom seriellen Port empfangene Zeichen lesen
        char receivedChar = Serial.read();
        // Das Zeichen in eine Ziffer umwandeln
        int digit = receivedChar - '0';

        if (digit >= 0 && digit <= 9) {
            digitalWrite(STcp, LOW);                        // ST_CP auf LOW setzen und während der Übertragung halten
            shiftOut(DS, SHcp, MSBFIRST, datArray[digit]);  // Daten übertragen, MSB zuerst
            digitalWrite(STcp, HIGH);                       // ST_CP auf HIGH setzen, um die Daten zu speichern
            delay(1000);                                    // Eine Sekunde warten
        }
    }
}

11. Vergiss nicht, deinen Code zu speichern und deinen Arbeitsplatz aufzuräumen.

Zusammenfassung

In dieser Lektion hast du gelernt, wie du das 74HC595-Schieberegister verwendest, um ein 7-Segment-Display anzusteuern und die Anzahl der benötigten Pins am Arduino Uno R3 zu reduzieren. Du hast auch die binären Darstellungen der Ziffern und die Umwandlung von binären Zahlen in Dezimal- und Hexadezimalformate kennengelernt, was die Lesbarkeit des Codes verbessert.

Zusätzlich hast du gelernt, wie der serielle Monitor für die serielle Eingabe genutzt wird und wie die eingegebenen Zeichen intern in ASCII-Codes umgewandelt werden. Durch das Verständnis dieser Umwandlung konntest du Zeichen in ihre numerischen Entsprechungen umwandeln und so die korrekte Anzeige auf dem 7-Segment-Display ermöglichen.

Insgesamt bot dir diese Lektion ein umfassendes Verständnis für die Verwendung von Schieberegistern, die Steuerung von 7-Segment-Anzeigen und den Umgang mit serieller Kommunikation für interaktive Projekte.