Battery Health Screening Device

#include <Wire.h>
#include <SPI.h>
#include <SD.h>
#include <Adafruit_ADS1X15.h>
#include <Adafruit_INA219.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

constexpr int SD_CS_PIN = 4;
constexpr int LOAD_GATE_PIN = 25;
constexpr int START_BUTTON_PIN = 32;
constexpr int STOP_BUTTON_PIN = 33;
constexpr int BUZZER_PIN = 27;
constexpr int REUSE_LED_PIN = 13;
constexpr int INSPECT_LED_PIN = 14;
constexpr int RECYCLE_LED_PIN = 26;

constexpr float DIVIDER_RATIO = 3.0f;       // 20 kOhm top / 10 kOhm bottom divider
constexpr float MIN_START_VOLTAGE = 3.00f;  // Do not test a deeply discharged cell
constexpr float CUTOFF_VOLTAGE = 2.80f;
constexpr float MAX_CELL_TEMP_C = 55.0f;
constexpr unsigned long TEST_DURATION_MS = 30000UL;
constexpr unsigned long SAMPLE_PERIOD_MS = 500UL;
constexpr float NTC_BETA = 3950.0f;
constexpr float NTC_R0 = 10000.0f;
constexpr float NTC_T0_K = 298.15f;

Adafruit_ADS1115 ads;
Adafruit_INA219 ina219;
Adafruit_SSD1306 display(128, 64, &Wire, -1);
bool sdReady = false;
bool testRunning = false;
unsigned long testStartedMs = 0;
unsigned long lastSampleMs = 0;
float openCircuitVoltage = 0.0f;
float minimumVoltage = 99.0f;
float peakCurrentA = 0.0f;
float startTempC = 0.0f;
float lastVoltage = 0.0f;
float lastCurrentA = 0.0f;
float lastTempC = 0.0f;

float readCellVoltage() {
  int16_t raw = ads.readADC_SingleEnded(0);
  float adcVolts = ads.computeVolts(raw);
  return adcVolts * DIVIDER_RATIO;
}

float readTemperatureC() {
  int16_t raw = ads.readADC_SingleEnded(1);
  float nodeVolts = ads.computeVolts(raw);
  if (nodeVolts <= 0.01f || nodeVolts >= 3.29f) return NAN;
  // 10 kOhm fixed resistor is from 3.3 V to the node; NTC is from node to GND.
  float ntcOhms = NTC_R0 * nodeVolts / (3.3f - nodeVolts);
  float invT = (1.0f / NTC_T0_K) + log(ntcOhms / NTC_R0) / NTC_BETA;
  return (1.0f / invT) - 273.15f;
}

float readCurrentA() {
  return ina219.getCurrent_mA() / 1000.0f;
}

void setResultLeds(bool reuse, bool inspect, bool recycle) {
  digitalWrite(REUSE_LED_PIN, reuse ? HIGH : LOW);
  digitalWrite(INSPECT_LED_PIN, inspect ? HIGH : LOW);
  digitalWrite(RECYCLE_LED_PIN, recycle ? HIGH : LOW);
}

void drawStatus(const char *title, const char *line4 = "") {
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);
  display.setTextSize(1);
  display.setCursor(0, 0);
  display.println("PUNARVA 18650 TEST");
  display.println(title);
  display.print("V: "); display.print(lastVoltage, 2); display.println(" V");
  display.print("I: "); display.print(lastCurrentA, 2); display.println(" A");
  display.print("T: "); display.print(lastTempC, 1); display.println(" C");
  display.println(line4);
  display.display();
}

void appendLog(const char *result, float resistanceOhms) {
  if (!sdReady) return;
  File log = SD.open("/punarva.csv", FILE_APPEND);
  if (!log) return;
  log.print(millis()); log.print(',');
  log.print(openCircuitVoltage, 3); log.print(',');
  log.print(minimumVoltage, 3); log.print(',');
  log.print(peakCurrentA, 3); log.print(',');
  log.print(lastTempC, 2); log.print(',');
  log.print(resistanceOhms * 1000.0f, 1); log.print(',');
  log.println(result);
  log.close();
}

void finishTest(const char *forcedResult = nullptr) {
  digitalWrite(LOAD_GATE_PIN, LOW);
  testRunning = false;
  float voltageDrop = openCircuitVoltage - minimumVoltage;
  float resistanceOhms = (peakCurrentA > 0.05f) ? voltageDrop / peakCurrentA : 99.0f;
  float temperatureRise = lastTempC - startTempC;
  const char *result = forcedResult;
  if (result == nullptr) {
    if (minimumVoltage < CUTOFF_VOLTAGE || lastTempC >= MAX_CELL_TEMP_C || resistanceOhms > 0.25f) result = "RECYCLE";
    else if (resistanceOhms > 0.12f || temperatureRise > 8.0f || minimumVoltage < 3.20f) result = "INSPECT";
    else result = "REUSE";
  }
  setResultLeds(strcmp(result, "REUSE") == 0, strcmp(result, "INSPECT") == 0, strcmp(result, "RECYCLE") == 0);
  tone(BUZZER_PIN, 2200, 180);
  lastVoltage = minimumVoltage;
  drawStatus(result, "Remove cell before next test");
  appendLog(result, resistanceOhms);
}

void startTest() {
  lastVoltage = readCellVoltage();
  lastCurrentA = readCurrentA();
  lastTempC = readTemperatureC();
  setResultLeds(false, false, false);
  if (isnan(lastTempC) || lastVoltage < MIN_START_VOLTAGE || lastVoltage > 4.25f) {
    drawStatus("CHECK CELL", "Use 3.00-4.25 V cell");
    tone(BUZZER_PIN, 500, 350);
    return;
  }
  openCircuitVoltage = lastVoltage;
  minimumVoltage = lastVoltage;
  peakCurrentA = 0.0f;
  startTempC = lastTempC;
  testStartedMs = millis();
  lastSampleMs = 0;
  testRunning = true;
  digitalWrite(LOAD_GATE_PIN, HIGH);
}

void setup() {
  pinMode(LOAD_GATE_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  pinMode(REUSE_LED_PIN, OUTPUT);
  pinMode(INSPECT_LED_PIN, OUTPUT);
  pinMode(RECYCLE_LED_PIN, OUTPUT);
  pinMode(START_BUTTON_PIN, INPUT_PULLUP);
  pinMode(STOP_BUTTON_PIN, INPUT_PULLUP);
  digitalWrite(LOAD_GATE_PIN, LOW);
  setResultLeds(false, false, false);

  Wire.begin(21, 22);
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  ads.begin(0x48);
  ads.setGain(GAIN_ONE);
  ina219.begin();
  SPI.begin(18, 19, 23, SD_CS_PIN);
  sdReady = SD.begin(SD_CS_PIN, SPI);
  lastVoltage = readCellVoltage();
  lastCurrentA = readCurrentA();
  lastTempC = readTemperatureC();
  drawStatus("READY", "Press START to test");
}

void loop() {
  if (!testRunning) {
    if (digitalRead(START_BUTTON_PIN) == LOW) {
      delay(25);
      if (digitalRead(START_BUTTON_PIN) == LOW) {
        startTest();
        while (digitalRead(START_BUTTON_PIN) == LOW) delay(5);
      }
    }
    return;
  }

  if (digitalRead(STOP_BUTTON_PIN) == LOW) {
    finishTest("INSPECT");
    while (digitalRead(STOP_BUTTON_PIN) == LOW) delay(5);
    return;
  }

  unsigned long now = millis();
  if (now - lastSampleMs >= SAMPLE_PERIOD_MS) {
    lastSampleMs = now;
    lastVoltage = readCellVoltage();
    lastCurrentA = readCurrentA();
    lastTempC = readTemperatureC();
    if (lastVoltage < minimumVoltage) minimumVoltage = lastVoltage;
    if (lastCurrentA > peakCurrentA) peakCurrentA = lastCurrentA;
    drawStatus("TESTING", "STOP aborts test");

    if (isnan(lastTempC) || lastTempC >= MAX_CELL_TEMP_C) {
      finishTest("RECYCLE");
      return;
    }
    if (lastVoltage <= CUTOFF_VOLTAGE) {
      finishTest();
      return;
    }
  }

  if (now - testStartedMs >= TEST_DURATION_MS) finishTest();
}