Nach dieser Lektion sollten Sie:
Im Video sind nur die ersten 30 Minuten relevant. Danach werden verschiedene Sleep-Modes betrachtet - diese sind für uns nicht relevant.
4_up-down-counter.hex
als firmware auf den Atemga 88 Chip0000
zurück.
/*============================================================================= Experiment 4: Up-Down-Counter ============= =============== Dateiname: Up-Down-Counter_de.c Autoren: Peter Blinzinger Marc Neumeister Prof. G. Gruhler (Hochschule Heilbronn) D. Chilachava (Georgische Technische Universitaet) Version: 1.2 vom 01.05.2020 Hardware: MEXLE2020 Ver. 1.0 oder höher AVR-USB-PROGI Ver. 2.0 Software: Entwicklungsumgebung: AVR Studio 7.0 C-Compiler:AVR/GENU C Compiler 5.4.0 Funktion: Es wird ein 4-stelliger Dezimal-Zaehler (0000..9999) mit Anzeige und Ueber-/ Unterlauf realisiert. Das Aufwaerts- und Abwaertszaehlen wird mit zwei Tasten (S2: +) (S3: -) gesteuert. Es werden die Flanken beim Druecken der Tasten ausgewertet. Die Taste S1 dient zum Ruecksetzen des Zaehlers auf 0000. Displayanzeige: Start (fuer 2s): Betrieb: +----------------+ +----------------+ |- Experiment 4 -| |Up/Down-Counter | |Up/Down-Counter | |RES + - 0000| +----------------+ +----------------+ Tastenfunktion: S1: Reset Counter (ohne Entprellung) S2: (+) Aufwaerts (mit Entprellung) S3: (-) Abwaerts (mit Entprellung) Jumperstellung: keine Auswirkung Fuses im uC: CKDIV8: Aus (keine generelle Vorteilung des Takts) Header-Files: lcd_lib_de.h (Library zur Ansteuerung LCD-Display Ver. 1.3) =============================================================================*/ // Deklarationen ============================================================== // Festlegung der Quarzfrequenz #ifndef F_CPU // optional definieren #define F_CPU 18432000UL // ATmega 88 mit 18.432 MHz Quarz #endif // Include von Header-Dateien #include <avr/io.h> // I/O-Konfiguration (intern weitere Dateien) #include <stdbool.h> // Bibliothek fuer Bit-Variable #include <avr/interrupt.h> // Definition von Interrupts #include <util/delay.h> // Definition von Delays (Wartezeiten) #include "lcd_lib_de.h" // Header-Datei fuer LCD-Anzeige // Konstanten #define ASC_ZERO 0x30// ASCII-Zeichen '0' #define VORTEILER_WERT 90 // Faktor Vorteiler = 90 (Timerticks) #define TAKT10MS_WERT 10 // Faktor Taks10ms = 10 (1/100 s) // Variable unsigned char vorteiler = VORTEILER_WERT;// Zaehlvariable Vorteiler unsigned char takt10msZaehler = TAKT10MS_WERT; // Zaehlvariable im 10ms Raster int counter = 0; // Variable fuer Zaehler bool timertick; // Bit-Botschaft alle 0,111ms (bei Interrupt) bool takt10ms; // Bit-Botschaft alle 10ms bool takt100ms; // Bit-Botschaft alle 100ms bool sw1_neu = 1; // Bitspeicher fuer Taste 1 bool sw2_neu = 1; // Bitspeicher fuer Taste 2 bool sw3_neu = 1; // Bitspeicher fuer Taste 3 bool sw1_alt = 1; // alter Wert von Taste 1 bool sw2_alt = 1; // alter Wert von Taste 2 bool sw3_alt = 1; // alter Wert von Taste 3 // Makros #define SET_BIT(BYTE, BIT) ((BYTE) |= (1 << (BIT))) // Bit Zustand in Byte setzen #define CLR_BIT(BYTE, BIT) ((BYTE) &= ~(1 << (BIT))) // Bit Zustand in Byte loeschen #define TGL_BIT(BYTE, BIT) ((BYTE) ^= (1 << (BIT))) // Bit Zustand in Byte wechseln (toggle) #define GET_BIT(BYTE, BIT) ((BYTE) & (1 << (BIT))) // Bit Zustand in Byte einlesen // Funktionsprototypen void initTaster(void); // Taster initialisieren void initDisplay(void); // Initialisierung des Displays void counterCounting(void); // Zaehlfunktion void counterDisplay(void); // Anzeigefunktion // Hauptprogramm ============================================================== int main() { initDisplay(); // Initialisierung LCD-Anzeige TCCR0A = 0; // Timer 0 auf "Normal Mode" schalten TCCR0B |= (1<<CS01); // mit Prescaler /8 betreiben TIMSK0 |= (1<<TOIE0); // Overflow-Interrupt aktivieren sei(); // generell Interrupts einschalten while(1) // unendliche Warteschleife mit Aufruf der // Funktionen abhaengig von Taktbotschaften { if (takt10ms) // alle 10ms: { takt10ms = 0; // Botschaft "10ms" loeschen counterCounting(); // Tasten abfragen, Zaehlfunktion } if (takt100ms) // alle 100ms: { takt100ms = 0; // Botschaft "100ms" loeschen counterDisplay(); // Zaehlerstand auf Anzeige ausgeben } } return 0; } // Interrupt-Routine ========================================================== ISR (TIMER0_OVF_vect) /* In der Interrupt-Routine sind die Softwareteiler für die Taktbotschaften (10ms, 100ms) realisiert. Die Interrupts stammen von Timer 0 (Interrupt 1) Verwendete Variable: vorteiler hunderstel Ausgangsvariable: takt10ms takt100ms */ { timertick = 1; // Botschaft 0,111ms senden --vorteiler; // Vorteiler dekrementieren if (vorteiler==0) // wenn 0 erreicht: 10ms abgelaufen { vorteiler = VORTEILER_WERT; // Vorteiler auf Startwert takt10ms = 1; // Botschaft 10ms senden --takt10msZaehler; // Hunderstelzähler dekrementieren if (takt10msZaehler==0) // wenn 0 erreicht: 100ms abgelaufen { takt10msZaehler = TAKT10MS_WERT; // Teiler auf Startwert takt100ms = 1; // Botschaft 100ms senden } } } // Zaehlfunktion ============================================================== void counterCounting(void) { // Bitposition im Register: // __76543210 DDRC = DDRC & 0b11111000; // Zunaechst Port B auf Eingabe schalten PORTC = 0b00000111; // Pullup-Rs eingeschaltet _delay_us(1); // Umschalten der Hardware-Signale abwarten // Einlesen der 3 Tastensignale sw1_neu = GET_BIT(PINC, PC0) ;// aktuelle Werte der Tasten 1-3 lesen sw2_neu = GET_BIT(PINC, PC1) ; sw3_neu = GET_BIT(PINC, PC2) ; // Auswertung der 3 Tasten if (sw1_neu==0) // solange Taste 1 gedrueckt: counter = 0000; // Counter auf 0000 setzen if ((sw2_neu==0)&(sw2_alt==1)) // wenn Taste 2 eben gedrueckt wurde: { counter++; // Counter hochzaehlen, Ueberlauf >9999 if (counter==10000) counter = 0; } if ((sw3_neu==0)&(sw3_alt==1)) // wenn Taste 3 eben gedrueckt wurde: { counter--; // Counter herabzaehlen, Unterlauf <0000 if (counter < 0) counter = 9999; // auf 9999 setzen } // Zwischenspeichern aktuelle Tastenwerte sw1_alt = sw1_neu; // aktuelle Tastenwerte umspeichern sw2_alt = sw2_neu; // in Variable für alte Werte sw3_alt = sw3_neu; DDRC = DDRC | 0b00000111; // Am Ende Port B wieder auf Ausgabe schalten } // Anzeige Zaehler ============================================================ void counterDisplay(void) { int temp; // lokale temporaere Variable lcd_gotoxy(1,12); // Cursor auf Ausgabeposition im Display temp = counter; lcd_putc(temp/1000+ASC_ZERO); // Ausgabe Tausender als ASCII-Wert temp = temp%1000; // Divisionrest = Hunderter + Zehner + Einer lcd_putc(temp/100+ASC_ZERO); // Ausgabe Hunderter als ASCII-Wert temp = temp%100; // Divisionsrest = Zehner + Einer lcd_putc(temp/10+ASC_ZERO); // Ausgabe Zehner als ASCII-Wert lcd_putc(temp%10+ASC_ZERO); // Ausgabe Einer als ASCII-Wert } // Initialisierung Display-Anzeige ============================================ void initDisplay() // Start der Funktion { lcd_init(); // Initialisierungsroutine aus der lcd_lib lcd_gotoxy(0,0); // Cursor auf 1. Zeile, 1. Zeichen lcd_putstr("- Experiment 4 -"); // Ausgabe Festtext: 16 Zeichen lcd_gotoxy(1,0); // Cursor auf 2. Zeile, 1. Zeichen lcd_putstr("Up/Down-Counter "); // Ausgabe Festtext: 16 Zeichen _delay_ms(2000); // Wartezeit nach Initialisierung lcd_gotoxy(0,0); // Cursor auf 1. Zeile, 1. Zeichen lcd_putstr("Up/Down-Counter "); // Ausgabe Festtext: 16 Zeichen lcd_gotoxy(1,0); // Cursor auf 2. Zeile, 1. Zeichen lcd_putstr("RES + - 0000"); // Ausgabe Festtext: 16 Zeichen } // Ende der Funktion
/*=============================================================================
Ändern Sie auch hier wieder die Beschreibung am Anfang des C-Files, je nachdem was Sie entwickeln
Deklarationen ===================================
interrupt.h
inkludiert. Damit können „Interrupt Service Routinen“ - also Unterprogramme für Unterbrechungen - definiert werden. VORTEILER_WERT
, HUNDERTSTEL_WERT
und ZEHNTEL_WERT
definiert. Diese sind notwendig, um von der Periode des Interrupts auf die Hunderstelsekunde und Zentelsekunde zu kommen (siehe ISR (TIMER0_OVF_vect)
) vorteiler
und hundertstel
sind für die Umrechnung des Interrupts auf längere Perioden wichtig.counter
wird die eigentliche, auf- bzw. absteigende Zahl gespeichert.
Welchen Wertebereich hat int
?
timertick
, takt10ms
, takt100ms
sind Bit-Botschaften (auch Flag genannt). Diese Boolewerte geben bescheid, ob die Interrupt Service Routine aufgerufen wurde (timertick), oder ob 10ms oder 100ms abgelaufen ist. sw1_neu
gesetzt. sw1_alt
entspricht dem vorherigen Wert. Gleiches gibt es für die anderen Taster.
Hauptprogramm =========================
TCCR0A
und TCCR0B
gesetzt. Im verwendeten „Normal Mode“ zählt der ein Timer (=Zählerbaustein) im Microprozessor hoch. Die entspricht etwa dem a=a+1 im C Code, nur, dass der Microprozessor dafür keinen Code ausführen muss. Das Register TCCR0B
gibt mit dem Prescaler an, dass das Hochzählen um ein nur alle 8 Prozessortakte erfolgen soll. Der verwendete Timer 0 ist ein 8-Bit Timer. Er zählt also von 0 bis 255, läuft dann über und beginnt wieder bei 0.TIMSK0
ist die „Timer Interrupt MaSK“ des Timers 0. Damit kann angegeben werden, ob und wenn ja, welcher Interrupt ausgelöst werden soll. Timer kann damit so konfiguriert werden, dass er keinen Interrupt auslöst, oder einen Interrupt bei einem bestimmten Wert auslöst, oder einen Interrupt beim Überlauf auslöst. TOIE0
wird der Interrupt bei Überlauf aktiviert (vgl. ATmegaX8 Datenblatt (Kap. 15.9.6) oder ATmega88 Datasheet (Kap. 14.9.6)).sei()
wird die Bearbeitung von Interrupts aktiv
Interrupt Routine =========================
ISR()
wird eine Interrupt Service Routine angelegt. Das verwendete TIMER0_OVF_vect
spezifiziert den gewünschten Interrupt, hier den OVerFlow Interrupt für TIMER0. Timertick
gesetzt. Diese gibt an: ISR wurde aufgerufen.vorteiler
ist auch ein Zähler, welcher mit jedem Aufruf von ISR heruntergezählt wird. Mit vorteiler = VORTEILER_WERT
als Ausgangswert (Zeile 65) zählt vorteiler
von 90 herunter. Da die ISR alle $0,1\bar{1}~\rm ms$ aufgerufen wird, wird vorteiler
alle $90\cdot0,1\bar{1}~\rm ms=10~\rm ms$ gleich 0.vorteiler
0 erreicht wird die Variable wieder auf den Startwert zurückgesetzt und der das Flag für das Erreichen der $10~\rm ms$ gesetzt. Um auch $10\cdot10~\rm ms$ abzählen zu können, muss nach $10~\rm ms$ takt10msZaehler
auch herunter gezählt werden.takt10msZaehler
den Wert 0, so wird auch diese Variable auf 0 und ebenso das Flag für das erreichen von $100~\rm ms$ zurückgesetzt main()
. Die ISR bleibt also sehr schlank. Wäre in der ISR() viel Code auszuführen, so würde der Prozessor zwischen zwei Interrupts kaum noch Zeit haben, um sich dem unterbrochenen Programm zu widmen.
Zaehlfunktion ==============
PINC
in die Variable ausgelesen. 0
auf 1
) wird reagiert. sw1_alt
bis sw3_alt
gespeichert werden. Damit kann beim nächsten Aufruf die Flankendetektion stattfinden.
Anzeige Zaehler =========================
3456
auszugeben, wird dieser Schritt für Schritt im Display aufgebaut. Für die Tausenderstelle wird zunächst der Wert $3456/1000$ ohne Nachkommastellen ausgerechnet. Für die Anzeige muss dieser Wert in einen ASCII-Wert umgewandelt werden. Dazu muss 0x30
addiert werden. 3456
muss nun vom Tausender-Rest 456
wieder die höchste Stelle ausgegeben werden. Der Tausender-Rest kann über die Modulo-Funktion (im Code mittels %
) ermittelt werden. Für Zehner- und Einerwert kann aus dem Hunderter-Rest direkt Division durch 10 ohne Rest und gerade dieser Rest verwendet werden
Initialisierung Display-Anzeige =========================
Bitte arbeiten Sie folgende Aufgaben durch: