Dauerkalender

Zahlenkonverter mit Arduino

Die folgende Schaltung kann sowohl zum Spielen als auch zum Lernen verwendet werden. Mit ihr ist es möglich, eine Zahl gleichzeitig in zwei Zahlensystemen, dezimal und binär, darzustellen. Der Wert der Zahl kann durch Betätigen der Eingabetaster verändert werden. Dabei kann man das Zahlensystem frei wählen. Zwei gelbe Taster ermöglichen das Erhöhen oder Verringern des Wertes im Dezimalsystem. Mit weiteren sechs Mikro-Eingabetastern können die Veränderungen im Binärsystem realisiert werden. Der Mikrocontroller führt nach jeder Änderung die notwendigen Berechnungen durch und blendet den neuen Wert der Zahl sowohl in Dezimal- als auch Binärform ein. Für die Dezimalanzeige stehen zwei 7-Segmenanzeigen bereit. Die Binäranzeige wird mit sechs Leuchtdioden realisiert. Der maximale Wert der Zahl, der auf diesem Weg gebildet werden kann, beträgt somit 63. Bei Bedarf kann die Schaltung nach gleichem Prinzip erweitert werden, wodurch auch größere Zahlen dargestellt werden können.
Beim Spielen oder Lernen kann eine der Anzeigen abgedeckt werden. Erst wenn man mit seiner Darstellung fertig ist, können die Ergebnisse verglichen werden.
Die Stellenwerte der Zahlen im Binärsystem (genauso wie im Dezimalsystem) verlaufen von rechts nach links. Die niedrigsten Wertigkeiten befinden sich auf der rechten Seite:

32 – 16 – 8 – 4 – 2 – 1

Mikrocontroller

Als Recheneinheit tritt in der Schaltung Arduino Mega auf. Die kleine Platine mit dem integrierten Mikrocontroller stellt uns ausreichende Anzahl an Pins zur Verfügung. Insgesamt benötigen wir hier 23 Anschlüsse, was nicht gerade wenig ist. Bei weniger Anschlussmöglichkeiten müsste man, um die Aufgabe realisieren zu können, auf andere Methoden zurückgreifen. Eine Reduzierung der Verbindungen wäre jedoch durchaus möglich.

Siebensegmentanzeige

Die Anzeige für die Zahlen im Dezimalformat besteht aus zwei Siebensegmentanzeigen. Jede Anzeige benötigt für Anzeige einer Ziffer sieben Verbindungen. Bei jedem Balken der Siebensegmentanzeige handelt es sich um eine Leuchtdiode, die zusätzlich mit einem Vorwiderstand abgesichert werden muss. Alternativ kann man alle Balken pauschal mit einem Widerstand, der an die gemeinsame Kathode angeschlossen wird, absichern. Bei solcher Lösung muss man allerdings damit rechnen, dass die Leuchtkraft von Ziffer zu Ziffern schwankt. In der Schaltung werden die Anzeigen nicht direkt von den Mikrocontroller, sondern über die Anzeigetreiber 74HC4511N angesteuert.

Anzeigentreiber

Es ist schon problematisch, für eine Siebensegmentanzeige sieben Anschlüsse eines Mikrocontrollers zu opfern. Diese Tatsache ist den Entwicklern nicht entgangen und man hat einige Methoden, um das Problem umzugehen, entwickelt. Dazu gehört auch ein BCD-Treiber, mit dem eine Siebensegmentanzeige angesteuert werden kann. Diese integrierte Schaltung nimmt nur vier Anschlüsse eines Mikrocontrollers in Anspruch. Die Informationen, welche Elemente einer Siebensegmentanzeige angesprochen werden sollen, erhält sie binär codiert. Die interne Elektronik übersetzt die Informationen und schaltet dann passend die Siebensegmentanzeige ein.

Schaltplan

Programm (Sketch)

int Taster_UM = 9;                                   // Eingabe 10er aktivieren
int Taster_Plus = 7;                                 // Dezimal +
int Taster_Minus = 8;                                // Dezimal -
int Digit1_BCD_Pin [] = { 36, 42, 40, 38 };          // Digit 1, Zehner
int Digit2_BCD_Pin [] = { 44, 50, 48, 46 };          // Digit 2, Einer
int LEDs_BCD_Pin [] = { 23, 25, 27, 29, 31, 33 };    // LEDs Binärausgabe
int Taster_Pin [] = { 53, 51, 49, 47, 45, 43 };      // Taster Binäreingabe
int BCD_Wert [] = { 1, 2, 4, 8, 16, 32 };            // Hilfswerte für Binäreingabe

int Zahl_Aktuell;                                    // Hauptvariable
int i, Ziffer;
bool Rest;


// *********************************************************************************************
void setup() {

  pinMode(Taster_UM, INPUT_PULLUP);                  // Taster Zehner-Eingabe
  pinMode(Taster_Plus, INPUT_PULLUP);                // taster +
  pinMode(Taster_Minus, INPUT_PULLUP);               // Taster -
  for (i = 0; i < 4; i++) {
    pinMode(Digit1_BCD_Pin[i], OUTPUT);
    pinMode(Digit2_BCD_Pin[i], OUTPUT);
  }
  for (i = 0; i < 6; i++) {
    pinMode(LEDs_BCD_Pin[i], OUTPUT);
    pinMode(Taster_Pin [i], INPUT_PULLUP);           // Taster Binäreingabe
  }  
}

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

    if (digitalRead(Taster_UM) == HIGH) {            // Erhöhung der Zahl um 1
        if (digitalRead(Taster_Plus) == LOW) {       // Plus Taster betätigt
            Zahl_Aktuell++;                          // Zahl erhöhen;
            Zahlkorrektur ();                        // Grenzwerte prüfen
            Zahl_anzeigen ();                        // Geändertn Wert anzeigen
        }
        if (digitalRead(Taster_Minus) == LOW) {      // Verringerung der Zahl um 1
            Zahl_Aktuell--;
            Zahlkorrektur ();
            Zahl_anzeigen ();
        }
    }

    if (digitalRead(Taster_UM) == LOW) {             // Zehner - Reihe
        if (digitalRead(Taster_Plus) == LOW) {
            Zahl_Aktuell = Zahl_Aktuell + 10;        // Erhöhung der Zahl um 10
            Zahlkorrektur ();
            Zahl_anzeigen ();                        // Anzeige
        }
        if (digitalRead(Taster_Minus) == LOW) {
            Zahl_Aktuell = Zahl_Aktuell - 10;
            Zahlkorrektur ();
            Zahl_anzeigen ();
        }
    }

    for (i = 0; i < 6; i++) {                        // Eingabe über Binär-Taster
        if (digitalRead(Taster_Pin [i]) == LOW) {
            bool B = digitalRead(LEDs_BCD_Pin [i]);
            B = not B;
            if (B) { 
                Zahl_Aktuell = Zahl_Aktuell + BCD_Wert [i]; 
            } else { 
            Zahl_Aktuell = Zahl_Aktuell - BCD_Wert [i]; }
            Zahlkorrektur ();
            Zahl_anzeigen ();
        }
    }
}

// *********************************************************************************************
void Zahl_anzeigen () {

    Ziffer = Zahl_Aktuell;                           // Einer Reihe
    if (Zahl_Aktuell > 9) {
        Ziffer = Zahl_Aktuell % 10;
    }

    for (i = 0; i < 4; i++ ) {                       // BCD-Ausgabe für 7-Segmentanzeige-Treiber
        Rest = Ziffer % 2;        
        if (Ziffer == 1) { Rest = 1; }
        Ziffer = Ziffer / 2;
        digitalWrite (Digit2_BCD_Pin [i], Rest);     // Augabe Digit 1
    }

    Ziffer = 0;                                      // Zehner-Reihe
    if (Zahl_Aktuell > 9) {
        Ziffer = Zahl_Aktuell / 10;
    }
    for (i = 0; i < 4; i++ ) {
        Rest = Ziffer % 2;        
        if (Ziffer == 1) { Rest = 1; }
        Ziffer = Ziffer / 2;
        digitalWrite (Digit1_BCD_Pin [i], Rest);     // Ausgabe Digit 1
    }

    Ziffer = Zahl_Aktuell;                           // Binärausgabe 6 LEDs
    for (i = 0; i < 6; i++ ) {                       // Zusrand aller LEDs bestimmen
        Rest = Ziffer % 2;        
        if (Ziffer == 1) { Rest = 1; }
        Ziffer = Ziffer / 2;
        digitalWrite (LEDs_BCD_Pin [i], Rest);       // LEDs EIN bzw. AUS
    }
    delay (150);                                     // Prellen abwarten
}

// *********************************************************************************************
 void Zahlkorrektur () {

    if (Zahl_Aktuell > 63) {                         // Wert Max = 63
        Zahl_Aktuell = 63;
    }

    if (Zahl_Aktuell < 0) {                          // Wert Min = 0
        Zahl_Aktuell = 0;
    }
 }
 
// *********************************************************************************************    

Das Programm beinhaltet wenig Geheimnisse. Alles dreht sich um die Hauptvariable „Zahl_Aktuell“. Es wird in der Hauptschleife loop() permanent danach gefragt, ob ein Taster betätigt wurde. Sobald dies geschah, wird der Hauptvariable ein neuer Wert, der von dem betätigten Taster abhängt, zugewiesen. In dem Unterprogramm Zahlkorrektur () wird dann untersucht, ob die äußeren Grenzwerte nicht überschritten wurden. Der maximale Wert, der mit einer sechsstelligen Binärzahl dargestellt werden kann, beträgt 63. Nach der Prüfung wird das Unterprogramm Zahl_anzeigen () aufgerufen und die Zahl gleichzeitig dezimal (Siebensegmentanzeige) und binär (Sechsstellige LEDs-Reihe) angezeigt. Nachdem die wegen Prellung eingebaute Wartezeit von 150 ms abgelaufen ist, beginnt die Taster Abfrage erneut.

Testschaltung

Kurzvideo

Weitere Themen: