Probleme mit Temperaturmessung

Ich stehe voll auf dem Schlauch!!!

Gibt es in diesem Forum jemand der Erfahrungen mit diesen Sensoren
gesammelt hat?

R25 ist der Innenwiderstand des Sensors bei 25 Grad Celsius
Raumtemperatur.
Und wenn du Glück hast, erwischt du einen, der genau 2kOhm hat.
Aber mit einer Abweichung vom +- 1% ist zu rechnen, d.h. der nächste
Sensor kann dann 2020Ohm haben.
Und da dieser Sensor eine nichtlineare Kennlinie hat, musst du schon
die im Datenblatt angegebenen Formeln bemühen,
oder du nimmst im 1 Grad Abstand die Kennlinie auf und zeigst dann
jeweils den nächsten zum Messergebnis passenden Wert an und berechnest
nur noch die Nachkommastellen aus den Tabellenwerten.

Mit Korrekturtabelle arbeiten übrigens auch die billigen
Temperatumessmodule von Conrad.

Gruss
Jadeclaw.

Warum nimmst Du nicht einfach einen Pt100 ofer Pt1000?
Die haben eine fast lineare Kennlinie.

Außerdem glaube ich, dass der AVR mit der Berechnung der Formeln
für Deinen Sensor überfordert sein wird.
z. B. bei Flieskommaberechnungen.

Gruß Hofer

Ja sicher. Vielleicht wäre ein anderer Sensor viel besser.Aber ich
habe nunmal nur diesen da. Den Sensor habe ich an einem Siemens
Controller 80C535 angehängt. Da hat alles toll funktioniert. Nur beim
ATMEGA8535 klappt es nocht so. Die Temperatur ist bei mir immer um 3
bis 4 Grad höher.

Mit deltaTa meint das Datenblatt die Temperatur-25° also abzüglich der
Referenztemperatur. Wenn du das in die Formel einsetzt, kannst du die
Werte errechnen, die auch in der Tabelle stehen.
Zur Schaltung schlage ich dir mal diese Schaltung vor:
           VCC
            +
            |
            |
           .-.
           | |
           | | 1000 Ohm
           '-'
            |
            o----------o AD-Wandler
            |
           .-.
           | | 840 Ohm
           | |
           '-'
            |
            |
           .-.
           | |
           | | KTY 16
           '-'
            |
            |
           ===
           GND
(created by AACircuit v1.28 beta 10/06/04 www.tech-chat.de)

Die Spannung am AD-Wandler ändert sich jetzt ziemlich linear mit der
Temperatur, bei einem 10-Bit Wandler erhältst du eine Auflösung von 1°.
Bei 0° liefert der Wandler den Wert 638, wenn du den von deinen
Messwerten abziehst, hast du direkt die Temperatur in °C.
Achtung, das ist theoretisch mit den Formeln und einer
Tabellenkalkulation ermittelt, nicht erprobt. Gerade der Nullpunkt,
also die 638, hängen deutlich von den anderen Widerständen und
natürlich vom genauen Wert des KTY ab. Aber diesen Wert kann man ja mit
Eiswasser oder einem Vergleichsthermometer leicht ermitteln.

Deutlich höhere Auflösung erhältst du übrigens nur mit einem
Messverstärker.
Uwe

@Hofer:
"Außerdem glaube ich, dass der AVR mit der Berechnung der Formeln
für Deinen Sensor überfordert sein wird.
z. B. bei Flieskommaberechnungen."

Das könnte sein, wenn der AVR sonst schon am Limit werkelt. Ist doch
pille palle, wie lange dauert eine float-Rechnung, und wie oft muss
eine Temperaturanzeige aktualisiert werden? 1/s ist schon viel, die
Zeit der heftig flackernden Anzeigen sollte doch vorbei sein.
Ansonsten kommt man fast immer mit Ganzzahl-Arithmetik zurecht, float
setze ich so gut wie nie ein.
Eine Temperaturanzeige mit 2 Stellen hinter dem Komma ist im täglichen
Leben sowieso entbehrlich/überflüssig/störend (0,5° Auflösung sind mehr
als genug), und mit einem Sensor wie dem KTY sowieso nur
Augenwischerei.
Je nach Dimensionierung und Gesamtmessbereich kommt man sogar gänzlich
ohne Linearisierung aus, mal Excel Diagramm malen lassen....

Wenn du z.B. einen Konstantstrom von 0.5 mA durch den KTY treibst,
welcher an Masse hängt, ergibt sich mit Uref=5V:

#define UREF 5.0
#define ALPHA 7.88e-3
#define BETA 1.937e-5

float kt, T;

kt = (UREF/1024.0) * ADC;
T = 25.0 + ((sqrt(ALPHA*ALPHA+4*BETA*(kt-1.0))-ALPHA)/(2*BETA));

Variationen von R25 sowie des Konstantstromes können mit UREF
kompensiert werden. Mit den o.g. Werten ist ADC@25° = 204 und ADC@100°
= 348, also ein Temperaturanstieg von 75K erhöht den Zählerstand um
144.


Gruß
Marco
-

Hi,

ad Formeln aus Datenblatt: wenn du mit diesem Fühler eine "genaue"
Messung machen willst, verwende diese Formeln. Wenn der µC irgendetwas
anzeigen soll, dann verwende deine linearisierte Funktion, wenn du
etwas für den Alltag mehr als ausreichendes verwenden willst befolge
den Rat von Uwe.

grüße,

Der2te_Michael

meld
ich hab erfahrung mit dem kty...
wenn es wirklich was genaues ist, würde ich das auch nicht mit dem
spannungsteiler, sondern mit einer brücke realisieren..
brücke aus sensor und r + poti bilden...op nachschalten und r in die
rückführung.
dann hast du über deinen ausgewählten temp-bereich die volle auflösung
von 0-5V.

Also meine Schaltung sieht so aus:
           VCC
            +
            |
            |
           .-.
           | |
           | | 1966 Ohm
           '-'
            |
            o----------o AD-Wandler
            |
           .-.
           | |
           | | KTY 16
           '-'
            |
            |
           ===
           GND
Diese Schaltung habe ich schon so beim 80C535 verwendet und es hat
prima funktioniert.

Also wenn ich dies hier so verwende, dann tut sich nichts.Auf dem
Display erscheint 25Grad.

#define UREF 5.0
#define ALPHA 7.88e-3
#define BETA 1.937e-5

float kt, T;

kt = (UREF/1024.0) * ADC;
T = 25.0 + ((sqrt(ALPHA*ALPHA+4*BETA*(kt-1.0))-ALPHA)/(2*BETA));
-->ausserdem kann es sein dass die Formel so wie sie da steht flasch
ist?Warum kt-1.0?Warum wird kt so berechnet
kt = (UREF/1024.0) * ADC; im Datenblatt steht eine andere Formel.

Was müsste ich tun damit ich die Schaltuing genau so wie ich sie gerade
habe verwenden kann?

Was müsste ich tun damit ich die Schaltuing genau so wie ich sie gerade
habe verwenden kann?

Diese Formeln rechnen den Widerstandswer in die Temperatur um. Der
Spannungsteiler erzeugt aber eine Spannung die keineswegs proportional
zum Widerstand ist. Dazu müsstest du einen konstanten Strom durch den
Sensor schicken.
Die Schaltung mit 1966Ohm ist auch sehr gut, sie erzeugt eine
Spannung die proportional zur Temperatur ist. Der Effekt des
Spannungsteilers und die krumme Kurve des Sensors kompensieren sich
hier recht gut. Also muss man garkeine Linearisierung mehr rechnen!

Hier sollte etwa gelten
T=(ADC-300)/1.8
oder wenn du lieber mit ganzen Zahlen rechnen willst
T=((ADC-300)*50)/9
dann hast du die Temperatur in 1/10°, ein Wert von 135 bedeutet also
13,5°C.
Nimm AVcc als Referenz, dann brauchst du dich um den absoluten Wert
deiner Spannung nicht zu kümmern.
Übrigens kann man das alles mit einer Tabellenkalkulation einfach
ausprobieren.

Uwe

Hmmm...verstehe immer noch nicht ganz. Warum jetzt sowas T=(ADC-300)/1.8

nimm eine Tabellenkalkulation!!! Open-Office kostet nix.
1. Spalte Temperatur
2. Spalte errechnet den Widerstandswert des KTY laut Formel
3. Spalte rechnet, was der Spannungsteiler erzeugt
4. Spalte rechnet den AD-Wert aus
und dann überlege mal, was du aus dem AD-Wert machen must, um wieder
die Temperatur zu erhalten!

Hallo Uwe,

ich verstehe nicht wie du auf das hier kommst:
T=(ADC-300)/1.8
oder
T=((ADC-300)*50)/9
dann hast du die Temperatur in 1/10°, ein Wert von 135 bedeutet also
13,5°C.

Oh je ich weiss gar nicht was und welche Formel ich verwenden soll.
Die Formeln im Datenblatt verstehe ich nicht.Ich weiss da nicht wie ich
die in meinem Programm umsetzen soll.

Hallo Uwe,

ich verstehe nicht wie du auf das hier kommst:
T=(ADC-300)/1.8
oder
T=((ADC-300)*50)/9
dann hast du die Temperatur in 1/10°, ein Wert von 135 bedeutet also
13,5°C.

Oh je ich weiss gar nicht was und welche Formel ich verwenden soll.
Die Formeln im Datenblatt verstehe ich nicht.Ich weiss da nicht wie
ich
die in meinem Programm umsetzen soll.

Hmmm...ich verzweifle noch. Ich bekomme das nicht hin.

Also zu meiner Konstantstromlösung:

  |
  | Ik = 0.5 mA
  |
  |------> AD-Converter (Ua)
 ---
 | |
 | | Rt
 | |
 ---
  |
 Gnd

Ua = Ik * Rt = Ik  R25  kt != Uref * ADC / 1024

also

kt = (Uref * ADC) / (Ik  R25  1024)

Nachfolgend nur noch die Formel aus dem Datenblatt, wobei ich mit
(kt-1.0) eigentlich code einsparen wollte. Dem ist aber nicht so, denn

T = 25.0 +
((sqrt((float(ALPHA*ALPHA-4*BETA)+4*BETA*kt)-ALPHA)/(2*BETA));

ist kürzer.

Verwendest du die 1966-Ohm-Lösung, so ergibt sich:

Uadc(@25°)  = 2,521432 V -> ADC = 516
Uadc(@75°)  = 2,973551 V -> ADC = 608
Uadc(@100°) = 3,168065 V -> ADC = 648

Zur Umrechung könntest du eine Gleichung erstellen, welche sich auf
100° bezieht.

T = 25 + (ADC - ADC@25) / ((ADC@100 - ADC@25)/(100 - 25))
T = 25 + (ADC - 516) / 1,76

Diese zeigt die Temperaturen von 25° und 100° exakt an, weicht aber
z.B. bei 75° mit einem Anzeigewert von 77,27° um mehr als 2° ab.

Wie schon gesagt, hängt es von deinen Ansprüchen ab, welche der
Schaltungsvarianten sinnvoll ist. Natürlich lässt sich auch ein
einfacher Spannungsteiler über die Formel
Ua = Uref * Rt / (Rt + 1966) linearisieren. Dann bildest du eben die
nichtlineare Hardware in Software nach.
Willst du auch kleine Werte angezeigt bekommen, so ist die
nachschaltung eines Verstärkers, welcher dir den relevanten
Temperaturbereich auf den AD-Maximalwert abbildet, sinnvoll.

Gruß
Marco
-

im Bereich -20 bis +40°C, also der Bereich der beim Wetter interessiert,
ist die 1966 Ohm-Lösung erstaunlich linear. Die Abweichung liegt bei
kleiner 0,2°C !
Bis 100° sieht es allerdings schlechter aus...

#!/usr/bin/env python

import sys
from pylab import *

# Die 1966 Ohm Loesung

t = arange(-50, 101)
t25 = 25.0*array(ones(len(t)))
dt = t - t25

alpha = 7.88e-3
beta = 1.937e-5

R1 = 1966.0
R25 = 2000.0
UREF = 5.0
RESOL_ADC = 1024.0

# temperaturabhaengiger widerstandswert
rt = R25 * (1.0 + alpha*dt + beta*dt*dt)

# spannung am ad-eingang
uadc = UREF * rt / (R1 + rt)

# wert im register ADC, wertdiskret
ADC = floor((RESOL_ADC / UREF) * uadc)

# berechnungen des m8
ua = (UREF / RESOL_ADC) * ADC
rt2 = ua * R1 / (UREF - ua)
kt = rt2 / R25
T = 25.0 + (sqrt(alpha*alpha - 4*beta + 4*beta*kt)-alpha)/(2*beta)


#
------------------------------------------------------------------------ 
-----------------------------------------
# Anzeige der Werte

def click(event):
    close('all')
    sys.exit(0)

connect('key_press_event', click)
print 'press any key to exit'

plot(t, (t-T), 'b')
title('absolute Abweichung, URSACHE: 10-bit-ADC')
xlim(t[0],t[-1])
grid('on')
xlabel('Temperatur in Grad Celsius')
ylabel('Tist - Tanzeige')
show()

Die Kurve sieht heftig aus.
Aber wundern tut mich das nicht,
da nur ein kleiner Bereich des Eingangsspannungsbereichs des ADC
ausgenutzt wird.
Für eine bessere Auflösung ist wohl eine externe Verstärkerschaltung
fällig.
(Messbrücke mit nachfolgendem Instrumentenverstärker)
Die Nichtlinearität des KTY kann man dann immer noch mit einer
Korrekturtabelle oder etwas Mathematik ausgleichen.

Gruss
Jadeclaw.

Exakt.

Der durchschnittliche Fehler liegt bei o.A. Berechnung bei ca. 0,25423.
Schaltet man nun einen Verstärker nach, liegt derselbe bei ca. 0,0712.
Lässt man die diskretisierung aus, schreibt also
ADC = (RESOL_ADC / UREF) * uadc ,
so verbleibt als Abweichung nur noch der Rundungsfehler der
Float-Berechnung. Also sind die Formeln schon exakt, nur der AD-Wandler
verschlechtert unser Ergebnis. Bedenkt man die Einfachheit der Schaltung
(nur 1 Widerstand + KTY), so ist die erzielbare Auflösung von 1K doch
nicht schlecht. Mit Verstärker sind 0.2K Auflösung drin.

Gruß
Marco
-

Hallo Marco S,

danke für die Unterstützung.Jetzt ist mir schon einiges klarer
geworden.
Ich verstehe nur noch nicht ganz das hier:

t = arange(-50, 101)
t25 = 25.0*array(ones(len(t)))
dt = t - t25

Was bedeutet array(ones(len(t)) bzw. ones und len?

Kann mir jemand erklären was damit gemeint ist?

t = arange(-50, 101)
t25 = 25.0*array(ones(len(t)))
dt = t - t25

Da ich mit CodeVision Programmiere, gibt es die Funktionen arange und
array und ones und len nicht.

Ups.

#!/usr/bin/env python -> Deutet darauf hin, dass es sich hier um einen
Python-Quellcode handelt.

Das ist quasi eine Simulation des AVR-Programmes inclusive Hardware.
Erstellt mit Python und dem Zusatzmodul pylab unter Linux. Das kann man
natürlich auch zuckersüß mit Matlab erstellen. Leider habe ich dieses
nicht, darum diese Lösung. Nun, warum überhaupt eine Simulation? Ganz
einfach: Wenn man in der Schaltung etwas ändert, muss man Bauteile
stecken und hier nur die Software umschreiben. Das Abfahren des
Temperaturbereiches ist in Hardware wohl schwerer zu realisieren, als t
= arange(-20, 40, 0.1) zu schreiben.

t ist hier ein Vektor, in welchem die Temperaturwerte geordnet abgelegt
sind. t25 ist ein Vektor gleicher Länge, mit konstant 25. dt ist das,
was im Datenblatt als deltaTa bezeichnet wird. Das ganze lässt sich am
Ende schön grafisch darstellen.

Elegant ist diese Sache, weil man damit sehr leich Veränderungen
einzelner Werte mit vorausgehenden Ergebnissen vergleichen kann. Z.B.
R1 hier gleich 1966 Ohm hat durch die linearisierung rt2 = ua * ...
einen eher untergeordneten Einfluss, 1,8k oder 4,7k funktionieren
auch.

Zur Anmerkung: Alle Formeln basieren auf Rt=R25*(1+alpha*dt+beta*dt^1).
Dies selbst ist nur eine Näherungslösung. Wie man dem DS entnehmen kann,
variiert R25 zum Beispiel in Abhängigkeit vom Strom, weswegen die
Schaltung des PTC in einem Spannungsteiler immer zu Nichtlinearitäten
führt. Daher wäre die Verwendung einer Konstantstromquelle für genaue
Ergebnisse wohl sinnvoll.

Mal was ähnliches: In einer Elektor war mal ein Thermometer, basierend
auf einem pn-Übergang, entwickelt. Dort hat man den differentiellen
Widerstand des Übergangs ausgewertet. Dieser ist im gegensatz zum PTC
sehr linear. Hat sich jemand schonmal damit auseinandergesetzt. Ein
DS18S20 funktioniert aufgrund derselben Formel, halt nur mit zwei
pn-Übergängen.

Gruß
Marco
-

Hallo Marco S,

ja wie setzte ich das ganze jetzt in CodeVisionAVR (Programmiersprache
C) um?

Ja wie kann ich das ganz hier in C realisieren?
WIe gesagt arange und array bzw. ones und len gibt es nicht bei mir.

t = arange(-50, 101)
t25 = 25.0*array(ones(len(t)))
dt = t - t25

Nur daran hängt es bei mir.

#define UREF 5.0
#define RESOL_ADC 1024.0
#define R1 1966.0
#define R25 2000.0
#define ALPHA 7.88e-3
#define BETA 1.937e-5

float ua, rt2, kt, T;


ua = (UREF / RESOL_ADC) * ((float) ADC);
rt2 = ua * R1 / (UREF - ua);
kt = rt2 / R25;
T = 25.0 + (sqrt(ALPHA*ALPHA - 4*BETA + 4*BETA*kt)-ALPHA)/(2*BETA);

Ja und was ist mit dem hier:
t = arange(-50, 101)
t25 = 25.0*array(ones(len(t)))
dt = t - t25
Brauche ich das nicht?

Nö.

Also, wenn du den Kram simulieren willst, brauchst du Python + pylab.
Dann nimmst du den Soucecode von 01:33, speicherst ihn unter kty.py ab
und rufts das ganze mit >python kty.py< auf. Daraufhin kriegtst du das
zugehörige Bildchen gemalt. Wenn die Ergebnisse zufriedenstellend sind,
übersetzt du die relevanten Teile nach C (das von 14:22).

Sachen wie import, from, arange, array, ones, len, def, event, close,
exit, connect, print, plot, title, xlim, grid, xlabel, ylabel, show
gibts eh nicht in C und auch Kommentare eingeleitet mit # dürfte der
C-Compiler reklamieren.

Ja funktioniert denn der Code von 14:22?

Gruß
Marco
-

Also der C -Code fun ktioniert von dir. Vielen vielen Dank.
Mit meinem Spannungsteiler und dem C-Code müsste doch der
Temperaturwert
richtig sein oder?

Unter welchen Voraussetzungen kann mit einem KTY 10 eine genaue 
Temperaturmessung durchgefürt werden?

Ich habe eine Praktikum mit KTY 10 gemacht.aufgabe steht so,man muss 
diese Werte mit gegebenen Werte von Silizium-Temperatursensor KTY10 
vergleichen.Ich habe so gemacht.Werten etwas unterschiedlich.Aber es 
gibt noch eine Frage:Wie kann man genau messen???

von  1/10 Grad bis 1 Grad ca.

[ ]  20 bis 65 Grad