Steinhart-hart oder standard-ntc-formel?

Hallo!

Ich verwende zur Zeit am Arduino die standard NTC-Formel

T=B*Tn / (B+log (Rt/Rn)*Tn)

Macht es auf Grund der Genauigkeit vll trotzdem Sinn, die Steinhart-Hart-Gleichung zu verwenden?

Gruß
Morris

NIcht unbedingt.

Wenn du die Daten des NTC hast dann kannst du auch die Standardgleichung nehmen.

Steinhart/Hart macht vor allem Sinn, wenn du die Kennlinie des NTC erst selbst ermitteln mußt.

Ich würde es aber trotzdem anders lösen. Logarithmen rechnet der Arduino nur sehr ungern.
Besser ist es hier offline (in Execl) mit dem verwendete Vorwiederstand eine Wertetabelle zu errechen. (AD-Wert / Temperatur)
Meist reichen ca. 10 Stützstellen mit einer Verdichtung im "interessanten" Bereich.
die Werte zwischen den Stützstelle werden dann linear interpoliert. Das kann der Arduino gut.

Wieso rechnet der Arduino ungerne Logarithmen?

maeckes:
Macht es auf Grund der Genauigkeit vll trotzdem Sinn, die Steinhart-Hart-Gleichung zu verwenden?

Oder ergibt es aufgrund der Genauigkeit (der Arduino ADC hat nur 10-Bit Auflösung) nicht sogar viel mehr Sinn, einen digitalen Temperatursensor mit beispielsweise 12-bit interner Auflösung zu verwenden, wenn man auf mehr Genauigkeit Wert legt?

Wenn es auf eine Stelle hinter dem Komma genau ist, wäre ich zufrieden.

Welche digitalen Sensoren meinst Du?

maeckes:
Wieso rechnet der Arduino ungerne Logarithmen?

Weil er dafür sehr, sehr lange braucht, und die Genauigkeit auch recht schlecht ist.

Ich hatte mal eine Funktion zum Interpolieren aus einer Wertetabelle geschrieben:

/*************************************************************************************************
**  NTClesen							by Gunther Breu 2013		**
**************************************************************************************************
** Funktionsbeschreibung									**
** Aus AD Wert wird mittels SensTab ein Temperaturwert interpoliert				**
** Aus diesem Wird ein gleitender Mittelwert (Wertigkeit Tempfilterfaktor) gebildet.		**
** ADFehler bei < ValidUG oder > ValidOG							**
**  											   	**
**  Input:	Sensornummer									**
**  Output:	nix										**
**  genutzte Globale Variablen: TempSensorfehler, TempWerte 					**
**************************************************************************************************/

void NTClesen(int _SensorNr) {
  static boolean init = true;
  const int Tempfilterfaktor = 50;
  const int ValidUG 8     // festlegen der unteren Grenze für gültige AD-Werte
  const int ValidOG 1020  // festlegen der oberen Grenze für gültige AD-Werte
  /* Wertetabelle Sensor Werte */  
  const int Sensorpunkte  25
  const float SensTab[Sensorpunkte][2]={{1,	911.940},   // Sensortabelle Accurite GT
					{8,	468.799},
					{16,	385.986},
					{35,	311.374},
					{60,	268.223},
					{90,	238.958},
					{130,	214.158},
					{180,	193.142},
					{250,	172.321},
					{350,	150.673},
					{450,	133.529},
					{530,	121.375},
					{600,	111.237},
					{665,	101.865},
					{730,	92.173},
					{790,	82.533},
					{845,	72.580},
					{890,	63.0},
					{925,	53.940},
					{955,	44.97},
					{976,	35.18},
					{992,	25.644},
					{1008,	11.104},
					{1016,	-2.58},
					{1023,	-35.470}};


                                    
                                    
  int SensorAD = analogRead(_SensorNr);  
      
  // Überprüfen des AD-Signales auf Gültigkeit
  if (SensorAD < ValidUG || SensorAD > ValidOG){
     TempSensorfehler = true;
     TempWerte = -99;
  } else{ TempSensorfehler = false;
  }
    
  if (!TempSensorfehler){              // Suchen des passenden Wertepaares zum Messwert
    int i = 0;    
    while (i < Sensorpunkte && SensorAD > SensTab[i][0]){i++;}   

    double Temp = (   ((SensTab[i][1] - SensTab[i-1][1]) * ( SensorAD - SensTab[i-1][0] ))  // interpolieren der Werte zwischen
   		    / (SensTab[i][0] - SensTab[i-1][0] ))                                   // Stelle i und Stelle i+1
                   + SensTab[i-1][1];


    if (init){  // beim ersten Mal den Speicher des gefilterten Wertes initialisieren.
      init =false;
      TempWerte = Temp;
    }
    
    // Filterung der Sensorwerte
    TempWerte = ((TempWerte * Tempfilterfaktor) + Temp) / (Tempfilterfaktor +1);  
  }    
} // End of NTClesen

Aber wenn du digitale Sensoren (DHT22 oder DS18B20) verwenden kannst, ist das sicherlich einfacher.
Welchen Temperaturbereich willst du denn Messen? Über 125°C tun sich die meisten digitalen Sensoren schwer.

Ich messe zur Zeit mit nem NTC eine Wassertemperatur (15-30°C).
Das ist gar kein Problem mit den NTC's, da man einfach in einen Schlauchverbinder nen Loch bohren kann und den Kopf des NTC in den Wasserstrom halten kann. Der NTC wird dann einfach mit 2K-Kleber eingeklebt und alles ist dicht.
Die Beine gucken aus dem Verbinder raus und man kann einfach nen 2poligen Stecker drauf stecken -> 1A Temperatursensor

Aber zurück zur eigentlichen Fragestellung...
Wie hoch ist der Unterschied in der Genauigkeit?

maeckes:
Aber zurück zur eigentlichen Fragestellung…
Wie hoch ist der Unterschied in der Genauigkeit?

Gegenfrage:
Welcher NTC?
Hast du die Steinhart-Hart Koeffinzienten des NTC?

Ein Standard NTC mit 10k Widerstand bei Nenntemperatur

Auf Grund des Farbcodes kann ich doch einfach die Steinhart-Hart-Koeffizienten aus dem Diagramm ziehen

maeckes:
Ein Standard NTC mit 10k Widerstand bei Nenntemperatur

Auf Grund des Farbcodes kann ich doch einfach die Steinhart-Hart-Koeffizienten aus dem Diagramm ziehen

wenn das so einfach geht, dann probier doch mal den Vergleich in Excel (oder per Taschenrechner oder eben auch im Arduino):
beide Formeln implementieren, dann die Ergebnisse untereinander und evtl mit dem Datenblatt vergleichen.

maeckes:
Welche digitalen Sensoren meinst Du?

Als reiner Temperatursensor: DS18B20 mißt von -55°C bis +125°C.
Gibt es als nackte Halbleiter oder wasserfest eingekapselt und mit Schrumpflauch und Kabel fertig vorkenfektioniert.

Für meteorologische Messungen in Luft gleich mit Luftfeuchte z.B.: DHT22