Temperaturmessung und Anzeige auf Display

**Mr Bean** · 04.12.2007, 19:52

Hallo

Also ich habe nun den Kondensator eingebaut und mir auch noch einen anderen Spannungsteiler mit einem neuen KTY 84 130 und 2K2 Widersand gemacht. Dann hab ich ein paar Messungen gemacht:

22°C (gemessen mit Multimeter) und 1K Widerstand : 0,326 V am ADW

3°C (gemessen mit Multimeter) und 1K Widerstand : 0,285V am ADW

22°C (gemessen mit Multimeter) und 2K2 Widerstand : 1,12 V am ADW

3°C (gemessen mit Multimeter) und 2K2 Widerstand : 0,998V am ADW

Jetzt bin ich leider so schlau wie vorher, welche Variante ist jetzt besser? Die Spannungsdifferenz ist ja bei der 2K2 Variante größer. Im Datenblatt des KTY steht aber dass man für Temperaturen über ~200° einen Strom >2mA einstellen soll (und in diesem Bereich will ich ja später messen). Und das käme wiederum der 1K Variante zu gute...

So langsam weiß ich nichtmehr was ich machen soll... Und die Anzeige stimmt leider auch noch nicht. Habe noch ein paar Kleinigkeiten am Programm verändert (ADCW >> ADC). Das hat aber auch keine Besserung gebracht. Dann hab ich mal noch versucht die Kommastelle zu verschieben, das ist aber auch nicht der richtige Weg. Könnt ihr mir noch irgendwie auf die Sprünge helfe? Wäre klasse... Würde gerne mal meine Zimmertemperatur messen und anzeigen...

Hier mal noch mein jetziger Code:

Code:

#include <avr/io.h>
#include <inttypes.h>
#include <stdlib.h>
#include <lcd.h>
#define F_CPU = 4000000UL;


uint16_t readADC(uint8_t);			//Prototyp von readADC
void display(uint16_t result);		//Prototyp von display

int main(void) 
{
	
	DDRD = 0xff;  					//PORT D als Ausgang definieren (Hier sind 8 LED`s angeschlossen
	DDRB = 0xff;					//PORT B als Ausgang
	uint16_t result = readADC(0);	//Auslesen der analogen Spannungen an Pin 0,
									// also ADC0. In result steht das Ergebnis.
	
	display(result);				//Umrechnung und Ausgabe der Temperatur auf Display und LED`s
	return 0;
}


void display(uint16_t result)
{
	lcd_init(LCD_DISP_ON_CURSOR);	//LCD initialisieren
	lcd_gotoxy(0,0);				//Cursor an erste Stelle setzen
	lcd_puts("Temperatur:");		//"Temperatur" ausgeben
	lcd_gotoxy(11,0);				// Cursor hinter "Temperatur:" setzen
	
		
	
	char buffer[8];					//Array für itoa anlegen
	float f=((float)result*5)/1024;	//
	if(f<0)f=0;
	itoa((int)f,buffer,10);
	lcd_puts(buffer);
	f=(f-(int)f)*1000;
	if(f<100)lcd_putc('0');
	if(f<10)lcd_putc('0');
	itoa((int)f,buffer,10);
	lcd_putc(',');
	lcd_puts(buffer);
	

	PORTD = result;					//Den Digitalen Wert mit Hilfe der LED`s anzeigen
	return;
}



uint16_t readADC(uint8_t channel) 

{
	uint8_t i;
	uint16_t result = 0;
	
	// Den ADC aktivieren und Teilungsfaktor auf 32 stellen
	ADCSRA = (1<<ADEN) | (1<<ADPS0) | (1<<ADPS2);

	// Kanal des Multiplexers waehlen (ADC 0)
	ADMUX = (!(1<<MUX0)) | (!(1<<MUX1)) | (!(1<<MUX2));
	
	// interne Referenzspannung verwenden (also 2,56 V)
	ADMUX |= (1<<REFS1) | (1<<REFS0);
	
	// Den ADC initialisieren und einen sog. Dummyreadout machen
	ADCSRA |= (1<<ADSC);
	while(ADCSRA & (1<<ADSC));
	
	// Jetzt 3x die analoge Spannung and Kanal channel auslesen
	// und dann Durchschnittswert ausrechnen.
	for(i=0; i<3; i++) {
		// Eine Wandlung
		ADCSRA |= (1<<ADSC);
		// Auf Ergebnis warten...
		while(ADCSRA & (1<<ADSC));
		
		result += ADC;
	}
	
	// ADC wieder deaktivieren
	ADCSRA &= ~(1<<ADEN);
	
	result /= 3;
	
	return result;
}

Grüße!!

Bean

**wkrug** · 04.12.2007, 22:53

Nun, ich hab die Werte aus dem Datenblatt in eine EXCEL Tabelle übertragen, ein Diagramm daraus gemacht und dabei festgestellt, das das Temperatur / Werteverhältnis der KTY alles andere als linear war.
Also bin ich hergegangen und hab mit verschiedenen Vorwiderstandswerten mir immer wieder neue Kurven berechnen und zeichnen lassen.
Mit einem 2,2k Ohm Widerstand war die Temperatur / Werte kurve der linearen Funktion am nächsten. Das kommt natürlich auch auf die verwendete Spannung an.

Meine Berechnungsformel Schaut in C so aus.

Code:

// Vordefinitionen der Kalibrierungsfaktoren im EEPROM
eeprom signed int ee_tempzero[2]={249,249}; /* (249) A/D Wandlerwert für 0°C "(A/D Wandler - X) *290 / tempfakt" */
eeprom signed int ee_tempfakt[2]={461,461}; /* (461) Teilerfaktor für Temperatursteilheit "(A/D Wandler - tempzero) *290 / X" */
......

si_tempzero[0]=ee_tempzero[0];
si_tempzero[1]=ee_tempzero[1];
si_tempfakt[0]=ee_tempfakt[0];
si_tempfakt[1]=ee_tempfakt[1];
.......

// Berechnung von 2 Temperaturen
li_temp1=((li_temp1-si_tempzero[0])*290)/si_tempfakt[0];
li_temp2=((li_temp2-si_tempzero[1])*290)/si_tempfakt[1];
........

// Einlesen der Temperaturen in einen String ohne Nachkommastellen
ltoa (li_temp1,uc_stringbuffer);
strcat (uc_sendbuffer,uc_stringbuffer);

Die einzelnen Abschnitte sind natürlich in definitionen bzw. Funktionen enthalten, werden aber prinzipiell so abgearbeitet.
Bei mir läuft das einwandfrei.
Versuchs vielleicht mal vorerst ganz ohne Berechnungen und gib mal nur den A/D Wert direkt aus. Und wenn das klappt, dann füge die Berechnungsformel ein.
So kannst DU feststellen ob der A/D Wandler zickt, oder ein Fehler bei der Berechnung gemacht wurde.

Diese KTY Sensoren haben eine krasse Serienstreuung. Um eine Kalibrierung wirst Du also nicht herumkommen.

Ich hab zuerst eine Kalibrierung auf 0°C vorgenommen (Eiswasser) und dann mit 98°C ( kochendes Wasser ) kalibriert und meine es passt so einigermassen.
Von 10 Sensoren, die ich gekauft hab, hatten gerade mal 2 annähernd gleiche Werte.

**robocat** · 05.12.2007, 13:28

Code:

void display(uint16_t result) 
{ 
   lcd_init(LCD_DISP_ON_CURSOR);   //LCD initialisieren 
   lcd_gotoxy(0,0);            //Cursor an erste Stelle setzen 
   lcd_puts("Temperatur:");      //"Temperatur" ausgeben 
   lcd_gotoxy(11,0);            // Cursor hinter "Temperatur:" setzen 
    
       
    
   char buffer[8];               //Array für itoa anlegen 
   float f=((float)result*5)/1024;   // 
   if(f<0)f=0; 
   itoa((int)f,buffer,10); 
   lcd_puts(buffer); 
   f=(f-(int)f)*1000; 
   if(f<100)lcd_putc('0'); 
   if(f<10)lcd_putc('0'); 
   itoa((int)f,buffer,10); 
   lcd_putc(','); 
   lcd_puts(buffer); 
    

   PORTD = result;               //Den Digitalen Wert mit Hilfe der LED`s anzeigen 
   return; 
}

sicher, dass das so überhaupt kompiliert? weil char buffer[8] und float f mitten im code deklariert sind..
das 10bit result direkt an PORTD auszugeben (der ja nur 8bit hat) wird zu falschen ergebnissen führen.

gruesse

**Mr Bean** · 06.12.2007, 18:24

So also wenn ich folgenden Code in meinen Controller schreibe:

Code:

#include <avr/io.h>
#include <inttypes.h>
#include <stdlib.h>
#include <lcd.h>
#define F_CPU = 4000000UL;


uint16_t readADC(uint8_t);			//Prototyp von readADC
void display(uint16_t result);		//Prototyp von display
char buffer[8];					//Array für itoa anlegen

int main(void) 
{
	
	DDRD = 0xff;  					//PORT D als Ausgang definieren (Hier sind 8 LED`s angeschlossen
	DDRB = 0xff;					//PORT B als Ausgang
	uint16_t result = readADC(0);	//Auslesen der analogen Spannungen an Pin 0,
									// also ADC0. In result steht das Ergebnis.
	display(result);				//Umrechnung und Ausgabe der Temperatur auf Display und LED`s
	return 0;
}


void display(uint16_t result)
{
	lcd_init(LCD_DISP_ON_CURSOR);	//LCD initialisieren
	lcd_gotoxy(0,0);				//Cursor an erste Stelle setzen
	lcd_puts("Temperatur:");		//"Temperatur" ausgeben
	lcd_gotoxy(0,1);				// Cursor in die zweite Zeile setzen
	itoa((int)result,buffer,10);	//AD-Wert umrechnen
	lcd_puts(buffer);				//AD-Wert in der zweiten Zeile ausgeben
	
	lcd_gotoxy(11,0);				// Cursor hinter "Temperatur:" setzen
	
	//float f=((float)result*5)/1024;	
	//if(f<0)f=0;
	//f=(f-(int)f)*1000;
	//if(f<100)lcd_putc('0');
	//if(f<10)lcd_putc('0');
	//itoa((int)f,buffer,10);
	//lcd_putc(',');
	//lcd_puts(buffer);
	

	PORTD = result;					//Den Digitalen Wert mit Hilfe der LED`s anzeigen
	return;
}



uint16_t readADC(uint8_t channel) 

{
	uint8_t i;
	uint16_t result = 0;
	
	// Den ADC aktivieren und Teilungsfaktor auf 32 stellen
	ADCSRA = (1<<ADEN) | (1<<ADPS0) | (1<<ADPS2);

	// Kanal des Multiplexers waehlen (ADC 0)
	ADMUX = (!(1<<MUX0)) | (!(1<<MUX1)) | (!(1<<MUX2));
	
	// interne Referenzspannung verwenden (also 2,56 V)
	ADMUX |= (1<<REFS1) | (1<<REFS0);
	
	// Den ADC initialisieren und einen sog. Dummyreadout machen
	ADCSRA |= (1<<ADSC);
	while(ADCSRA & (1<<ADSC));
	
	// Jetzt 3x die analoge Spannung and Kanal channel auslesen
	// und dann Durchschnittswert ausrechnen.
	for(i=0; i<3; i++) {
		// Eine Wandlung
		ADCSRA |= (1<<ADSC);
		// Auf Ergebnis warten...
		while(ADCSRA & (1<<ADSC));
		
		result += ADC;
	}
	
	// ADC wieder deaktivieren
	ADCSRA &= ~(1<<ADEN);
	
	result /= 3;
	
	return result;
}

Dann zeigt mir das Display in der zweiten Zeile an erster Stelle den AD-Wert an (43

. Was auch der Spannung entspricht die ich am AD-Wandler Eingang mit dem Multimeter messen kann. Das zeigt mir dass die AD-Wandlung korrekt funktioniert. Nun werde ich mich also noch einmal intensiver mit der Umrechnung beschäftigen müssen...

Grüße!!

Bean

**T.J.** · 06.12.2007, 19:00

wenn du direkt den AD wert hast, bist du schon sehr weit!

lustigerweise habe ich genau das gleiche (kty, 2k2 weil linear) vor einiger zeit aufgebaut um ein thermometer im auto zu haben. Aber die genauigkeit(ca. 0,5°C lässt zu wünschen übrig, da ich keinen OP verwende.

Ich rechne so:

Code:

   W = <aktueller ADCWERT> - <ADC bei 0°C>
   T = W / (<ADC bei 100°C> - <ADC bei 0°C>)
   T = T * 100

**Mr Bean** · 06.12.2007, 19:15

Hallo

Danke für den Tipp! Ich hab jetzt grad noch den Vorschlag von wkrug implementiert. Dann zeigt mir das Display 1,3 an

. Da kann also noch etwas nicht stimmen

. Vermute dass es an dem Wert si_multiplyer liegt. Aber weigstens bin ich etwas weiter. Leider hab ich den AD-Wert für 100C nicht. Sonst könnte ich Deinen Vorschlag auch noch versuchen. Was mir auch noch nicht so ganz klar ist wie ich mit den Werten später die Steilheit verändern kann. Das muss ja auch irgendwie gehen. Also mein Code sieht jetzt jedenfalls folgendermaßen aus:

Code:

#include <avr/io.h>
#include <inttypes.h>
#include <stdlib.h>
#include <lcd.h>
#define F_CPU = 4000000UL;
#define ad_nullwert 399
#define si_multiplyer 460
#define si_const 1024


uint16_t readADC(uint8_t);			//Prototyp von readADC
void display(uint16_t result);		//Prototyp von display

char buffer[8];						//Array für itoa anlegen
int si_temp;						//Hilfvariable für Temperaturberechnung anlegen
int	si_ones;
int si_komma;

int main(void) 
{
	
	DDRD = 0xff;  					//PORT D als Ausgang definieren (Hier sind 8 LED`s angeschlossen
	DDRB = 0xff;					//PORT B als Ausgang

	//Auslesen der analogen Spannungen an Pin 0, also ADC0. In result steht das Ergebnis.
	uint16_t result = readADC(0);	
									 
	display(result);				//Umrechnung und Ausgabe der Temperatur auf Display und LED`s
	return 0;
}


void display(uint16_t result)
{
	lcd_init(LCD_DISP_ON_CURSOR);	//LCD initialisieren
	lcd_gotoxy(0,0);				//Cursor an erste Stelle setzen
	lcd_puts("Temperatur:");		//"Temperatur" ausgeben
	lcd_gotoxy(0,1);				// Cursor in die zweite Zeile setzen
	itoa((int)result,buffer,10);	//AD-Wert umrechnen
	lcd_puts(buffer);				//AD-Wert in der zweiten Zeile ausgeben
	
	lcd_gotoxy(11,0);				// Cursor hinter "Temperatur:" setzen

	//Berechnung der Temperatur 
	si_temp=((result-ad_nullwert)*si_multiplyer)/si_const;
	// Die Ganzen Grade Berechnen 
	si_ones=si_temp/10;
	//Die eine Nachkommastelle Berechnen 
	si_komma=si_temp%10; 
	// Die Zehnerstellen ans Display ausgeben 
	itoa(si_ones,buffer,10); 
	lcd_puts(buffer); 
	lcd_putc(','); 
	itoa(si_komma,buffer,10); 
	lcd_puts(buffer);

	PORTD = result;					//Den Digitalen Wert mit Hilfe der LED`s anzeigen
	return;
}


uint16_t readADC(uint8_t channel) 

{
	uint8_t i;
	uint16_t result = 0;
	
	// Den ADC aktivieren und Teilungsfaktor auf 32 stellen
	ADCSRA = (1<<ADEN) | (1<<ADPS0) | (1<<ADPS2);

	// Kanal des Multiplexers waehlen (ADC 0)
	ADMUX = (!(1<<MUX0)) | (!(1<<MUX1)) | (!(1<<MUX2));
	
	// interne Referenzspannung verwenden (also 2,56 V)
	ADMUX |= (1<<REFS1) | (1<<REFS0);
	
	// Den ADC initialisieren und einen sog. Dummyreadout machen
	ADCSRA |= (1<<ADSC);
	while(ADCSRA & (1<<ADSC));
	
	// Jetzt 3x die analoge Spannung and Kanal channel auslesen
	// und dann Durchschnittswert ausrechnen.
	for(i=0; i<3; i++) {
		// Eine Wandlung
		ADCSRA |= (1<<ADSC);
		// Auf Ergebnis warten...
		while(ADCSRA & (1<<ADSC));
		
		result += ADC;
	}
	
	// ADC wieder deaktivieren
	ADCSRA &= ~(1<<ADEN);
	
	result /= 3;
	
	return result;
}

Grüße!!

Bean

**T.J.** · 06.12.2007, 19:39

nimm doch einfach mal n Wasserkocher her, dann hast du den Wert auch

aber du kannst dir doch auch die ADC-Wertänderung pro°C nehmen, den ADC-Wert bei 0°C und das zusammenrechnen!

**Mr Bean** · 06.12.2007, 20:08

Hallo

Vielen Dank!!! Da hätt ich auch selber drauf kommen könne...

Aber wäre ich bestimmt auch noch wenn ich mich angestrengt hätte. Ich hab jetzt noch etwas mit den Werten herumgespielt und jetzt wird eine Temp von 22 °C angezeigt. Nur die "Steilheit" stimmt glaube ich noch nicht so ganz. Vielleicht könnte mir wkrug da noch einmal den genauen Zusammenhang erklären. Das wäre super.
Vielen Dank noch einmal für alle Lösungsvorschläge!! Ihr helft einem wirklich weiter!!! =D> =D> =D>

Grüße!!

Bean

Code:

#include <avr/io.h>
#include <inttypes.h>
#include <stdlib.h>
#include <lcd.h>

#define F_CPU = 4000000UL
#define ad_nullwert 399
#define si_multiplyer 460
#define si_const 70


uint16_t readADC(uint8_t);			//Prototyp von readADC
void display(uint16_t result);		//Prototyp von display

char buffer[8];						//Array für itoa anlegen
int si_temp;						//Hilfvariable für Temperaturberechnung anlegen
int	si_ones;
int si_komma;

int main(void) 
{
	DDRB = 0xff;					//PORT B als Ausgang

	//Auslesen der analogen Spannungen an Pin 0, also ADC0. In result steht das Ergebnis.
	uint16_t result = readADC(0);	
									 
	display(result);				//Umrechnung und Ausgabe der Temperatur auf Display und LED`s
	return 0;
}


void display(uint16_t result)
{
	lcd_init(LCD_DISP_ON_CURSOR);	//LCD initialisieren
	lcd_gotoxy(0,0);				//Cursor an erste Stelle setzen
	lcd_puts("Temperatur:");		//"Temperatur" ausgeben
	lcd_gotoxy(0,1);				// Cursor in die zweite Zeile setzen
	itoa((int)result,buffer,10);	//AD-Wert umrechnen
	lcd_puts(buffer);				//AD-Wert in der zweiten Zeile ausgeben
	
	lcd_gotoxy(11,0);				// Cursor hinter "Temperatur:" setzen

	//Berechnung der Temperatur 
	si_temp=((result-ad_nullwert)*si_multiplyer)/si_const;
	// Die Ganzen Grade Berechnen 
	si_ones=si_temp/10;
	//Die eine Nachkommastelle Berechnen 
	si_komma=si_temp%10; 
	// Die Zehnerstellen ans Display ausgeben 
	itoa(si_ones,buffer,10); 
	lcd_puts(buffer); 
	lcd_putc(','); 
	itoa(si_komma,buffer,10); 
	lcd_puts(buffer);
	return;
}


uint16_t readADC(uint8_t channel) 

{
	uint8_t i;
	uint16_t result = 0;
	
	// Den ADC aktivieren und Teilungsfaktor auf 32 stellen
	ADCSRA = (1<<ADEN) | (1<<ADPS0) | (1<<ADPS2);

	// Kanal des Multiplexers waehlen (ADC 0)
	ADMUX = (!(1<<MUX0)) | (!(1<<MUX1)) | (!(1<<MUX2));
	
	// interne Referenzspannung verwenden (also 2,56 V)
	ADMUX |= (1<<REFS1) | (1<<REFS0);
	
	// Den ADC initialisieren und einen sog. Dummyreadout machen
	ADCSRA |= (1<<ADSC);
	while(ADCSRA & (1<<ADSC));
	
	// Jetzt 3x die analoge Spannung and Kanal channel auslesen
	// und dann Durchschnittswert ausrechnen.
	for(i=0; i<3; i++) {
		// Eine Wandlung
		ADCSRA |= (1<<ADSC);
		// Auf Ergebnis warten...
		while(ADCSRA & (1<<ADSC));
		
		result += ADC;
	}
	
	// ADC wieder deaktivieren
	ADCSRA &= ~(1<<ADEN);
	
	result /= 3;
	
	return result;
}

**izaseba** · 06.12.2007, 20:39

Hallo Bean,

ich wollte noch eine andere Möglichkeit zeigen, wie man die Temperatur problemlos ermitteln kann, auch wenn der Sensor nicht linear ist und zwar die lookup Tabelle.

Es hat leider einen Nachteil, man muß sich mit einer Messreihe die ADC Werte für die entsprechende Temperatur im Wasserbad ermiteln.

Es geht so, man legt eine Array im Flash an:

Code:

const int TEMP_Celsius_pos[] PROGMEM =    // Positive Celsius temperatures (ADC-value)
        {                           // from 0 to 60 degrees
            806,796,786,775,765,754,743,732,720,709,697,685,673,661,649,
            636,624,611,599,586,574,562,549,537,524,512,500,488,476,464,
            452,440,429,418,406,396,385,374,364,354,344,334,324,315,306,
            297,288,279,271,263,255,247,240,233,225,219,212,205,199,193,
            187,
        };

Das sind jetzt Werte von 0-60 Grad.

Auslesen kann man es dann so:

Code:

for (i=0; i<60; i++)
                {
                   
                    if (ADCresult >= pgm_read_word(&TEMP_Celsius_pos[i]))
                    {
                        break;
                    }
                }

in i steht nach verlassen der Schleife die Temperatur drin.

Quelle : AVR Butterfly gccport

Gruß Sebastian

**robocat** · 06.12.2007, 20:41

hi Mr Bean,
ein 16bit integer kann ja (unsigned) nur zahlen bis 2^16=65536 darstellen. wenn ein zwischenergebnis einer berechnung einen groesseren wert ergibt, läuft der 16bit int über (1111 1111 1111 1111 (binär für 65536) + 1 = 0!!). bei..

Code:

si_temp=((result-399)*460)/70;

..ist das bereits der fall, wenn result > 541 ist. du solltest also (da es sich eh kürzt) *46 und geteilt durch 7 rechnen. bei uint16_t´s bist du dann auf der sicheren seite.

gruesse von der katz

Thema: Temperaturmessung und Anzeige auf Display

Themen-Optionen

Thema durchsuchen

Anzeige

Lesezeichen

Lesezeichen

Berechtigungen