Bemerkung

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

Warum beitreten?

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

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

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

  • Spezielle Rabatte: Profitiere von exklusiven Rabatten auf unsere neuesten Produkte.

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

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

32. Stoppuhr

In diesem spannenden Projekt lernen wir, wie man ein 4-stelliges 7-Segment-Display verwendet, um eine funktionsfähige Stoppuhr zu erstellen. Am Ende dieser Lektion wirst du verstehen, wie man ein mehrstelliges 7-Segment-Display steuert, und in der Lage sein, eine einfache Stoppuhr zu bauen, die die Zeit in Minuten und Sekunden misst. Mach dich bereit, in die Welt der digitalen Anzeigen einzutauchen und deine Arduino-Fähigkeiten zu erweitern!

Am Ende dieser Lektion wirst du:

  • Lernen, wie man ein 4-stelliges 7-Segment-Display multiplexiert.

  • Code schreiben, um Zahlen auf einer einzelnen Ziffer anzuzeigen.

  • Eine scrollende Zahlenanzeige erstellen.

  • Eine Stoppuhr implementieren, die ein 4-stelliges 7-Segment-Display verwendet, um Minuten und Sekunden zu verfolgen.

  • Den AND-Operator und den >>-Operator kennenlernen.

Lerne das 4-stellige 7-Segment-Display kennen

Einführung

  1. Finde das 4-stellige 7-Segment-Display.

_images/32_stopwatch_4_digit.png

Ein 7-Segment-Display ist eine 8-förmige Komponente, die 7 LEDs enthält. Jede der LEDs im Display ist einem Positionssegment zugeordnet, dessen Anschlussstift aus dem rechteckigen Kunststoffgehäuse herausgeführt wird. Diese LED-Anschlüsse sind von „a“ bis „g“ beschriftet, wobei jeder Buchstabe ein individuelles LED-Segment darstellt.

_images/32_stopwatch_7segment.png

Ein 4-stelliges Display kombiniert vier 7-Segment-Anzeigen, wobei jede einzelne Ziffer darstellt. Um die Anzahl der benötigten Pins zu reduzieren, werden die Segmente jedes Displays multiplexiert, d.h., jeder Segmentpin ist mit den entsprechenden Segmentpins der anderen Displays verbunden.

_images/32_stopwatch_common_pins.png

Dies reduziert die Anzahl der Pins, erhöht jedoch die Steuerungskomplexität. Zum Beispiel leuchtet das „a“-Segment bei Spannung an Pin „a“ in allen Ziffern auf. Um zu steuern, welche Ziffer das Segment anzeigt, hat jede Ziffer einen separaten Steuerungspin (d1 ~ d4).

_images/32_stopwatch_control_pins.png

Wenn wir also die Zahl 2222 anzeigen wollen, müssen wir Spannung an die Pins d1, d2, d3 und d4 anlegen, da alle Anzeigen eine Ziffer anzeigen. Außerdem müssen wir Spannung an die Eingänge a, b, d, e, g und dp anlegen, wie unten gezeigt:

_images/32_stopwatch_show_2.png

Pinbelegung

Ein typisches 4-stelliges 7-Segment-Display hat 12 Pins, sechs auf jeder Seite.

Vier Pins (d1, d2, d3 und d4) steuern die einzelnen Ziffern. Die verbleibenden Pins entsprechen den Segmenten.

_images/32_stopwatch_pins.png

Gemeinsame Kathode oder gemeinsame Anode

Um festzustellen, ob ein 4-stelliges 7-Segment-Display eine gemeinsame Kathode oder eine gemeinsame Anode hat, kannst du ein Multimeter verwenden. Mit dem Multimeter kannst du auch testen, ob jedes Segment des Displays ordnungsgemäß funktioniert:

  1. Stelle das Multimeter auf Diodentestmodus ein. Der Diodentest ist eine Funktion des Multimeters, die zur Überprüfung der Durchlassrichtung von Dioden oder ähnlichen Halbleiterbauelementen (wie LEDs) verwendet wird. Das Multimeter lässt einen kleinen Strom durch die Diode fließen. Wenn die Diode intakt ist, lässt sie den Strom durch.

_images/multimeter_diode.png
  1. Setze das 4-stellige 7-Segment-Display in ein Steckbrett ein. Führe ein Kabel in dieselbe Reihe wie Pin d1 des Displays ein und berühre es mit der schwarzen Messleitung des Multimeters. Führe ein weiteres Kabel in dieselbe Reihe wie Pin e des Displays ein und berühre es mit der roten Messleitung.

_images/32_stopwatch_test_cathode.png
  1. Beobachte, ob ein LED-Segment aufleuchtet. Wenn ja, zeigt dies an, dass das Display eine gemeinsame Kathode hat. Wenn nicht, vertausche die rote und schwarze Messleitung; wenn ein Segment nach dem Vertauschen aufleuchtet, zeigt dies an, dass das Display eine gemeinsame Anode hat.

Bemerkung

Unser Kit enthält ein 4-stelliges 7-Segment-Display mit gemeinsamer Kathode. Setze die Steuerpins d1-d4 auf LOW und die Segmentpins a-g auf HIGH, damit es funktioniert.

Frage

Wenn du möchtest, dass die linke Ziffer (d1) des 4-stelligen 7-Segment-Displays „2“ anzeigt, welche Pegel sollten die Pins d1~d4 und a~g haben?

_images/32_stopwatch_show_2d1.png

7-Segment-Anzeige

HIGH oder LOW

7-Segment-Anzeige

HIGH oder LOW

d1

a

d2

b

d3

c

d4

d

e

f

g

dp

Den Schaltkreis aufbauen

Benötigte Komponenten

1 * Arduino Uno R3

1 * 4-stelliges 7-Segment-Display

4 * 220Ω Widerstand

1 * Multimeter

list_uno_r3

list_4digit

list_220ohm

list_meter

1 * USB-Kabel

1 * Steckbrett

list_usb_cable

list_breadboard

Aufbauschritte

Folge dem Schaltplan oder den unten stehenden Schritten, um deinen Schaltkreis aufzubauen.

_images/32_stopwatch_connect_ag.png
  1. Setze das 4-stellige 7-Segment-Display in das Steckbrett ein.

_images/32_stopwatch_connect_4digit.png
  1. Setze vier 220Ω Widerstände in das Steckbrett ein.

_images/32_stopwatch_connect_resistors.png
  1. Verbinde den Steuerpin d1 mit einer Seite des ersten Widerstands. Verbinde die andere Seite des Widerstands mit Pin 10 des Arduino Uno R3. Dies verbindet den Steuerpin d1 über den Widerstand mit Pin 10.

_images/32_stopwatch_connect_d1.png
  1. Verbinde auf ähnliche Weise d2 mit Pin 11, d3 mit Pin 12 und d4 mit Pin 13.

_images/32_stopwatch_connect_d1d3.png
  1. Verbinde nun die adp-Pins gemäß der Verdrahtungstabelle mit den Pins 2~9 des Arduino.

7-Segment-Anzeige

Arduino Uno R3

a

2

b

3

c

4

d

5

e

6

f

7

g

8

dp

9

_images/32_stopwatch_connect_ag.png

Codeerstellung - Anzeige der Zahl 2 auf einer Ziffer

Nun lass uns den Code schreiben, um eine Zahl auf einer Ziffer des 4-stelligen 7-Segment-Displays anzuzeigen.

  1. Öffne die Arduino IDE und starte ein neues Projekt, indem du im Menü „Datei“ auf „Neuer Sketch“ klickst.

  2. Speichere deinen Sketch unter dem Namen Lesson32_Show_2_One_Digit mit Ctrl + S oder durch Klicken auf „Speichern“.

  3. Erstelle zuerst zwei Arrays, um die Segment- und Ziffernpins des 4-stelligen 7-Segment-Displays zu speichern.

// Definiere die Pins der Segmente und Ziffern des 4-stelligen 7-Segment-Displays
int segmentPins[] = { 2, 3, 4, 5, 6, 7, 8, 9 };  // Segmente a~g und dp (Dezimalpunkt)
int digitPins[] = { 10, 11, 12, 13 };            // Ziffern d1-d4
  1. Setze in der Funktion void setup() alle Pins als Ausgänge. Da dies ein 4-stelliges 7-Segment-Display mit gemeinsamer Kathode ist, setze alle Segmentpins auf LOW und alle Ziffernpins auf HIGH, um das Display initial auszuschalten.

void setup() {
  // Setze alle Segmentpins als Ausgang
  for (int i = 0; i < 8; i++) {
    pinMode(segmentPins[i], OUTPUT);
    digitalWrite(segmentPins[i], LOW);  // Stelle sicher, dass alle Segmente initial ausgeschaltet sind
  }

  // Setze alle Ziffernpins als Ausgang und schalte sie aus (gemeinsame Kathode, daher ist HIGH aus)
  for (int i = 0; i < 4; i++) {
    pinMode(digitPins[i], OUTPUT);
    digitalWrite(digitPins[i], HIGH);
  }
}
  1. Um in der Funktion loop() die erste Ziffer links (d1) zu aktivieren, setze ihren Zustand auf LOW. Wenn du die erste Ziffer rechts (d4) aktivieren möchtest, ändere 0 in 3.

void loop() {
  digitalWrite(digitPins[0], LOW);     // Schalte die erste Ziffer ein
}
  1. Um eine Zahl, wie zum Beispiel 2, anzuzeigen, müssen die Segmente a, b, d, e und g auf HIGH gesetzt werden. Dadurch wird die Zahl 2 angezeigt.

void loop() {
  digitalWrite(digitPins[1], LOW);     // Erste Ziffer einschalten

  digitalWrite(segmentPins[0], HIGH);  // Segment a einschalten
  digitalWrite(segmentPins[1], HIGH);  // Segment b einschalten
  digitalWrite(segmentPins[3], HIGH);  // Segment d einschalten
  digitalWrite(segmentPins[4], HIGH);  // Segment e einschalten
  digitalWrite(segmentPins[6], HIGH);  // Segment g einschalten
}
  1. Lade den Code auf das Arduino Uno R3 Board hoch, und du solltest sehen, dass die erste Ziffer links die Zahl 2 anzeigt.

// Definiere die Pins der Segmente und der Ziffern des 4-stelligen 7-Segment-Displays
int segmentPins[] = { 2, 3, 4, 5, 6, 7, 8, 9 };  // Segmente a~g und dp (Dezimalpunkt)
int digitPins[] = { 10, 11, 12, 13 };            // Ziffern d1-d4

void setup() {
  // Setze alle Segmentpins als Ausgang
  for (int i = 0; i < 8; i++) {
    pinMode(segmentPins[i], OUTPUT);
    digitalWrite(segmentPins[i], LOW);  // Stelle sicher, dass alle Segmente initial ausgeschaltet sind
  }

  // Setze alle Ziffernpins als Ausgang und schalte sie aus (gemeinsame Kathode, daher ist HIGH aus)
  for (int i = 0; i < 4; i++) {
    pinMode(digitPins[i], OUTPUT);
    digitalWrite(digitPins[i], HIGH);
  }
}

void loop() {
  digitalWrite(digitPins[1], LOW);     // Erste Ziffer einschalten

  digitalWrite(segmentPins[0], HIGH);  // Segment a einschalten
  digitalWrite(segmentPins[1], HIGH);  // Segment b einschalten
  digitalWrite(segmentPins[3], HIGH);  // Segment d einschalten
  digitalWrite(segmentPins[4], HIGH);  // Segment e einschalten
  digitalWrite(segmentPins[6], HIGH);  // Segment g einschalten
}

Codeerstellung - Zahlen auf einer Ziffer scrollen lassen

Im vorherigen Projekt haben wir gelernt, wie man eine einzelne Zahl, wie zum Beispiel die 2, auf einer Ziffer anzeigt. Aber was ist, wenn wir die Zahlen von 0~9 scrollen möchten? Die Verwendung derselben Methode wäre sehr langwierig.

In Lektion 28 haben wir die binären, dezimalen und hexadezimalen Codes für die Zahlen 0-9 auf einem Display mit gemeinsamer Kathode gelernt.

Zahl

Binär

Dezimal

Hexadezimal

0

B00111111

63

0x3F

1

B00000110

6

0x06

2

B01011011

91

0x5B

3

B01001111

79

0x4F

4

B01100110

102

0x66

5

B01101101

109

0x6D

6

B01111101

125

0x7D

7

B00000111

7

0x07

8

B01111111

127

0x7F

9

B01101111

111

0x6F

Hier ist, wie man dies verwenden kann, um die Zahlen von 0~9 auf einer Ziffer scrollen zu lassen.

  1. Öffne den Sketch, den du zuvor gespeichert hast, Lesson32_Show_2_One_Digit. Wähle im Menü „Datei“ die Option „Speichern unter…“, und benenne ihn in Lesson32_Scroll_Numbers_One_Digit um. Klicke auf „Speichern“.

  2. Speichere die Binärcodes für die Zahlen 0~9 im Array numArray[].

// Definiere die Pins der Segmente und der Ziffern des 4-stelligen 7-Segment-Displays
int segmentPins[] = { 2, 3, 4, 5, 6, 7, 8, 9 };  // Segmente a~g und dp (Dezimalpunkt)
int digitPins[] = { 10, 11, 12, 13 };            // Ziffern d1-d4

//Anzeige 0,1,2,3,4,5,6,7,8,9
int numArray[] = { B00111111, B00000110, B01011011, B01001111, B01100110, B01101101, B01111101, B00000111, B01111111, B01101111 };
  1. Erstelle nun eine Funktion, um die ausgewählte Zahl auf der gewünschten Ziffer anzuzeigen.

void displayNumberOnDigit(int number, int digit) {
  // Schalte alle Ziffern aus, um Geisterbilder beim Wechsel der Zahlen zu vermeiden
  for (int i = 0; i < 4; i++) {
    // Ziffer ausschalten (gemeinsame Kathode -> HIGH ist aus)
    digitalWrite(digitPins[i], HIGH);
  }

  // Setze die Segmente für die aktuelle Zahl
  int value = numArray[number];
  for (int i = 0; i < 8; i++) {
    digitalWrite(segmentPins[i], (value >> i) & 1);  // Setze jedes Segment
  }

  // Schalte die ausgewählte Ziffer ein (gemeinsame Kathode -> LOW ist an)
  digitalWrite(digitPins[digit], LOW);
}
  • Schaltet alle Ziffern aus, um Geisterbilder zu vermeiden, insbesondere beim Ändern der angezeigten Zahl.

// Schalte alle Ziffern aus, um Geisterbilder beim Wechsel der Zahlen zu vermeiden
for (int i = 0; i < 4; i++) {
  // Ziffer ausschalten (gemeinsame Kathode -> HIGH ist aus)
  digitalWrite(digitPins[i], HIGH);
}
  • Verwendet eine bitweise Operation, um zu bestimmen, welche Segmente für jede Zahl aufleuchten sollen.

    // Setze die Segmente für die aktuelle Zahl
    int value = numArray[number];
    for (int i = 0; i < 8; i++) {
      digitalWrite(segmentPins[i], (value >> i) & 1);  // Setze jedes Segment
    }
    
    • Hier wird das Element aus dem Array numArray[] der Variablen value zugewiesen. Wenn number 2 ist, wird das dritte Element (B01011011) aus numArray[] value zugewiesen.

    • Dann schreibt eine for-Schleife jedes der 8 Bits von B01011011 (ohne das B) in das Array segmentPins[i] mithilfe von digitalWrite(). Das bedeutet, dass die Segmente a, b, d, e und g auf 1 gesetzt werden, und c, f und dp auf 0, was die Zahl 2 anzeigt.

    • & ist der AND-Operator, der eine bitweise AND-Operation auf die Zahlen durchführt. 1&1 ergibt 1, 1&0 ergibt 0.

    _images/32_stopwatch_and.png
    • >> ist der Rechtsverschiebeoperator, der die Bits der Zahl um die angegebene Anzahl von Positionen nach rechts verschiebt. Zum Beispiel, wenn i 1 ist, verschiebt B01011011 nach rechts um ein Bit, wobei das rechteste Bit entfernt wird und eine 0 links hinzugefügt wird. Wenn i 2 ist, verschiebt B01011011 nach rechts um zwei Bits, wobei die zwei rechtesten Bits entfernt werden und zwei 0en links hinzugefügt werden.

    • Das Ergebnis der Rechtsverschiebung wird dann bitweise mit 1 verundet, um entweder 1 oder 0 zu erhalten.

    _images/32_stopwatch_shift_right.png
  • Aktiviert nur die Ziffer, auf der die Zahl angezeigt werden soll.

// Schalte die ausgewählte Ziffer ein (gemeinsame Kathode -> LOW ist an)
digitalWrite(digitPins[digit], LOW);
  1. Im Hauptprogramm void loop verwende eine for-Schleife, um die erste Ziffer von links durch die Zahlen 0 bis 9 scrollen zu lassen.

void loop() {
  // Zeige nacheinander die Zahlen 0 bis 9 auf der ersten Ziffer (D1) an
  for (int num = 0; num < 10; num++) {
    displayNumberOnDigit(num, 0);  // Zeige die Zahl auf der Ziffer 1 (Index 0) an
    delay(1000);                   // Zeige jede Zahl für 1 Sekunde an
  }
}
  1. Der vollständige Code ist unten aufgeführt. Du kannst ihn auf das Arduino Uno R3 hochladen, und du wirst sehen, wie die erste Ziffer von links durch die Zahlen 0 bis 9 scrollt.

// Definiere die Pins der Segmente und der Ziffern des 4-stelligen 7-Segment-Displays
int segmentPins[] = { 2, 3, 4, 5, 6, 7, 8, 9 };  // Segmente A-G und DP (Dezimalpunkt)
int digitPins[] = { 10, 11, 12, 13 };            // Ziffern D1-D4

// Anzeige 0,1,2,3,4,5,6,7,8,9
int numArray[] = { B00111111, B00000110, B01011011, B01001111, B01100110, B01101101, B01111101, B00000111, B01111111, B01101111 };

void setup() {
  // Setze alle Segmentpins als Ausgang
  for (int i = 0; i < 8; i++) {
    pinMode(segmentPins[i], OUTPUT);
    digitalWrite(segmentPins[i], LOW);  // Stelle sicher, dass alle Segmente initial ausgeschaltet sind
  }

  // Setze alle Ziffernpins als Ausgang und schalte sie aus (gemeinsame Kathode, daher ist HIGH aus)
  for (int i = 0; i < 4; i++) {
    pinMode(digitPins[i], OUTPUT);
    digitalWrite(digitPins[i], HIGH);
  }
}

void loop() {
  // Zeige nacheinander die Zahlen 0 bis 9 auf der ersten Ziffer (D1) an
  for (int num = 0; num < 10; num++) {
    displayNumberOnDigit(num, 0);  // Zeige die Zahl auf der Ziffer 1 (Index 0) an
    delay(1000);                   // Zeige jede Zahl für 1 Sekunde an
  }
}

void displayNumberOnDigit(int number, int digit) {
  // Schalte alle Ziffern aus, um Geisterbilder beim Wechsel der Zahlen zu vermeiden
  for (int i = 0; i < 4; i++) {
    // Ziffer ausschalten (gemeinsame Kathode -> HIGH ist aus)
    digitalWrite(digitPins[i], HIGH);
  }

  // Setze die Segmente für die aktuelle Zahl
  int value = numArray[number];
  for (int i = 0; i < 8; i++) {
    digitalWrite(segmentPins[i], (value >> i) & 1);  // Setze jedes Segment
  }

  // Schalte die ausgewählte Ziffer ein (gemeinsame Kathode -> LOW ist an)
  digitalWrite(digitPins[digit], LOW);
}

Frage

In der Programmierung sind bitweise Operationen wie AND und OR entscheidend, um einzelne Bits von Daten zu manipulieren. Die bitweise AND-Operation (&) vergleicht jedes Bit ihrer Operanden, wobei das Ergebnis 1 ist, wenn beide Bits 1 sind, und 0, wenn eines der Bits 0 ist. Umgekehrt ergibt die bitweise OR-Operation (|) 1, wenn mindestens eines der Bits 1 ist, und 0 nur dann, wenn beide Bits 0 sind.

Angesichts dieser Informationen, betrachte den Ausdruck (B01011011 >> 2) | 1. Nachdem die Binärzahl B01011011 um 2 Positionen nach rechts verschoben wurde, was ist das Ergebnis der Anwendung des bitweisen OR mit 1?

Code-Erstellung - Stoppuhr

Zuvor haben wir gelernt, wie man eine einzelne Ziffer anzeigt und durch Zahlen auf einer Ziffer scrollt. Jetzt lernen wir, wie man das 4-stellige 7-Segment-Display verwendet, um eine Stoppuhr zu erstellen.

  • Um eine Stoppuhr zu erstellen, müssen die linken beiden Ziffern Minuten und die rechten beiden Ziffern Sekunden anzeigen.

  • Wenn die Sekundenanzeige 59 erreicht, wird sie auf 0 zurückgesetzt und die Minutenanzeige erhöht sich um 1.

  • Wenn die Minutenanzeige 99 erreicht, wird sie auf 0 zurückgesetzt.

  1. Öffne den zuvor gespeicherten Sketch, Lesson32_Show_2_One_Digit. Wähle im Menü „Datei“ die Option „Speichern unter…“, und benenne ihn in Lesson32_Stopwatch um. Klicke auf „Speichern“.

  2. Erstelle nun 3 Variablen, um die Zeitkomponenten zu speichern. previousMillis wird verwendet, um die Zeit seit dem letzten Update zu verfolgen, seconds und minutes speichern die Zeit der Stoppuhr.

// Definiere die Pins der Segmente und der Ziffern des 4-stelligen 7-Segment-Displays
int segmentPins[] = {2, 3, 4, 5, 6, 7, 8, 9};  // Segmente A-G und DP (Dezimalpunkt)
int digitPins[] = {10, 11, 12, 13};            // Ziffern D1-D4

// Anzeige 0,1,2,3,4,5,6,7,8,9
int numArray[] = { B00111111, B00000110, B01011011, B01001111, B01100110, B01101101, B01111101, B00000111, B01111111, B01101111 };

// Variablen zur Speicherung der Zeitkomponenten
unsigned long previousMillis = 0;  // Speichert die letzte Zeit, zu der die Anzeige aktualisiert wurde
int seconds = 0;  // Speichert die Sekunden
int minutes = 0;  // Speichert die Minuten
  1. In der Funktion void loop():

  • Verwende die Funktion millis(), um die Anzahl der Millisekunden seit dem Start des aktuellen Programms auf dem Arduino-Board zurückzugeben.

  • Erhöhe dann die Sekundenanzeige einmal alle 1000 Millisekunden (eine Sekunde). Wenn die Sekundenanzeige 60 erreicht, wird sie auf 0 zurückgesetzt und die Minutenanzeige erhöht. Wenn die Minutenanzeige 100 erreicht, wird sie auf 0 zurückgesetzt, wodurch die Zählung erneut beginnt.

  • Die Funktion updateDisplay() wird in jeder Schleifeniteration aufgerufen, um die Anzeige basierend auf den aktuellen Sekunden und Minuten aktiv zu multiplexen.

void loop() {
  unsigned long currentMillis = millis();        // Aktuelle Zeit in Millisekunden abrufen
  if (currentMillis - previousMillis >= 1000) {  // Überprüfen, ob eine Sekunde vergangen ist
    previousMillis = currentMillis;              // Timer zurücksetzen
    seconds++;                                   // Sekunden erhöhen
    if (seconds >= 60) {                         // Überprüfen, ob 60 Sekunden vergangen sind
      seconds = 0;                               // Sekunden zurücksetzen
      minutes++;                                 // Minuten erhöhen
      if (minutes > 99) {                        // Überprüfen, ob 100 Minuten vergangen sind
        minutes = 0;                             // Minuten zurücksetzen
      }
    }
  }
  updateDisplay();  // Anzeige aktualisieren, um die aktuelle Zeit anzuzeigen
}
  1. Zur Funktion updateDisplay(): Anstatt die Anzeige einmal pro Sekunde zu setzen, wird updateDisplay() kontinuierlich in der Hauptschleife aufgerufen. Es durchläuft jede Ziffer, schaltet sie für kurze Zeit mit den richtigen Segmenten ein und schaltet sie dann wieder aus. Dieser Vorgang wiederholt sich schnell, um den Eindruck einer stabilen Anzeige zu erzeugen.

void updateDisplay() {
  for (int digit = 0; digit < 4; digit++) {
    setDigitValues(minutes, seconds, digit);
    digitalWrite(digitPins[digit], LOW); // Schalte die aktuelle Ziffer ein
    delay(5); // Verzögerung, um die Ziffer sichtbar zu halten
    digitalWrite(digitPins[digit], HIGH); // Ziffer ausschalten
  }
}
  1. Zur Funktion setDigitValues(): setDigitValues() kümmert sich darum, die Segmente für jede Ziffer basierend auf der aktuellen Zeit (Minuten und Sekunden) zu setzen. Diese Funktion wird jedes Mal aufgerufen, wenn eine Ziffer aktiviert wird, um sicherzustellen, dass sie den richtigen Wert anzeigt.

void setDigitValues(int mins, int secs, int digit) {
  int values[] = {
    mins / 10, // Zehner der Minuten
    mins % 10, // Einer der Minuten
    secs / 10, // Zehner der Sekunden
    secs % 10  // Einer der Sekunden
  };

  int value = numArray[values[digit]];

  for (int segment = 0; segment < 8; segment++) {
    digitalWrite(segmentPins[segment], (value >> segment) & 1);
  }
}
  1. Der vollständige Code ist unten aufgeführt. Du kannst ihn jetzt auf das Arduino-Board hochladen, um den Stoppuhr-Effekt auf dem 4-stelligen 7-Segment-Display zu sehen.

// Definiere die Pins der Segmente und der Ziffern des 4-stelligen 7-Segment-Displays
int segmentPins[] = { 2, 3, 4, 5, 6, 7, 8, 9 };  // Segmente A-G und DP (Dezimalpunkt)
int digitPins[] = { 10, 11, 12, 13 };            // Ziffern D1-D4

// Anzeige 0,1,2,3,4,5,6,7,8,9
int numArray[] = { B00111111, B00000110, B01011011, B01001111, B01100110, B01101101, B01111101, B00000111, B01111111, B01101111 };

// Variablen zur Speicherung der Zeitkomponenten
unsigned long previousMillis = 0;  // Speichert die letzte Zeit, zu der die Anzeige aktualisiert wurde
int seconds = 0;                   // Speichert die Sekunden
int minutes = 0;                   // Speichert die Minuten

void setup() {
  // Setze alle Segmentpins als Ausgang
  for (int i = 0; i < 8; i++) {
    pinMode(segmentPins[i], OUTPUT);
    digitalWrite(segmentPins[i], LOW);  // Stelle sicher, dass alle Segmente initial ausgeschaltet sind
  }

  // Setze alle Ziffernpins als Ausgang und schalte sie aus (gemeinsame Kathode, daher ist HIGH aus)
  for (int i = 0; i < 4; i++) {
    pinMode(digitPins[i], OUTPUT);
    digitalWrite(digitPins[i], HIGH);
  }
}

void loop() {
  unsigned long currentMillis = millis();        // Aktuelle Zeit in Millisekunden abrufen
  if (currentMillis - previousMillis >= 1000) {  // Überprüfen, ob eine Sekunde vergangen ist
    previousMillis = currentMillis;              // Timer zurücksetzen
    seconds++;                                   // Sekunden erhöhen
    if (seconds >= 60) {                         // Überprüfen, ob 60 Sekunden vergangen sind
      seconds = 0;                               // Sekunden zurücksetzen
      minutes++;                                 // Minuten erhöhen
      if (minutes > 99) {                        // Überprüfen, ob 100 Minuten vergangen sind
        minutes = 0;                             // Minuten zurücksetzen
      }
    }
  }
  updateDisplay();  // Anzeige aktualisieren, um die aktuelle Zeit anzuzeigen
}

void updateDisplay() {
  for (int digit = 0; digit < 4; digit++) {
    setDigitValues(minutes, seconds, digit);
    digitalWrite(digitPins[digit], LOW);   // Schalte die aktuelle Ziffer ein
    delay(5);                              // Verzögerung, um die Ziffer sichtbar zu halten
    digitalWrite(digitPins[digit], HIGH);  // Ziffer ausschalten
  }
}

void setDigitValues(int mins, int secs, int digit) {
  int values[] = {
    mins / 10,  // Zehner der Minuten
    mins % 10,  // Einer der Minuten
    secs / 10,  // Zehner der Sekunden
    secs % 10   // Einer der Sekunden
  };

  int value = numArray[values[digit]];

  for (int segment = 0; segment < 8; segment++) {
    digitalWrite(segmentPins[segment], (value >> segment) & 1);
  }
}
  1. Speichere abschließend deinen Code und räume deinen Arbeitsplatz auf.

Zusammenfassung

In dieser Lektion haben wir die Funktionalität des 4-stelligen 7-Segment-Displays erkundet und gelernt, wie man es mit einem Arduino steuert. Wir begannen damit, eine einzelne Zahl auf einer Ziffer anzuzeigen, und gingen dann dazu über, durch Zahlen zu scrollen. Schließlich haben wir diese Fähigkeiten kombiniert, um eine einfache Stoppuhr zu erstellen, die Minuten und Sekunden anzeigt. Dieses Projekt hat uns nicht nur die Arbeit mit digitalen Anzeigen nähergebracht, sondern auch unsere Programmierfähigkeiten mit dem Arduino verbessert. Gut gemacht, dass du diese Lektion abgeschlossen hast, und mach weiter mit dem Experimentieren, um noch erstaunlichere Projekte zu erstellen!