KTY 10-5 Formelprobleme

[Paul (Gast)]

Guten Abend :)
hab mal ne kleine Frage ^^ aber nicht motzen wenn sie dumm ist, bin erst 
14 ;)

und zwar hab ich einen Temperatursensor von Infineon -> KTY 10-5
ich habe auch das Datenblatt gelesen und die Formeln zum berechnen der 
Temperatur haben mich schon ne weile beschäftigt ^^ aber jetzt weiß ich 
wies geht! :)
naja jetzt stellt sich mir die Frage wie ich meinem µC sag das er aus 
meinem Spannungsteiler den AD Wert in nen Widerstand von dem Sensor 
umrechnet und diese dann in die Temperatur :(
ich weiß nicht mehr weiter :(

die Formel für die Temperatur bitte ich euch aus dem Datenblatt zu 
entnehmen da ich nicht weiß wie man ne wurzel mit dem pc macht ^^
-> 
http://www.datasheetarchive.com/pdf-datasheets/Datasheets-14/DSA-266037.html
(die Formel mit dem T=(25+...)

und k(T) wird ja berechnet aus dem Sensorwiderstand geteilt durch den 
Widerstand bei 25°C ... ich nehme einfach mal 2000 Ohm an...

Spannungsteiler:
GND---Sensor--------2,6k Ohm---VCC
               -
               -
               ADC

das Programm ist bisher in C geschrieben ... kann mir einer die Formeln 
bitte schreiben, damit ich die Temperatur auf meinem µC 
weiterverarbeiten kann? :)

wie gesagt ich bin erst 14 und für alle infos offen solange sie 
hilfreich sind! ich bitte euch nicht einfach auf andere threads zu 
verweißen sondern vlt. auch ein bißchen zu erklären :) wäre nett ... ich 
will nämlich daraus lernen! :)

mfg. Paul

[spess53 (Gast)]

Hi

>keiner ne ahnung? :(

Falsches Forum!

MfG Spess

[Helfer (Gast)]

> Spannungsteiler:
> GND---Sensor---+----2,6k Ohm---VCC
>                |
>                |
>               ADC

Beim Spannungsteiler bist du doch schon. In der dortigen Formel 
kennst du: U_aus von der ADC Messung (Die Umrechnung des ADC-Messwerts 
in die Spannung U_aus steht z.B. im Tutorial zum ADC), U_ein (=Vcc), R1 
(=2,6kOhm). Unbekannt ist nur R2, dein Sensorwiderstand.

Die Wurzel kannst du mit den Mathefunktionen in Fliesskomma rechnen, 
wenn das dein unbekannter µC beherrscht. Die Doku zu sqrt() ist dann 
wichtig. Oder du kannst die Wurzel mit einen Näherungsverfahren 
berechnen. Schlag in Wikipedia das Newton-Verfahren nach. Oder du kannst 
dir für typische Werte eine Tabelle im Programm anlegen.

[Branko G. (branko)]

Etwas über Temperaturmessung mit dem KTY:
http://www.sprut.de/electronic/temeratur/temp.htm#ptc

[Werner F. (frewer)]

Hallo Paul,

eine dumme Frage gibt es nicht, es gibt nur dumme Antworten! Will 
versuchen, Dir eine gute Antwort zu geben, denn ich habe auch einige 
Zeit mit dem KTY10-8 rumprobiert und nunmehr ein gehendes TempMessgerät 
auf dem Tisch. Wenn Du Dir den Artikel bei "sprut" durchgelesen und das 
Datenblatt angesehen hast, dann wird klar, dass der hauptvorteil der 
KTY-Sensoren ihre Linearität in gewissen Bereichen ist. Das solltest Du 
nutzen und den Formelkram vergessen, weil dessen Abweichungen von 
linearen Fall kaum mit einem normalen Anzeigesystem auffällt. Übrigens, 
wenn Du Dir mal die käuflichen TempMessgeräte anschaust, dann gehen alle 
höchstens auf 1 Grad genau - wenn überhaupt -.
Also ich habe mein damaliges Projekt damit begonnen, dass ich mal die 
Spannung am KTY bei verschiedenen Temperaturen im Spannungsteiler 
gemessen und mir auf diese Weise eine Tabelle zusammengestellt habe. 
Durch einfachste Interpolation (Meßwerte auf kariertes Papier und mit 
dem Lineal eine vernünftig passende Gerade durch die Meßwerte legen) 
habe ich dann meinen linearen Zusammenhang zwischen Temperatur und 
Spannung erhalten.
Nun kommt es im 2ten Schritt auf den Mikrocontroller an, denn Du 
brauchst ja einen Analog-Digital-Wandler, um die Spannung zu messen. Den 
haben die AVR's von ATMEL bereits eingebaut, die einfachen AT89 Typen 
aber nicht. Also wäre es notwendig zu wissen, welchen Controller Du 
verwenden willst.

mfG
frewer

[Michael (Gast)]

Hallo,
das hier funktioniert super :)

#include <stdio.h> 
#include <math.h> 

#define KTY_R25 2000            // R at 25?C 
#define KTY_RS 3900             // serial resistor 
#define KTY_ALPHA 0.00788 
#define KTY_BETA 0.00001937 

float V_REF, vcc = 5.0; 

float kty_calc(int adcResult) 
{ 
    float vAdc, temp, kt; 

    vAdc = (adcResult * V_REF) / 1024; 
    kt = (KTY_RS / (vcc / vAdc - 1)) / KTY_R25; // Temperaturfaktor 

    temp = pow(KTY_ALPHA, 2) - 4 * KTY_BETA + 4 * KTY_BETA * kt; 
    temp = 25 + ((sqrt(temp) - KTY_ALPHA) / (2 * KTY_BETA));    // Temperatur in ?C 

    return temp; 
} 

void main(void) 
{ 
    int adc = 844; 
    for (adc = 836; adc <= 848; adc += 4) { 
        for (V_REF = 2.549; V_REF <= 2.585; V_REF += 0.005) { 
            printf("V_REF = %05.3lf\tkty_calc(%03u) = %06.4lf\n", V_REF, adc, kty_calc(adc)); 
        } 
    } 
}

[Michael (Gast)]

sorry hab auf die schnelle nicht das richtig erwischt, hier die 
ursprüngliche Variante:

//***************************************************************** 
//* Calculate KTY-Temperature 
//***************************************************************** 

// KTY100-6 
#define KTY_R25 2000 // R at 25°C 
#define KTY_RS 3900 // serial resistor 
#define KTY_ALPHA 0.00788 
#define KTY_BETA 0.00001937 

float kty_calc(int adcResult) 
{ 
float vAdc, temp, kt; 

vAdc = (adcResult * V_REF) / 1024; 
kt = (KTY_RS / (vcc / vAdc - 1)) / KTY_R25; // Temperaturfaktor 

temp = KTY_ALPHA*KTY_ALPHA - 4 * KTY_BETA + 4 * KTY_BETA * kt; 
temp = 25 + ((sqrt(temp) - KTY_ALPHA) / (2 * KTY_BETA)); // Temperatur in °C 

tempHighbyte = temp; 
tempLowbyte = (temp - tempHighbyte) * 10; 

return temp; 
}

was nicht beschrieben ist:

vAdc = deine Versorgungsspannung am Spannungsteiler.

die Daten nimmst aus dem Datenblatt:
#define KTY_R25 2000 // R at 25°C

Den Widerstandswert vom Spannungsteiler hier eintragen
#define KTY_RS 3900 // serial resistor

aufgerufen wird dann in etwa so:
du hast z.b. in der Variable adcwert deinen eingelesenen wert.

float temperatur;
temperatur = kty_calc(adcwert);


dann hast du in Temperatur die Temperatur mit Kommastellen. Um damit 
leichter weiterzuarbeiten kannst du es mit 100 multiplizieren.

ich war wirklich überrascht das gleich auf Anhieb ein guter Wert 
rausgekommen ist :)

[Jörg W. (dl8dtl) (Moderator)]

Das mit den Spannungen sollte man vermeiden, denn das bringt nur noch
zusätzliche Messfehler.  Einen Widerstand misst man ratiometrisch,
d. h. er wird in einem Spannungsteiler gegen einen bekannten
Widerstand verglichen.  Dadurch kürzt sich der absolute Wert der
Referenzspannung heraus aus der Berechnung.  Wenn man dann noch den
zweiten Widerstand im Spannungsteiler genauso groß dimensioniert wie
den Nennwiderstand des Temperatursensors (macht sich besonders gut,
wenn man die -6 oder gar die -62 Variante des KTY nutzt), dann kürzt
sich noch mehr, s. u.

Ich habe das vorhin auch gerade durch, hier ist es ein KTY13-6,
"v" ist dabei der Messwert des ADC (linksbündig eingetragen,
also maximal 0xffc0):

      const double alpha = 7.88E-3;
      const double beta = 1.937E-5;
      v = ((b[0] << 8) + b[1]);
      /*
       * The reference resistor in the voltage divider has the same
       * value (2 kOhm) as the nominal 25 oC value of the KTY13-6, so
       * the formula for kt:
       *
       *              Rref
       * kT = ---------------------
       *      R25 * (Uref/Ukty - 1)
       *
       * eventually reduces to:
       *
       *         Ukty
       * kT = -----------
       *      Ukty - Uref
       *
       * Instead of using absolute voltages, it suffices to use the
       * ADC values (with 0xffc0 = ADCmaxval being the reference
       * level).
       */
      double kt = (double)v / (0xffc0 - v);
      t = 25 + (sqrt(alpha * alpha - 4 * beta + 4 * beta * kt) - alpha) / (2 * beta);
      PRINTF("KTY13    %5.2f oC\r\n", t);

Sonderlich genau sind die Dinger aber ohne weitere Kalibrierung
nicht.  Hier mal einige Temperatursensor-Messergebnisse im Vergleich:

SHT-21#1 22.79 oC, 20.08 % RH
SHT-21#2 22.75 oC, 19.57 % RH
LM75     20.00 oC
TMP141#1 22.75 oC
TMP141#2 22.75 oC
TMP141#3 22.50 oC
DS18B20  23.44 oC
KTY13    21.30 oC
RFA1int  22.13 oC

Warum der LM75 gerade so weit "abgeschlagen" auf seinen 20 °C
beharrt, weiß ich nicht.  Sonst lag der eher bei einer Abweichung
von ca. -1 K gegenüber den SHT-21.

[Michael (Gast)]

ah ok, auch nicht schlecht, dann brauche ich aber 2 analoge Eingänge ?

[Jörg W. (dl8dtl) (Moderator)]

Michael schrieb:
> ah ok, auch nicht schlecht, dann brauche ich aber 2 analoge Eingänge ?

Nein, wieso?  Der Spannungsteiler hängt einfach an der Referenz-
spannung des ADC, welche auch immer das ist.  Deren absoluter Wert
ist ziemlich uninteressant.  In meinem Falle wurde ein ATmega128RFA1
benutzt, bei dem der ADC absolut nur bis 1,8 V aussteuerbar ist, sodass
ich die interne 1,6-V-Referenz am Aref-Ausgang zugleich für den
Spannungsteiler benutzt habe.  Du kannst aber genauso gut (wenn dein
ADC das mitmacht) Vcc als Referenz benutzen und den Spannungsteiler
dann daran setzen.

Voraussetzung für die ratiometrische Methode ist natürlich, dass dein
ADC im Falle, dass der KTYxx nicht dran ist, dann auch tatsächlich den
in der Rechnung angegebenen Max-Wert ausspuckt.

[Michael (Gast)]

dann habe ich noch irgendwo einen denkfehler.


Jörg Wunsch schrieb:
> Einen Widerstand misst man ratiometrisch,
>
> d. h. er wird in einem Spannungsteiler gegen einen bekannten
>
> Widerstand verglichen

Ich dachte man macht 2 Spannungsteiler einen mit bekannten Werten den 
anderen mit dem KTY und nun vergleicht man die eingelesenen Werte von 
beiden und rechnet.

Wie sieht dann die Beschaltung aus ?

[Jörg W. (dl8dtl) (Moderator)]

Michael schrieb:

> Wie sieht dann die Beschaltung aus ?

So:

                         +---------------
                         |               .
  Vref ----+-------------| Aref
           |             |               .
           |             |
           -             |               .
          | | R          |
          | |  ref       |               .
           -             |
           |             |               .
           |             |
           *-------------| ADCinput      .
           |             |
           |             |               .
           -             |
          | | KTYxx      |               .
          | |            |
           -             +---------------
           |
           |
          ---

[Jörg W. (dl8dtl) (Moderator)]

Jörg Wunsch schrieb:

> Warum der LM75 gerade so weit "abgeschlagen" auf seinen 20 °C
> beharrt, weiß ich nicht.  Sonst lag der eher bei einer Abweichung
> von ca. -1 K gegenüber den SHT-21.

Jetzt sackte er immer weiter ab, und nun ist's mir klar: die
Batteriespannung geht allmählich runter, sie ist jetzt bei 2,5 V.
Das mag der LM75 gar nicht (auch, wenn's ein -3 ist).

[Michael (Gast)]

ah, ok danke.

Also den Spannungsteiler an ARef statt an VCC, danke

[Jörg W. (dl8dtl) (Moderator)]

Michael schrieb:

> Also den Spannungsteiler an ARef statt an VCC, danke

Nicht zwingend.  Wenn du bei einem AVR intern Vcc als Referenz für
den ADC einstellst, dann kannst du den Spannungsteiler natürlich
sehr wohl an Vcc hängen.  Das Prinzip bleibt dann das gleiche,
denn der Draht von Vcc nach Aref wird in diesem Falle intern
geschaltet.

[Michael (Gast)]

Hallo Jörg,

ich versuche gerade deine Formel durch meine zu ersetzen.

Klappt leider noch nicht.

      v = ((b[0] << 8) + b[1]);

was ist v und was ist b ?

viele Grüße
Michael

[Michael (Gast)]

ok, v ist der Messwert vom ADC, hab ich überlesen.
Wiso linksbündig ?

[Jörg W. (dl8dtl) (Moderator)]

Michael schrieb:
> ok, v ist der Messwert vom ADC, hab ich überlesen.
> Wiso linksbündig ?

Weil ADLAR gesetzt ist (AVR).

[Michael (Gast)]

ah ok danke, welchen Vorteil hat das ?

Was ist

v = ((b[0] << 8) + b[1]);

b ?

[Jörg W. (dl8dtl) (Moderator)]

Michael schrieb:
> ah ok danke, welchen Vorteil hat das ?

Eigentlich nur den, dass man nur das High-Byte auswerten muss, wenn
man nur an 8 der 10 bits interessiert ist.

> Was ist
>

> v = ((b[0] << 8) + b[1]);
>

>
> b ?

Ein Array aus dem high- und low-Byte des Messwertes (weil das hier
so über einen I²C-Bus ankam).

[Paul (Gast)]

Hallo :)
hatte lange keine Zeit hier vorbeizuschauen ^^
danke für die vielen Antworten! :)

hab mir jetzt mal aus euren Code-Schnipseln was zusammengebastelt ^^

#include <avr/io.h>
#include <stdint.h>
#include <math.h>

// KTY10-5 
#define KTY_R25 1970 // R at 25°C 
#define KTY_RS 4570 // serial resistor 
#define KTY_ALPHA 0.00788 
#define KTY_BETA 0.00001937 


//***************************************************************** 
//* ADC initialisieren
//***************************************************************** 

void ADC_Init(void) {
 
  uint16_t ergebnis;
 
  ADMUX = (0<<REFS1) | (1<<REFS0);      // interne Referenzspannung nutzen (5V)
  ADCSRA = (1<<ADPS2) | (1<<ADPS0);     // Frequenzvorteiler: 32
  ADCSRA |= (1<<ADEN);                  // ADC aktivieren
 
  ADCSRA |= (1<<ADSC);                  // ADC-Wandlung
  while (ADCSRA & (1<<ADSC) ) {}        // auf Abschluss der Konvertierung warten
  ergebnis = ADCW;
}
 

//***************************************************************** 
//* ADC-Messung
//***************************************************************** 

uint16_t ADC_Read( uint8_t channel ) {
  
  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);  // Kanal waehlen, ohne andere Bits zu beeinflußen
  ADCSRA |= (1<<ADSC);                    // ADC-Wandlung
  while (ADCSRA & (1<<ADSC) ) {}          // auf Abschluss der Konvertierung warten
  return ADCW;                            // ADC auslesen und zurückgeben
}
 

uint16_t ADC_Read_Avg( uint8_t channel, uint8_t average ) {
  uint32_t result = 0;
 
  for (uint8_t i = 0; i < average; ++i )
    result += ADC_Read( channel );
 
  return (uint16_t)( result / average );
}


//***************************************************************** 
//* KTY-Temperature 
//***************************************************************** 

float kty_calc(int adcResult) 
{ 
float vAdc, temp, kt; 
float V_REF = 5.0, vcc = 5.0;

vAdc = (adcResult * V_REF) / 1024; 
kt = (KTY_RS / (vcc / vAdc - 1)) / KTY_R25; // Temperaturfaktor 

temp = KTY_ALPHA*KTY_ALPHA - 4 * KTY_BETA + 4 * KTY_BETA * kt; 
temp = 25 + ((sqrt(temp) - KTY_ALPHA) / (2 * KTY_BETA)); // Temperatur in °C 

// tempHighbyte = temp; 
// tempLowbyte = (temp - tempHighbyte) * 10; 

return temp; 
}


//***************************************************************** 
//* Hauptschleife
//***************************************************************** 

int main() {

  uint16_t adcwert;
  float temperatur;

  ADC_Init();    // springt zu ADC_Init

  // DDRB = 0x00;    // Port B Eingang
  DDRD = 0xff;    // Port D Ausgang
  PORTD = 0x00;

  // PORTB = 0xff;    // interne Pull-Up Widerstände aktivieren

  while( 1 ) {
  
  adcwert = ADC_Read_Avg(0, 4);    // Kanal 0, Mittelwert aus 4 Messungen
  temperatur = kty_calc(adcwert);

  // PORTD = 0x00;

  if (temperatur < 17) {      // Wenn Temperatur kleiner als 17°C...
    
    PORTD = ~0b0000011;    //...dann PORTD 0b0000011

  }
  
  if (temperatur > 25) {      // Wenn Temperatur größer als 25°C...

    PORTD = ~0b0011000;    //...dann PORTD 0b0011000

  }

  if ( (temperatur > 17) & (temperatur < 25) ) {  // Wenn Temperatur zwischen 17°C und 25°C
    
    PORTD = ~0b0000100;        //...dann PORTD 0b0000100

  }

  }

}

hab mein stk500 nicht da und komme erst wieder nächste Woche heim :(
kann mal einer der Profis drüberschauen und mir sagen ob das so 
funktionieren würde? :)

was heißt eigentlich diese High und Low byte bei kty_calc? habs einfach 
mal ausgeklammert damit die simulation funktioniert ^^
und vcc und V_REF hab ich einfach mit 5 für 5V gemacht...so in ordnung?

bin für jede Hilfe dankbar! :)

Grüßle

[Paul (Gast)]

hab mal probiert und nun klappts mit dem high und low byte ...
aber für was ist das da?!

#include <avr/io.h>
#include <stdint.h>
#include <math.h>

// KTY10-5 
#define KTY_R25 1970.0 // R25 KTY 
#define KTY_RS 2600.0 // Widerstand Spannungsteiler 
#define KTY_ALPHA 0.00788 
#define KTY_BETA 0.00001937 


//***************************************************************** 
//* ADC initialisieren
//***************************************************************** 

void ADC_Init(void) {
 
  uint16_t ergebnis;
 
  ADMUX = (0<<REFS1) | (1<<REFS0);      // interne Referenzspannung nutzen (5V)
  ADCSRA = (1<<ADPS2) | (1<<ADPS0);     // Frequenzvorteiler: 32
  ADCSRA |= (1<<ADEN);                  // ADC aktivieren
 
  ADCSRA |= (1<<ADSC);                  // ADC-Wandlung
  while (ADCSRA & (1<<ADSC) ) {}        // auf Abschluss der Konvertierung warten
  ergebnis = ADCW;
}
 

//***************************************************************** 
//* ADC-Messung
//***************************************************************** 

uint16_t ADC_Read( uint8_t channel ) {
  
  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);  // Kanal waehlen, ohne andere Bits zu beeinflußen
  ADCSRA |= (1<<ADSC);                    // ADC-Wandlung
  while (ADCSRA & (1<<ADSC) ) {}          // auf Abschluss der Konvertierung warten
  return ADCW;                            // ADC auslesen und zurückgeben
}
 

uint16_t ADC_Read_Avg( uint8_t channel, uint8_t average ) {
  uint32_t result = 0;
 
  for (uint8_t i = 0; i < average; ++i )
    result += ADC_Read( channel );
 
  return (uint16_t)( result / average );
}


//***************************************************************** 
//* KTY-Temperatur 
//***************************************************************** 

float kty_calc(int adcResult) 
{ 
float vAdc, temp, kt; 
float V_REF = 5.0, vcc = 5.0;
float tempHighbyte, tempLowbyte;

vAdc = (adcResult * V_REF) / 1024.0; 
kt = (KTY_RS / (vcc / vAdc - 1.0)) / KTY_R25; // Temperaturfaktor 

temp = KTY_ALPHA*KTY_ALPHA - 4.0 * KTY_BETA + 4.0 * KTY_BETA * kt; 
temp = 25.0 + ((sqrt(temp) - KTY_ALPHA) / (2.0 * KTY_BETA)); // Temperatur in °C 

tempHighbyte = temp; 
tempLowbyte = (temp - tempHighbyte) * 10.0; 

return temp; 
}


//***************************************************************** 
//* Hauptschleife
//***************************************************************** 

int main() {

  uint16_t adcwert;
  float temperatur;

  ADC_Init();    // springt zu ADC_Init

  // DDRB = 0x00;    // Port B Eingang
  DDRD = 0xff;    // Port D Ausgang
  PORTD = 0x00;

  // PORTB = 0xff;    // interne Pull-Up Widerstände aktivieren

  while( 1 ) {
  
  adcwert = ADC_Read_Avg(0, 1);    // Kanal 0, Mittelwert aus 4 Messungen
  temperatur = kty_calc(adcwert);

  PORTD = 0x00;

  if (temperatur < 17) {      // Wenn Temperatur kleiner als 17°C...
    
    PORTD = ~0b0000011;    //...dann PORTD 0b0000011

  }
  
  if (temperatur > 25) {      // Wenn Temperatur größer als 25°C...

    PORTD = ~0b0011000;    //...dann PORTD 0b0011000

  }

  if ( (temperatur > 17) & (temperatur < 25) ) {  // Wenn Temperatur zwischen 17°C und 25°C
    
    PORTD = ~0b0000100;        //...dann PORTD 0b0000100

  }

  }

}

[Paul (Gast)]

sorry die zeile muss natürlich so lauten!

adcwert = ADC_Read_Avg(0, 4);    // Kanal 0, Mittelwert aus 4 Messungen

[Sonntag (Gast)]

Hallo,

Hab mal ne Frage: Kann mir bitte jemand erklären bzw. herleiten wie man 
auf die Formel (KTY_RS/(vcc/vAdc-1))/KTY_RS25 kommt?
Vielen Dank schon im Voraus!

LG