A DIY Micro-Ohm Meter with Arduino (vollrathd's design & concept)

/*

Micro-Ohm Meter by RSA first published: https://techenclave.com/threads/a-diy-micro-ohm-meter-with-arduino-vollrathds-design-concept.220788/

Original design & concept by VollrathD: https://www.rcgroups.com/forums/showthread.php?3647559-MicroOhmmeter-Project-Revisited/page10

*******************************************************************************
WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING

    DO NOT DO RESISTOR TESTS WITH ONLY THE USB POWER TO THE METER!

    THAT RESISTOR UNDER TEST REVERSES BIASES THE ARDUINO NANO 5 VOLT REGULATOR
    AND WILL BLOW THE REGULATOR. A POWER SOURCE MUST BE CONNECTED TO THE METER
    ANY TIME THE USB PC PORT IS PLUGGED INTO THE ARDUINO NANO WHEN CONNECTING
    A TEST RESISTOR TO THE MICRO OHM METER.

WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
*******************************************************************************

*/

#include <Wire.h>
#include <MCP342x.h> // https://github.com/stevemarple/MCP342x
#include <LiquidCrystal.h>

const int en = 12, rs = 11, d4 = 10, d5 = 9, d6 = 8, d7 = 7;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

uint8_t address = 0x68; // default for MCP3422
MCP342x adc = MCP342x(address);

const int voltage_adjust = 1045; // find via trial & error
float voltage_multiplier = 5.15; // find via mathematics
float battery_volts = 0;
int battery_input = 0;

float calibration = 1.0; // uncalibrated
float conductor;
double current;

void setup()
{
  //Serial.begin(9600);
  //Serial.print("\n\nRESET\n");

  analogReference(INTERNAL); // 1.1V
  Wire.begin();

  MCP342x::generalCallReset();
  delay(1);

  lcd.begin(8, 1);
  lcd.print("\xE4\xF4");
  delay(500);
  for (int animate = 1; animate < 7; animate++) // cool animation
  {
  lcd.scrollDisplayRight();
  delay(250);
  }
  delay(1000);
  lcd.clear();
}

void check_battery()
{
  battery_input = analogRead(6);
  battery_volts = map(battery_input, 0, 1023, 0, voltage_adjust); // remap reading to match measured microvolts
  battery_volts = battery_volts / 1000 * voltage_multiplier; // comment out this line while doing above
  //Serial.print("\nBattery: ");
  //Serial.print(battery_volts);
}

void measure_shunt()
{
 long value = 0;
  MCP342x::Config status;
  uint8_t err = adc.convertAndRead(MCP342x::channel1, MCP342x::oneShot, MCP342x::resolution16, MCP342x::gain8, 1000000, value, status);
  if (!err)
  {
    current = value * 2.048 / 8 / 32768 / 0.1 * calibration;
    // nominal 3.7V / 5R = 0.74A
    //Serial.print("\nCurrent: ");
    //Serial.print(current);
  }
}

void calc_8x18bit()       
{
 long value = 0;
  MCP342x::Config status;
  uint8_t err = adc.convertAndRead(MCP342x::channel2, MCP342x::oneShot, MCP342x::resolution18, MCP342x::gain8, 1000000, value, status);
  if (!err && value > -131071 && value < 131071)
  {
    conductor = value * 2.048 / 8 / 131072 / current;
    // LSB = 0.256V / 0.74A = 0.3459 R (max) / 131072 = 2.6 micro-ohm
    //Serial.print("\n8x18bit Range: ");
  }
}

void calc_4x16bit()       
{
 long value = 0;
  MCP342x::Config status;
  uint8_t err = adc.convertAndRead(MCP342x::channel2, MCP342x::oneShot, MCP342x::resolution16, MCP342x::gain4, 1000000, value, status);
  if (!err && value > -32767 && value < 32767)
  {
    conductor = value * 2.048 / 4 / 32768 / current;
    // LSB = 0.512V / 0.74A = 0.6918 R (max) / 32768 = 21 micro-ohm
    //Serial.print("\n4x16bit Range: ");
  }
}

void calc_2x14bit()       
{
 long value = 0;
  MCP342x::Config status;
  uint8_t err = adc.convertAndRead(MCP342x::channel2, MCP342x::oneShot, MCP342x::resolution14, MCP342x::gain2, 1000000, value, status);
  if (!err && value > -8191 && value < 8191)
  {
    conductor = value * 2.048 / 2 / 8192 / current;
    // LSB = 1.048V / 0.74A = 1.4162 R (max) / 8192 = 172 micro-ohm
    //Serial.print("\n2x14bit Range: ");
  }
}

void calc_1x12bit()       
{
 long value = 0;
  MCP342x::Config status;
  uint8_t err = adc.convertAndRead(MCP342x::channel2, MCP342x::oneShot, MCP342x::resolution12, MCP342x::gain1, 1000000, value, status);
  if (!err && value > -2047 && value < 2047)
  {
    conductor = value * 2.048 / 1 / 2048 / current;
    // LSB = 2.048V / 0.74A = 2.7675 R (max) / 2048 = 1.35 milli-ohm
    //Serial.print("\n1x12bit Range: ");
  }
}

void loop()
{
  check_battery();
  measure_shunt();
  lcd.setCursor(0, 0);
  if (current > 0) // if test conductor is connected
  {
    calc_8x18bit(); // start with highest resolution range
    if (!conductor) // switch to lower ranges if saturated
    {
      calc_4x16bit();
    }
    if (!conductor)
    {
      calc_2x14bit();
    }
    if (!conductor)
    {
      calc_1x12bit();
    }
    if (conductor < 0)
    {
      conductor = conductor * -1; // convert to positive if negative (shorted probes)
    }
    //Serial.print(conductor);
    if (conductor >= 2)
    {
      lcd.print("OL1.999\xF4"); // overlimit
    }
    else if (conductor >= 1) // auto-range below for 8x1 display
    {
      lcd.print(conductor, 4); // 1.0000 to 1.999 ohms
      lcd.print(" \xF4");
    }
    else if (conductor * 1000 >= 100)
    {
      lcd.print(conductor * 1000, 1); // 100.0 to 999.9 milli-ohms
      lcd.print(" m\xF4");
    }
    else if (conductor * 1000 >= 10)
    {
      lcd.print(conductor * 1000, 2); // 10.00 to 99.99 milli-ohms
      lcd.print(" m\xF4");
    }
    else if (conductor * 1000 >= 1)
    {
      lcd.print(conductor * 1000, 3); // 1.000 to 9.999 milli-ohms
      lcd.print(" m\xF4");
    }
    else if (conductor * 1000000 >= 100)
    {
      lcd.print(conductor * 1000000, 1); // 100.0 to 999.9 micro-ohms
      lcd.print(" \xE4\xF4");
    }
    else if (conductor * 1000000 >= 10)
    {
      lcd.print(conductor * 1000000, 2); // 10.00 to 99.99 micro-ohms
      lcd.print(" \xE4\xF4");
    }
    else
    {
      lcd.print(conductor * 1000000, 3); // 1.000 to 9.999 micro-ohms
      lcd.print(" \xE4\xF4");
    }
    conductor = 0; // reset for next run
  }
  else // if no test conductor is connected
  {
    lcd.print("b: " + String(battery_volts) + "v");
  }
  delay(1000);
}