Drucken
Hauptkategorie: Raspberry Pi

Nach langem Suchen bin ich nie auf eine wirkliche Lösung gekommen. Aber nach dem ich mit Pollux2, aus dem Forum hier (falls eine forbidden Website erscheint, drückt noch einmal F5 um die Seite zu aktualisieren oder kopiert den Link in einen neuen Tab) ein wenig Konversation geführt hatte, habe ich die Lösung der Berechnung etc gelöst. Da solche Dinge immer mit der Community leben und sterben, möchte ich euch dies vorstellen.

Der Grundgedanke war und ist, wie messe ich Temperaturen mit der Standardfirmware des AVR-NET-IO?

Ihr könnt übrigens jeden anderen KTY81/XXX ebenso verwenden, aber ihr müsst dann die Berechnungen selbst erstellen, falls das nicht schon jemand für euch vorgenommen hat. Auch werde ich von Auflösung, Liniearisierung, URI und den Spannungsteiler schreiben. Aber dies sollte euch nicht davon abhalten, es einmal selbst zu versuchen. Ich werde die Themen entsprechend ausschmücken.

Für mich ist es der Versuch, ein kleines kostengünstiges IoT Projekt zu realisieren.

Als Voraussetzungen, sollten allerdings trotzdem einige Dinge schon stehen. Zum einen ein aufgebautes AVR-Net-IO. Zum anderen, aber das ist keine Pflicht, die zusätzlichen Schutzkondensatoren. Diese helfen euch das AVR-Net-IO am Leben zu halten. Denn im Grundaufbau ist es nicht besonders gut damit ausgestattet und so kann es vorkommen, dass selbst die geflashte Firmware verloren geht. Ist mir passiert und ohne AVR Programmer habt ihr eher schlechte Karten.

Die ersten Hinweise zu den zusätzlich zu verlötenden Kondensatoren findet ihr bei Ethersex. Die anderen Kondensatoren findet ihr dann bei Schorsch.at. Leider musste ich gerade feststellen, dass bei Schorsch das Bild mit den Umrandungen fehlt. Deswegen liefere ich es hier noch einmal nach. Und alle Kondensatoren sind immer 100nF groß. Natürlich können die Kondensatoren von Schorsch und Ethersex auch doppelt sein. Ihr müsst aber immer nur einen verlöten.

Grundgedanken zum Temperaturfühler

Ich habe mich für den KTY81/110 entschieden. Er ist der genauere Typ und hat die geringere Fehlerrate als andere Typen des KTY81. Im Schnitt müssen wir trotzdem mit einem Fehler von ungefähr 1,5K bis 2K rechnen. Das K steht für Kelvin und ist dabei mit °C gleich zusetzen. Wer es möchte kann den KTY81 auch eichen. Das werden wir dann später sehen, dann ist der Fehler geringer, aber sollte immer noch vorhanden sein. Der Grund ist die Auflösung des AVR-Net-IO, wenn es um die Umwandlung der Analogen Spannung in digitale Bits geht.

Wer die Anleitung von Pollin gelesen hat, der hat sicherlich riesige Fragezeichen im Gesicht. Gerade der Abschnitt, bei der es um die Übersetzung des ADC hin zu °C geht, ist fehlerhaft. Denn das kann eigentlich nicht funktionieren. Und so ist auch in der Beschreibung ein Fragezeichen in der Formel.

Das kann nicht funktionieren. Richtig ist aber die Angabe, dass die Auflösung des ADC bei 0,0048828V liegt. Das sind also 4,88mV (Millivolt). Wir werden bei späteren Berechnungen trotzdem mit 0,0048828V rechnen. Die Referenzspannung des AVR-Net-IO liegt bei 5Volt. Wir haben einen 10Bit ADC, was in Zahlen für uns bedeutet, dass wir 1024 verschiedene Zustände anzeigen können. Um diese Auflösung zu berechnen, müssen wir also 5Volt durch 1024 teilen. Das ergibt dann die 0,0048828Volt pro Bit. Der 10Bit ADC bedeutet nichts anderes als 20 + 21 + 22 + 23 + 24 + 25 + 26 +27 +28 +29. Was übersetzt bedeutet 20 ist 1, 21 ist 2, 22 ist 4, 23 ist 8 usw. Das müssen wir am Ende addieren und erhalten daraus 1023 und da dieser Wert 0 basiert ist, sagen wir 1024, weil wir immer bei 1 anfangen und nicht bei 0.

Auflösung des KTY/110

Diese Auflösung kann man berechnen. Dazu benötigen wir das Datenblatt, Excel und URI. Keine Angst URI ist die Umrechnung von Spannung, Strom und Widerstand. Wenn wir eine Spannung durch einen Widerstand leiten, dann haben wir genau diesen, einen Widerstand. Damit wir diesen Widerstand überwinden können, wird immer eine gewisse Stromstärke benötigt. Das muss man sich in etwa so vorstellen. Du möchtest 100 Liter Wasser eine Rinne entlang fließen lassen. Die Menge des Wassers ist die Spannung. In der Rinne liegen eine Menge Steine und versperren den Weg. Die Steine sind der Widerstand, den das Wasser überwinden muss. Die Stromstärke ist die Neigung der Rinne. Wenn die Rinne also eben liegt, dann fließt das Wasser auch nicht ab. Stellt man die Rinne steiler, dann kann das Wasser fließen, weil es von oben nach unten läuft und so den Widerstand der Steine bricht. Und dies wurde in einem physikalischem Gesetz festgehalten, welches sagt:

Spannung U = Widerstand R * Stromstärke I

Wenn wir den Temperatursensor nur an 5V und dem ADC Eingang selbst anschließen, dann messen wir immer ca. 5V am Eingang.

Die verwendeten Formeln sind folgende. Die Temperatur und Ohmzahlen sind aus dem Datenblatt. Den Strom rechnet man mit den 5Volt. Also bei -30°C... sind das 5V / 624 Ohm = 0,00801 Ampere. In eine normale Form gebracht sind das 5/624 = 0,00801. Die Spannung rechnet man dann wieder rückwärts. Also 0,00801 * 624 = 5.

Temperatur Ohm Strom Ampere U an KTY81
-30 624 0,00801 5,00000
-20 684 0,00731 5,00000
-10 747 0,00669 5,00000
0 815 0,00613 5,00000
10 886 0,00564 5,00000
20 961 0,00520 5,00000
25 1000 0,00500 5,00000
30 1040 0,00481 5,00000
40 1122 0,00446 5,00000
50 1209 0,00414 5,00000
60 1299 0,00385 5,00000
70 1392 0,00359 5,00000
80 1490 0,00336 5,00000
90 1591 0,00314 5,00000
100 1696 0,00295 5,00000
110 1805 0,00277 5,00000
120 1915 0,00261 5,00000

Damit lassen sich aber keine Temperaturen berechnen. Es ändert sich nur der Strom, aber nicht die Spannung. Und beim ADC wird nur die Spannung gemessen. Zu dem sind die Ströme am ADC ziemlich hoch, was für den Prozessor nicht unbedingt zu empfehlen ist.

Wir sehen hier eine Kurve, die aber nicht gemessen wird, sondern am ADC in Wärme ungewandelt und somit nur negativ für unseren Messaufbau ist. Wir bräuchten idealerweise einen Strom der in etwa so verläuft wie die Spannung im oberen Diagramm. Auch hier kann uns die Physik weiterhelfen. Und diese sagt: Der Strom durch, in Reihe geschaltete Widerstände, ist vom Widerstand des anderen und damit von dessen Größe abhängig. Bei hohen Widerständen ist der Strom etwas kleiner… Und das nutzen wir aus. Wenn der KTY etwas wärmer ist, dann fließt weniger Strom und umgekehrt. Dadurch ist der Spannungsabfall am in Reihe geschalteten Widerstand auch unterschiedlich, dies führt zu einer mehr oder weniger linearen Temperaturkurve.

Wir nehmen also einen 2,7 Kiloohm großen Widerstand und schalten diesen in Reihe zum Temperatursensor. Messen werden wir aber nur den Spannungsabfall am KTY81.

Nehmen wir nun wieder URI so gibt es eine Gesetzmäßigkeit, die uns hilft. Die Stromstärke am 2,7 Kiloohm Widerstand und dem Temperatursensor sind immer gleich. Das berechnet man, indem man 2700 Ohm + Ohm am Temperatursensor addiert. Nun kann man 5 Volt geteilt durch 2700 + Ohm am Sensor ist gleich Stromstärke in Ampere berechnen. Also bei 20°C bedeutet dies die Stromstärke in Ampere von: 5 / (2700 + 961) = 0,00136575. Die beiden Widerstände muss man vorher addieren, denn es gilt Punkt- vor Strichrechnung, deswegen stehen diese beiden Werte in Klammern. Wenn wir dies in Excel einmal wie vorher eingeben sehen wir das.

Temperatur Ohm Ohm Spannungsteiler Strom mA U an KTY81
-30 624 2700 1,50421 0,93863
-20 684 2700 1,47754 1,01064
-10 747 2700 1,45054 1,08355
0 815 2700 1,42248 1,15932
10 886 2700 1,39431 1,23536
20 961 2700 1,36575 1,31248
25 1000 2700 1,35135 1,35135
30 1040 2700 1,33690 1,39037
40 1122 2700 1,30822 1,46782
50 1209 2700 1,27910 1,54643
60 1299 2700 1,25031 1,62416
70 1392 2700 1,22190 1,70088
80 1490 2700 1,19332 1,77804
90 1591 2700 1,16523 1,85388
100 1696 2700 1,13740 1,92903
110 1805 2700 1,10988 2,00333
120 1915 2700 1,08342 2,07476

Ein Diagramm von Spannung und Temperatur ergibt dann dies.

Die Kurve? ist wirklich schön gerade. Dazu muss man allerdings den 25°C Bereich einmal ausblenden. Denn die Stufen sind, bis auf diesen Bereich, in 10°C Schritten angegeben. Ansonsten sieht die Kurve eher so aus.

Zurück zur Auflösung des KTY81/110. Die Auflösung lässt sich dann so berechnen. Man nehme die Spannung bei 120°C und subtrahiere die Spannung bei -30°C, dieses Ergebniss teilt man durch das Delta der Temperatur. Dies sind bei uns 150K (-30 bis 120). Also (2,07476 - 0,93863) / 150 = 0,0075742... siehe Tabelle oben.

Dies bedeutet, dass wir eine Auflösung von ca. 7,6mV pro Kelvin(°C) haben oder in Volt ausgedrück 0,0075742 Volt pro Kelvin.

Berechnung der Temperatur aus den Ergebnissen

In der Firmware des Pollin erhalten wir immer mit dem Befehl GETADC einen Dezimalwert der Spannung. Dieser entspricht der oben schon einmal besprochenen Auflösung des ADC. Diesen Wert kann man auch einfach wieder in die tatsächlich gemessene Spannung umrechnen. Dazu muss man lediglich den Wert von GETADC mit der Auflösung des ADC multiplizieren. Also z.B. 280 * 0,0048828 = 1,367184. Das Ergebniss ist die Spannung in Volt.

Die Temperatur lässt sich aber nun ebenfalls mathematisch herleiten.

Der kleinste Wert im Datenblatt des Sensors, der noch einen Sinn ergibt, lässt sich bei 0°C ablesen. Idealerweise kühlen wir den Sensor auf 0°C herunter und messen den tatsächlichen Spannungsabfall und merken uns diesen als Konstante. Diese Konstante ist nur für diesen Sensor konstant, andere Sensoren, auch wenn diese gleich heißen, haben andere Werte. So haben wir, wenn wir dies einmal getan haben, den Sensor geeicht oder wie man auch sagt kalibriert.

Die Formel wie man nun die tatsächliche Temperatur misst ist. (Aktueller Dezimalwert - Dezimalwert bei 0°C) * Auflösung ADC / Auflösung Sensor. Wir können dies auch einmal im Taschenrechner nachvollziehen. So haben wir eine Temeratur von 25°C. Also nehmen wir uns die folgenden Werte vor. (277 - 237) * 0,0048828 / 0,0075742.

C# Code zur Berechnung der Temperatur

Die Klasse ist schnell geschrieben und hilft einem bei seinen Projekten immer die Temperatur leicht zu berechnen.

    public class Kty81
    {
        /// <summary>
        /// Der ADC Wert bei 0°C als Dezimalzahl
        /// </summary>
        public double AdcZero = 237;

        /// <summary>
        /// Die Auflösung des ADC in Volt
        /// </summary>
        public double ResAdc = 0.0048828f;
        
        /// <summary>
        /// Die Auflösung des Temperatursensors in Volt
        /// </summary>
        public double ResKty = 0.0075742f;
        
        /// <summary>
        /// Konstruktor mit ADC Wert bei 0°C und Auflösung des ADC
        /// </summary>
        /// <param name="AdcZero"></param>
        /// <param name="ResAdc"></param>
        public Kty81(double AdcZero, double ResAdc)
        {
            this.AdcZero = AdcZero;
            this.ResAdc = ResAdc;
        }
        
        /// <summary>
        /// Konstruktor mit ADC Wert bei 0°C
        /// </summary>
        /// <param name="AdcZero"></param>
        public Kty81(double AdcZero)
        {
            this.AdcZero = AdcZero;
        }
        
        /// <summary>
        /// Normaler Konstruktor
        /// </summary>
        public Kty81() { }

        /// <summary>
        /// Berechnet die Temperatur in °C 
        /// </summary>
        /// <param name="AdcCurrentValue">Der ADC Wert</param>
        /// <returns>Die Temperatur in °C</returns>
        public double GetTemperature(double AdcCurrentValue)
        {
            return Math.Round((AdcCurrentValue - AdcZero) * ResAdc / ResKty, 2);
        }
    }

 

 Diese Klasse kann man nun, wenn man seine Defaultwerte ganz oben richtig setzt, sehr leicht einsetzen.

        public string GetADC1Temperature(double AdcValue)
        {
            var kty = new Kty81();
            return kty.GetTemperature(AdcValue).ToString() + "°C";
        }

 

soweit...