Dauerkalender

Digitaler Würfel mit Mikrocontroller
(Schaltung mit ATtiny24A)

Einen Würfel mit Komparator und Zähler haben wir bereits konstruiert. In der folgenden Schaltung übernimmt die Aufgabe des Würfelns der Mikrocontroller ATtiny24. Seine Aufgabe werden wir ein wenig erweitern. Es sollen nicht nur via Zufall Würfel-Zahlen generiert werden. Die Schaltung soll einen Würfel-Wurf möglichst genau imitieren. Um den Eindruck des Rollens zu erwecken, soll die Geschwindigkeit bei der Anzeige der Würfelzahlen zunehmend langsamer werden.
Die Würfelzahlen werden mit Leuchtdioden visualisiert. Um dafür zu sorgen, dass nach jeder Einschaltung andere Zufallszahlen generiert werden, wird beim Start des Programms ein analoger Eingang, der unverdrahtet ist, abgefragt.
Das Programm für diese Aufgabe wird mit Arduino IDE erstellt. Die Programmierung des Mikrocontrollers wird mithilfe des Programmers Diamex AVR-ISP durchgeführt.

ATtiny24A

ATtiny24A zählt zu der Familie der 8-Bit AVR Mikrocontroller. Er stellt 2KB Flash-Speicher, 128B EEPROM und 128B SRAM zur Verfügung. Der Chip hat 14 Anschlüsse, 12 können als I/Os verwendet werden. Der Mikrocontroller verfügt über einen intern kalibrierten Oszillator und vier per Software wählbare Energiesparmodi. Die Versorgungsspannung kann zwischen 1,8 V bis 5,5 V gewählt werden.

Pinbelegung

Merkmale:

• Programmspeichers: 2 KB
• CPU-Taktfrequenz: 20 MHz
• SRAM: 128 Byte
• Daten EEPROM: 128 Byte
• Schnittstellen: 1 x SPI, 1 x I2C
• Zeitgeber: 1 x 8-Bit, 1 x 16-Bit
• Anzahl der Komparatoren: 1
• Temperaturbereich: -40 bis 85 °C
• Betriebsspannungsbereich: 1,8 bis 5,5 V
• Pin-Zahl: 14
• Low Power: Ja

Schaltplan

Programm

int Leuchtdiode [] = { 1,2,3,4,5,6,7 };      // Ausgänge
int Taster = 10;                             // Eingang
int Wuerfel_Zahl;                            // Gewürfelte Zahlen
int Pause;                                   // Wartezeiten
int i,j;                                     // Laufvariablen

// ********************************************************************
void setup() {
    
    for (i=0; i<8; i++) {
        pinMode(Leuchtdiode[i], OUTPUT);     // LEDs Ausgänge
    }
    pinMode(Taster, INPUT);                  // Taster Start
    randomSeed (analogRead (0));             // Zufallszahl Startwert

    for (i=0; i<8; i++) {                    // LEDs Test
        digitalWrite(Leuchtdiode [i], HIGH);  
        delay (100);
    }    
    delay(1000);
    Alle_LEDs_Aus ();
}

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

    if (digitalRead(Taster) == LOW) {        // Taster betätigt?
        Pause = 20;                          // Pause Startwert
        j = 0;
        Weiter_rollen:                       // Goto Sprungziel
        Alle_LEDs_Aus ();                    // LEDs Aus
        delay(50);                           // Wartezeit
        j++;
        Wuerfel_Zahl = random (1,7);         // Zufallszahl generieren
        LED_wuerfel();                       // Zufallszahl anzeigen
        Pause += 50;                         // Pause Zeit erhöhen
        delay (Pause);                       // warten
        if (j < 20) {                        // 20 mal würfeln
            goto Weiter_rollen;
        }
        Blinken_lassen:                      // Goto Sprungziel
        j++;                                 // 15 mal blinken lassen
        Alle_LEDs_Aus ();                    // LEDs aus
        delay (50);                          // kurz warten
        LED_wuerfel ();                      // Zahl anzeigen
        delay (50);                          // kurz warten
        if (j < 35) {                        // bei j=35 Blinken Ende
            goto Blinken_lassen;
        }
    }
}

// ********************************************************************
void LED_wuerfel() {
                                             // Würfelzahl anzeigen
    switch (Wuerfel_Zahl) {                    
        case 1: {
            digitalWrite (Leuchtdiode [3], HIGH);
            break; }
        case 2: {
            digitalWrite (Leuchtdiode [1], HIGH);
            digitalWrite (Leuchtdiode [5], HIGH);
            break; }
        case 3: {
            digitalWrite (Leuchtdiode [0], HIGH);
            digitalWrite (Leuchtdiode [3], HIGH);
            digitalWrite (Leuchtdiode [6], HIGH);
            break; }
        case 4: {
            digitalWrite (Leuchtdiode [0], HIGH);
            digitalWrite (Leuchtdiode [1], HIGH);
            digitalWrite (Leuchtdiode [5], HIGH);
            digitalWrite (Leuchtdiode [6], HIGH);
            break; }
        case 5: {
            digitalWrite (Leuchtdiode [0], HIGH);
            digitalWrite (Leuchtdiode [1], HIGH);
            digitalWrite (Leuchtdiode [3], HIGH);
            digitalWrite (Leuchtdiode [5], HIGH);
            digitalWrite (Leuchtdiode [6], HIGH);
            break; }
        case 6: {
            digitalWrite (Leuchtdiode [0], HIGH);
            digitalWrite (Leuchtdiode [1], HIGH);
            digitalWrite (Leuchtdiode [2], HIGH);
            digitalWrite (Leuchtdiode [4], HIGH);
            digitalWrite (Leuchtdiode [5], HIGH);
            digitalWrite (Leuchtdiode [6], HIGH);
            break; }                                                                          
    }
}

