How to build an ESP-NOW remote
charger monitor with INA219
and OLED

MAC address: AA:BB:CC:DD:EE:FF

/*
 * We stand on the shoulders of giants when we build
 * with knowledge gained from others' efforts.
 * That doesn't make us giants. Be humble.
 * Create with care. Open source is the way.
 *
 * ESP-NOW Remote Monitor - Sender
 * --------------------------------
 * Reads voltage and current from an INA219 and sends both
 * to a specific receiver board over ESP-NOW every two seconds.
 *
 * Unicast mode: paste the receiver's MAC address into receiverMAC[]
 * before flashing. Flash the get-your-MAC sketch to the receiver
 * first if you have not already noted its address.
 *
 * Board:   ESP32 Dev Board (38-pin)
 * Library: Adafruit INA219 by Adafruit
 *
 * Wiring:
 *   INA219: SDA -> GPIO 21   SCL -> GPIO 22
 *   INA219: VCC -> 3.3V      GND -> GND
 *   INA219 inline: VIN+ from TP4056 B+, VIN- to battery +
 *
 * Open source - MIT Licence
 * Electronic Zoology - field notes from the garage
 * https://electroniczoology.com/guides/how-to-build-esp-now-ina219-remote-monitor
 */

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

// --- Paste the receiver's MAC address here ---
uint8_t receiverMAC[] = { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };

#define SEND_INTERVAL_MS 2000

typedef struct {
  float voltage;
  float current_mA;
} PacketData;

PacketData outgoing;
esp_now_peer_info_t peerInfo;
Adafruit_INA219 ina219;

void OnDataSent(const wifi_tx_info_t *tx_info, esp_now_send_status_t status) {
  Serial.print("Send status: ");
  Serial.println(status == ESP_NOW_SEND_SUCCESS ? "OK" : "FAIL");
}

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

  WiFi.mode(WIFI_STA);
  delay(100);

  Serial.print("Sender MAC: ");
  Serial.println(WiFi.macAddress());

  Wire.begin(21, 22);

  if (!ina219.begin()) {
    Serial.println("INA219 not found - check wiring");
    while (true) delay(1000);
  }

  if (esp_now_init() != ESP_OK) {
    Serial.println("ESP-NOW init failed");
    while (true) delay(1000);
  }

  esp_now_register_send_cb(OnDataSent);

  memcpy(peerInfo.peer_addr, receiverMAC, 6);
  peerInfo.channel = 0;
  peerInfo.encrypt = false;

  if (esp_now_add_peer(&peerInfo) != ESP_OK) {
    Serial.println("Failed to add peer - check receiver MAC");
    while (true) delay(1000);
  }

  Serial.println("Sender ready");
}

void loop() {
  static uint32_t lastSend = 0;

  if (millis() - lastSend >= SEND_INTERVAL_MS) {
    lastSend = millis();

    outgoing.voltage    = ina219.getBusVoltage_V();
    outgoing.current_mA = max(0.0f, ina219.getCurrent_mA());

    Serial.printf("Sending: %.3fV  %.1fmA\n", outgoing.voltage, outgoing.current_mA);

    esp_err_t result = esp_now_send(
      receiverMAC,
      (uint8_t *)&outgoing,
      sizeof(outgoing)
    );

    if (result != ESP_OK) {
      Serial.println("Send error");
    }
  }
}

/*
 * We stand on the shoulders of giants when we build
 * with knowledge gained from others' efforts.
 * That doesn't make us giants. Be humble.
 * Create with care. Open source is the way.
 *
 * ESP-NOW Remote Monitor - Receiver
 * -----------------------------------
 * Receives voltage and current readings from a remote INA219 sender
 * and displays them on an SSD1306 OLED with dual scrolling graphs.
 *
 * Two views rotate every VIEW_ROTATE_MS milliseconds:
 *
 *   Live view:   one sample per packet (every 2s), 128 samples = ~4 min
 *                Shows recent current draw as a scrolling bar graph.
 *
 *   Charge view: one sample per minute, 128 samples = ~2 hours
 *                Shows the full CC/CV curve as the charge progresses.
 *
 * Both views share the same numeric top line (live voltage and current).
 * Shows "signal lost" if no packet arrives within 10 seconds.
 *
 * Board:   ESP32 Dev Board (38-pin)
 * Library: Adafruit SSD1306 + Adafruit GFX by Adafruit
 *
 * Wiring:
 *   OLED: SDA -> GPIO 21   SCL -> GPIO 22
 *   OLED: VCC -> 3.3V      GND -> GND
 *
 * Open source - MIT Licence
 * Electronic Zoology - field notes from the garage
 * https://electroniczoology.com/guides/how-to-build-esp-now-ina219-remote-monitor
 */

#include <WiFi.h>
#include <esp_now.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH    128
#define SCREEN_HEIGHT   64
#define OLED_RESET      -1
#define OLED_ADDRESS    0x3C

#define GRAPH_MAX_MA    1200.0f
#define CHARGE_SAMPLE_MS 60000   // one sample/min, 128 samples = ~2hr
#define VIEW_ROTATE_MS  5000
#define TIMEOUT_MS      10000

#define GRAPH_Y         10
#define GRAPH_H         (SCREEN_HEIGHT - GRAPH_Y)   // 54px
#define BUF_SIZE        SCREEN_WIDTH                // 128 points

typedef struct {
  float voltage;
  float current_mA;
} PacketData;

PacketData incoming;
volatile bool newPacket = false;

// Live buffer - one entry per received packet
float   liveBuf[BUF_SIZE];
uint8_t liveHead = 0;
bool    liveFull = false;

// Charge buffer - one entry per minute
float   chargeBuf[BUF_SIZE];
uint8_t chargeHead = 0;
bool    chargeFull = false;

bool showLive = true;
uint32_t lastPacket = 0;

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

void OnDataRecv(const esp_now_recv_info_t *recv_info, const uint8_t *incomingData, int len) {
  memcpy(&incoming, incomingData, sizeof(incoming));
  newPacket = true;
}

void addToLive(float mA) {
  liveBuf[liveHead] = mA;
  liveHead = (liveHead + 1) % BUF_SIZE;
  if (liveHead == 0) liveFull = true;
}

void addToCharge(float mA) {
  chargeBuf[chargeHead] = mA;
  chargeHead = (chargeHead + 1) % BUF_SIZE;
  if (chargeHead == 0) chargeFull = true;
}

void drawGraph(float* buf, uint8_t head, bool full) {
  uint8_t count    = full ? BUF_SIZE : head;
  uint8_t startIdx = full ? head     : 0;

  for (uint8_t i = 0; i < count; i++) {
    uint8_t idx    = (startIdx + i) % BUF_SIZE;
    float   sample = buf[idx];

    if (sample < 0)            sample = 0;
    if (sample > GRAPH_MAX_MA) sample = GRAPH_MAX_MA;

    int barH = (int)((sample / GRAPH_MAX_MA) * (float)(GRAPH_H - 1));
    if (barH < 1 && sample >= 1.0f) barH = 1;

    int x = i;
    int y = GRAPH_Y + (GRAPH_H - 1) - barH;
    display.drawFastVLine(x, y, barH, SSD1306_WHITE);
  }
}

void drawDisplay(float volts, float mA) {
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);

  // --- Numeric line ---
  display.setTextSize(1);
  display.setCursor(0, 0);
  display.print(volts, 2);
  display.print("V");

  // View label centred
  const char* label = showLive ? "LIVE" : "CHARGE";
  int labelW = strlen(label) * 6;
  display.setCursor((SCREEN_WIDTH - labelW) / 2, 0);
  display.print(label);

  // mA right-aligned
  char maBuf[10];
  if (mA < 1.0f) {
    snprintf(maBuf, sizeof(maBuf), "<1mA");
  } else {
    snprintf(maBuf, sizeof(maBuf), "%dmA", (int)mA);
  }
  int maWidth = strlen(maBuf) * 6;
  display.setCursor(SCREEN_WIDTH - maWidth, 0);
  display.print(maBuf);

  // --- Divider ---
  display.drawFastHLine(0, GRAPH_Y - 1, SCREEN_WIDTH, SSD1306_WHITE);

  // --- Graph ---
  if (showLive) {
    drawGraph(liveBuf, liveHead, liveFull);
  } else {
    if (chargeHead == 0 && !chargeFull) {
      display.setTextSize(1);
      display.setCursor(10, GRAPH_Y + 18);
      display.print("< 1 min of data");
    } else {
      drawGraph(chargeBuf, chargeHead, chargeFull);
    }
  }

  display.display();
}

void drawSignalLost() {
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(20, 24);
  display.print("signal lost");
  display.display();
}

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

  WiFi.mode(WIFI_STA);
  delay(100);

  Serial.print("Receiver MAC: ");
  Serial.println(WiFi.macAddress());

  memset(liveBuf,   0, sizeof(liveBuf));
  memset(chargeBuf, 0, sizeof(chargeBuf));

  Wire.begin(21, 22);

  if (!display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDRESS)) {
    Serial.println("SSD1306 not found - check wiring and OLED_ADDRESS");
    while (true) delay(1000);
  }

  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.println("ESP-NOW receiver");
  display.println("waiting...");
  display.display();

  if (esp_now_init() != ESP_OK) {
    Serial.println("ESP-NOW init failed");
    while (true) delay(1000);
  }

  esp_now_register_recv_cb(OnDataRecv);

  Serial.println("Receiver ready - waiting for packets");

  lastPacket = millis();
}

void loop() {
  static uint32_t lastCharge = 0;
  static uint32_t lastRotate = 0;
  static bool signalLost = false;

  uint32_t now = millis();

  if (newPacket) {
    newPacket  = false;
    lastPacket = now;
    signalLost = false;

    Serial.printf("Received: %.3fV  %.1fmA\n", incoming.voltage, incoming.current_mA);

    addToLive(incoming.current_mA);

    if (now - lastCharge >= CHARGE_SAMPLE_MS) {
      lastCharge = now;
      addToCharge(incoming.current_mA);
    }

    drawDisplay(incoming.voltage, incoming.current_mA);
  }

  if (now - lastRotate >= VIEW_ROTATE_MS) {
    lastRotate = now;
    showLive = !showLive;
  }

  if (!signalLost && now - lastPacket >= TIMEOUT_MS) {
    signalLost = true;
    drawSignalLost();
    Serial.println("Signal lost");
  }
}

Sending: 3.752V  843.0mA
Send status: OK