INA219 and SK

[mikekolling1966]

I am trying to get 4X INA219 Sensors to talk to SK via a ESP32. I can get either end to work, i can get the INA219 code to work in one version and i can get the SENESP bit to work in the old version, but i cannot get them all to work.
I have spent two days with chatgpt and copilot and they just cannot do it, som many changes in SENSESP they just get themselves in knots

version 1 – from April – works for SENSESP but need to change to INA219

Main.cpp

#include
#include "sensesp.h"
#include "sensesp/sensors/analog_input.h"
#include "sensesp/sensors/digital_input.h"
#include "sensesp/sensors/sensor.h"
#include "sensesp/signalk/signalk_output.h"
#include "sensesp/system/lambda_consumer.h"
#include "sensesp_app_builder.h"
using namespace sensesp;
void setup() {
SetupLogging(ESP_LOG_DEBUG);
SensESPAppBuilder builder;
sensesp_app = (&builder)
->set_hostname("manxman-sensesp-project")
->get_app();
const unsigned int kAnalogInputReadInterval = 500;
const uint8_t kAnalogInputPin0 = 0; // GP0
const uint8_t kAnalogInputPin1 = 1; // GP1
const uint8_t kAnalogInputPin2 = 2; // GP2
const uint8_t kAnalogInputPin3 = 3; // GP3

// ONE
// ONE sensor for raw ADC (scale = 1.0)
auto analog_input_raw0 = std::make_shared(
kAnalogInputPin0, kAnalogInputReadInterval, "", 1.0);
// ONE sensor for voltage (scale = 3.3 / 4095.0)
auto analog_input_voltage0 = std::make_shared(
kAnalogInputPin0, kAnalogInputReadInterval, "", 3.3 / 4095.0);
// Debug print the raw ADC value
analog_input_raw0->attach(analog_input_raw0 {
debugD("Analog input raw 0 value: %f", analog_input_raw0->get());
});
//TWO
// ONE sensor for raw ADC (scale = 1.0)
auto analog_input_raw1 = std::make_shared(
kAnalogInputPin1, kAnalogInputReadInterval, "", 1.0);
// ONE sensor for voltage (scale = 3.3 / 4095.0)
auto analog_input_voltage1 = std::make_shared(
kAnalogInputPin1, kAnalogInputReadInterval, "", 3.3 / 4095.0);
// Debug print the raw ADC value
analog_input_raw1->attach(analog_input_raw1 {
debugD("Analog input raw 1 value: %f", analog_input_raw1->get());
});
//THREE
// ONE sensor for raw ADC (scale = 1.0)
auto analog_input_raw2 = std::make_shared(
kAnalogInputPin2, kAnalogInputReadInterval, "", 1.0);
// ONE sensor for voltage (scale = 3.3 / 4095.0)
auto analog_input_voltage2 = std::make_shared(
kAnalogInputPin2, kAnalogInputReadInterval, "", 3.3 / 4095.0);
// Debug print the raw ADC value
analog_input_raw2->attach(analog_input_raw2 {
debugD("Analog input raw 2 value: %f", analog_input_raw2->get());
});
//FOUR
// ONE sensor for raw ADC (scale = 1.0)
auto analog_input_raw3 = std::make_shared(
kAnalogInputPin3, kAnalogInputReadInterval, "", 1.0);
// ONE sensor for voltage (scale = 3.3 / 4095.0)
auto analog_input_voltage3 = std::make_shared(
kAnalogInputPin3, kAnalogInputReadInterval, "", 3.3 / 4095.0);
// Debug print the raw ADC value
analog_input_raw3->attach(analog_input_raw3 {
debugD("Analog input raw 3 value: %f", analog_input_raw3->get());
});

// --- Signal K Outputs ---
//RAW ADC
//ONE
// RAW ADC Output
auto adc_metadata0 = std::make_shared("", "Analog input raw ADC value");
auto adc_sk_output0 = std::make_shared<SKOutput>(
"sensors.analog_input.adc.0",
"/Sensors/Analog Input/ADC 0 Value",
adc_metadata0
);
ConfigItem(adc_sk_output0)
->set_title("Analog Input ADC Raw Value SK Output Path")
->set_description("Publishes raw 0–4095 ADC reading")
->set_sort_order(100);
analog_input_raw0->connect_to(adc_sk_output0);
//TWO
// RAW ADC Output 1
auto adc_metadata1 = std::make_shared("", "Analog input raw ADC value");
auto adc_sk_output1 = std::make_shared<SKOutput>(
"sensors.analog_input.adc.1",
"/Sensors/Analog Input/ADC 1 Value",
adc_metadata1
);
ConfigItem(adc_sk_output1)
->set_title("Analog Input ADC Raw Value SK Output Path")
->set_description("Publishes raw 0–4095 ADC reading")
->set_sort_order(100);
analog_input_raw1->connect_to(adc_sk_output1);

//THREE
// RAW ADC Output 1
auto adc_metadata2 = std::make_shared("", "Analog input raw ADC value");
auto adc_sk_output2 = std::make_shared<SKOutput>(
"sensors.analog_input.adc.2",
"/Sensors/Analog Input/ADC 2 Value",
adc_metadata2
);
ConfigItem(adc_sk_output2)
->set_title("Analog Input ADC Raw Value SK Output Path")
->set_description("Publishes raw 0–4095 ADC reading")
->set_sort_order(100);
analog_input_raw2->connect_to(adc_sk_output2);
//FOUR
// RAW ADC Output 1
auto adc_metadata3 = std::make_shared("", "Analog input raw ADC value");
auto adc_sk_output3 = std::make_shared<SKOutput>(
"sensors.analog_input.adc.3",
"/Sensors/Analog Input/ADC 3 Value",
adc_metadata3
);
ConfigItem(adc_sk_output3)
->set_title("Analog Input ADC Raw Value SK Output Path")
->set_description("Publishes raw 0–4095 ADC reading")
->set_sort_order(100);
analog_input_raw3->connect_to(adc_sk_output3);
//
//
// VOLTAGES
//ONE
// Voltage Output
auto voltage_metadata0 = std::make_shared("V", "Analog input voltage");
auto voltage_sk_output0 = std::make_shared<SKOutput>(
"sensors.analog_input.voltage.0",
"/Sensors/Analog Input/Voltage",
voltage_metadata0
);
ConfigItem(voltage_sk_output0)
->set_title("Analog Input Voltage SK Output Path")
->set_description("Publishes scaled 0.0–3.3V reading")
->set_sort_order(110);
analog_input_voltage0->connect_to(voltage_sk_output0);
//TWO
// Voltage Output
auto voltage_metadata1 = std::make_shared("V", "Analog input voltage");
auto voltage_sk_output1 = std::make_shared<SKOutput>(
"sensors.analog_input.voltage.1",
"/Sensors/Analog Input/Voltage",
voltage_metadata1
);
ConfigItem(voltage_sk_output1)
->set_title("Analog Input Voltage SK Output Path")
->set_description("Publishes scaled 0.0–3.3V reading")
->set_sort_order(110);
analog_input_voltage1->connect_to(voltage_sk_output1);
//THREE
// Voltage Output
auto voltage_metadata2 = std::make_shared("V", "Analog input voltage");
auto voltage_sk_output2 = std::make_shared<SKOutput>(
"sensors.analog_input.voltage.2",
"/Sensors/Analog Input/Voltage",
voltage_metadata2
);
ConfigItem(voltage_sk_output2)
->set_title("Analog Input Voltage SK Output Path")
->set_description("Publishes scaled 0.0–3.3V reading")
->set_sort_order(110);
analog_input_voltage2->connect_to(voltage_sk_output2);
//FOUR
// Voltage Output
auto voltage_metadata3 = std::make_shared("V", "Analog input voltage");
auto voltage_sk_output3 = std::make_shared<SKOutput>(
"sensors.analog_input.voltage.3",
"/Sensors/Analog Input/Voltage",
voltage_metadata3
);
ConfigItem(voltage_sk_output3)
->set_title("Analog Input Voltage SK Output Path")
->set_description("Publishes scaled 0.0–3.3V reading")
->set_sort_order(110);
analog_input_voltage3->connect_to(voltage_sk_output3);

while (true) {
loop();
}
}
void loop() { event_loop()->tick(); }

Platformio.ini

[platformio]
default_envs = pioarduino_esp32
[env]
upload_speed = 2000000
monitor_speed = 115200
lib_deps =
SignalK/SensESP @ >=3.0.0-beta.6,<4.0.0-alpha.1
adafruit/Adafruit INA219 @ ^1.2.2

build_flags =
-D CORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_VERBOSE
-D USE_ESP_IDF_LOG
board_build.partitions = min_spiffs.csv
build_unflags =
-Werror=reorder
monitor_filters = esp32_exception_decoder
test_build_src = true
check_tool = clangtidy
check_flags =
clangtidy: --fix --format-style=file --config-file=.clang-tidy
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Platform configurations follow
[arduino]
platform = espressif32 @ ^6.9.0
framework = arduino
lib_ignore =
esp_websocket_client
build_flags =
${env.build_flags}
[pioarduino]
platform = https://github.com/pioarduino/platform-espressif32/releases/download/stable/platform-espressif32.zip
framework = arduino
lib_deps =
${env.lib_deps}
esp_websocket_client=https://components.espressif.com/api/downloads/?object_type=component&object_id=dbc87006-9a4b-45e6-a6ab-b286174cb413
build_flags =
${env.build_flags}
[espidf]
platform = https://github.com/pioarduino/platform-espressif32/releases/download/stable/platform-espressif32.zip
framework = espidf, arduino
board_build.embed_txtfiles =
managed_components/espressif__esp_insights/server_certs/https_server.crt
managed_components/espressif__esp_rainmaker/server_certs/rmaker_mqtt_server.crt
managed_components/espressif__esp_rainmaker/server_certs/rmaker_claim_service_server.crt
managed_components/espressif__esp_rainmaker/server_certs/rmaker_ota_server.crt
lib_deps =
${env.lib_deps}
esp_websocket_client=https://components.espressif.com/api/downloads/?object_type=component&object_id=dbc87006-9a4b-45e6-a6ab-b286174cb413
build_flags =
${env.build_flags}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Board configurations follow
[esp32]
board = esp32dev
build_flags =
${env.build_flags}
-D BUTTON_BUILTIN=0
-D LED_BUILTIN=2
[esp32c3]
board = esp32-c3-devkitm-1
build_flags =
${env.build_flags}
-D SENSESP_BUTTON_PIN=9
-D PIN_RGB_LED=8
-DARDUINO_USB_MODE=1
-DARDUINO_USB_CDC_ON_BOOT=1
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Permutations of platform and device.
[env:arduino_esp32]
extends = arduino, esp32
build_flags =
${arduino.build_flags}
${esp32.build_flags}
[env:pioarduino_esp32]
extends = pioarduino, esp32
build_flags =
${pioarduino.build_flags}
${esp32.build_flags}
[env:espidf_esp32]
extends = espidf, esp32
build_flags =
${espidf.build_flags}
${esp32.build_flags}
[env:arduino_esp32c3]
extends = arduino, esp32c3
build_flags =
${arduino.build_flags}
${esp32c3.build_flags}
[env:pioarduino_esp32c3]
extends = pioarduino, esp32c3
build_flags =
${pioarduino.build_flags}
${esp32c3.build_flags}
[env:espidf_esp32c3]
extends = espidf, esp32c3
build_flags =
${espidf.build_flags}
${esp32c3.build_flags}
[env:shesp32]
extends = pioarduino, esp32
build_flags =
${pioarduino.build_flags}
${esp32.build_flags}
[env:halmet]
extends = pioarduino, esp32
board_build.partitions = default_8MB.csv
build_flags =
${pioarduino.build_flags}
${esp32.build_flags}
[env:halser]
extends = pioarduino, esp32c3
build_flags =
${pioarduino.build_flags}
${esp32c3.build_flags}

