Lots of thermistors but no readout
If you have access to both leads of a NTC thermistor, then the electronics for reading the temperature are quite simple:



I deliberately showed the microcontroller and the thermistor divider running from the same supply.  That makes the readings ratiometric, with the actual supply voltage cancelling out.

These kinds of thermistors vary quite a lot in resistance over their usable temperature range.  The voltage presented to the A/D is quite non-linear as a function of resistance, and the resistance is quite non-linear as a function of temperature.  What I usually do is put the whole mess into a lookup table.  You can use all the nasty floating point exponentials you want to compute the lookup table at build time.  At run time you just get the A/D value and look it up in a table if you have lots of program memory, or you make the table smaller than the A/D range and interpolate between adjacent entries using the lower bits of the A/D reading.  Either way, it's pretty simple at run time to go from A/D reading to whatever temperature representation you choose internally.

I recently did a project where a dsPIC had to read a temperature, among other things.  I used the preprocessor to build the lookup table for me.  First, I created a preprocessor subroutine to convert Ohms to &deg;C using the equation and constants straight out of the thermistor datasheet:


////////////////////////////////////////////////////////////////////////////////
//
//   Subroutine THERM_R_C r
//
//   Set the variable DEGC to the temperature in degrees C indicated by the
//   thermistor having a resistance of R.  R is in Ohms.
//
/const   a1      real = 3.354016e-3
/const   b1      real = 2.569850e-4
/const   c1      real = 2.620131e-6
/const   d1      real = 6.383091e-8
/const   rref    real = 10.0e3 ;resistance at the reference temperature
/const   c0k     real = 273.15 ;degK at 0 degC

/var exist degc real

/subroutine therm_r_c
  /var local r real = [arg 1] ;get thermistor resistance in Ohms
  /var local lrr real = [log [/ r rref]]
  /var local x real

  /set x a1
  /set x [+ x [* b1 lrr]]
  /set x [+ x [* c1 [exp lrr 2]]]
  /set x [+ x [* d1 [exp lrr 3]]]
  /set x [/ 1 x]
  /set degc [- x c0k]
  /endsub

I then added code to the A/D module that wrote the A/D reading to temperature lookup table at build time:


////////////////////////////////////////////////////////////////////////////////
//
//   Temperature sensor to temperature lookup table.
//
//   This lookup format is compatible with the library subroutine
//   LOOKUP_LIN_PROG.  The first word is the number of segments in the table,
//   which must be a power of 2 and at least 2.  Subsequent words are the data
//   points.  Since segments are the ranges between adjacent data points, there
//   segments+1 data points.
//
//   Both the table input and output values are unsigned 16 bit integers.  The
//   input value is the filtered A/D reading shifted left to maximally fill the
//   16 bits.  FFULL is the input value for a full scale reading.
//
//   Since the temperature values are signed, 32768 will be added to them in the
//   table so that they can be interpolated as unsigned values.  The user of the
//   lookup table must subtract 32768 from the result to get the temperature
//   corresponding to the 0-FFF0h filtered and shifted temperature sensor A/D
//   reading.
//
/const   tempibits integer = [rnd [log2 ntempseg]] ;num int bits in input value
/if [ [exp 2 tempibits] ntempseg] then
  /show "  NTEMPSEG is not a power of 2"
         .error  "NTEMPSEG"
  /stop
  /endif

tbl_temp:                    ;start of A/D reading to temperature lookup table
         .pword  [v ntempseg] ;number of linear segments in the table.
/block
  /var local ii integer      ;0-NTEMPSEG data point number
  /var local reading integer ;16 bit shifted A/D reading at this point
  /var local v real          ;voltage at this data point
  /var local r real          ;thermistor resistance
  /var local dpoint integer  ;integer table value at this data point
  /var local s string

  /set ii 0                  ;init to first data point
  /block                     ;back here each new data point
    /set reading [shiftl ii [- 16 tempibits]] ;make 16 bit table input value here
    /set v [* [/ reading ffull] vfull] ;make voltage at this point
    /set v [max v 0.005]     ;clip to min/max voltage range
    /set v [min v [- vfull 0.005]]

    /set r [/ [- vfull v] v] ;ratio of top to bottom resistances
    /set r [* r tempr2]      ;thermistor resistance

    /call therm_r_c [v r]    ;compute temperature from this resistance

    /set dpoint [+ [rnd [/ degc .1]] 32768] ;make integer table value

    /set s ""
    /call tabopcode s
    /set s [str s ".pword"]
    /call taboperand s
    /set s [str s dpoint]
    /call startcomm s
    /set s [str s [int ii "fw 4"]]
    /set s [str s "   " [fp v "fw 6 sig 0 mxl 6 rit 3"] " V"]
    /set s [str s "   " [int [rnd r] "fw 7"] " Ohms"]
    /set s [str s "   " [fp degc "fw 7 sig 0 mxl 6 rit 1"] " C"]
    /write s

    /set ii [+ ii 1]         ;advance to next data point number
    /if [&lt;= ii ntempseg] then
      /repeat
      /endif
    /endblock
  /endblock

Most of the bulk of this code is nicely formatting the table to make it easy to verify by looking at the result and during debugging.

Here is the final assembly code for the table:


tbl_temp:                    ;start of A/D reading to temperature lookup table
         .pword  256 ;number of linear segments in the table.
         .pword  32134       ;   0    0.005 V   1796400 Ohms     -63.4 C
         .pword  32222       ;   1    0.010 V    917775 Ohms     -54.6 C
         .pword  32321       ;   2    0.020 V    457087 Ohms     -44.7 C
         .pword  32382       ;   3    0.029 V    303525 Ohms     -38.6 C
         .pword  32427       ;   4    0.039 V    226744 Ohms     -34.1 C
         .pword  32463       ;   5    0.049 V    180675 Ohms     -30.5 C
         .pword  32493       ;   6    0.059 V    149963 Ohms     -27.5 C
         .pword  32520       ;   7    0.068 V    128025 Ohms     -24.8 C
   ...
         .pword  33252       ; 124    1.211 V      3830 Ohms      48.4 C
         .pword  33256       ; 125    1.221 V      3771 Ohms      48.8 C
         .pword  33260       ; 126    1.231 V      3713 Ohms      49.2 C
         .pword  33264       ; 127    1.241 V      3655 Ohms      49.6 C
         .pword  33269       ; 128    1.250 V      3598 Ohms      50.1 C
         .pword  33273       ; 129    1.260 V      3542 Ohms      50.5 C
         .pword  33277       ; 130    1.270 V      3488 Ohms      50.9 C
         .pword  33281       ; 131    1.280 V      3433 Ohms      51.3 C
   ...
         .pword  34540       ; 249    2.432 V       100 Ohms     177.2 C
         .pword  34618       ; 250    2.442 V        85 Ohms     185.0 C
         .pword  34713       ; 251    2.452 V        71 Ohms     194.5 C
         .pword  34835       ; 252    2.462 V        56 Ohms     206.7 C
         .pword  35000       ; 253    2.471 V        42 Ohms     223.2 C
         .pword  35254       ; 254    2.481 V        27 Ohms     248.6 C
         .pword  35759       ; 255    2.491 V        13 Ohms     299.1 C
         .pword  36256       ; 256    2.495 V         7 Ohms     348.8 C


Note that due to how the resistor divider works, you get the maximum resistance resolution in the middle of the range.  In other words, make R2 the value the thermistor will have at the point you want the maximum resolution.

In this case, the processor had a 12 bit A/D but I only used a table with 256 entries.  The high 8 bits of the A/D reading indexed into the table, and the additional low 4 bits were used to linearly interpolate between the adjacent table entries identified by the high 8 bits.

Keep in mind these thermistors are not that accurate, but you can get a lot of resolution using this method.  For a stable control system, good resolution is useful to keep the numbers "smooth".  Accuracy is what it is.  Look at the thermistor datasheet, and don't forget to account for the error of R2 also.  Put another way, these NTC thermistors with a resistor divider may only be able to tell you it's 51.2&deg;C &plusmn; 2&deg;C, but can tell you the temperature just went up by 0.1&deg;C.