RE: YAPS Part Seven - Prototyping of Arduino Interface

shabaz — Fri, 07 Jun 2019 17:33:12 GMT

Hi Andrew,

This is great seeing the 4D systems display/controller and the code.

The 4D systems stuff looks fantastic, I saw some of their displays at an exhibition, and the latest generation ones look very cool.

I recently tried a cheap ebay display, while it works, it isn't a top-quality screen and suffers from poor viewing angles.

Also, it is very cool that you're using the Steinhart-Hart equation to get accurate temperature conversions.

It's nice seeing designs with such a screen, since there is a lot of information that can be gleaned from your sensors, and it's fun trying new things like this, deciding how the UI should look, and what functionality to have!

RE: YAPS Part Seven - Prototyping of Arduino Interface

Andrew J — Fri, 07 Jun 2019 10:09:48 GMT

Now we're cooking on gas!

I've made a few updates to the code to improve accuracy.

Firstly, the Voltage, Current and Power - the mistake I made initially with the power reading was ignoring the 10mW LSB value the INA260 holds - accounting for that brings it into expectation. All values have some LSB size to take account of:

Voltage: 1.25mV
Current: 1.25mA
Power: 10mW I suppose I could just take the Voltage and Current values and work out the power myself, save a read etc.

[View:/resized-image/__size/620x312/__key/commentfiles/f7d226abd59f475c9d224a79e3f0ec07-38448b26-f6b8-419a-8dac-f14ce32efa94/2313.contentimage_5F00_191033.jpg:620:312]

The Fluke is measuring Voltage; the Extech Current. What we are seeing:

Fluke: 5.4840V
Extech: 11.44mA
4Duino: 5.488V; 0.009mA; 0.050mW reported (against a P=VI calculation of 0.049mW)

I'd say that was pretty good! 2mA of current off. The datasheet for the INA260 states it has a 5mA offset maximum and a current sense gain error of 0.2%typical to 0.5%max. That wouldn't count for it all but I'm also measuring that current through 2" of hookup wire. It's accurate enough.

Secondly, the temperature readings. I was right in that the culprit in the inaccuracy was the nominal 5V Vin on the 4Duino. That's used as a reference in the analog reading conversion: if it isn't precisely 5V then the conversion is off. Even providing it with a regulated 5V supply isn't going to give that level of accuracy and it will always fluctuate somewhat. In fact, the voltage supplied is a few 10's of mV lower than 5V causing the analog reading to go high - hence the higher temperature readings displayed.

Here's what I show now:

[View:/resized-image/__size/620x353/__key/commentfiles/f7d226abd59f475c9d224a79e3f0ec07-38448b26-f6b8-419a-8dac-f14ce32efa94/8512.contentimage_5F00_191034.jpg:620:353]

Hive is showing: 22.6C
Clock is showing: 22.1C
4Duino is showing: 22.26C; 22.78C; 22.33C

I can definitely live with that accuracy! I made two changes to the code. Firstly, when taking the analog reading I also took a Vcc reading using the ATMega32U4 internal voltage reference of 1.1V. I then used that reference to accurately convert the analog reading into a voltage reading. This bypasses the conversion using the 5V 'perfect' supply. Secondly, although minor, I changed the Steinhart Hart calculation to use a more accurate equation incorporating coefficients from the datasheet. I've only used those applicable to a range of 50.5C to 103C and could squeeze a little more accuracy by including the range from -2C to 50.5C but I don't think that's necessary: I think a fraction of a degree discrepancy is accurate enough, will always be subject to the actual resistances of the Thermistors (which I can't be bothered to calibrate) and it's impossible to say which of the 3 Thermistors, Hive and Clock are the correct reading in any case.

You'll also notice that the display shows a Control Temperature: this is actually a specific resistance taken from the datasheet and pushed through the calculation to make sure it was accurate - the answer for 8766Ohms should be, and is, 28C. As an aside, Excel calculated it out at 26.somethingC which led me down a lot of pointless cross-checking. There's something screwy within its calculation I'm sure - possibly the logarithm function.

I'm really happy with that. The final display I want to incorporate graphics and the like but I now have something to test the build against.

Latest Code

/* Simple prototype for the 4Duino using three thermistors and an INA260.

* These form part of the monitoring of the final build and this code should form the basis of a graphical build

* as part of the final version.

* Prototype is using simple print/println commands

// For SDA/SCL connections

#include <Wire.h>

// Picaso display libraries

#include <Picaso_Const4D.h>

#include <Picaso_Serial_4DLib.h>

#define DisplaySerial Serial1

Picaso_Serial_4DLib Display(&DisplaySerial);

// Thermistors - references in schematic

#define TH1 A0 // analog pin connected

#define TH2 A1 // analog pin connected

#define TH3 A2 // analog pin connected

// Resistors - measured with DMM - references in schematic

#define R1 10065

#define R2 9948

#define R3 9909

#define THERMISTORNOMINAL 10000.0 // resistance at 25C

#define TEMPERATURENOMINAL 25.0 // degrees centigrade

#define CONTROLRESISTANCE 8766 // This should calculate a temperature of 28C

#define NUMSAMPLES 5 // Improve calculation efficiency by averaging reads over a number of samples

void setup() {

setupLCD();

setupINA260();

}

void setupLCD() {

Display.Callback4D = mycallback; // For handling errors

Display.TimeLimit4D = 5000; // 5secs timeout on all commands

DisplaySerial.begin(200000);

delay(5000); // let the display startup

Display.gfx_ScreenMode(LANDSCAPE);

}

void setupINA260() {

// write to the INA260: Address:Register:High Byte:Low Byte

// See datasheet for values

Wire.begin();

Wire.beginTransmission(0x40); //address set by A1 and A0 pins on INA260

Wire.write(0x00); // config register

Wire.write(0x61); // high byte -> take 1 average

//Wire.write(0x65); // high byte -> take 4 averages

Wire.write(0xb7); // low byte -> conversion time for voltage and current = 4.156 ms

// (average out the data for low noise), and operate in continous mode

Wire.endTransmission();

}

void loop() {

// Clear the screen and display the temperature from each thermistor in turn.

// Followed by V,I,P from INA260

// The 10 second delay is to give a chance to read it.

Display.gfx_Cls();

DisplayTemperature(TH1, R1);

DisplayTemperature(TH2, R2);

DisplayTemperature(TH3, R3);

Display.println("Control Temperature");

Display.print("Control Resistance: ");

Display.println(CONTROLRESISTANCE);

Temperature(CONTROLRESISTANCE); // Lets check we see 28C with the calculation

DisplayVoltage();

DisplayCurrent();

DisplayPower();

delay(10000);

}

* 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 Thermistor voltage divider

float ReadThermistor(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;

}

Displays values associated with the passed Thermistor and series resistance

void DisplayTemperature(int thermistor, long seriesResistor) {

float reading;

float resistance;

float vOut;

// Obtain reading from thermistor

reading = ReadThermistor(thermistor);

Display.print("Analog reading TH");

Display.print(thermistor - 13); // Analog Pins seem to have an int value starting at 14.

Display.print(": ");

Display.println(reading);

// Convert the value to a resistance at the current temperature

resistance = seriesResistor * (1024.0 / reading - 1.0);

Display.print("Thermistor resistance: ");

Display.println(resistance);

// Calculate and display temperature

Temperature(resistance);

}

Calculate the temperature based on the Steinhart-Hart equation.

Coefficients are from the datasheet

An alternative would be to hold a table of resistances/temperatures from the datasheet.

Must consider memory usage.

void Temperature(float r2) {

float temperature;

double coeffA = 3.354016e-03;

double coeffB = 2.541522e-04;

double coeffC = 3.730922e-06;

double coeffD = -7.881561e-08;

double logR2 = 0.0;

logR2 = log(r2/THERMISTORNOMINAL);

temperature = (1.0 / (coeffA + coeffB*logR2 + coeffC*logR2*logR2 + coeffD*logR2*logR2*logR2));

temperature -= 273.15;

Display.print("Temperature: ");

Display.print(temperature);

Display.println(" *C");

Display.println("");

}

void DisplayVoltage() {

double dVoltage = 0.0;

// ask for voltage readings

Wire.beginTransmission(0x40); // Address

Wire.write(0x02); // Bus Voltage Register

Wire.endTransmission();

dVoltage = ReadData(1.25); // Voltage is accurate to 1.25V

// Display

Display.print("Voltage: ");

Display.print(dVoltage, 3);

Display.println("V");

}

void DisplayCurrent() {

double dCurrent = 0.0;

// ask for current readings

Wire.beginTransmission(0x40); // Address

Wire.write(0x01); // Bus Voltage Register

Wire.endTransmission();

dCurrent = ReadData(1.25); // Current is accurate to 1.25mA

// Display

Display.print("Current: ");

Display.print(dCurrent, 3);

Display.println("A");

}

void DisplayPower() {

double dPower = 0.0;

// ask for power readings

Wire.beginTransmission(0x40); // Address

Wire.write(0x03); // Bus Voltage Register

Wire.endTransmission();

dPower = ReadData(10.0); // Power is accurate to 10mW

// Display

Display.print("Power: ");

Display.print(dPower, 3);

Display.println("W");

}

* Read NUMSAMPLES values from the preset register (for V, I or P) and average them.

* The LSB size represents the LSB size as stated in the datasheet.

double ReadData(float lsbSize) {

long total = 0;

int value = 0;

double dValue = 0.0;

total = 0;

for(int i = 0; i < NUMSAMPLES; i++){

Wire.requestFrom(0x40, 2); // Read two bytes

delay(5);

if (2 <= Wire.available()) {

value = Wire.read(); // receive high byte (overwrites previous reading)

value = value << 8; // shift high byte to be high 8 bits

value |= Wire.read(); // receive low byte as lower 8 bits

total += value;

}

// Turn into high precision, average them and convert to result

dValue = total;

dValue = ((dValue * lsbSize) / 5.000) / 1000.000;

return dValue;

}

* Simple error handling: flash an LED.

void mycallback(int ErrCode, unsigned char Errorbyte)

{

// Pin 13 has an LED connected on most Arduino boards. Just give it a name

int led = 13;

pinMode(led, OUTPUT);

while(1)

{

digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)

delay(1000); // wait for 200 ms

digitalWrite(led, LOW); // turn the LED off by making the voltage LOW

delay(1000); // wait for 200 ms

}