======================================================

Version 2 – works for INA219 but no SENSESP

MAIN.CPP

#include
#include <Wire.h>
#include <Adafruit_INA219.h>

#include "sensesp.h"
#include "sensesp/sensors/analog_input.h"
#include "sensesp/sensors/digital_input.h"
#include "sensesp/sensors/sensor.h"
#include "sensesp/signalk/signalk_output.h"
#include "sensesp/system/lambda_consumer.h"
#include "sensesp_app_builder.h"
#include <SPIFFS.h>

using namespace sensesp;

// Create INA219 objects for your sensors (adjust addresses as needed)
Adafruit_INA219 ina219_0(0x40);
Adafruit_INA219 ina219_1(0x41);
Adafruit_INA219 ina219_2(0x44);
Adafruit_INA219 ina219_3(0x45);

void resetI2CBus() {
Serial.println("Resetting I2C bus...");
Wire.end();
delay(100);
Wire.begin(8, 9, 100000);
delay(100);
Serial.println("I2C bus reset complete.");
}

bool initializeSensors() {
bool allGood = true;

if (!ina219_0.begin()) {
Serial.println("Failed to find INA219 @0x40");
allGood = false;
}
if (!ina219_1.begin()) {
Serial.println("Failed to find INA219 @0x41");
allGood = false;
}
if (!ina219_2.begin()) {
Serial.println("Failed to find INA219 @0x44");
allGood = false;
}
if (!ina219_3.begin()) {
Serial.println("Failed to find INA219 @0x45");
allGood = false;
}

return allGood;
}

void setup() {
SetupLogging(ESP_LOG_DEBUG);

Serial.begin(115200);
while (!Serial) { delay(10); }

if (!SPIFFS.begin(true)) {
Serial.println("Failed to mount SPIFFS");
} else {
Serial.println("SPIFFS Mounted");
}

Wire.begin(8, 9, 100000);

Serial.println("Initializing INA219 sensors...");
initializeSensors();

SensESPAppBuilder builder;
sensesp_app = (&builder)
->set_hostname("my-sensesp-project")
->get_app();

// Your existing analog/digital inputs setup can go here if needed
}

void loop() {
// Try reading from sensors, if error detected, reset I2C and reinitialize
bool sensorError = false;

float voltage_0 = 0, voltage_1 = 0, voltage_2 = 0, voltage_3 = 0;

// We wrap each read in try/catch style error detection by checking if the sensor is responding
// INA219 library does not throw, so we detect errors by simple sanity checks here

// If sensor is not ready, mark error
if (!ina219_0.begin()) sensorError = true;
else voltage_0 = ina219_0.getBusVoltage_V();

if (!ina219_1.begin()) sensorError = true;
else voltage_1 = ina219_1.getBusVoltage_V();

if (!ina219_2.begin()) sensorError = true;
else voltage_2 = ina219_2.getBusVoltage_V();

if (!ina219_3.begin()) sensorError = true;
else voltage_3 = ina219_3.getBusVoltage_V();

if (sensorError) {
Serial.println("Error detected reading INA219 sensors, resetting I2C bus and reinitializing...");
resetI2CBus();
initializeSensors();
delay(2000); // Wait before retrying
return; // Skip this cycle
}

Serial.print("INA219 0x40 Voltage: ");
Serial.print(voltage_0);
Serial.println(" V");

Serial.print("INA219 0x41 Voltage: ");
Serial.print(voltage_1);
Serial.println(" V");

Serial.print("INA219 0x44 Voltage: ");
Serial.print(voltage_2);
Serial.println(" V");

Serial.print("INA219 0x45 Voltage: ");
Serial.print(voltage_3);
Serial.println(" V");

delay(1000);

event_loop()->tick();
}

PLATFORMIO.INI

[platformio]
default_envs = pioarduino_esp32

[env]
upload_speed = 2000000
monitor_speed = 115200

lib_deps =
SignalK/SensESP @ >=3.0.0-beta.6,<4.0.0-alpha.1
adafruit/Adafruit INA219 @ ^1.2.2

build_flags =
-D CORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_VERBOSE
-D USE_ESP_IDF_LOG

board_build.partitions = min_spiffs.csv

build_unflags =
-Werror=reorder
monitor_filters = esp32_exception_decoder

test_build_src = true
check_tool = clangtidy
check_flags =
clangtidy: --fix --format-style=file --config-file=.clang-tidy

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Platform configurations follow

[arduino]
platform = espressif32 @ ^6.9.0
framework = arduino
lib_ignore =
esp_websocket_client
build_flags =
${env.build_flags}

[pioarduino]
platform = https://github.com/pioarduino/platform-espressif32/releases/download/stable/platform-espressif32.zip
framework = arduino
lib_deps =
${env.lib_deps}
esp_websocket_client=https://components.espressif.com/api/downloads/?object_type=component&object_id=dbc87006-9a4b-45e6-a6ab-b286174cb413
build_flags =
${env.build_flags}

[espidf]
platform = https://github.com/pioarduino/platform-espressif32/releases/download/stable/platform-espressif32.zip
framework = espidf, arduino
board_build.embed_txtfiles =
managed_components/espressif__esp_insights/server_certs/https_server.crt
managed_components/espressif__esp_rainmaker/server_certs/rmaker_mqtt_server.crt
managed_components/espressif__esp_rainmaker/server_certs/rmaker_claim_service_server.crt
managed_components/espressif__esp_rainmaker/server_certs/rmaker_ota_server.crt
lib_deps =
${env.lib_deps}
esp_websocket_client=https://components.espressif.com/api/downloads/?object_type=component&object_id=dbc87006-9a4b-45e6-a6ab-b286174cb413
build_flags =
${env.build_flags}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Board configurations follow

[esp32]
board = esp32dev
build_flags =
${env.build_flags}
-D BUTTON_BUILTIN=0
-D LED_BUILTIN=2

[esp32c3]
board = esp32-c3-devkitm-1
build_flags =
${env.build_flags}
-D SENSESP_BUTTON_PIN=9
-D PIN_RGB_LED=8
-DARDUINO_USB_MODE=1
-DARDUINO_USB_CDC_ON_BOOT=1

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Permutations of platform and device.

[env:arduino_esp32]
extends = arduino, esp32
build_flags =
${arduino.build_flags}
${esp32.build_flags}

[env:pioarduino_esp32]
extends = pioarduino, esp32
build_flags =
${pioarduino.build_flags}
${esp32.build_flags}

[env:espidf_esp32]
extends = espidf, esp32
build_flags =
${espidf.build_flags}
${esp32.build_flags}

[env:arduino_esp32c3]
extends = arduino, esp32c3
build_flags =
${arduino.build_flags}
${esp32c3.build_flags}

[env:pioarduino_esp32c3]
extends = pioarduino, esp32c3
build_flags =
${pioarduino.build_flags}
${esp32c3.build_flags}

[env:espidf_esp32c3]
extends = espidf, esp32c3
build_flags =
${espidf.build_flags}
${esp32c3.build_flags}

[env:shesp32]
extends = pioarduino, esp32
build_flags =
${pioarduino.build_flags}
${esp32.build_flags}

[env:halmet]
extends = pioarduino, esp32
board_build.partitions = default_8MB.csv
build_flags =
${pioarduino.build_flags}
${esp32.build_flags}

[env:halser]
extends = pioarduino, esp32c3
build_flags =
${pioarduino.build_flags}
${esp32c3.build_flags}

======================================================

[hwater]

I would use the working version #1 and change it from internal analog to your INA-Chip step by step.
The INA-Library is preferable if it works via Interrupt.
Polling for 4 Ports if one is ready maybe too slow.

--# Matti - we would like to see more Example Projects for the SensESP....