// ********************************************************************
void Alle_LEDs_Aus () {
                                             // LEDs ausschalten
    for (i=0; i<8; i++) {
        digitalWrite(Leuchtdiode [i], LOW);  
    }
}

// ********************************************************************     


 

ATtiny-Programmierung mit Diamex-Programmer

Nachdem ein Programm erstellt wurde, muss es in den Mikrocontroller geladen werden. In unserem Beispiel verwenden wir zu diesem Zweck einen fertigen Programmer von Diamex (USB ISP-Programmer für Atmel AVR). Das Gerät ist im Handel zum Preis von ca. 22 Euro erhältlich (2024).
Das Programm wurde mit Ardunio IDE Version 2.3.2 erstellt. Von dieser Plattform wird es auch in den Mikrocontroller geladen.
Damit es möglich ist, muss die Software zunächst über die ATtiny Mikrocontroller erweitert werden. In dem Fenster "Datei/Einstellungen" geben wir folgende Adresse ein:
http://drazzy.com/package_drazzy.com_index.json

Die Eingabe wird anschließend mit „OK“ bestätigt.
Mit dem Klick auf „Werkzeuge/Bibliotheken verwalten…“ wird der Bibliotheksverwalter geöffnet. Hier scrollen wir bis zu dem Eintrag „ATTinyCore von Spence Konde“ und betätigen den Button „Installieren“.

Jetzt bei der Boardsauswahl unter „Werkzeuge/Board/ATTinyCore“ können auch ATtiny Mikrocontroller ausgewählt werden.

Die Software Arduino IDE ist jetzt vorbereitet, um ein Programm in den ATtiny Mikrocontroller zu laden. Es muss noch eine Hardware-Verbindung zwischen dem Mikrocontroller und dem PC hergestellt werden. Dazu nutzen wir in dem Beispiel als passende Schnittstelle den ISP-Programmer von Diamex: DIAMEX AVR-ISP.

Das Gerät wird via USB mit dem PC verbunden. Je nach Einstellung kann man für die Versorgung des Mikrocontrollers während der Programmübertragung die USB-Spannung nutzen oder eine externe Spannungsquelle anschließen. In dem Fall nutzen wir die USB-Spannung als Spannungsversorgung für den Mikrocontroller und stellen dementsprechend die zwei auf dem Programmer angebrachte DIP-Schalter auf ON.

An den Programmer wird eine selbst gebastelte Platine mit drei Chip-Fassungen angeschlossen. Die Sockel sind an unterschiedliche ATtinys angepasst. In den 8-poligen Sockel kann z.B. ATtiny 85 eingesteckt werden. In unserem Beispiel wird ATtiny24 in den mittleren, 14-poligen Sockel gesteckt. In den 24-poligen Sockel können dann größere ATtinys, wie z.B. ATtiny2313 gesteckt werden. Zu beachten ist, dass nicht alle ATtinys gleich angeschlossen werden. Man muss von Fall zu Fall die Pinbelegung untersuchen und auf richtige Verdrahtung achten.

Im nächsten Schritt muss der Mikrocontroller mit dem Programmer verbunden werden. Man kann hierzu ein 6-poliges oder 10-poliges Flachkabel mit Stecker, die im Lieferumfang enthalten sind, nutzen. In dem Versuch kommt die 6-polige Leitung zum Einsatz. Die Verbindung zwischen der sechspoligen Buchse des Programmers und dem 14-poligen Chip ATtiny24 sieht wie folgt aus:

Nachdem die Verbindungen stehen, kann das Programm übertragen werden. Die Übertragung erfolgt in zwei Schritten. Im ersten Schritt wird die Funktion „Werkzeuge/Bootloader brennen „ ausgeführt. Dies geschieht, nachdem unter „Werkzeuge“ alle Einstellungen erfolgt sind. In dem Beispiel sehen sie wie folgt aus:

Nachdem alle Einstellungen erfolgt sind und die Funktion „Bootloader brennen“ ausgeführt wurde, kann das eigentliche Programm übertragen werden.

Dazu betätigt man unter „Sketch“ die Auswahl „Mit Programmer hochladen“.

Das Programm wurde geladen und der ATtiny 24 ist jetzt einsatzbereit. Er kann jetzt in die Schaltung eingebaut werden.

Testschaltung

Kurzvideo

Kurzvideo

Weitere Themen: