In dem Versuch werden wir ein Thermometer bauen, das gleich drei Aufgaben erfüllen muss. Seine
Hauptaufgabe besteht natürlich vor allem darin, die Temperatur zu messen und sie anzuzeigen. Des weiterem soll es möglich
sein, die gemessenen
Temperaturwerte zu speichern, um sie zu späterem Zeitpunkt abzurufen und auszuwerten. Seine letzte Aufgabe soll darin
bestehen, den aktuellen Temperaturwert in Form eines äquivalenten analogen Signals für diverse Steuerungszwecke zur
Verfügung zu stellen.
Die Hauptkomponenten der Schaltung:
Die meiste Arbeit wird von Arduino Uno erledigt. Der Mikrocontroller muss sich gleichzeitig um die Werte
des Temperatursensors kümmern, die Umrechnung, die Ausgabe auf der 7-Segmentanzeige, Datenspeicherung und schließlich
um den analogen Ausgang.
Die Temperaturwerte werden auf einer SD-Speicherkarte festgehalten. Diese Aufgabe übernimmt in der Schaltung
ein SD Card Shield. In dem Arduino-Programm (Sketch) müssen wir lediglich bestimmen, welche Daten und zu welchem
Zeitpunkt gespeichert werden sollen.
Das Anzeigen der aktuellen Temperatur übernimmt eine 7-Segmentanzeige, der der Anzeigetreiber TM1637
vorgeschaltet wurde. Der Treiber und die Anzeige zusammen mit einigen elektronischen Komponenten bilden ein Modul,
das von Arduino gesteuert wird.
L78L12. Ein Spannungsregler ist in dieser Schaltung nicht zwingend notwendig. Der Bauteil soll hier lediglich
dafür sorgen, dass bei falscher Einstellung der Versorgungsspannung am Netzteil Arduino & Co. nicht gleich kaputt gehen.
Grundsätzlich wäre eine Spannungsversorgung von 12VDC ausreichend.
Die integrierte Schaltung LM358 besteht aus zwei unabhängig arbeitenden Operationsverstärkern. Der Bauteil
verfügt über acht Anschlüsse. Zwei von ihnen (Pin 4: V-, Pin 8: V+) sind für Spannungsversorgung vorgesehen. Die Pins
1,2,3 beziehen sich auf den ersten, die Pins 5,6,7 auf den zweiten Operationsverstärker. Jeder Operationsverstärker hat
zwei Eingänge und einen Ausgang.
Pinbelegung
Der LM358 wird oft als Signalverstärker verwendet. Der Baustein kann allerdings durch entsprechende
externe Verschaltung für viele andere Aufgaben eingesetzt werden. Er kann als Komparator fungieren, Signalwandler,
Impedanzwandler oder Oszillator. LM358P ist ähnlich wie NE555 sehr populär und vielen Schaltung vorzufinden. Er kann
in einem Spannungsbereich von 3 bis 30 V arbeiten.
Der Schaltplan
Der Schaltplan
Die Testschaltung
Die Testschaltung kann man schnell auf einem Steckbrett aufbauen. In diesem Fall werden die Bauteile auf
einem Prototyp-Shield zusammengelötet. Solche leere Shields für Arduino kann man günstig in diversen Ausführungen im
Handel erwerben. Der Vorteil dieser Lösung ist die Wiederverwendbarkeit der Schaltung.
Arduino Shield unbestückt
Shield bestückt
Komplette Testschaltung mit allen Komponenten.
Das Programm (Sketch)
// *******************************************************************************************
// Temperaturmessung mit NTC
// Speicherung der Messwerte
// Analoges Signal 0-10V
// Arduino UNO, IDE 1.8.16
// *******************************************************************************************
#include<TM1637Display.h> // Anzeige Bibliothek
#include<SPI.h> // SPI Bibliothek
#include<SD.h> // SD Bibliothek
#define CLK 6 // Pin 6 Anzeige
#define DIO 7 // Pin 7 Anzeige
TM1637Display display(CLK, DIO);
int chipSelect = 4;
int R = 9980; // Spannungsteiler, fester Widerstand
float Rn = 10110; // Widerstand gemessen in Ohm bei Tn
float Tn = 23; // Bezugstemperatur (Rn)
float B = 3398; // Thermistorkonstante B (errechnet)
int Taster_Start = 8; // Datenaufzeichnug start
int PWM_Ausgang = 9;
int Anzeige_LED = 10; // Pin 8, Status LED
int Zaehler; // Nummer der aktuellen Messungen
void setup() {
display.setBrightness(10); // Display Helligkeit
display.clear();
pinMode (Taster_Start, INPUT_PULLUP);
pinMode (Anzeige_LED, OUTPUT);
Zaehler = -1; // Startwert für Messungen
if (!SD.begin(chipSelect)) { // SD-Karte initialisieren
digitalWrite (Anzeige_LED, HIGH); // LED An (nach der Einschaltung) = Karten-Fehler
while (1);
}
digitalWrite (Anzeige_LED, LOW); // LED Aus (nach der Einschaltung) = Karte OK
}
void loop() { // Ablaufprogramm
float Analog_Wert = (float)analogRead (A0); // analogen Wert A0 auslesen
float U_ntc = (5.0 * Analog_Wert) / 1023; // Start der Temperatur-Berechnung
float R_ntc = (U_ntc * Rn) / (5.0 - U_ntc);
float A1 = log(R_ntc / Rn) / B;
float A2 = A1 + 1 / (Tn + 273.15);
float T = (1 / A2) - 273.15; // T = Berechnete Temperatur in °C
display.showNumberDecEx(T, 0b00000000, false, 4, 4); // Anzeige der Temperatur auf der 7-Segmentanzeige
// PWM Ausgabe
float PWM_Wert = T * 255 / 100; // Bezogen auf Bereich 0 bis 100°C
byte PWM_Ausgabewert = byte(PWM_Wert); // Vorbereitung der Ausgabe
analogWrite(PWM_Ausgang, PWM_Ausgabewert); // PWM Signal über PIN 9 ausgeben
if (digitalRead (Taster_Start) == LOW) { // Daten-Aufzeichnung starten
digitalWrite (Anzeige_LED, HIGH); // LED an während der Aufzeichnug
} // LED aus = Aufzeichnung abgeschlossen
if (digitalRead (Anzeige_LED) == HIGH) { // Aufzeichnung läuft
Zaehler++; // Nummer der Aufzeichnung inkrementieren
String Temperatur_Daten = ""; // Datensatz vorbereiten
Temperatur_Daten += String(Zaehler); // Messung Nummer
Temperatur_Daten += ","; // Komma
Temperatur_Daten += String(T); // Temperatur
File dataFile = SD.open("datalog.txt", FILE_WRITE); // Daten auf Speicherkarte schreiben
if (dataFile) {
dataFile.println(Temperatur_Daten); // Daten schreiben
dataFile.close();
}
if (Zaehler > 498) { // Maximal 500 Datensätze
Zaehler = -1; // Zähler zurücksetzen
digitalWrite (Anzeige_LED, LOW); // Speicherung abgeschlossen, LED aus
}
}
delay(1000); // Messung und Speicherung 1 mal pro Sekunde
}
// *******************************************************************************************
Kalibrierung
Nachdem die Schaltung zusammengestellt und das Programm geladen wurde, kann die Schaltung kalibriert werden.
Dazu wird ein externes Thermometer benötigt, das uns die Bezugstemperatur liefert. Der Abgleich wird mit dem Potenziometer
R1 durchgeführt. Er ist so einzustellen, dass beide Thermometer gleiche Temperaturwerte anzeigen. In diesem Fall liegt der
Wert des Potenziometers bei ca. 11,8 kOhm. Damit ist unsere Thermometer-Schaltung zum ersten Test bereit. Das Thermometer
wird jetzt bei diversen Temperaturen geprüft. Gleichzeitig wird bei jeder Messung die Spannung am analogen Ausgang
gemessen.
Der erste Test
Für den ersten Test kann z.B. ein Kochtopf mit Wasser verwendet werden. Mal mit Eiswürfeln, mal mit
Tauchsieb wird die Wassertemperatur verändert und mit beiden Thermometern gemessen. Bei diesem Test zeigte sich, dass
unser selbst gemachtes Thermometer ziemlich genau das anzeigt, was das externe Thermometer „vorschreibt“. Bei dem
analogen Signal gab es Abweichungen, die bei 0,1V lagen. Die Ergebnisse:
Temperaturdiagramm.
Auf der Grafik kann man sehen, dass die mit unserem Thermometer gemessenen Temperaturwerte mit denen des
externen Thermometers (Achse X) übereinstimmen. Auch der Verlauf der Spannungslinie ist zufriedenstellend und verspricht
gute Ergebnisse bei folgenden Versuchen. Das Thermometer werden wir bei weiteren Experimenten mit Frequenzumrichtern oder
SPS verwenden.
Funktionalität
Nach Anlegen der Versorgungsspannung beginnt das Thermometer sofort mit der Temperaturmessung. Am Arduino
Pin 5V ist der R1-R2-Spannungsteiler angeschlossen. R2 steht für die NTC-Messsonde. Bei Temperaturänderung ändert sich
sein Widerstand und folglich auch die Spannung, die am analogen Eingang A0 ausgelesen wird. Anhand dieses Wertes berechnet
Arduino die aktuelle Temperatur und zeigt sie auf dem Display an. Entsprechend der Temperatur wird am Pin
9 des Arduino ein PWM-Signal generiert. Mithilfe des Widerstandes R3 und des Kondensators C1 wird das Signal geglättet
und steht an
Verbindungsstelle der beiden Komponenten als analoges Signal zur Verfügung. In der Form kann das Signal maximal 5V
erreichen.
An dieser Stelle kommt der Operationsverstärker LM358P zum Einsatz. Das Signal wird mit einem Verstärkungsfaktor von 2
verdoppelt. Die Verstärkung wird mit den Widerständen R5 und R6 eingestellt.
Mit dem Taster S1 wird die Speicherung der Daten gestartet. In dem Beispiel werden 500 Werte abgespeichert. Es
erfolgt eine Speicherung pro Sekunde.
