Programmable DC Electronic Load - First Look

I have made a little progress...

Received these parts which more or less match the 2nd schematic drawn above:

• Bourns PWR220T-35-1R00FBourns PWR220T-35-1R00F TO-220 style 1% 1 ohm resistors
• IRLZ34NPBFIRLZ34NPBF Infineon N-Ch MOSFET
• MCP4725A0T-E/CHMCP4725A0T-E/CH Microchip 12 Bit DAC
• OPA192IDBVROPA192IDBVR Texas Instruments Op Amp
• 10C035410C0354 Bourns 2 Ch Encoder

I also recently purchased an Adafruit Feather M4 Express which has the ATSAMD51J19 microcontroller with 12 bit ADCs and 12 BIT DACs so I did some experimentation with that.  The DAC was programmed in the Arduino IDE to output various voltages and then measured with via ADC (2 pins away) and a digital multimeter.  The first ADC reading was thrown out and then the next 5 averaged. The following plot shows the deviation of the programmed DAC output and ADC readings from the meter.

The DAC output in blue is very linear and could be easily corrected to a large extent in software.  There is a lot of scatter in the orange ADC readings.  One ADC reading at around 1800 mV is in error by approximately 35 mV which is outside what the datasheet gives as maximum error - not sure what caused that.  I seem to remember the MSP432 giving much better results and had a look at the TI datasheet.  It reports error differently but does seem to be both more accurate and precise.  It might be interesting to do a real world comparison to the Atmel chip.  It is a shame there isn't a MSP432 variant with a DAC.

The following plot shows the percent error for the ADC and DAC on the Feather M4 Express.  The title is a bit misleading - the X axis is the meter reading in mV and the Y axis is the percent error for the DAC in blue and the ADC in orange.

Percent error in the DAC would improve if the software correction described above was implemented.

In summary, DAC output seems good on the Atmel SAMD boards so far.  The ADC is probably only good for 20 mV or so.  This may be good enough for reading the input voltage of the DUT but not good enough for reading current.  For that, it would be better to just report the DAC setting.

The Bourns 1 ohm resistors were measured with the milliohm meter and are within 0.1% of 1 ohm.

Hello Frank,

Your ADC seems to be very noisy.

Could you try two experiments:

1) 1000 samples with maybe 50mV input (the 50mV must be low noise - ideally source from a battery and divider with a big low esr cap across it.

2) 1000 samples close to full scale

The first measurement will tell you about the ADC noise, the second will tell you if the ADC reference voltage is noisy

From your results so far it looks as if you have both problems.

How has the ADC been set up. (in terms of acqusition time, sampling speed averaging etc) ?

If you don't need to sample very fast you should be able to get a decent noise performance out of this chip by oversampling.

MK

Hello Michael,

Great insight and suggestions and I set up experiments as you suggested.  Power is from two alkaline batteries with a voltage divider of ~ 100k and 2.2k resistor for the lower voltage (66 mV) and batteries in series for the higher voltage (3.08 V).

I ran 1000 tests on both the higher and lower voltages with the following Arduino code.

/*
 * Test ADC on Adafruit Feather M4 Express
 * Reads raw analog input on ADC_PIN, calculates voltage, and outputs results numTests times...
 */
const int DAC_RES = 12;                    // Set resolution
const int ADC_RES = 12;                    // Set resolution
const int MAX_DAC = pow(2,DAC_RES);
const int MAX_ADC = pow(2,ADC_RES);
const float V3 = 3.309;                    // 3V Feather Reference Voltage per DMM
const float VIN = 3.07;                    // Measured input voltage per DMM
const int ADC_PIN = A2;
const int numTests = 1000;
void setup() {
  Serial.begin(115200);
  Serial.setTimeout(8000);
  while (!Serial) {
    ;                                     // wait for serial to start
  }
  
  Serial.println("i,RAW_ADC,ADC_V,V_ERR");      // Output labels
  analogReference(AR_DEFAULT);            // use V3 (3V3) Reference Voltage
  analogReadResolution(ADC_RES);          // ADC input resolution
  analogWriteResolution(DAC_RES);         // DAC output resolutio
  int i = 0;
  for (i=0; i< numTests; i++){
    unsigned int rawAnalogInput = analogRead(ADC_PIN);
    float voltInput = V3 * (float)rawAnalogInput / MAX_ADC;
    float voltErr = voltInput - VIN;
    Serial.print(i);              Serial.print(",");
    Serial.print(rawAnalogInput); Serial.print(",");
    Serial.print(voltInput,4);    Serial.print(",");
    Serial.println(voltErr,4);
  }
}
void loop() {
  // do nothing
}   

Below is the summary output run through an Excel spreadsheet for the 66 mV test.  The raw analog input readings have been plotted.  Shown in the table below it are the raw readings, the calculated voltage, and the error when calculated voltage is subtracted from the voltage as read by a DMM.

Below is the same data for a 3.08 V test.

So we might interpret this as meaning there is high ADC noise?  The readings at 3.08 V are quite tight.

A friend pointed out that the Adafruit Feather M4 Express does not have a ferrite bead to prevent digital VDD noise interfering with VDDANA on the SAM D5 as recommended in the datasheet.  I hooked up the oscilloscope and found the following on the 3V3 pin which appears to also be feeding VDDANA.

EDIT:  The following screenshot was taken while the Feather was powered from an Ikea USB on a power strip.  The data above was all taken while the Feather was powered from the USB on a laptop.

Regarding the way the ADC been set up in terms of acquisition time, sampling speed, averaging etc. I would have to dig into the way Adafruit has implemented the Arduino functions and have not done that yet.  In my first trials above I did average 5 samples.  Based on what is seen above I could take more samples and maybe throw out fliers.

The screenshot above was taken when the Feather was powered from a USB slot on an Ikea power strip.  If powered from my laptop (which supplied power during all the measurements above) we get the following which is cleaner than the Ikea supply:

Powered by battery over Feather LiPo battery port, same settings as above

Crummy Ikea USB Source:  175 mV Pk-Pk

Laptop USB Source:  69 mV Pk-Pk

LiPo Battery Power: 38 mV Pk-Pk

I still don't know if this is the cause though....

The screenshot above was taken when the Feather was powered from a USB slot on an Ikea power strip.  If powered from my laptop (which supplied power during all the measurements above) we get the following which is cleaner than the Ikea supply:

Powered by battery over Feather LiPo battery port, same settings as above

Crummy Ikea USB Source:  175 mV Pk-Pk

Laptop USB Source:  69 mV Pk-Pk

LiPo Battery Power: 38 mV Pk-Pk

I still don't know if this is the cause though....

Does the ADC reference readings agains an internal reference source?  What about the MKR1000?  It's not possible from the code to see how the analog reads are being taken, and this may be a bit of a tangent/red herring, but I found that using the Arduino internal reference source improved accuracy significantly.  Is it possible for you to look at the library code and tell?  If the analogRead is the standard Arduino library code then it may benefit from something like this:

/*
 * Obtain the actual Vcc value of the 4Duino from an internal reference source.
 * The nominal 5V Vin can fluctuate a lot and affect analog read accuracy.
 */
long readVCC() {
  long result;
  // Read 1.1V reference against AVcc
  ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
  delay(2); // Wait for Vref to settle
  ADCSRA |= _BV(ADSC); // Convert
  while (bit_is_set(ADCSRA, ADSC));
  result = ADCL;
  result |= ADCH << 8;
  result = 1126400L / result; // Calculate Vcc (in mV); 1126400 = 1.1*1024*1000
  return result;
}

/*
  Return an averaged reading from the Analog pin
*/
float ReadAnalog(int pin) {
  uint8_t i;
  float average;
  float samples[NUMSAMPLES];

  for (i = 0; i < NUMSAMPLES; i++) {
    int value = analogRead(pin);
    float supply = readVCC() / 1000.0; // obtain vcc at time of read
    float valueCorrected = supply / 5 * value; // improve the accuracy of the analog reading
    samples[i] = valueCorrected;
    delay(10); // spread readings out otherwise they are likely to be the same value or very close
  }
  average = 0;
  for (i = 0; i < NUMSAMPLES; i++) {
    average += samples[i];
  }
  return average / NUMSAMPLES;
}

The useful bit is the readVCC() function and lines 27, 28 and 29.  The 'valueCorrected' variable is determined from a 5V range.  I don't think this will eliminate noise (probably just read that more accurately!) but may firm up readings.  I've not tried this on a MKR1000 by the way.

It's an interesting project to follow along.

Hi Andrew,

I think you are right that the internal reference may give better results and have that on my list of things to explore.  I used the Adafruit SAMD51 board as opposed to MKR1000 in these latest experiments because it has a 12 bit DAC and I want 1 mA precision.  I ran the functions listed in the Arduino reference for Arduino SAMD boards, e.g. MKR1000, through the compiler for the Adafruit Feather Express SAMD51 and it appears to support the following for analog references to the ADC:

•   analogReference(AR_DEFAULT);  // This is what I am currently using and is shared with VDD
•   // analogReference(AR_INTERNAL);   // Not supported on Feather M4 Express
•   analogReference(AR_INTERNAL1V0);   // Internal 1.0 V reference
•   analogReference(AR_INTERNAL1V65);  // Internal 1.65 V reference
•   analogReference(AR_INTERNAL2V23);  // Internal 2.23 V reference
•   analogReference(AR_EXTERNAL);      // External reference applied to AREF pin

I may have to revert to direct register writes to the microcontroller to get the control necessary which is what I normally do with the TI MSP430 and MSP432 microcontrollers.  I have been using the Arduino IDE because I am not really familiar with Atmel SAMD microcontrollers and wanted to keep things simple.  That is a good idea until it isn't :-).

Edit:  see new comment to Michael above