A02|04 Der analoge Temperatur-Sensor
Analog Temperature Sensor
Sensorwerte / Temperatur messen
Temperatur-Sensoren gibt es in unterschiedlichen Technologien. Dieses Modul basiert auf dem Funktionsprinzip eines Thermistors: Thermistoren sind variable Widerstände, die ihren Widerstand mit der Temperatur verändern. Die Temperatur hat also einen direkten Einfluss auf den Stromfluss. Sie sind in zwei Ausführungen erhältlich:
Spezifikationen
- Signalart: analog
- Spannung: 5V
- Pinabstand: 2,54mm
- Temperaturbereich:
-55℃～315℃
NTC und PTC. Bei Thermistoren mit negativem Temperaturkoeffizienten (NTC) nimmt der Widerstand mit steigender Temperatur ab. Thermistoren mit positivem Temperaturkoeffizienten (PTC) verhalten sich genau umgekehrt: Der Widerstand steigt mit steigender Temperatur.
Der analoge Temperatur-Sensor ist ein relativ einfaches Bauteil und wird vielseitig eingesetzt. Beispielsweise werden sie in Thermostaten, Wetterstationen oder in Steuer- und Schutzschaltungen für Geräte eingesetzt. Sie haben den Vorteil, dass sie schnell auf Temperaturänderungen reagieren. Außerdem sind sie sehr günstig, robust und haben einen großen Arbeitsbereich von –55° bis +315°C.
Die Beziehung zwischen der Temperatur eines Thermistors und seinem Widerstand hängt stark von den Materialien ab, aus denen er zusammengesetzt ist. Er besteht aus Metalloxiden, Bindemitteln und Stabilisatoren, die zu Scheiben gepresst und dann auf Chipgröße geschnitten werden. Das genaue Verhältnis der Verbundwerkstoffe bestimmt das Temperatur-Verhalten. Die Hersteller kontrollieren dieses Verhältnis in der Regel sehr genau, da es die grundlegende Funktionsweise des Thermistors bestimmt.
Zwar ist der analoge Temperatur-Sensor kein komplexes Modul, aber eine genaue Temperatur-Angabe erfordert einige mathematische Berechnungen. Wie oben bereits gezeigt gibt es ein Problem mit dem Thermistor: Sein Verhalten ist nicht linear, sondern algorithmisch. Das heißt der Widerstand verhält sich mit steigender Temperatur nicht linear, sondern folgt einer Kurve. Zum Glück gibt es mathematische Formeln, die die Beziehung zwischen Widerstand und Temperatur beschreiben.
Der Sketch von Keyestudio für dieses Modul ist unbrauchbar und nicht kommentiert. Eine sehr gute Anleitung zu einem NTC Thermistor bietet Adafruit (in englischer Sprache). Folgende Inhalte und Berechnung sind an das Tutorial von Adafruit angelehnt. Bevor wir die Temperatur auslesen können, müssen den Prozess in vier Schritte teilen.
Schritt 1: Der Spannungsteiler
Um die Temperatur auszugeben ist es notwendig den Widerstand zu messen. Das Arduino hat aber keinen Widerstandsmesser. Dafür kann es mit seinem Analog-Digital-Wandler (ADC Analog-Digital-Converter) des Arduinos Spannungen einlesen. Durch ein paar grundlegende Gleichungen aus der Elektronik können wir dann mit der Spannung indirekt den Widerstand berechnen.
Hier zu brauchen wir einen Spannungsteiler. Spannungsteiler sind eine der grundlegendsten Schaltungen in der Elektronik. Es ist eine einfache Schaltung, die eine größere Spannung mithilfe von mehreren Widerständen in kleinere Spannungen zerteilt. Wozu soll das gut sein? Da wir alle Angaben im Spannungsteiler kennen, können wir die unbekannte Größe des Temperatur-Sensors in Beziehung setzen und seinen Wert ausrechnen.
U = Gesamtspannung in V
R1 = bekannter Teilwiderstand in Ohm
R2 = Gesamtwiderstand des Thermistors in Ohm
Das Keyestudio Modul hat einen integrierten Spannungsteiler mit zwei Widerständen: Es verwendet einen variablen Thermistor-Sensor mit einem maximalen Wert von 10.000Ohm und einem Widerstand mit einem festen Wert von 4700Ohm.
Mit folgender einfachen Formel werden in der Elektronik innerhalb eines Spannungsteilers Widerstand und Stromspannung in Beziehung gesetzt:
UT = Teilspannung in V
Spannung zwischen dem Thermistor und dem bekannten Widerstand
U = Gesamtspannung in V
Versorgungsspannung 5V
R1 = bekannter Teilwiderstand in Ohm
R2 = Gesamtwiderstand des Thermistors in Ohm
R1 + R2 Gesamtwiderstand in Ohm
Verwenden wir die obere Formel und machen ein Rechenbeispiel. Dazu nehmen wir an, dass der Thermistor-Widerstand die Hälfte seines Wertes erreicht hat: 5000Ohm. Diese Angaben reichen bereits, um die Spannung auszurechnen, die der Arduino an einem Analog-Digital-Wandler messen wird.
R2 hat einen Wert von 5000Ohm und R1 ist fest bei 4700Ohm. Die Arduino-Spannung ist fix bei 5V. Das Ergebnis von UT=2,57V sollte uns nicht überraschen. Da wir die Spannung von 5V teilen und beide Teiler fast identisch sind (4700:5000) erhalten wir fast die Hälfte von 5V - nämlich 2,5V.
Schritt 2: Der Analog-Digital-Wandler
Eines dürfen wir nicht vergessen: Das Arduino liest zwar mit einem ADC Spannungen ein, wandelt sie aber in digitale Werte um. Das Arduino wird beispielsweise keine Spannung in Form von 2,5V ausgeben. Mithilfe eines ADC-Port (Analog-Digital-Converter) werden elektrische Spannungen im Arduino in digitale Werte umgewandelt.
Ein ADC-Port wie z.B. A0 hat eine Auslösung von 10 Bit (2^10) - das ergibt eine Auflösung von 0 bis 1023 Schritten. Mit der Zahl 0 sind es insgesamt 1024 Schritte. Der ADC überträgt 0V bis 5V auf den Bereich von 0 bis 1023 digitalen Schritten. Dabei entspricht ein digitaler Schritt 4,9mV (5/1024=4,9mV). Wenn wir also 2,5V am ADC-Port messen erhalten wir den entsprechenden Wert von 512ADC (512*4,9mV=2508,8mV => 2,5V).
Der ADC-Wert kommt also zustande, in dem die gemessene Spannung (VA) mit der maximalen Auflösung (1024) multipliziert wird und das dann durch die Referenzspannung des Arduino (5V) geteilt wird. Das Ergebnis aus dieser Berechnung fließt später in die Formel für die Teilspannung ein, die wir bereits in Schritt #1 gesehen haben.
ADC = Analog-Digital-Converter
VREF = Referenzspannung
VA = gemessene analoge Spannung
Schritt 3: Der Kreis schließt sich: ADC + Spannungsteiler
Wir haben in Schritt #1 gesehen, dass wir mithilfe der Formel des Spannungsteilers die unbekannte Teilspannung, die durch den Thermistor hindurchfließt, berechnen können. In Schritt #2 haben wir die Formel für den ADC kennengelernt, der gemessene analoge Spannungen in eine entsprechenden digitalen Wert umwandelt. In Schritt #3 kombinieren wir diese beiden Formeln und setzen sie somit in Beziehung zueinander: Wir setzen die Spannungsteiler-Formel in die Formel für ADC ein.
Für unseren Sketch müssen wir den Aufbau und Beziehung des Spannungsteilers beschreiben. Dies erreichen wir in dem wir die Formel für die Teilspannung UT in die Formel für ADC einfügen. Dabei wird die gemessene Spannung VA durch UT ersetzt.
Unten ist eine Beispielrechnung für einen angenommenen Wert des Thermistors von 5000Ohm - also der Hälfte von 10000Ohm. Das Tolle an dieser Gleichung ist, dass sich die Spannungen wegkürzen lassen. Dies hat den Vorteil, dass man zur 3,3V Versorgungsspannung wechseln kann ohne die Formel ändern zu müssen.
Bei unseren bisherigen Berechnungen haben wir die Annahme getroffen, dass unser Thermistor einen fixen Widerstandswert von 5.000Ohm hat. Wir werden nun die Formel aus Schritt #3 so umformen, dass wir nach dem gesuchten Wert R2 (unbekannter Thermistor-Wert) umstellen. So können wir ihn später im Sketch einsetzen. Wie bereits erwähnt können wir die beiden Spannungen U und VREF kürzen.
Wir haben nun alle Schritte um die korrekte Spannung des Thermistor auszulesen. Als letzten Schritt #4 müssen wir der Spannung noch die entsprechende Temperatur zu weisen.
Der Aufbau
Bitte beachte, dass dieses Tutorial anders verkabelt ist, als im Keyestudio Wiki angegeben ist: Der Plus-Pol ist mit dem Minus-Pol vertauscht. Stecke die Schaltung wie unten angegeben zusammen:
Sketch: Der Wert des Thermistor
Der folgende Sketch nutzt die oben beschriebene Formel für R2 = R1 / (1024/ADC-1). Diese Formel wird über zwei Code-Zeilen berechnet. Am seriellen Monitor gibt er zum einen den analogen Wert zwischen 0 und 1023 aus und zum anderen den aktuellen Widerstandswert des Thermistors. Kopiere den unteren Sketch, füge ihn in die Arduino IDE ein und lade ihn auf das Arduino-Board rauf.
/*******************************************************
A02|04 Der analoge Temperatur-Sensor A
Sketch: Der Wert des Thermistor
Mr Robot UXSD
www.mrrobotuxsd.com
https://www.mrrobotuxsd.com/arduino-module-rezepte
Dieser Sketch basiert auf dem Beispiel von
Adafruit Learning System
https://learn.adafruit.com/thermistor/using-a-thermistor
*********************************************************/
#define resistor 4700 //der Wert des Festwiderstandes
#define thermistorPin A0 //Pin-Nummer des Sensors
void setup()
{
//Initialisiere die Serielle Kommunikation mit 9600 Bits pro Sekunde:
Serial.begin(9600);
}
void loop()
{
float reading;
reading = analogRead(thermistorPin); //lies den aktuellen Wert am Pin A0
Serial.print("Analoger Wert: ");
Serial.println(reading);
//Umrechnung des ADC-Wertes in ein Widerstandswert
reading = (1023 / reading) - 1; //(1023/ADC - 1)
reading = resistor / reading; //4700Ohm / (1023/ADC - 1)
Serial.print("Thermistor-Widerstandswert: ");
Serial.println(reading);
delay(1000); //Zeitverzögerung um Werte besser abzulesen
}Schalte den seriellen Monitor ein, indem du in der Arduino IDE in der Menüleiste auf Werkzeuge > Serieller Monitor gehst. Du solltest nun die folgende Anzeige sehen:
Gegentest mit einem Multimeter
Du kannst deine Werte folgenderweise überprüfen: Nimm aus dem Tiefkühlfach ein Stück Eis. Ich habe meine Würfeleis-Form genommen und es in einem Fach etwas mit Wasser aufgefüllt. Stecke den schwarzen Kopf des Thermistors in das Eiswasser, aber so das die blanken Drähte keinen Kontakt mit dem Wasser haben. Notiere dir den Wert, der auf dem seriellen Monitor angezeigt wird. Bei mir hat er den Wert von 30141Ohm ausgegeben.
Nun stecke alle Kabel vom Temperatur-Modul aus, halte den schwarzen Kopf wieder ins Eiswasser und messe mit einem Multimeter an den beiden Beinchen des Thermistors. Ich hatte einen Wert von ca. 30000Ohm. Das ist ein ziemlich genauer Wert, der nahe an der Arduino-Messung liegt.
Das Messergebnis glätten und präzisieren
Das Arduino ist zwar ein leistungsstarker Mikrocontroller, es ist aber nicht vergleichbar mit Profi-Geräten. Als Low-Budget Mikrocontroller unterliegt das Arduino gewissen Toleranzen. Messergebnisse sind zum Teil verrauscht. Du kannst zwei Tricks einsetzen, um analoge Messungen zu glätten und zu präzisieren.
Der erste besteht darin statt die 5Volt-Referenz des Arduinos, die 3,3Volt einzusetzen - es ist nur ein Verkabelungstrick. Die 5V-Spannungsversorgung des Arduinos kommt direkt vom USB-Anschluss des Computers. Mit dieser Spannungsleitung werden jede Menge Prozesse im Arduino erledigt und zwangsläufig kann es zu Schwankungen und Rauschen führen. Deutlich stabiler läuft die 3,3V-Spannungsleitung, da dieser weniger involviert ist und eine eigene Filter- und Regelstufe durchläuft. Du musst lediglich den 3,3V-Pin zusätzlich an den AREF-Pin anschließen und diese Spannung als Versorgungsspannung für das analoge Temperatur-Modul verwenden. Hierzu müssen wir nicht mal unsere Formel umstellen. Du wirst dich erinnern, dass die Spannung heraus gekürzt wurde. Verkabele die Schaltung wie in der unteren Abbildung. Falls du keine Jumper Wire mit Verzweigung hast, wirst du ein Breadboard brauchen, um die beiden Kabeln miteinander zu verbinden, die zum 3,3V-Pin führen.
Der zweite Trick glättet das Ergebnis, in dem eine Reihe von Messwerten hintereinander erfasst werden und daraus der Mittelwert gebildet wird. Der untere Sketch-Ausschnitt macht 5 Messungen in sehr kurzen Zeitabständen, addiert sie zusammen und teilt ihre Summe durch die Anzahl der Messungen. Das Ergebnis stellt ein Mittelwert dar und glättet damit Schwankungen. Je mehr Messungen du machst, um so mehr ruhiger und glatter wird das Ergebnis. Bedenke aber, dass dadurch die Messung länger dauert und eventuell das Ergebnis zur realen Temperaturveränderung zeitverzögert sein kann.
// Mache 5 Messungen in Folge mit kleinen Pausen dazwischen
for (i=0; i< 5; i++) {
samples[i] = analogRead(THERMISTORPIN);
delay(10);
}
//addiere alle 5 Messungen
average = 0;
for (i=0; i< 5; i++) {
average += samples[i];
}
//berechne den Mittelwert aus => glätten
average /= NUMSAMPLES;
}Sketch: Den Wert des Thermistor glätten und präzisieren
Dieser Sketch enthält die zwei bereits vorgestellten Verbesserungen. Kopiere den unteren Sketch, füge ihn in die Arduino IDE ein und lade ihn auf das Arduino-Board rauf.
/********************************************************
A02|04 Der analoge Temperatur-Sensor B
Sketch: Den Wert des Thermistor glätten und präzisieren
Mr Robot UXSD
www.mrrobotuxsd.com
https://www.mrrobotuxsd.com/arduino-module-rezepte
Dieser Sketch basiert auf dem Beispiel von Adafruit
Learning System
https://learn.adafruit.com/thermistor/using-a-thermistor
*********************************************************/
#define thermistorPin A0 //Pin-Nummer des Thermistor-Sensors
//Anzahl an Messungen: wie viele Proben genommen und gemittelt werden sollen
//je höher die Anzahl um so länger dauert es. Ergebnis ist aber geglättet.
#define numSamples 5
#define seriesResistor 4700 //der Wert des Fix-Widerstands
int samples[numSamples];
void setup()
{
Serial.begin(9600);
//AREF an 3,3V anschließen und als VCC verwenden, weniger Rauschen!
analogReference(EXTERNAL);
}
void loop()
{
uint8_t i;
float average;
//5 Proben nacheinander nehmen, mit einer leichten Verzögerung
for (i=0; i< numSamples; i++)
{
samples[i] = analogRead(thermistorPin);
delay(10);
}
//Durchschnitt aller Stichproben
average = 0;
for (i=0; i< numSamples; i++)
{
average += samples[i];
}
average /= numSamples;
Serial.print("Durchschnittlicher analoger Messwert ");
Serial.println(average);
//Umrechnung des ADC-Wertes in den Widerstandswert
average = 1023 / average - 1;
average = seriesResistor / average;
Serial.print("Thermistor Widerstand ");
Serial.println(average);
delay(1000);
}Schritt 4: Die Steinhart-Formel
Fast geschafft. Dies ist der vierte und letzte Schritt. Anfangs erwähnte ich das Problem, dass sich der Thermistor logarithmisch verhält. Bei linearem Verhalten hätten wir einem ADC-Wert ganz einfach einen Temperaturwert zuordnen können. Das Temperaturverhalten eines Thermistors kann mit der Steinhart-Gleichung bestimmt werden. Jedoch ist diese Gleichung ziemlich komplex und erfordert detaillierte Kennzahlen aus dem Datenblatt des Thermistors, die wir nicht haben. Es gibt jedoch eine vereinfachte B-Parameter-Gleichung, die mit weniger Variablen auskommt, dafür aber etwas weniger präzise Resultate liefert.
Folgende Variablen werden benötigt: Die Raumtemperatur To (25C°), den Koeffizient des Thermistors B (in unserem Fall 3300) und den Widerstand bei Raumtemperatur Ro (in unserem Fall 10kOhm). Den Thermistor-Widerstand R haben wir bereits im “Sketch: Den Wert des Thermistor glätten und präzisieren” berechnet und fügen ihn an dieser Stelle ein. Eine letzte Sache noch: Die Steinhart-Gleichung spuckt Fahrenheit als Einheit aus. Das heißt wir müssen zum Schluss Fahrenheit in Grad Celsius umwandeln.
/********************************************************
A02|04 Der analoge Temperatur-Sensor C
Die Steinhart-Formel
Mr Robot UXSD / www.mrrobotuxsd.com
/*Dieser Sketch basiert auf dem Beispiel von Adafruit Learning System
https://learn.adafruit.com/thermistor/using-a-thermistor
*********************************************************/
#define ThermistorPin A0 //Pin-Nummer des Sensors
#define ThermistorNominal 10000 //Widerstand bei 25 Grad Celsius
#define TemperatureNominal 25 //Temp. für Nennwiderstand (fast immer 25C)
//Anzahl an Messungen: wie viele Proben genommen und gemittelt werden sollen
//je höher die Anzahl um so länger dauert es. Ergebnis ist aber geglättet:
#define numSamples 5
//Der Beta-Koeffizient des Thermistors (normalerweise 3000-4000)
#define BCoefficient 3500
//der Wert des "anderen" Widerstands
#define seriesResistor 4700
int samples[numSamples];
void setup()
{
//Initialisiere die Serielle Kommunikation mit 9600 Bits pro Sekunde:
Serial.begin(9600);
analogReference(EXTERNAL);
}
void loop()
{
uint8_t i;
float average;
//5 Proben nacheinander nehmen, mit einer leichten Verzögerung
for (i=0; i< numSamples; i++)
{
samples[i] = analogRead(ThermistorPin);
delay(10);
}
//Durchschnitt aller Stichproben
average = 0;
for (i=0; i< numSamples; i++)
{
average += samples[i];
}
average /= numSamples;
Serial.print("Durchschnittlicher analoger Messwert ");
Serial.println(average);
//Umrechnung des ADC-Wertes in den Widerstandswert
average = 1023 / average - 1;
average = seriesResistor / average;
Serial.print("Thermistor Widerstand ");
Serial.println(average);
float steinhart;
steinhart = average / ThermistorNominal; // (R/Ro)
steinhart = log(steinhart); // ln(R/Ro)
steinhart /= BCoefficient; // 1/B * ln(R/Ro)
steinhart += 1.0 / (TemperatureNominal + 273.15); // + (1/To)
steinhart = 1.0 / steinhart; //Umrechnen
steinhart -= 273.15; //Temperatur in C umrechnen
Serial.print("Temperatur ");
Serial.print(steinhart);
Serial.println(" *C");
delay(1000);
}
Falls du die hier beschriebenen Elektronik-Module nicht hast, kannst du sie in meiner Einkaufsliste finden. Warum ich selber hauptsächlich mit Modulen der Marke Keyestudio arbeite, erläutere ich unter diesem Blog-Artikel.