Faced with the need to measure heatsink temperature in an Arduino project and being unwilling to putz around with a MAX6675 thermocouple amp, I found a bag of thermistors in the heap. Unlike most surplus, the bag pedigreed them as Semitec 103CT-4, which led to some relevant parameters:

• T0 = 25 °C
• R0 = 10 kΩ
• B = 3270 K

The equation for a thermistor’s resistance at a given temperature (in K, not °C) is:

R = R0 * e(B/T - B/T0)

The canonical Arduino thermistor circuit uses a series resistor with a value equal to R0:

Thermistor Linearization - Rseries

Setting Rseries = 10 KΩ and applying a bit of spreadsheet-fu produces this:

Thermistor Linearization - Rseries - Graph

Getting within +2 °C /-1 °C over -20 °C to 60 °C isn’t all that bad, but … I wondered whether there might be an easy way to get better linearization. The heatsink temperature will range from about -10 °C to 60 °C (yes, there will be a Peltier cooler involved), so the range is a bit broader than usual.

A bit of diligent rummaging turned up that description, which led to US Patent 3,316,765 from back in 1967, which teaches the concept of two different thermistors, one for low temperatures and one for high temperatures, with some resistive blending:

Patent 3316765 Fig 3

The patent includes the claim of many different thermistors, each with a series resistor, to cover a much broader temperature range.

Given a bag of identical thermistors, I wondered what might be possible. A bit more spreadsheet-fu produced this:

Thermistor Linearization - Dual Thermistors - Graph

Which corresponds to this sketch, with Rseries = 6.2 kΩ, R1 = 27 kΩ, and R2 = 0.0:

Thermistor Linearization - Dual Thermistors

All in all, a nicely centered ±1 °C error from -15 °C to +60 °C can’t be beat. The output voltage even spans 0.13 to 0.71 of Vcc, about 9 of the available 10 ADC bits.

Those two resistors came from hand-tweaking with standard values, so it’s not like there’s a genetic algorithm involved. The value of Rseries wants to be a bit below the parallel combination of the two branches near 30 °C and R1 seems happiest around the 0 °C thermistor resistance. I vaguely thought about using a multivariable solver, but what’s the point?

The result seems good enough that I didn’t try three thermistors. T2, the one with R2=0, already handles the high temperature range and the low end is fine, so it seems there’s not much to be gained. If you had a stash of different thermistors and knew their characteristics, then the results would be different.

Admittedly, one could program the actual logarithmic equation to unbend a single thermistor’s voltage into temperature, but I must kludge up a thermistor mount anyway, so why not entomb two thermistors and an SMD resistor, then use a linear fit? It’s not like fancy math will give the whole lashup any greater accuracy.

The spreadsheet may be of interest. It started out as an OpenOffice spreadsheet, but WordPress doesn’t permit *.ods files, soooo it’s in MS Excel format.

A small tweak to that code produces a sync pulse for each full sine wave of microstepping current, aligned with the step pulses. The sync pulse occurs on the rising edge of the current waveform (because I set it up that way) and has 50% duty cycle to allow triggering at either zero-current microstep.

Then pix like this happen:

Microstepping Group Sync

The traces:

• top = 1/group sync
• middle = winding current at 500 mA/div
• bottom = step pulse, 1/microstep

The big jump just before the zero-current microstep on the decreasing-current sides of the sine wave indicates that it’s hard to get all the current out of the windings at 12 V. A detail view of those steps shows that the current is 50% higher than it should be at the start of the zero-current microstep, having completely missed the last microstep:

Decreasing Current

Which, of course, is why I’m doing all this: to explore that kind of behavior.

You may find the generated sync pulses are off by ±1 microstep from the expected start of the zero-current microstep, because the optical 1/rev signal threshold may line up perversely with the start of a microstep. You can twist the sync wheel just slightly on the shaft, but it’s pretty much a matter of shaking the dice to see if a better combination comes up. Doesn’t make any real difference to the scope triggering, though, as any stable sync alignment is as good as any other.

The code uses the 1/rev optical sync pulse once, to get the initial alignment, so whacking the wheel as it rotates may cause the generated sync pulses to skip a beat or twenty. The result remains stable, just at a different alignment.

One could argue that you really don’t need the 1/rev optical signal at all, but I find it comforting to use an absolute rotational reference to lock the pulses in (pretty nearly) the same place every time. If you’re stuck with an in-place motor, then you probably don’t have a 1/rev signal and you must wing it.

The Arduino source code:

// Stepper motor driver synchronization
// Ed Nisley KE4ZNU June 2011

//-- Stepper parameters

#define SYNC_OFFSET            8        // steps from 1/rev pulse to start of first 4-full-step group

#define FULL_STEPS_PER_REV    200
#define MICROSTEPPING        8

#define GROUPS_PER_REV (FULL_STEPS_PER_REV / 4)
#define STEPS_PER_GROUP (MICROSTEPPING * 4)

//-- Pin definitions, all of which depend on internal hardware: do *not* change

#define PIN_REV        2                // INT0 = positive 1/rev pulse from optical switch
#define PIN_STEP    5                // T1 = positive 1/step pulse from stepper driver
#define PIN_TRIGGER    9                // OC1A = positive trigger pulse to scope

//-- Trace outputs may be chosen freely

#define PIN_TRACE_A    10
#define PIN_TRACE_B    11
#define PIN_TRACE_C    12

#define PIN_LED        13                // standard Arduino LED

//---------------------
// State Variables

word PulseCounter;

//---------------------
// Useful routines

//--- Input & output pins

void TogglePin(char bitpin) {
digitalWrite(bitpin,!digitalRead(bitpin));    // toggle the bit based on previous output
}

//----------------
// Initializations

void setup() {

pinMode(PIN_REV,INPUT);        // INT0 1/rev pulse from wheel

pinMode(PIN_STEP,INPUT);        // T1 step pulse from stepper driver

pinMode(PIN_LED,OUTPUT);
digitalWrite(PIN_LED,LOW);

pinMode(PIN_TRACE_A,OUTPUT);
pinMode(PIN_TRACE_B,OUTPUT);
pinMode(PIN_TRACE_C,OUTPUT);

//--- Prepare Timer1 to count external stepper drive pulses

TCCR1B = B00001000;                // Timer1: Mode 4 = CTC, TOP = OCR1A, clock stopped

pinMode(PIN_TRIGGER,OUTPUT);        // OC1A to scope trigger

//-- Wait for rising edge of 1/rev pulse from optical switch

TCCR1A = B11000000;                        // COM1A set on compare
TCNT1 = 0;                                // ensure we start from zero
OCR1A = SYNC_OFFSET;                        // set step counter

while(!digitalRead(PIN_REV)) {            // stall until 1/rev input rises
TogglePin(PIN_TRACE_A);
}

//-- Got it, fire up the timer to count steps to start of first group

TCCR1B |= B00000111;                        // enable clock from T1 pin, rising edge

digitalWrite(PIN_LED,HIGH);                // show we got here
digitalWrite(PIN_TRACE_A,LOW);

while(!(TIFR1 & _BV(OCF1A))) {            // wait for compare
digitalWrite(PIN_TRACE_B,digitalRead(PIN_STEP));
continue;
}
TIFR1 |= _BV(OCF1A);                        // clear match flag

//-- Scope sync pulse is now active, we can enter the main loop

}

//----------------
// The main event

void loop() {

//-- Scope sync pulse active

digitalWrite(PIN_LED,LOW);                // show we got here
digitalWrite(PIN_TRACE_B,LOW);

//-- Set up for first half of the group, sync high -> low

TCCR1A = B10000000;                        // COM1A clear on compare
OCR1A = (STEPS_PER_GROUP / 2) - 1;

while(!(TIFR1 & _BV(OCF1A))) {            // wait for compare
digitalWrite(PIN_TRACE_B,digitalRead(PIN_STEP));
continue;
}
TIFR1 |= _BV(OCF1A);                        // clear match flag
digitalWrite(PIN_TRACE_B,LOW);

//-- Set up for the second half, sync low -> high

TCCR1A = B11000000;                        // COM1A set on compare
OCR1A = (STEPS_PER_GROUP - (STEPS_PER_GROUP / 2)) - 1;    // may be odd, so allow for that

while(!(TIFR1 & _BV(OCF1A))) {            // wait for compare
digitalWrite(PIN_TRACE_B,digitalRead(PIN_STEP));
continue;
}
TIFR1 |= _BV(OCF1A);                        // clear match flag
digitalWrite(PIN_TRACE_B,LOW);

//-- Shut down counter and wait for end of 1/rev pulse

#if 0
TCCR1B &= ~B00000111;                        // turn off timer clock

while(digitalRead(PIN_REV)) {                // stall until 1/rev pulse goes low again
TogglePin(PIN_TRACE_C);
}
digitalWrite(PIN_TRACE_B,LOW);
#endif

}