Dies ist eine alte Version des Dokuments!
8. Temperatur-Messung und Analog-Digital-Wandler
ADC - wie kommt mehr als nur ein Bit über einen Pin?
Ziele
Nach dieser Lektion sollten Sie:
- wissen, wie ein ADC genutzt wird
weiterführende Links
Video
Messsignal-Digitalisierung und Auswertung
Um Sensorwerte in C sinnvoll nutzen zu können sind einige Schritte zwischen dem passiven Sensor über den ADC bis in den Code umzusetzen (siehe Abbildung 2).
- Sensor: $T \rightarrow R_{NTC}$
Umwandlung der physikalischen Größe in ein Messsignal
- Sensorschaltung: $R_{NTC} \rightarrow V_{NTC}$
Aufbereitung des Messsignal (z.B. Filter, Verstärkung oder Umwandlung in Spannungssignal)
- ADC: $V_{NTC} \rightarrow ad\_wert$
Digitalisierung in ein Zahlenwert im Code
- Aufbereitung im Code $ad\_wert \rightarrow t\_wert$
um ein Abbild des Sensorwerts zu erhalten
Häufig ergeben sich hierbei folgende Herausforderungen:
- Der digitalisierte Wert ist nicht linear zur physikalischen Größe
- Die Relation zwischen digitalisiertem Wert und physikalischen Größe muss platzsparend und effizient umgesetzt werden.
Diese Einzelschritte und Herausforderungen sollen im Folgenden beschrieben werden.
1.a Umwandlung der physikalischen Größe in ein Messsignal (Sensorwert zu Widerstandswert)
- Bei vielen passiven Sensoren wird der Sensorwert in eine Widerstandsänderung umgewandelt. Die Relation von Sensorwert zu Widerstandswert ist im Datenblatt des Sensors angegeben.
- Das Datenblatt der gewünschten Komponente (hier: Thermistors 2381 640 6472) ist im Internet zu finden.
- Häufig sind im Datenblatt Stützpunkte angegeben, bei welchen der physikalischen Größe ein Messsignal gegenübersteht. Die ist auch hier der fall.
- Suchen Sie dort nach der gewünschten Komponente (hier Thermistor 2381 640 6472). Beachten Sie, das manche Datenblätter eine andere Sortierung / Benamung nutzen, als sie von den Distributoren genutzt wird. Im konkreten Fall hilft eine Suche nach den letzten drei Ziffern „472“.
Konvertierung des Datenblatts in Excel
Um die Daten aus dem Datenblatt aufzubereiten empfiehlt sich eine Verarbeitung in einem Analyse-Tool, z.B. Matlab. Für kleinere Tabelle kann auch ein Tabellenkalkulationsprogramm wie Excel eine Hilfe sein. Im Folgenden sollen die Schritte anhand von Excel erklärt werden.- In vielen Fällen kann das Datenblatt über
Daten » Daten abrufen » Aus Datei » Aus PDF
eingelesen werden.
Über diese Variante ist aber hier in vertretbarer Zeit kein Import möglich, da das Datenblatt viele verschiedene Tabellen enthält. - Eine andere Variante ist ein Umweg über Word
- Erstellen Sie ein leeres Dokument in Word
- Öffnen Sie über
Datei » Öffnen » Durchsuchen
mit dem Filter*.pdf
das gewünschte Datenblatt. Der Import sollte nur wenige Sekunden dauern - Es soll nun die relevante Tabelle ausgewählt werden (hier: im pdf Seite 80, in Word Seite 84). Nutzen Sie hierzu das Auswahltool „$\boxed{{\leftarrow}\mkern-10mu{\rightarrow}\mkern-17mu{\uparrow}\mkern-9mu{\downarrow}\;\;}$“ links oben bei der Tabelle.
- Kopieren Sie die ausgewählte Tabelle
- In Excel muss nun zunächst das Dezimaltrennzeichen geändert werden, da es sich um eine englischsprachiges Datenblatt handelt. Dies geschieht im Menu
Datei » Optionen » Erweitert
. Hier sollteTrennzeichen von Betriebssystem übernehmen
deaktiviert und als Dezimaltrennzeichen ein Punkt (.
) gewählt werden. - Nun kann die Tabelle eingefügt werden. Es empfiehlt sich nach dem Einfügen das Dezimaltrennzeichen wieder zurückzustellen.
- Im Anschluss sollten nur die relevanten Zeilen und Spalten gewählt werden (hier nur Zeilen und Spalten für „… 472“). Sinnvoll ist auch mögliche doppelte oder verbundene Zeilen / Spalten zu reduzieren.
- Nun sollten die relevanten Spalten (hier: Temperatur und Widerstandswert) in Excel vorhanden sein
2. + 3. Relation von Widerstandswert zu ADC-Wert
Der Analog-Digitalwandler konvertiert die anliegende Spannung in einen Wert, welcher im Code weiter genutzt werden kann. Im ATmega328 ist ein 10-Bit ADC verbaut. Dieser wandelt Spannungen von 0V bis VCC (hier 0..5V) in einen internen ADC-Wert von 0 bis 1023 ($2^{10}-1$) um.
Es muss aber nun auch eine Beziehung zwischen Temperatur und ADC-Wert gefunden werden, um die Temperatur intern aus dem digitalisierten Wert ermitteln zu können. Hierzu ist es notwendig zunächst die Schaltung zu betrachten (siehe Abbildung 3).
Die Spannung am ADC lässt sich leicht über den Widerstandswert berechnen:
\begin{align} {{V_{NTC}} \over {V_{CC}}} = {{R_{NTC}}\over{R_{NTC} + R_{pullup}}} \tag{8.1} \end{align}
Daraus ergibt sich der digitalisierte Wert zu
\begin{align} ADCwert = round \left({{V_{NTC}}\over{V_{CC}}} \cdot 1024 \right) \tag{8.2} \end{align}
aus $(8.1)$ und $(8.2)$ ergibt sich
\begin{align} ADCwert = round \left({{R_{NTC}}\over{R_{NTC} + R_{pullup}}} \cdot 1024 \right) \tag{8.3} \end{align}
Diese Relation muss nun im Analyse-Tool abgebildet werden und wurde in diesem Ecxelfile umgesetzt. Einige der verwendeten Excel-Tricks sollen hier beschrieben werden:
- Benamung von Zellen und Bereichen: Für viele Zellen wurden Namen vergeben, z.B. Zelle J2 in Tabelle 1 erhielt die Benamung $V\_CC$ oder der Bereich E7:E45 die Benamung $R\_NTC$.
- Rechnen mit Bereichen: In den Zellen F7 und G7 in Tabelle 1 wurden mit Angabe der Bereichsnamen Formeln eingefügt. Damit entfällt das Auffüllen der weiteren Zeilen
- Einfügen einer Trendlinie: Für das Diagramm wurde ADCval als x-Werte und $R\_NTC$ als y-Werte verwendet. Für die Trendlinie wurde ein Polynom 4. Grades genutzt. Mit Anzeige der Trendlinien-Formel wird die Relation von Widerstandswert zu ADC-Wert sichtbar. Die Zahl-Eigenschaft der Trendlinienbeschriftung sollte dabei auf
Wissenschaftlich
mit 2 Dezimalstellen gestellt werden, um die Auflösung zu erhöhen.
4. Aufbereitung der des ADC-Werts im Code
Mit den bisherigen Betrachtungen ist zwar klar, wie die Relation von Widerstandswert zu ADC-Wert aussieht, aber diese ist noch nicht im Code umgesetzt. Zunächst sollte der notwendige Wertebereich geklärt werden: In welchem Bereich werden Messwerte erwartet? In diesem Konkreten Fall geht es um die Innenraumtemperatur. Damit wird die Temperatur im Bereich $[-30°C, 50°C]$ sein.
direkte Verwendung der Datenblattwerte
Die einfachste Variante wäre die vorhandenen Daten aus dem Datenblatt direkt zu nehmen und zu prüfen, ob der eingelesene ad_wert zwischen zwei bekannten Werten liegt.
#define MAX_INDEX 17 // Anzahl der Stuetzstellen const int TEMP[MAX_INDEX] = { -30, -25, -20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50}; const int ADC_VAL[MAX_INDEX] = { 968, 950, 927, 899, 866, 827, 783, 734, 681, 625, 568, 512, 456, 404, 356, 311, 271}; // Datenwerte aus dem Datenblatt // TEMP[] enthaelt die Temperaturen // In ADC_VAL[] sind die den Temperaturen entsprechenden ADC-Werte abgespeichert ... for(int index=0; index<MAX_INDEX; index++) { // suche den Index, bei dem der gemessene Wert zum ersten mal darueber liegt if (ad_wert >= ADC_VAL[index]) break; // wenn gefunden, breche ab (dann zeigt index auf die untere Temperatur) }; int t_wert = TEMP[index]; // Der Temperaturwert mit dem gefundenen index wird zugewiesen ...
Nachteil dabei ist, dass die Ausführung unterschiedlich lange benötigt und die Auflösung nur 5°C beträgt.
direkte Verwendung der Datenblattwerte mit Interpolation
In einem weiteren Schritt könnte eine Interpolation zwischen den Werten umgesetzt werden
#define MAX_INDEX 17 // Anzahl der Stuetzstellen const int TEMP[MAX_INDEX] = { -30, -25, -20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50}; const int ADC_VAL[MAX_INDEX] = { 968, 950, 927, 899, 866, 827, 783, 734, 681, 625, 568, 512, 456, 404, 356, 311, 271}; // Datenwerte aus dem Datenblatt // TEMP[] enthaelt die Temperaturen // In ADC_VAL[] sind die den Temperaturen entsprechenden ADC-Werte abgespeichert ... for(int index=0; index<MAX_INDEX-1; index++) { // suche den Index, bei dem der gemessene Wert zum ersten mal darueber liegt if (ad_wert >= ADC_VAL[index]) break; // wenn gefunden, breche ab (dann zeigt index auf die untere Temperatur) }; int t_uW = TEMP[index]; // Der Temperaturwert mit dem gefundenen index wird gespeichert (unterer Wert = uW) int t_oW = TEMP[index+1]; // Der darauffolgende Temperaturwert wird gespeichert (oberer Wert = oW) int ADC_uW = ADC_VAL[index]; // Der ADC-Wert mit dem gefundenen index wird zugewiesen (unterer Wert = uW) int ADC_oW = ADC_VAL[index+1]; // Der darauffolgende ADC-Wert wird zugewiesen (oberer Wert = oW) float t_wert = TEMP[index] + 5 * (ad_wert -ADC_uW ) / (ADC_oW - ADC_uW ) ; // lineare Interpolation // zum unteren Temperaturwert wird ein Bruchteil entsprechend der // Differenz von ad_wert zum unteren ADC Wert ADC_uW hinzuaddiert ...
Die Auflösung ist nun sehr genau. Nachteile sind aber, dass die Ausführung immernoch unterschiedlich lange benötigt und die ein float-Wert relativ viel Speicher und CPU-Zeit bei weiteren Berechnungen benötigt.
Der float-Wert kann umgangen werden, wenn im gesamten Programm die Temperaturwerte in Zehntel-Grad geschrieben werden. Also 37,5°C $\rightarrow$ 375. Dann kann ein t_wert als signed integer geschrieben werden.
Umrechnung der Datenblattwerte
Eine geschicktere Option ist es, den Temperatur-Array TEMP[]
bereits so vorauszuberechnen, dass diese über den ADC-Wert ad_wert
adressiert werden kann. Dazu würde aber für alle Werte ein Array mit 1024 Werten benötigt (1kB Speicher). Eine Reduktion des Arrays ist also sinnvoll.
- Betrachtet man die obige Tabelle
ADC_VAL[]
, so ist jeder Wert größer als 256 und kleiner als 976. Diese Werte können also ignoriert werden. - Statt die restlichen Werte in Einzelschritten abzuspeichern, könnte auch nur jeder 16. Wert gespeichert werden
Der Index kann damit als index = (ad_wert-256)/16;
ermittelt werden. Der Vorteil in den verwendeten Zahlen (Vielfache von 2, hier 16) ist, dass der Microcontroller mit diesen leichter rechnen kann. Dies ist in dem untenstehenden Code umgesetzt. Die Umrechnung des Temperatur-Arrays TEMP[]
ist in obigen Excel-File beschrieben.
Übung
- I. Vorarbeiten
-
- Laden Sie folgende Datei herunter:
- II. Analyse des fertigen Programms
-
- Initialisieren des Programms
- Laden Sie
8_temperature.hex
als firmware auf den 328 Chip - Zunächst wird eine Startanzeige mit dem Namen des Programms dargestellt.
- Als nächstes sind im Display zwei Temperaturanzeigen zu sehen. Die obere Zeile zeigt den aktuellen Wert, die untere Zeile den Maximalwert seit Start.
- Der Drehregler neben dem NTC ermöglicht es die Temperatur des NTC zu verändern.
- III. Eingabe in Atmel Studio
-
/* ---------------------------------------------------------------------------- Experiment 8: Temperaturmessung mit MiniMEXLE ============= =============================== Dateiname: 8_Temperature.c Autoren : Peter Blinzinger Prof. G. Gruhler (Hochschule Heilbronn, Fakultät T1) D. Chilachava (Georgische Technische Universität) Datum : 01.05.2020 Version : 1.1 Hardware: MEXLE2020 Ver. 1.0 oder höher AVR-USB-PROGI Ver. 2.0 Software: Entwicklungsumgebung: AtmelStudio 7.0 C-Compiler: AVR/GNU C Compiler 5.4.0 Funktion : Thermometer mit Anzeige der aktuellen Temperatur und der Maximaltemperatur im Betriebszeitraum in °C mit 1/10 Grad. Keine Tastenbedienung Displayanzeige: Start (fuer 2s): Betrieb: +----------------+ +----------------+ |- Experiment 8 -| |Temp. 18.5°C| | Temperature | |Maximum 21.6°C| +----------------+ +----------------+ Tastenfunktion: keine Jumperstellung: keine Fuses im uC: CKDIV8: Aus (keine generelle Vorteilung des Takts) Header-Files: lcd_lib_de.h (Library zur Ansteuerung LCD-Display Ver.1.3) Module 1) Taktgenerator 2) AD-Wandlung (Takt: 100 ms) 3) Umrechnung für Temperatur (Takt: 100 ms) 4) Anzeigetreiber (Takt: 1 s) 1) Das Modul "Taktgenerator" erzeugt den Takt von 100 ms für die AD-Wandlung und Umrechnung und einen zusätzlichen Takt von 1 s für die Anzeige. Verwendung von Hardware-Timer 0 und T0 Overflow-Interrupt. Frequenzen: Quarzfrequenz 12,288 MHz. Timer-Vorteiler / 8 => 1,536 MHz Hardware-Timer /256 => 6 kHz / 166 µs Software-Vorteiler / 60 => 100 Hz / 10 ms Hundertstel-Zaehler / 10 => 10 Hz / 100 ms Zehntel-Zaehler / 10 => 1 Hz / 1 s 2) Das Modul "AD-Wandlung" wird durch den Takt 100 ms aufgerufen. Der AD-Wandler wird mit einem internen Takt von 96 kHz betrieben. Im Modul wird eine einzelne AD-Wandlung des Kanals ADC0 mit 10 Bit Auflösung gestartet. Dort ist der NTC des Boards mit Vorwiderstand als temperaturabhängiger Spannungsteiler bzw. Potentiometer angeschlossen. Als Referenzspannung wird die 5V-Versorgung verwendet. Das Ergebnis wird in der globalen Variable ad_wert gespeichert. 3) Das Modul "Umrechnung" wird nach der AD-Wandlung alle 100 ms gestartet. Der Ergebniswert des Moduls "AD_Wandlung" wird mit Hilfe einer Tabelle in einen entsprechenden Temperaturwert umgerechnet. In der Tabelle sind Temperaturwerte über äquidistante (Abstand = 16) AD-Werte aufgetragen. Die Werte dazwischen werden mit linearer Interpolation ermittelt. Weiterhin wird im Modul jede aktuelle Temperatur mit der gespeicherten maximalen Temperatur verglichen und der Maximalwert optional angepasst. 4) Das Modul "Anzeigetreiber" ist an den 1 s-Takt gekoppelt. Damit wird ein zu schnelles Umschalten der Anzeigewerte vermieden. Das Modul gibt die Werte der aktuellen und der maximalen Temperatur in 1/10 °C aus. Zwischen AD-Wandlung / Umrechnung und Anzeige kann später noch eine Mittelwertsbildung mit 10 Werten eingefügt werden. Die Kopplung der Module wird über global definierte Variable realisiert: 1-Bit-Variable: Takt 100 ms: Taktgenerator => AD-Wandlung => Umrechnung Takt 1 s: Taktgenerator => Anzeigetreiber 16-Bit-Variable: ad-wert AD-Wandlung => Umrechnung t-wert Umrechnung => Anzeige tmax-wert Umrechnung => Anzeige // ----------------------------------------------------------------------------*/ // Deklarationen ============================================================== // Festlegung der Quarzfrequenz #ifndef F_CPU // optional definieren #define F_CPU 12288000UL // MiniMEXLE mit 12,288 MHz Quarz #endif // Include von Header-Dateien #include <avr/io.h> // Header-Dateien zum ATmega88 #include <stdbool.h> // Header-Datei fuer Bit-Berechnung #include <avr/interrupt.h> // Header-Datei fuer Interrupts #include <util/delay.h> // Header-Datei fuer Wartezeit #include "lcd_lib_de.h" // Header-Datei fuer LCD-Anzeige // Konstanten #define VORTEILER_WERT 60 #define HUNDERTSTEL_WERT 10 #define ZEHNTEL_WERT 10 const int TEMP[45] = {521,499,479,459,440,422,404,388,371,354, 338,323,308,293,279,264,250,236,221,207, 193,179,165,151,137,122,108,93,78,63, 48,32,15,-1,-19,-38,-56,-77,-97,-121, -145,-173,-202,-237,-278}; // Die Tabellenwerte sind in 1/10 °C angegeben // Der erste Tabellenwert entspricht einem AD-Wert // von 256. Die Abstände der AD-Werte sind 16 // Variable unsigned char vorteiler = VORTEILER_WERT; // Zählvariable Vorteiler unsigned char hundertstel = HUNDERTSTEL_WERT; unsigned char zehntel = ZEHNTEL_WERT; unsigned int ad_wert = 0; // Variable für den AD-Wandlungswert int t_wert=0; // Variable für die Temperatur (in 1/10 °C) int tmax_wert=-300; // Variable für maximale Temperatur (1/10 °C) bool takt10ms; // Bit-Botschaft alle 10 ms bool takt100ms; // Bit-Botschaft alle 100 ms bool takt1s; // Bit-Botschaft alle 1s //Funktionsprototypen void initTimer0 (void); void adWandlerInit (void); void adWandlung (void); void umrechnung (void); void anzeigeTreiber (void); void initDisplay (void); // Initialisierung und Hauptprogramm // ============================================================================ int main () { initDisplay(); // Initialisierung LCD-Anzeige initTimer0(); // Initialisierung von Timer0 adWandlerInit(); // Initialisierung des AD-Wandlers sei(); // generell Interrupts einschalten // Hauptprogrammschleife __________________________________________________ while(1) // unendliche Warteschleife mit Aufruf der // Funktionen abhängig von Taktbotschaften { if(takt100ms == true) // Durchführung der Funktion einmal pro 100ms { takt100ms = false; // Taktbotschaft zurücksetzen adWandlung(); // Ausführung des Modules der A/D-Wandlung umrechnung(); // Ausführung des Modules der Umrechnung } if(takt1s == true) // Durchführung der Anzeige einmal pro 1s { takt1s = false; // Taktbotschaft zurücksetzen anzeigeTreiber(); // Ausführung des Modules der Anzeige } } } // Funktionen ============================================================== // Timer-Initialisierung: // --------------------- // // Initialisierung des Timer0 zur Erzeugung eines getakteten Interrupts. // Er dient dazu, die benötigten Taktbotschaften zu erzeugen. void initTimer0() { TCCR0A |= (0<<WGM00) | (0<<WGM01); // Timer 0 auf "Normal Mode" schalten TCCR0B |= (0<<WGM02) | (1<<CS01); // mit Prescaler /8 betreiben TIMSK0 |= (1<<TOIE0); // Overflow-Interrupt aktivieren } // A/D-Wandler-Initialisierung: // --------------------------- // Initialisierung des A/D-Wandlers: // Vorteiler = 128 => interner Takt = 96 kHz // Abfrage des ADC0 (NTC-Spannungsteiler) // Referenzspannung = analoge Versorgung Avcc void adWandlerInit () { ADMUX |= (1<<REFS0); // Vref =AVCC; ADC0 ADCSRA |= (1<<ADPS0)|(1<<ADPS1)|(1<<ADPS2)|(1<<ADEN); // Teiler 128; ADC ON } // Interrupt-Routine // ============================================================================ ISR (TIMER0_OVF_vect) // In der Interrupt-Routine sind die Softwareteiler realisiert, die die Takt- // botschaften (10ms, 100ms, 1s) für die Module erzeugen. Die Interrupts // werden von Timer 0 ausgelöst (Interrupt Nr. 1) // // Veränderte Variable: vorteiler // hunderstel // zehntel // // Ausgangsvariable: takt10ms // takt100ms // takt1s { --vorteiler; // Vorteiler dekrementieren if (vorteiler==0) // wenn 0 erreicht: 10ms abgelaufen { vorteiler = VORTEILER_WERT; // Vorteiler auf Startwert takt10ms = true; // Botschaft 10ms senden --hundertstel; // Hundertstelzähler dekrementieren if (hundertstel==0) // wenn 0 erreicht: 100ms abgelaufen { hundertstel = HUNDERTSTEL_WERT; // Teiler auf Startwert takt100ms = true; // Botschaft 100ms senden --zehntel; if (zehntel==0) // Zehntelzähler dekrementieren { zehntel = ZEHNTEL_WERT; // Teiler auf Startwert takt1s = true; // Botschaft 1s senden } } } } // Modul ADWandlung: // ---------------- // Durchführung einer Einzelwandlung der am NTC-Spannungsteiler anstehenden // Spannung in einen digitalen 10-bit-Wert (einmal pro 100 ms). void adWandlung() { ADCSRA |= (1<<ADSC); // Wandlung starten while (ADCSRA & (1<<ADSC)); // Ende der Wandlung abwarten ad_wert = ADCL + (ADCH<<8); // 10-Bit-Wert berechnen // ADCL muss vor ADCH stehen!! // siehe Datenblatt des ATmega 328 } // Modul Umrechnung: // -------------------- // (wird alle 100 ms aufgerufen) void umrechnung () { unsigned char index; // Tabellenindex für Temperaturtabelle unsigned char abschnitt; // Abstand zum nächstkleineren Wert // der AD-Werte der Temperaturtabelle index = (ad_wert-256)/16; // Indexberechnung (Zeiger in Tabelle) abschnitt = (ad_wert-256)%16; // Rest für Tabellen-Interpolation t_wert = abschnitt * (TEMP[index+1] - TEMP[index])/16 + TEMP[index]; // Temperaturwert berechnen if(t_wert>=tmax_wert) // aktueller Wert mit Maximalwert { tmax_wert = t_wert; // vergleichen und ggf. ersetzen } } // Modul Anzeigetreiber: // -------------------- // // Beschreiben der Anzeige mit dem erstellten Temperaturwert // und mit dem maximalen Wert (wird alle 1 s aufgerufen). // // Umrechnung der Zahlenwerte (1/10 °C) in Anzeigewerte wie folgt: // Hunderter: einfache Integer-Teilung (/100). // Zehner: Modulo-Ermittlung (%100), d.h. Rest bei der Teilung durch 100 // dann nochmals Integer-Teilung (/10) dieses Restes. // Einer: Modulo-Ermittlung (%10), d.h. Rest bei der Teilung durch 10. // // Umrechnung in ASCII-Werte für die Anzeige durch Addition von 0x30. void tempAnzeige(int ausgabewert, char zeile, char spalte) { int i; i = ausgabewert; lcd_gotoxy(zeile, spalte); // Startposition für Temperatur-Wert if (i>=0) // zuerst Vorzeichen: ' ' oder '-' { lcd_putc(' '); } else { lcd_putc('-'); i = -i; // Vorzeichenumkehr bei negativer Zahl } lcd_putc(i/100 + 0x30); // Hunderter ausgeben (°C Zehner) i = i%100; lcd_putc(i/10 + 0x30); // Zehner ausgeben (°C Einer) lcd_putc(0x2E); // Punkt ausgeben lcd_putc(i%10 + 0x30); // Einer ausgeben (°C Zehntel) } // Anzeigefunktion // --------------- // // Der aktuelle Temperatur und die maximale Temperatur werden ausgegeben void anzeigeTreiber() { tempAnzeige(t_wert, 0, 9); // aktuelle Temperatur ab Position 0,9 tempAnzeige(tmax_wert, 1, 9); // maximale Temperatur ab Position 1,9 } // 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 8 -"); // Ausgabe Festtext: 16 Zeichen lcd_gotoxy(1,0); // Cursor auf 2. Zeile, 1. Zeichen lcd_putstr(" Temperature "); // Ausgabe Festtext: 16 Zeichen _delay_ms(2000); // Wartezeit nach Initialisierung lcd_gotoxy(0,0); // Cursor auf 1. Zeile, 1. Zeichen lcd_putstr("Temp. ßC"); // Ausgabe Festtext: 16 Zeichen // "ßC" wird als °C dargestellt lcd_gotoxy(1,0); // Cursor auf 2. Zeile, 1. Zeichen lcd_putstr("Maximum ßC"); // Ausgabe Festtext: 16 Zeichen // "ßC" wird als °C dargestellt } // Ende der Funktion
/*=============================================================================
Ändern Sie auch hier wieder die Beschreibung am Anfang des C-Files, je nachdem was Sie entwickeln
Deklarationen ===================================
- Hier wird wieder geprüft ob die Frequenz des Quarz bereits eingestellt wurde und - falls nicht - dessen Frequenz eingestellt.
- Die Header-Dateien entsprechen denen der letzten Programme.
- Die Konstanten entsprechen denen der letzten Programme.
- Es wird eine zusätzliches Array
TEMP[]
angelegt, in denen die Temperaturen in 1/10 °C abgespeichert sind. Beispielsweise entspricht der erste Eintrag521
einer Temperatur von $52,1°C$. Der erste Eintrag wird bei einem ADC-Wert von 256 benötigt. Der zweite Eintrag entspricht $49,9°C$ und wird bei einem ADC-Wert von 256+16 = 272 benötigt. Die weiteren entsprechend. Die Herleitung erfolgt wie unter Messsignal-Digitalisierung und Auswertung vorgegeben.
- Bei den Variablen entsprechen einige denen der letzten Programme.
- Die Variable
ad_wert
wird mit dem digitalisierten ADC-Wert befüllt. - Die Variable
t_wert
beinhaltet die aktuelle Temperatur in 1/10°C und mit Vorzeichen. - Die Variable
tmax_wert
beinhaltet die höchsten seit Start gemessene Temperatur in 1/10°C und mit Vorzeichen (entspricht einem Schleppzeiger).
- Bei den Funktionsprototypen sind einige bekannte Unterprogramme vorhanden. Details werden weiter unten erklärt.
Hauptprogramm =========================
- Das Hauptprogramm ähnelt sehr stark dem Up/Down Counter. Entsprechend werden die Zeilen 143-157 hier nicht weiter erklärt.
- In der Endlosschleife sind auf der ersten Ebene wieder nur If-Abfragen zu den Flags
takt10ms
undtakt100ms
zu finden.
- Alle $10ms$ (bzw. wenn das entsprechende Flag gesetzt wird) wird das Flag zurückgesetzt und das Unterprogramm
uhrStellen()
aufgerufen
- Alle $100ms$ (bzw. wenn das entsprechende Flag gesetzt wird) wird das Flag zurückgesetzt und das Unterprogramm
uhrAnzeigen()
aufgerufen
- Alle $1s$ (bzw. wenn das entsprechende Flag gesetzt wird) wird das Flag zurückgesetzt und das Unterprogramm
uhrZaehlen()
aufgerufen
Interrupt Routine =========================
- Auch die Interrupt Routine ist dem Programm Up/Down Counter entlehnt und wird hier nicht weiter erklärt.
Taster initialisieren ==============
- Auch das Einstellen des Data Direction Registers und der Pullups wurde bereits in vorherigen Programmen erklärt.
Stellfunktion ==============
- In dieser Funktion werden zunächst die Stellungen aller Taster eingelesen (vgl.
counterCounting(void)
bei Up/down Counter).
- Neu hier ist, dass die Bedienung der Schalter die Variablen für Stunden, Minuten um eins hochsetzen, bzw. bei Überlauf wider zurück auf 0 setzen. Zusätzlich wird bei eine Änderung des Minuten-Werts der Sekunden-Wert auf 0 gesetzt.
Anzeigefunktion Uhr =========================
- Hierüber wird die Uhrzeit in der ersten Zeile im Format hh:mm:ss ausgegeben.
- Ähnlich zum Counter werden die zweistelligen Werte mit Division durch 10 und dessen Rest in zwei einzelne Ziffern gewandelt
Initialisierung Display-Anzeige =========================
- Die Funktion
initDisplay()
wird zu Beginn des Programms aufgerufen und führt zunächst die Initialisierung des Displays aus. - Danach wird der erste Text auf den Bildschirm geschrieben und damit der Programmname dargestellt.
- Nach zwei Sekunden wird der Auswahlbildschirm angezeigt.
Zaehlfunktion Uhr ===============================
- Die Zähl-Funktion
uhrZaehlen()
ist ganz ähnlich aufgebaut zur Interrupt-Service-Routine - Zunächst wird ein Schaltwechsel am Ausgang mit dem Lautsprecher ausgegeben, um einen Knackton zu erzeugen
- Dann werden die Sekunden hochgezählt
- ist das Maximum erreicht, so wird der Sekunden-Wert zurückgesetzt und der Minuten-Wert um eins hochgezählt.
- ebenso wird beim Maximum des Minuten-Serts dieser zurückgesetzt und der Stundenwert hochgezählt.
- beim Maximum des Stunden-Werts wird dieser wieder auf Null gesetzt
- IV. Ausführung in Simulide
-
- Geben Sie die oben dargestellten Codezeilen ein und kompilieren Sie den Code.
- Öffnen Sie Ihre hex-Datei in SimulIDE und testen Sie, ob diese die gleiche Ausgabe erzeugt
Bitte arbeiten Sie folgende Aufgaben durch:
- Aufgabe
-
- Die Anzeige am Display scheint nicht immer genau zum eingestellten Temperaturwert zu passen. Um dies zu verstehen, sollten Sie betrachten, welche Parameter in Simulide beim NTC eingestellt werden können. Weiterhin gibt es dazu Tipps unter dem Elektrotechnik 1-Kapitel: Temperaturabhängigkeit von Widerständen