Dauerkalender

Digitaluhr mit Arduino

Mit einem relativ kleinen Aufwand lässt sich mit einem Arduino, sechs 7-Segmentanzeigen und einigen weiteren Bauteilen eine einfache Digitaluhr konstruieren. Die Nachteile einer solchen Ausführung wollen wir nicht beachten. Dazu gehört die Tatsache, dass die Uhr, da keine Funkverbindung zur Außenwelt besteht, manuell eingestellt werden muss. Des Weiteren muss man beachten, dass bei Spannungsausfall die eingestellte Zeit verloren geht und bei Einschaltung neu eingestellt werden muss.
Die Zeitmessung übernimmt der Arduino Nano, der uns ausreichend I/Os zur Verfügung stellt. Sieben Pins werden als Ausgänge, die die einzelnen Segmente der Anzeigen ansteuern, konfiguriert. Mit weiteren sechs Pins, die ebenfalls als Ausgänge definiert werden, werden die einzelnen 7-Segmentanzeigen ein- und ausgeschaltet. Das Ein- und Ausschalten der Anzeigen ist notwendig und gehört zu dem Steuerverfahren, das den Namen Multiplexing trägt. Das Problem bei unserer Schaltung besteht nämlich darin, dass wir sechs 7-Segmentanzeigen verwenden, die insgesamt aus (6 * 7) 42 einzelnen Elementen bestehen. So viele Pins stellt uns jedoch der Arduino Nano nicht zur Verfügung. Dank Multiplexing können wir das Problem umgehen. Die sechs 7-Segmentanzeigen werden nacheinander ein- und ausgeschaltet, sodass zu einem bestimmten Zeitpunkt nur eine einzige Anzeige in Wirklichkeit unter Spannung steht und eine Ziffer anzeigt. Da die Umschaltung von einer Anzeige zu der anderer sehr schnell erfolgt, in unserem Beispiel beträgt der Zeitintervall 1ms, bleiben diese Schaltvorgänge für das menschliche Auge unsichtbar. Bei solcher Zeiteinstellung muss die erste 7-Segmentanzeige, nachdem sie ausgeschaltet wurde, fünf Millisekunden warten, bevor sie mit Strom wieder versorgt wird und ihre Anzeige aktualisieren kann.

Arduino

Das kleine Modul mit dem Chip Mega328P stellt insgesamt 14 digitale und acht analoge I/O-Pins zur Verfügung. In unserer Schaltung werden die meisten I/Os des Mikrocontrollers in Anspruch genommen. Mit sieben Ausgängen werden die Anzeigeelemente angesteuert. Dazu kommen sechs Ausgänge, um die jeweiligen Anzeigen zu aktivieren. Zwei Taster belegen zwei weitere I/Os, die als Eingänge konfiguriert werden. Schließlich wird ein weiterer Ausgang für eine Leuchtdiode, die zur Modusunterscheidung gebraucht wird, angeschlossen.

7-Segmentanzeige

Bei den eingesetzten 7-Segmentanzeigen handelt es sich um Modelle mit gemeinsamer Anode. Vier Anzeigen haben ein rotes „Ziffernblatt“ (5161BS), zwei weitere leuchten gelb (SA56-11YWA). Beide Varianten weisen die gleiche Pinbelegung auf:

In unserem Beispiel wird der Punkt-Anschluss dp nicht berücksichtigt. Die Pins drei und/oder acht sind in unserem Fall mit Spannung zu versorgen. Bei Anzeigen mit einer gemeinsamen Kathode werden die Pins drei und/oder acht mit Masse verbunden.

Transistoren

Bei der Dimensionierung von Widerständen, die den Strom begrenzen sollen, muss man darauf achten, dass die Ausgänge des Mikrocontrollers nicht zu stark belastet werden. Da in unserem Beispiel die 7-Segmentanzeigen bei Multiplexing nicht gleichzeitig den Mikrocontroller belasten, könnte man auf Transistoren, die als Zwischenschalter fungieren, verzichten. Um Zwischenfälle zu vermeiden, wird in unserem Versuch jede 7-Segmentanzeige mithilfe eines Transistors ein- und ausgeschaltet. Bei den Transistoren BC 640, die hier zum Einsatz kommen, handelt es sich um PNP-Transistoren. Diese Art von Transistoren ist hier notwendig, da es sich bei den 7-Segmentanzeigen um Anzeigen mit gemeinsamer Anode handelt.

Schaltplan

Testschaltung

Programm (Sketch)

                                                           // Ausgänge für die Segmente 
                                                           // der 7-Segmentanzeige
int Segment [7] = { 2, 3, 4, 5, 6, 7, 8};                  // Segmente: a, b, c, d, e, f, g
                                                         
int Digit [6] = { 9, 10, 11, A5, A4, A3};                  // Digit-Ausgänge (Links-(*groeser)Rechts)

int Ziffern [10] = { B00000011, B10011111, B00100101, B00001101, B10011001,
                     B01001001, B01000001, B00011111, B00000001, B00001001 };

int Sekunden, Minuten, Stunden;                            // Zeit-Variablen
int Digit_Nummer, Ziffer;
unsigned long Millis_Aktuell, Millis_Alt, Millis_Anzeige_Alt;
unsigned long Millis_Prellen_Alt;
int Eingabe;                                               // 1-:-3: Std, Min, Sek
int Taster_Eingabe_e_a = A0;                               // Eingabe Ein-Aus
int Taster_Eingabe = A1;                                   // Werteinstellung
bool Eingabe_freigegeben = true;
int Eingabe_LED = 12;                                      // "Ein" bei aktiver Eingabe
int Prellzeit = 200;                                       // Schalterprellung abwarten


// *******************************************************************************************
void setup() {
                                                           // PINs Bestimmung
    for (int i=0; i<7; i++) {                              // Ausgänge
        pinMode (Segment[i], OUTPUT); 
    }
    for (int i=0; i<6; i++) {
        pinMode (Digit[i], OUTPUT); 
    }
    pinMode (Eingabe_LED, OUTPUT);
    pinMode (Taster_Eingabe_e_a, INPUT_PULLUP);            // Eingänge
    pinMode (Taster_Eingabe, INPUT_PULLUP);

    Millis_Aktuell = Millis_Alt = Millis_Anzeige_Alt = Millis_Prellen_Alt = millis();
}
                                                         
// *******************************************************************************************
void Anzeige (int DigitNr, int Wert) {

    for (int i=0; i<6; i++) {                              // Alle Digits aus
        digitalWrite (Digit [i], HIGH); 
    }
    digitalWrite (Digit [DigitNr], LOW);                   // Anzeige mit "DigitNr" ein
    for (int i=0; i<7; i++) {                              // Segmente a-g ein/aus
        digitalWrite(Segment[i], bitRead(Ziffern[Wert], 7-i));
    } 
}

// *******************************************************************************************
void loop() {

    // ----------------------------------------------------
    Millis_Aktuell = millis();                             // Berechnung der aktuellen Zeit
    if (Millis_Aktuell - Millis_Alt (*groeser)= 1000) {             // nach Ablauf 1 Sekunde
        Millis_Alt = Millis_Aktuell;
        if (Eingabe == 0) {
            Sekunden++;
        }
        if (Sekunden (*groeser) 59) {
            Sekunden = 0;
            Minuten++;
        }
        if (Minuten (*groeser) 59) {
            Minuten = 0;
            Stunden++;
        }
        if (Stunden (*groeser) 23) {
            Stunden = 0;
        }
    }

    // ----------------------------------------------------
    if (Millis_Aktuell - Millis_Anzeige_Alt (*groeser)= 1) {        // Multiplexing, Anzeige wird
        Millis_Anzeige_Alt = Millis_Aktuell;               // im Takt von 1 ms 
                                                           // aktualisiert.
        switch (Digit_Nummer) {
            case 4: { 
                Ziffer = Sekunden / 10;
                break;
            }
            case 5: { 
                Ziffer = Sekunden - (Ziffer * 10);
                break;
            } 
            case 2: { 
                Ziffer = Minuten / 10;
                break;
            }
            case 3: { 
                Ziffer = Minuten - (Ziffer * 10);
                break;
            }
            case 0: { 
                Ziffer = Stunden / 10;
                break;
            }
            case 1: { 
                Ziffer = Stunden - (Ziffer * 10);
                break;
            }                                                          
        }
        Anzeige (Digit_Nummer, Ziffer);                    // Anzeige aktualisieren
        Digit_Nummer++;              
        if (Digit_Nummer (*groeser) 5) {
            Digit_Nummer = 0;
        }
    }

    // ----------------------------------------------------
                                                           // Eingabe Modus
    if (digitalRead (Taster_Eingabe_e_a) == LOW or digitalRead (Taster_Eingabe) == LOW) {
        if (Eingabe_freigegeben) {

            if (digitalRead (Taster_Eingabe_e_a) == LOW) { // Umschaltung Std/Min/Sek
                Eingabe++;
                if (Eingabe (*groeser) 3) {
                    Eingabe = 0;
                }
            }
            if (Eingabe == 1) {                            // Einstellung Stunden
                if (digitalRead(Taster_Eingabe) == LOW) {
                    Stunden++;
                    if (Stunden (*groeser) 23) {
                        Stunden = 0;
                    }
                }
            }
            if (Eingabe == 2) {                            // Einstellung Minuten
                if (digitalRead(Taster_Eingabe) == LOW) {
                    Minuten++;
                    if (Minuten (*groeser) 59) {
                        Minuten = 0;
                    }
                }
            }
            if (Eingabe == 3) {                            // Einstellung Sekunden
                if (digitalRead(Taster_Eingabe) == LOW) {
                    Sekunden++;
                    if (Sekunden (*groeser) 59) {
                        Sekunden = 0;
                    }
                }
            }
            Eingabe_freigegeben = false;                   // Prellzeit jeweils abwarten
            Millis_Prellen_Alt = Millis_Aktuell;
        }
    }

    // ----------------------------------------------------    
                                                           // Prellzeit abgelaufen
    if ((Millis_Aktuell - Millis_Prellen_Alt) (*groeser) Prellzeit) {
        Eingabe_freigegeben = true;                        // Weitere Eingaben möglich
    }

    // ----------------------------------------------------    
    if (Eingabe (*groeser) 0) {                            // Info-LED bei aktiven Eingaben
        digitalWrite (Eingabe_LED, HIGH);                  // "Ein"
    } else {
        digitalWrite (Eingabe_LED, LOW);
    }
} 
// *******************************************************************************************        

Kurzvideo

Kurzvideo

Weitere Themen: