NTC Erfassung ohne Fließkomma-Arithmetik

Klarer Fall für eine Wertetabelle.

Einfach in Excel (oder LibreOffice) die erwarteten ADC Werte für 
ganzzahlige Temperaturwerte ausrechnen und als Array (im Flash) 
speichern.

Der Code muss nur die Position in der Tabelle finden, für die Tabelle[x] 
<= adc_wert <= Tabelle[x+1] gilt, und dann linear interpolieren für 
einen recht genauen Temperaturwert.

Die Tabelle bräuchte allerdings für 230 Temperaturwerte 460 Byte 
Speicherplatz. Kannst Du den Bereich weiter einschränken? Können 
Temperaturen >100°C überhaupt auftreten?

Ja Entschuldigung! Es geht um die T-R Beziehung von Heißleitern:

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

Der Kern der Frage ist, wie man long-Variablen logarithmieren kann ohne 
arg an Genauigkeit zu verlieren. Eine "eingebaute" Funktion gibt es 
offenbar dafür nicht.

> ... , rechne doch mit 'float' ;-)

Die 8bit AVR Mikrocontroller rechnen eh nur mit "float" auch wenn man 
"double" im C-Programm schreibt.

hab was gefunden. Hier wurde das Thema mit dem Logarithmus schon mal 
beackert:

Beitrag "Code für Logarithmus gesucht"

Danke für alle Reaktionen.

Bernd

Dank des Beitrages: Beitrag "Algorithmus für Logarithmus-Bererechnung?"
bin ich zu einer Lösung gekommen, die auf meinem Tiny 1.5kbyte spart.
Die feste Skalierung in ln_m() ist natürlich ein Kompromiss. Im 
mittleren Temperaturbereich ist aber eine Auflösung von 0.1 °C gut 
erreichbar.

long adc2_mC(long adcval){    // 10bit ADC > T in milli°C Einheiten
#define B_ntc    3988L        // NTC-Empfindlichkeit in K
#define Tn_ntc    298L        // 25°C Bezugstemperatur in K
#define Rn_ntc  10000L        // 10k Widerstand bei Bezugstemperatur
#define Tzero  273150L        // mK
#define R       10000L        // 10k Gegenwiderstand der Halbbruecke
long rntc,tntc,ne;
    if (adcval<10) adcval=10;      // 194.1°C
    if (adcval>1010) adcval=1010;   // -47.3°C
    rntc = ((long)adcval*R)/(1024-adcval);          // Rntc 1/1000 genau
    ne = B_ntc + (ln_m((rntc*1000)/Rn_ntc)*Tn_ntc)/1000; // Nenner in K
    tntc= (1000*B_ntc*Tn_ntc)/ne;   // mK= mK*K/K
    return (tntc-Tzero);      // mC
}

long ln_m(long x){// In/Output als milli-Zahlen von 
10(=0.01)..100000(=100)
#define SCALE 9    // Erweitern mit 2^SCALE und später SCALE abziehen
long lval;    // (Logarithmengesetz)
uint32_t rval;
   lval=(x*(1<<SCALE))/1000;  //
   if (lval>0xFFFF) lval=0xFFFF; if (lval<1) lval=1;// Begrenzen
   rval=fixlog2((uint16_t)lval);  // Aufruf mit Typ-Anpassung
   lval=(rval >> 16)*1000000 + ((rval & 0xffff) * 15625 >> 10) - 
SCALE*1000000;// ppm genau -9...7
   lval=((lval/100)*6931)/100000; // Umrechnung log2->ln -6.238 bis 
4.852
   return lval ;      // Ausgabe als milli-Zahl
}

uint32_t fixlog2(uint16_t x) { // Input 0...64k   Output: Fixkomma 16.16
  uint32_t q;                          // 2.30
  uint16_t y = 0;                      // 0.16
  uint8_t intpart = 15, i;             // 8.0

  while(!(x & 0x8000)) {x <<= 1;intpart--;} // die Ganzen ermitteln

  for(i=0; i<16; i++) {
    q = (uint32_t)x * x;               // x: 1.15, q: 2:30
    y <<= 1;
    if(q & (uint32_t)1 << 31)          // q >= 2.0?
      y |= 1;                          // 1-Bit -> y, q *= 2, q: 1.31
    else
      q <<= 1;                         // 0-Bit -> y, q: 1.31
    x = q >> 16;                       // x = q
  }
  return (uint32_t)intpart << 16 | y;  // return: 16.16
}  // Quelle: Beitrag "Algorithmus für Logarithmus-Bererechnung?"

Bernd N schrieb:
> adcval=10 = 194.1°C
> adcval=1010 = -47.3°C
>
> Und daraus machst du eine einfache Gleichung.

Die NTCs sind leider alles andere als linear. So einfach geht es IMHO 
nicht.

Erst sollte man mal das Problem spezifizieren und nicht gleich die 
Loesung vorwegnehmen. Also, man moechte einen NTC im Bereich von -47 bis 
182 °C betreiben, glaub ich gleich mal nicht. Und dann noch 0.1 Grad 
anzeigen wollen. Aha. Mit einem 10bit ADC. Sonst noch was ?

Woher kommen die -47 Grad ? Von einem Peltier ? Da muss man gut sein. 
Einen 2 stoeckigen und sehr gute Isolation. Nicht trivial.
Die 180 Grad ? Ein Epoyk NTC ist nur bis 150 oder so spezifiziert.
Mit 10 bit? Nie. NIE ! Schreib mal eine Simulation der Werte, und der 
Aufloesung auf dem PC. Aus dem Bauch heraus sag ich mal, die 10 bit 
reichen nicht mal fuer 1 Grad Aufloesung. Die Genauigkeit lassen wir mal 
weg.

Jetzt Nicht schrieb:
> Und dann noch 0.1 Grad anzeigen wollen. Aha. Mit einem 10bit ADC.
War auch mein Gedanke. Die "Auflösung" kann der TE ja bei der Ausgabe 
haben, was die dann aber mit dem realen Wert zu tun hat ist eine ganz 
andere Frage.

Ich rechne auch NTC, allerdings nur 3 mal pro Sekunde.
Ich rechne die Linearisierung mit float, 32bit, aus
folgenden Gruenden:
- Ein approximierendes Polynom muesste fuer die gewuenschte
  Aufloesung und Genauigkeit 6.Ordnung sein. Der
  Linearisierungspunkt waere dann aber ohne Float nicht
  mehr frei waehlbar.
- Ich verwende einen 24bit Wandler
- ich moechte besser als 5mK Aufloesung, zum Regeln
- der NTC ist spezifiziert als 1%
- die absolute Genauigkeit ist vielleicht 2 Grad, begrenzt
  durch den NTC

Alle nachfolgenden Berechnungen gehen dann mit 32 bit
Integern.

Bernd K. schrieb:
> Die Code-Zeilen mit double-Arithmetik kosten ganze 1500bytes.

Wo ist das Problem, schon die 8-Pinner AVR haben bis zu 8kB Flash.
Mußt Du unbedingt einen 6-Pinner verwenden?

Bernd K. schrieb:
> Hat jemand eine Idee zu einer codesparenden und trotzdem genauen
> Alternative?
Ich würde eine Lookuptabelle und lineare Interpolation vorschlagen.

Definiere "genau".
Bernd K. schrieb:
> if (adcval<10) adcval=10;      // 194.1°C
> if (adcval>1010) adcval=1010;   // -47.3°C
Vergiss diese Kommastellen ganz schnell. Vermutlich hat nämlich dein NTC 
schon 5% Fehler...

SMT-160-30-18
Nicht gerade günstig, aber ne super Auflösung.

Vielen Dank für die Hinweise!
Das schöne am NTC ist ja seine Nichtlinearität.
Im konkreten Einsatz als Drainback-Steuerung einer Thermischen 
Solaranlage ist das sehr praktisch. Außerdem werden dort üblicherweise 
nur PT100 oder NTCs verbaut. Die Anforderung bestand aus zwei Punkten:
1. genaue Messungen um die 0°C (Frostschutzfunktion) und
2. über den ganzen real auftretenden T-Bereich von sagen wir mal -30 bis 
+150°C überhaupt Meßergebnisse zu bekommen und keinen Over-/Underflow.

LUTs sind sicher ein pragmatischer Ansatz. Der Weg über den 
Festpunkt-Logarithmus funktioniert aber auch.

OK, Profis nehmen einfach einen größeren Prozessor und haben die 
Probleme nicht. Hab mich aber auf den ATtiny85 mit Funk-Interface HM-TRP 
eingeschossen. Ich finde es immer wieder beeindruckend, was man aus dem 
Kistchen rausholen kann. Dank dem Bootloader von Peter Dannegger fürs 
Update via Klinkenbuchse und Debugging via Soft-UART (beides 1-Wire), 
kommt man trotz der knappen Resourcen schnell zum Erfolg. Man darf nur 
nicht auf die Idee kommen, dicke Libs einzubinden.

8 Pins sind wenig, aber es reicht mit ein Paar Kniffen für die 
Ansteuerung/Auslesung von:
1x Ventil
1x Pumpe
1x NTC
1x Messung von Pumpen oder Ventilstrom
3 Tasten
2 LEDs
1x RS232 (1-Wire)
1x Servomotor mit Stromüberwachung
... und der Resetpin ist immer noch aktiv :-)

Wen es interessiert, bitte melden.

>>   Der
>   Linearisierungspunkt waere dann aber ohne Float nicht
>   mehr frei waehlbar.

>Quatsch.

Aber nicht im Feld als Parameter, denn dann wuerde man ja wieder float 
brauchen um das Polynom zu rechnen.