Op mijn print zit de volgende temperatuur sensor :Tc1046

Hier bij moet ik de ADC waarde omrekenen naar een temperatuur en doorsturen via de Can bus. Ik ben wel nieuwsgierig hoe jullie dat doen. Bijvoorbeeld met een lookuptable of de formule omrekenen? De adc waarde staat in de variabele an_value[TEMP_PRINT]. Ik doe het op de volgende manier:

/*calculation
formule temperatuur sensor:
        
Vout = temp * 6.25mV + 424mV

                           ad_value (0-1023)
Aref = 3.3 Volt -> Vout = ------------------- * 3300 mV ->
                                    1024
        / ad_value       \
       |---------  * 3300 |
        \  1024          /     424
temp = -------------------- - -----  = 0.515625 * ad_value - 67.84
              6.25             6.25

Ik wil niet met komma getallen werken, dus daarom vermenigvuldig ik de formule met een
factor 2^x. x hangt af van de resolutie die ik nodig heb. Deze is 1 graad (3 digits -40-125). Als ik de formule met 
2^8 vermenigvuldig kom ik op een goede resolutie uit. De formule wordt nu:

temp = 132 * ad_value - 17367 

Kijk in de functie get_temp_print hoe ik deze geimplementeerd heb.
*/
void get_temp_print(void)
{ Can_message message;
 signed short temp_print;

  // >>3 om binnen de signed short waarde te blijven
  temp_print = (132 * (unsigned long)an_value[TEMP_PRINT]) >> 3;


  //Controleren of de uitgerekende waarde groter is als 17367 >> 3 = 2171
  if(temp_print >= 2171)
  { temp_print = (temp_print - 2171) >> 5;     
  }
  else
  {temp_print = -((2171 - temp_print) >> 5);
  }

  //Versturen via de CAN bus
  message.destination = CAN_NODE_MC; 	  
  message.length = 2;
  message.id = CAN_SENSOR_TEMP_PCB;	
  message.data[0] = READ_HIGH_BYTE(temp_print);
  message.data[1] = READ_LOW_BYTE(temp_print);
  can_send (&message);
}

Het lijkt in eerste instantie ingewikkeld maar valt mee. Op deze manier heb ik een nauwkeurigheid die groot genoeg is en (volgens mij) vrij snel is.

Hoe doen jullie dit ?

Wat je gebruikt heet "fixed point" rekenwerk en wordt vaak gebruikt om fp rekenwerk te vermijden. Zo kan je van een long (32bit) een fixed point maken met 16bits voor en 16 bits na de komma. Maar elke schaling mag, dus ook 8 (3 bits). Voordeel van een punt op een veelvoud van 8 is dat je op 8 bits micros niet hoeft te shiften. Kwestie van de goede bytes ophalen.

Je hebt een beperkte precisie, maar het is veel sneller dan werken met floats.

of je een lookup table gebruikt of een formule hangt af van de lineairiteit van de sensor.
Is deze lineair dan zou ik een formule gebruiken.
Is deze verre van lineair of in een formule uit te drukken zou ik ene lookup table gebruiken.
Als je een sensor hebt die een kromme curve heeft zoals een ntc, kan je ook kiezen omdie curve op te splitsen in bijvoorbeeld 4 rechte lijnen.
Afhankelijk van de precisie die je wilt hebben