Category: Electronics Workbench

The MOSFET tester spits out datasets using this tedious Arduino code:

void PrintHeader(void) {
  Serial.println();                         // Gnuplot group break
  Serial.println("#-----------------------------");
  Serial.print("# VGate: ");
  Serial.print(VGateSet,3);
  Serial.println();
  Serial.print("# TSetpoint: ");
  Serial.print(TSetpoint,1);
  Serial.println(" C");
  Serial.println("# VGS \tVDS \tID  \tRDS \tC   \tTime");
}

void PrintTempHeader() {
  Serial.println();                                    // Gnuplot index break
  Serial.println();
  Serial.print("#T=");                                //  ... index name
  Serial.println(TSetpoint,1);
  Serial.println("#=============================");
  Serial.print("# Setting temperature to: ");        // human-readable annotation
  Serial.print(TSetpoint,1);
  Serial.println(" C ...");
}

... later, deep inside the main loop ...

    Serial.print(VGateSet,3);
    Serial.print('\t');
    Serial.print(VDrainSense,3);
    Serial.print('\t');
    Serial.print(IDrainSense,3);
    Serial.print('\t');
    Serial.print((IDrainSense == 0.0) ? 0.0 : (VDrainSense / IDrainSense),3);
    Serial.print('\t');
    Serial.print(Temperature,1);
    Serial.print('\t');
    Serial.print(millis() - StartTime);
    Serial.println();

All that produces a text file formatted to work with Gnuplot, including a blank line between successive gate voltage groups to produce separate plot traces:

#T=0.0
#=============================
# Setting temperature to: 0.0 C ...

#-----------------------------
# VGate: 4.250
# TSetpoint: 0.0 C
# VGS 	VDS 	ID  	RDS 	C   	Time
4.250	1.200	0.000	0.000	1.0	1757
4.250	1.665	0.044	37.851	1.0	1861

#-----------------------------
# VGate: 4.500
# TSetpoint: 0.0 C
# VGS 	VDS 	ID  	RDS 	C   	Time
4.500	0.003	0.000	0.000	1.0	2038
4.500	0.016	0.044	0.370	1.0	2143
... snippage ...
4.500	0.212	1.953	0.108	0.9	6105
4.500	0.216	2.001	0.108	0.9	6210

Which produces a plot like this:

It’d be handy to automatically generate labels for the gate voltages, but I haven’t been able to figure out how to read values from the dataset and plunk them into the label strings. You can, however, select blocks of gate voltage and superblocks of temperature with a bit of effort.

The Bash script that feeds Gnuplot looks something like this:

#!/bin/sh
#-- set plot limits
tx=3
vgs_min="4.0"
vds_max="0.2"
rds_max=100
rds_tics=$((${rds_max} / 4))
id_max="2.0"
#-- overhead
export GDFONTPATH="/usr/share/fonts/truetype/"
base="${1%.*}"
echo Base name: ${base}
ofile=${base}.png
echo Output file: ${ofile}
#-- do it
gnuplot << EOF
#set term x11
set term png font "arialbd.ttf" 18 size 950,600
set output "${ofile}"
set title "${base}"
set key noautotitles
unset mouse
set bmargin 4
set grid xtics ytics
set xlabel "Drain-Source Voltage - VDS - V"
set format x "%4.2f"
set xrange [0:${vds_max}]
#set xtics 0,5
set mxtics 2
set ytics nomirror autofreq
set ylabel "Drain Current - ID - A"
set format y "%4.1f"
set yrange [0:${id_max}]
#set mytics 2
set y2label "Drain Resistance - RDS - mohm"
set y2tics nomirror autofreq ${rds_tics}
set format y2 "%3.0f"
set y2range [0:${rds_max}]
#set y2tics 32
#set rmargin 9
set datafile separator "\t"
#set label 1 "Temp index = ${tx}" at 0.81,0.55 font "arialbd,18"
set label 2 "VGS >= ${vgs_min} V" at 0.11,0.55 font "arialbd,18"
plot    \
"$1" using 2:((\$1 >= ${vgs_min})?\$3:NaN)            index $tx:$tx           with lines lt 3 lw 2 title "ID" ,\
""   using 2:((\$1 >= ${vgs_min})?(\$4*1000):NaN)    index $tx:$tx axes x1y2 with lines lt 4 lw 2 title "RDS"
EOF

The variables up near the top control the plot limits; it’d be nice to have a complex Bash script that prompted for values, had useful defaults, and fed all that into Gnuplot. Given what I’m doing, it’s easier to just keep the Bash script open in the portrait monitor, watch the results on the landscape monitor, and twiddle until it looks right.

This script produces a plot for a single temperature range based on the superblock index tx; you can select a single block using index name (along the lines of “T=0.0”), but you can’t select multiple such blocks in a single plot statement.

Selecting gate voltages requires testing the first column for a match with the trinary operator and assigning the data value for lines that don’t match to the not-a-number value NaN to prevent it from appearing in the plot:

((\$1 >= ${vgs_min})?\$3:NaN)

All in all, the whole apparat makes for a fairly brittle set of code, but the plots come out ready for printing and that makes up for a lot.

Well, truth be known, it took a bit of tweaking to get to this point, but this was the first dependable & repeatable measurement:

Rescaling the graph to show just the interesting part down near the origin:

The V_GS output steps from 4.0 to 10.0 V by 0.25 V, which is too fine until I get the Gnuplot script sorted out. The I_D output runs from 0.0 A to 2.0 A in steps of 50 mA, which makes for smooth curves. These are all at 30 °C.

The drain resistance flattens out nicely for V_GS beyond 7 V, which is well over the BUZ71A max threshold of 4.0 V. That means you really need more than the usual 5 V supply to control the thing; I’ll eventually try some “logic level” MOSFETs. Part of the trick will be to find a logic-level MOSFET with a relatively high drain resistance suitable for current sensing.

The board looks like this, with the foam shako for the thermal block and some MOSFET victims off to the side:

The key part of the schematic:

Two Arduino PWM outputs set the gate voltage and maximum drain current. The three jumpers near the middle allow various feedback paths, although the only one that really makes sense is closing the current loop. The trimpot is unused and the analog output directly sets the drain current limit at 0.5 A/V: 4 V → 2 A. The PWM outputs must run at 32 kHz, not the Arduino-standard 500-ish Hz.

The MAX4544 SPDT analog multiplexers switch between ground and the PWM voltages. That’s a simple way to turn the outputs off and on without waiting for the PWM values to ramp up and down. The LEDs on those control signals provide an indication that the firmware hasn’t fallen off the rails.

Three Arduino analog inputs report the drain voltage, actual drain current, and temperature input. The LM324 op amps run from ±12 V, so a pair of BAT54S dual diodes clamp the analog inputs at one Schottky diode drop below ground and above 5 V. That should be close enough to prevent any damage without rounding off the values near the extremes, given the fairly high op-amp output resistors; the analog inputs present a reasonably high impedance and it seems to not matter much.

The measuring sequence amounts to a pair of nested loops:

• Step the gate voltage
• Step the drain current limit

The inner loop ends when the current limit, the actual current, or the drain voltage exceeds the corresponding maximum value. The outer loop ends when the gate voltage exceeds its limit.

A 100 ms delay after changing any analog output allows time for the voltages to settle before taking the next set of inputs.

Each pass of the loop updates the PI loop controlling the thermal block temperature. That’s certainly sub-optimal, but works well enough for my simple needs.

The Arduino source code for the measurement loop:

void loop() {

    digitalWrite(PIN_HEARTBEAT,HIGH);           // show that we've arrived

//--- Stabilize temperature

    Temperature = ReadTemperature();
    SetPeltier(Temperature,TSetpoint);

    if (abs(Temperature - TSetpoint) > T_ACCEPT) {

      Serial.print("# Exceed T limit: ");
      Serial.print(Temperature,1);
      Serial.print(" C ");

      while (abs(Temperature - TSetpoint) > T_DEADBAND) {
        Temperature = ReadTemperature();
        SetPeltier(Temperature,TSetpoint);
        TogglePin(PIN_HEARTBEAT);
        delay(SETTLING_TIME);
        Serial.print('.');
      }
      Serial.print(" Now at: ");
      Serial.print(Temperature,1);
      Serial.println(" C");
    }

//--- Record current data point

    IDrainSense = GetIDrain();
    VDrainSense = GetVDrain();

    Serial.print(VGateSet,3);
    Serial.print('\t');
    Serial.print(VDrainSense,3);
    Serial.print('\t');
    Serial.print(IDrainSense,3);
    Serial.print('\t');
    Serial.print((IDrainSense == 0.0) ? 0.0 : (VDrainSense / IDrainSense),3);
    Serial.print('\t');
    Serial.print(Temperature,1);
    Serial.print('\t');
    Serial.print(millis() - StartTime);
    Serial.println();

//--- Step to next point

    if ((IDrainLimit > MAX_DRAIN_CURRENT) ||        // beyond last current increment
        (IDrainSense > MAX_DRAIN_CURRENT) ||        // power supply current limit
        (VDrainSense > MAX_DRAIN_VOLTAGE)) {        // beyond linear voltage measurement
      IDrainLimit = 0.0;
      VGateSet += VGATE_STEP;
      if (VGateSet <= MAX_GATE_VOLTAGE) {
        PrintHeader();
      }
    }
    else {
      IDrainLimit += IDRAIN_STEP;
    }

    SetIDrain(IDrainLimit);
    SetVGate(VGateSet);

    TogglePin(PIN_HEARTBEAT);
    delay(SETTLING_TIME);                           // wait for settling

    if (VGateSet > MAX_GATE_VOLTAGE) {
      Serial.print("# Done! Elapsed: ");
      Serial.print((millis() - StartTime)/1000);
      Serial.println(" sec");

      SetIDrain(0.0);
      SetVGate(0.0);
      digitalWrite(PIN_DISABLE_IDRAIN,HIGH);
      digitalWrite(PIN_DISABLE_VGATE,HIGH);
      digitalWrite(PIN_ENABLE_HEAT,LOW);
      analogWrite(PIN_SET_IPELTIER,0);

      while (true) {
        TogglePin(PIN_HEARTBEAT);
        delay(25);
      }
    }

}

Everything is a compile-time option, which is certainly user-hostile. On the other paw, that allows me to get on with writing column instead of putzing around with the user interface… [grin]

The MOSFET tester I’m building controls the MOSFET’s gate voltage and drain current, while measuring the drain voltage. That, however, puts the drain terminal at a relatively high-impedance node between two current sources: the limiter and the MOSFET-under-test. When they’re both set to nearly the same value, the drain terminal picks up a generous helping of 32 kHz noise from the 3 A PWM Peltier module current. When either current source is set much larger than the other, the higher one serves as a relatively low impedance path that reduces the pickup.

I thought about grounding the thermal block, but that means adding an insulating washer under every MOSFET-under-test, which means an even greater thermal control problem. So the easiest solution is to just turn off the PWM during measurements:

The lower trace (at 5 V/div, not 500 mV as shown) is a digital output marking the duration of the three analog reads: temperature, drain voltage, and drain current. The upper trace shows the absolute worst case for the noise, which looks rather awful.

The Peltier PWM comes from Arduino digital output 10, which is lashed to hardware Timer 1. Turning off the PWM requires setting the corresponding clock prescaler to “no input”, then setting it back to select the appropriate clock input after the measurement.

Just on general principles, I average three successive analog inputs, so the Arduino source code for the analog reads looks like this:

#define TCCRxB                  0x01        // set prescaler to 1:1 for 32 kHz PWM
#define NUM_T_SAMPLES    3

float ReadAI(byte PinNum) {
word RawAverage;

    digitalWrite(PIN_SYNC,HIGH);                // scope sync
    TCCR1B = 0x00;                              // turn off Peltier module PWM

    RawAverage = analogRead(PinNum);            // prime the averaging pump

    for (int i=2; i <= NUM_T_SAMPLES; i++) {
        RawAverage += (word)analogRead(PinNum);
    }

    TCCR1B = TCCRxB;                            // restart Peltier PWM
    digitalWrite(PIN_SYNC,LOW);

    RawAverage /= NUM_T_SAMPLES;

    return (float)RawAverage;
}