Water Level [Pressure] Probe

/*
	 Pro Mini INA219 Test
 
   Function:
   Test the function of the INA219 module in conjunction with a water level probe
  
   Description:
   1. Reads current (water level probe pressure, 4~20mA version) from INA219.
   
   20 Feb 2026 1.0.0  Initial implementation

   Digital Concepts
   20 Feb 2026
   digitalconcepts.net.au
 */
#include <Wire.h>             // I2C bus
#include <INA219.h>           // Tillaart INA219 library
#include "ProMiniPins.h"	    // Pro Mini Pin Definitions

// Define INA219 sensor
INA219 ina219(0x40);

float shuntvoltage = 0.00;
float busvoltage = 0.00;
float current_mA = 0.00;
float loadvoltage = 0.00;
float power_mW = 0.00;

void setup() {
  Serial.begin(115200);
  while (!Serial);        // Wait for serial line to become active
  Serial.println("[setup] Pro Mini [I2C] INA219/HDL300 Test");
  Serial.println();

  Wire.begin();
  Serial.println(F("[setup] Initialise INA219..."));
  if (!ina219.begin()) {
    Serial.println("[setup] Failed to find INA219 module");
    while (true);					// Twiddle your thumbs, no point proceeding...
  }
  // Bus voltage range can be 16 or 32 only
  ina219.setBusVoltageRange(16);
  // Gain can be 1, 2, 4, 8 (lower gain, higher sensitivity)
  ina219.setGain(1);
  // Average over 1..128 samples on powers of 2 steps [0..7] (4 => 16 samples)
  ina219.setBusSamples(4);
  // Average over 1..128 samples on powers of 2 steps [0..7] (4 => 16 samples)
  ina219.setShuntSamples(4);
  // Max current 400mA (minimum for module configuration), shunt resistance 0.1ohm
  ina219.setMaxCurrentShunt(0.4, 0.1);

  Serial.print(F("[setup] Bus Voltage Range: "));
  Serial.println(ina219.getBusVoltageRange());
  Serial.print(F("[setup]              Gain: "));
  Serial.println(ina219.getGain());
  // For ADC configuration register settings see INA219 Datasheet p.20, Table 5
  Serial.print(F("[setup]           Bus ADC: "));
  Serial.println(ina219.getBusADC(),BIN);
  Serial.print(F("[setup]         Shunt ADC: "));
  Serial.println(ina219.getShuntADC(),BIN);
  Serial.println();

  Serial.println(F("[setup] Set-up Complete"));
  Serial.println();
}

void loop() {
  readCurrent();
  delay(5000);
}

void readCurrent() {
  Serial.println("[readCurrent] Sensor read...");
  // Conversion flag will be set [1] if new data is available (should be 1)
  Serial.print("              Conversion Flag: "); Serial.println(ina219.getConversionFlag());
  // Overflow flag will be set [1] in case of mathematical error (should be 0)
  Serial.print("                Overflow Flag: "); Serial.println(ina219.getMathOverflowFlag());
 
  busvoltage = ina219.getBusVoltage();
  shuntvoltage = ina219.getShuntVoltage_mV();
  current_mA = ina219.getCurrent_mA();
  power_mW = ina219.getPower_mW();
  loadvoltage = busvoltage + (shuntvoltage / 1000);
  Serial.print("                  Bus Voltage: "); Serial.print(busvoltage); Serial.println(" V");
  Serial.print("                Shunt Voltage: "); Serial.print(shuntvoltage); Serial.println(" mV");
  Serial.print("                 Load Voltage: "); Serial.print(loadvoltage); Serial.println(" V");
  Serial.print("                      Current: "); Serial.print(current_mA); Serial.println(" mA");
  Serial.print("                        Power: "); Serial.print(power_mW); Serial.println(" mW");
  Serial.println();
}

/*
	 Pro Mini Tank Water Level Monitoring Node
 
   Function:
   Read local battery voltage, DS18B20 temperature sensor and water level probe data and
   forward to LoRa Gateway
  
   Description:
   1. Reads temperature data from onboad battery voltage measurement circuitry, DS18B20
      temperature sensor and current (water level probe pressure, 4~20mA version) from INA219.
   2. Communicates data to [Heltec WiFi LoRa 32 / Raspberry Pi] LoRa Gateway
   3. Uses EEPROM [configuration data] structures defined in the EepromHandler library
   4. Uses packet structures defined in the PacketHandler library
   
   2 Mar 2026 0.1.0  Initial implementation

   Digital Concepts
   2 Mar 2026
   digitalconcepts.net.au
 */

#include <LowPower.h>           // Low Power library
#include <SPI.h>                // SPI Interface for RFM95
#include <LoRa.h>               // LoRa library
#include <Wire.h>             	// I2C bus
#include <INA219.h>             // Tillaart INA219 library
#include <OneWire.h>            // DS18B20 bus
#include <DallasTemperature.h>  // DS18B20 library

#include "ProMiniPins.h"	      // Pro Mini Pin Definitions
#include "LoRa915.h"            // LoRa configuration parameters
#include "PacketHandler.h"      // Packet structures
#include "EepromHandler.h"      // EEPROM management

#define batteryMonitor  A4a_A0  // ADC
#define wakeControl     A4a_A1  // Battery monitor circuit
#define timerDone       A4a_A3  // TPL5111 timer signal

// DS18B20
#define ONE_WIRE_BUS A4a_A2
#define TEMPERATURE_PRECISION 9

struct softwareRevision {
  const uint8_t major;			// Major feature release
  const uint8_t minor;			// Minor feature enhancement release
  const uint8_t minimus;		// 'Bug fix' release
};

softwareRevision sketchRevision = {0,1,0};
String sketchRev = String(sketchRevision.major) + "." + String(sketchRevision.minor) + "." + String(sketchRevision.minimus);

// EEPROM structure
EepromHandler eeprom;

// Packet structure
PacketHandler packet;

const uint8_t batterySensorId = 1;

// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature.
DallasTemperature ds18b20Sensor(&oneWire);
const uint8_t ds18b20SensorId = 2;

int16_t nodeTemperature = 0;

// Define INA219 sensor
INA219 ina219(0x40);
const uint8_t ina219SensorId = 3;

float shuntvoltage = 0.00;
float busvoltage = 0.00;
float current_mA = 0.00;
float loadvoltage = 0.00;
float power_mW = 0.00;

const int reportInterval = 60000;             // Report values every 60000 milliseconds (60 seconds)
const int sleepCycles = 8;   // Can only sleep for 8 seconds at a time

uint8_t* descriptor;
uint16_t messageCounter = 0;

void setup() {
  Serial.begin(115200);
  while (!Serial);        // If just the the basic function, must connect to a computer
    delay(100);

  Serial.println(F("[setup] HDL300 Probe [I2C INA219] Node"));
  Serial.println();

  pinMode(Builtin_LED,OUTPUT);     // Will use LED to signal packet transmission
  digitalWrite(Builtin_LED, HIGH);  // Turn it off to begin with (although, I don't know why HIGH is off...

  pinMode(timerDone, OUTPUT);          // Output signal to control TPL5111 timer
  digitalWrite(timerDone, LOW);        // Set the initial state to 'Off'

  Wire.begin();
  Wire.setClock(400000);
  eeprom.begin(&Wire);
  eeprom.setSmartSerial(false);
  
  Serial.print(F("[setup] Initialising "));
  descriptor = eeprom.readBytes(EH_DESCRIPTOR);
  int byteCount = eeprom.getParameterByteCount(EH_DESCRIPTOR);
  for (int i = 0; i < byteCount; i++) {
    Serial.print((char)descriptor[i]);
  }
  Serial.println(F("..."));
  Serial.println();
  Serial.println("[setup]        Sketch " + sketchRev);
  Serial.println("[setup] PacketHandler " + packet.softwareRevision(PACKET_HANDLER));
  Serial.println("[setup]   NodeHandler " + packet.softwareRevision(NODE_HANDLER));
  Serial.println("[setup] EepromHandler " + eeprom.softwareRevision());
  Serial.println();
  
//  Initialise the RFM95 radio
//  SPI.begin(SCK,MISO,MOSI,NSS);
  LoRa.setPins(NSS, RST, DIO0);
  Serial.println(F("[setup] Activate LoRa Sender"));
//  if (!LoRa.begin(BAND, PABOOST)) {
  if (!LoRa.begin(BAND)) {
    Serial.println(F("[setup] Starting LoRa failed!"));
    while (true);
  }

  Serial.print(F("[setup] LoRa Frequency: "));
  Serial.println(BAND);
  
  LoRa.setSpreadingFactor(SpreadingFactor);
  LoRa.setSignalBandwidth(SignalBandwidth);
  LoRa.setPreambleLength(PreambleLength);
  LoRa.setCodingRate4(CodingRateDenominator);
  LoRa.setSyncWord(SyncWord);
  LoRa.disableCrc();
  
  Serial.println(F("[setup] LoRa initialisation complete"));
  Serial.println();

  messageCounter = eeprom.readUint16(EH_SEQUENCE);
 
  // initialise the Packet Handler
  packet.begin(eeprom.readUint32(EH_GATEWAY_MAC),eeprom.readUint32(EH_NODE_MAC));

  // Initialize the INA219 (note that prior definition of the SDA & SCL pins is required)
  Serial.println(F("[setup] Initialise INA219..."));
  if (!ina219.begin()) {
    Serial.println(F("[setup] Failed to find INA219 module"));
    while (true);					// Twiddle your thumbs, no point proceeding...
  }
  // Bus voltage range can be 16 or 32 only
  ina219.setBusVoltageRange(16);
  // Gain can be 1, 2, 4, 8 (lower gain, higher sensitivity)
  ina219.setGain(1);
  // Average over 1..128 samples on powers of 2 steps [0..7] (4 => 16 samples)
  ina219.setBusSamples(4);
  // Average over 1..128 samples on powers of 2 steps [0..7] (4 => 16 samples)
  ina219.setShuntSamples(4);
  // Max current 400mA (minimum for module configuration), shunt resistance 0.1ohm
  ina219.setMaxCurrentShunt(0.4, 0.1);

  Serial.print(F("[setup] Bus Voltage Range: "));
  Serial.println(ina219.getBusVoltageRange());
  Serial.print(F("[setup]              Gain: "));
  Serial.println(ina219.getGain());
  // For ADC configuration register settings see INA219 Datasheet p.20, Table 5
  Serial.print(F("[setup]           Bus ADC: "));
  Serial.println(ina219.getBusADC(),BIN);
  Serial.print(F("[setup]         Shunt ADC: "));
  Serial.println(ina219.getShuntADC(),BIN);
  Serial.println();

  Serial.println(F("[setup] Set-up Complete"));
  Serial.println();
}

void loop() {
  Serial.println(F("[loop] Send Messages"));
  Serial.println();

  messageCounter++;
  packet.setSequenceNumber(messageCounter);
  packet.setPacketType(VOLTAGE);
  packet.setSensorId(batterySensorId);
  packet.setVoltage(getBatteryVoltage());
//  packet.hexDump();
  packet.serialOut();
  Serial.println();
  sendMessage();
  // Have a snooze while the gateway porocesses that one
  LowPower.powerDown(SLEEP_1S, ADC_OFF, BOD_OFF);

  messageCounter++;
  packet.setSequenceNumber(messageCounter);
  packet.setPacketType(TEMPERATURE);
  packet.setSensorId(ds18b20SensorId);

  packet.setTemperature(readDS18B20Sensor());
//  packet.hexDump();
  packet.serialOut();
  Serial.println();
  sendMessage();
  // Have a snooze while the gateway porocesses that one
  LowPower.powerDown(SLEEP_1S, ADC_OFF, BOD_OFF);

  messageCounter++;
  packet.setSequenceNumber(messageCounter);

  packet.setPacketType(TANK);
  packet.setSensorId(ina219SensorId);
  packet.setTankLevel(readCurrent());
//  packet.hexDump();
  packet.serialOut();
  Serial.println();
  sendMessage();

  eeprom.writeUint16(EH_SEQUENCE, messageCounter); // Save the message counter

//  Trigger the TPL5111 timer
  digitalWrite(timerDone, HIGH);

//  If the timer is triggered, we should never get here...
//  It seems that 8s is the longest sleep so, if we are still here, we need to loop to get to 5 min

  for ( int i = 0; i < sleepCycles; ++i ) {
//    Serial.print("[loop] Sleep cycle ");
//    Serial.println(i);
    LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
  }
}

uint16_t getBatteryVoltage() {
  // ADC resolution
  const int resolution = 10;
  const int adcMax = pow(2,resolution) - 1;
  const float adcMaxVoltage = 3.3;
  // On-board voltage divider
  const int R1 = 27;
  const int R2 = 100;
  // Calibration measurements
  const float measuredVoltage = 4.160;
  const float reportedVoltage = 4.166;
  // Measured value multiplication factor
  const float factor = (adcMaxVoltage / adcMax) * ((R1 + R2)/(float)R2) * (measuredVoltage / reportedVoltage);

  float averageReading;
  uint16_t analogValue = 0;
  uint16_t voltage = 0;

  digitalWrite(wakeControl,HIGH);
  delay(500); // Wait a moment for things to settle down

  Serial.println(F("[getBatteryVoltage] Read battery voltage..."));

  // Take an average

  int averageCount = 10;
  for (int i = 0; i < averageCount; i++) {
    analogValue += analogRead(batteryMonitor);
    delay(10);
  }
  averageReading = analogValue / (float)averageCount;

  Serial.print(F("          Average ["));
  Serial.print(averageCount);
  Serial.print(F("] ADC reading: "));
  Serial.println(averageReading);

  digitalWrite(wakeControl,LOW);
  voltage = (uint16_t)(averageReading * factor * 1000); // milliVolts
  Serial.print(F("                           Voltage: "));
  Serial.print(voltage);
  Serial.println(" mV");

  return voltage;
}

int16_t readDS18B20Sensor() {
  int16_t temperature = 0;
//  Serial.println("[readDS18B20Sensor] Read sensor...");
  ds18b20Sensor.requestTemperatures(); // Send the command to get temperatures
  
  // After we get the temperature(s), we can print it/them here.
  // We use the function ByIndex and get the temperature from the first sensor (there's only one at the moment).
//  Serial.println("[readDS18B20Sensor] Device 1 (index 0)");
  float sensorValue = ds18b20Sensor.getTempCByIndex(0);
//  Serial.print("[readDS18B20Sensor] Returned value: ");
//  Serial.println(sensorValue);

  temperature = (int) (10*(sensorValue + 0.05));  // °C x 10
  Serial.print("[readDS18B20Sensor] Temperature: ");
  Serial.println((float) temperature/10, 1);

  return temperature;
}

uint16_t readCurrent(void) {
  Serial.println("[readCurrent] Sensor read...");
  Serial.print("              Conversion Flag: "); Serial.println(ina219.getConversionFlag());
  Serial.print("                Overflow Flag: "); Serial.println(ina219.getMathOverflowFlag());
 
  busvoltage = ina219.getBusVoltage();
  shuntvoltage = ina219.getShuntVoltage_mV();
  current_mA = ina219.getCurrent_mA();
  power_mW = ina219.getPower_mW();
  loadvoltage = busvoltage + (shuntvoltage / 1000);
  Serial.print("                  Bus Voltage: "); Serial.print(busvoltage); Serial.println(" V");
  Serial.print("                Shunt Voltage: "); Serial.print(shuntvoltage); Serial.println(" mV");
  Serial.print("                 Load Voltage: "); Serial.print(loadvoltage); Serial.println(" V");
  Serial.print("                      Current: "); Serial.print(current_mA); Serial.println(" mA");
  Serial.print("                        Power: "); Serial.print(power_mW); Serial.println(" mW");

  return (uint16_t)(current_mA * 100 + 0.5);
}

void sendMessage() {
// If the host is little endian, we need to reverse the byte order before sending

//  Serial.println(F("[sendMessage] Sending packet: "));
  digitalWrite(Builtin_LED, LOW);  // Turn on the LED to signal sending
/*  
// Check that no one else is transmitting first
  while ((bool) LoRa.available()) {
    Serial.println("[sendMessage] Busy...");
// It would take 212 ms to transmit a [max size] 255 byte packet at 9600 bps
    delay(random(200));
  }
*/  
  LoRa.beginPacket();             // start packet
  LoRa.write((uint8_t *)packet.byteStream(), packet.packetByteCount());    // Load the output buffer
//  Serial.println("[sendMessage] Finished Packet");
  LoRa.endPacket();             // Finish packet and send it
//  Serial.println(F("[sendMessage] Packet Sent"));
  digitalWrite(Builtin_LED, HIGH);  // Done
//  Serial.println();
}

/*
	 CubeCell Plus 3-Wire QDY30A Probe Test
 
   Function:
   Test the function of a 3-Wire QDY30A water level probe with a CubeCell Dev-Board Plus
  
   Description:
   1. Reads voltage (water level probe pressure, 0~3.3V signal) from ADC2 and calculates 							
   		tank water level.
   		
   13 Apr 2026 1.0.0  Initial implementation

   Digital Concepts
   13 Apr 2026
   digitalconcepts.net.au
*/

#include <HT_SH1107Wire.h>    // CubeCell Plus display library

#define SIGNAL_PIN ADC2       // probe signal wire connection

unsigned long reportPeriod_msec = 5000;        // Report period in msec

uint16_t adcReading;
uint16_t signalVoltage;

uint16_t tankHeight = 2050;
uint16_t probeDepthRange = 3000;
uint16_t probeVoltageRange = 3300;
uint16_t signalVoltageOffset = 0;
uint16_t baseSignalVoltage = 2;		// Reported value with probe in free air
uint16_t maxSignalVoltage = baseSignalVoltage + uint16_t((((float)tankHeight/probeDepthRange) * probeVoltageRange));
uint16_t signalVoltageRange = maxSignalVoltage - baseSignalVoltage;
uint8_t waterLevel = 0;   // Will be calculated as a percentage of tank capacity

  // CubeCell ADC resolution
  const int resolution = 12;
  const int adcMax = pow(2,resolution) - 1;
  const float adcMaxVoltage = 2.4;
  // Voltage divider - The following brings a 3.5V signal back to 2.4V at the ADC
  const int R1 = 100;
  const int R2 = 220;
  // Calibration measurements (not used in this case)
  const float measuredVoltage = 3.3;
  const float reportedVoltage = 3.3;
  // Calibration factor
  const float calibrationFactor = (adcMaxVoltage / adcMax) * ((R1 + R2)/(float)R2) * (measuredVoltage / reportedVoltage); 

SH1107Wire  boardDisplay(0x3c, 500000, SDA, SCL, GEOMETRY_128_64, GPIO10), *displayPtr; // addr, freq, sda, scl, resolution, rst

void setup() {
  Serial.begin(115200);

  pinMode(Vext, OUTPUT);    // Sensor (boost converter) power
  digitalWrite(Vext, LOW);  // Activate Vext (we're really writing to Vext_Ctrl here)
  pinMode(ADC2, INPUT);     // probe anlaog input

  boardDisplay.init();
  boardDisplay.setFont(ArialMT_Plain_10);
  boardDisplay.screenRotate(ANGLE_180_DEGREE);
    
  boardDisplay.clear();
  boardDisplay.setFont(ArialMT_Plain_10);
  boardDisplay.setTextAlignment(TEXT_ALIGN_LEFT);
  boardDisplay.drawString(5,0,"QDY30A Sensor");
  boardDisplay.display();
  delay(1000);
}

void loop() {            
  adcReading = analogRead(SIGNAL_PIN);
  signalVoltage = uint16_t(1000.0 * adcReading * calibrationFactor);
  waterLevel = int(100 * signalVoltage / signalVoltageRange);

  Serial.print("[loop] adcReading : ");
  Serial.println(adcReading);
  Serial.print("[loop] signalVoltage : ");
  Serial.println(signalVoltage);
  Serial.print("[loop] baseSignalVoltage : ");
  Serial.println(baseSignalVoltage);
  Serial.print("[loop] maxSignalVoltage : ");
  Serial.println(maxSignalVoltage);
  Serial.print("[loop] signalVoltageRange : ");
  Serial.println(signalVoltageRange);
  Serial.print("[loop] waterLevel : ");
  Serial.println(waterLevel);
  
  boardDisplay.clear();
  boardDisplay.setFont(ArialMT_Plain_10);
  boardDisplay.setTextAlignment(TEXT_ALIGN_LEFT);
  boardDisplay.drawString(5,10,"QDY30A");

  boardDisplay.setTextAlignment(TEXT_ALIGN_RIGHT);
  boardDisplay.drawString(45,20,"ADC");
  boardDisplay.drawString(45,30,"Voltage");
  boardDisplay.drawString(45,40,"Level");

  boardDisplay.setTextAlignment(TEXT_ALIGN_LEFT);
  boardDisplay.drawString(55,20,String(adcReading));
  boardDisplay.drawString(55,30,String(signalVoltage) + "mV");
  boardDisplay.drawString(55,40,String(waterLevel) + "%");

  boardDisplay.display();
  
  Serial.print(reportPeriod_msec/1000);
  Serial.println(" second pause..");
  Serial.println();
  delay(reportPeriod_msec);
}