1S Battery fuel gauge op 2S lipo

#include <LTC2944.h>

const unsigned int fullCapacity = 6000; // Maximum value is 22000 mAh

LTC2944 gauge(50); // Takes R_SENSE value (in milliohms) as constructor argument, can be omitted if using CJMCU-294

void setup() {
  Serial.begin(115200);
  Serial.println("LTC2944 Battery Readings Example");
  Serial.println();

  Wire.begin();

  while (gauge.begin() == false) {
    Serial.println("Failed to detect LTC2944!");
    delay(5000);
  }

  gauge.setBatteryCapacity(fullCapacity);
  // gauge.setBatteryToFull(); // Sets accumulated charge registers to the maximum value
  gauge.setADCMode(ADC_MODE_SLEEP); // In sleep mode, voltage and temperature measurements will only take place when requested
  gauge.startMeasurement();
}

void loop() {
  unsigned int raw = gauge.getRawAccumulatedCharge();
  Serial.print(F("Raw Accumulated Charge: "));
  Serial.println(raw, DEC);

  float capacity = gauge.getRemainingCapacity();
  Serial.print(F("Battery Capacity: "));
  Serial.print(capacity, 3);
  Serial.print(F(" / "));
  Serial.print(fullCapacity, DEC);
  Serial.println(F(" mAh"));

  float voltage = gauge.getVoltage();
  Serial.print(F("Voltage: "));
  Serial.print(voltage, 3);
  Serial.println(F(" V"));

  float temperature = gauge.getTemperature();
  Serial.print(F("Temperature: "));
  Serial.print(temperature, 2);
  Serial.println(F(" 'C"));

  float current = gauge.getCurrent();
  Serial.print(F("Current: "));
  Serial.print(current, 6);
  Serial.println(F("A"));

  Serial.println();

  delay(5000);
}

#include <EEPROM.h>
#include <LTC2944.h>
#include <math.h>  // voor fabs, fmax, fmin

#define EEPROM_ADDR 0

// ===== BATTERIJ SETUP =====
float DESIGN_CAPACITY_MAH = 6000.0;
float learnedCapacity = DESIGN_CAPACITY_MAH;

const float FULL_VOLTAGE  = 8.10;
const float EMPTY_VOLTAGE = 6.60;

const float SOC_WRITE_DELTA = 0.5;
const unsigned long SAVE_INTERVAL = 300000; // 5 min

LTC2944 gauge(50);

// ===== EEPROM STRUCT =====
struct GaugeState {
  float soc;
  uint16_t raw;
  float learnedCap;
  uint16_t crc;
};

GaugeState state;
uint16_t lastRaw = 0;
int32_t totalRaw = 0;
float lastSavedSOC = -1;
unsigned long lastSave = 0;
bool forceSave = false;

// ===== Kalman filter voor current & voltage =====
float kalmanCurrent = 0;
float kalmanErrorCurrent = 1;
float kalmanQCurrent = 0.02;
float kalmanRCurrent = 0.5;

float kalmanVoltage = 0;
float kalmanErrorVoltage = 1;
float kalmanQVoltage = 0.001;
float kalmanRVoltage = 0.002;

// ===== Kalman filter voor timers =====
float kalmanTimerEmpty = 0;
float kalmanErrorTimerEmpty = 1;

float kalmanTimerFull = 0;
float kalmanErrorTimerFull = 1;

float kalmanQTimer = 0.01;   // process noise
float kalmanRTimer = 0.1;    // measurement noise

float kalmanUpdateTimerEmpty(float measurement){
    kalmanErrorTimerEmpty += kalmanQTimer;
    float gain = kalmanErrorTimerEmpty / (kalmanErrorTimerEmpty + kalmanRTimer);
    kalmanTimerEmpty += gain * (measurement - kalmanTimerEmpty);
    kalmanErrorTimerEmpty *= (1 - gain);
    return kalmanTimerEmpty;
}

float kalmanUpdateTimerFull(float measurement){
    kalmanErrorTimerFull += kalmanQTimer;
    float gain = kalmanErrorTimerFull / (kalmanErrorTimerFull + kalmanRTimer);
    kalmanTimerFull += gain * (measurement - kalmanTimerFull);
    kalmanErrorTimerFull *= (1 - gain);
    return kalmanTimerFull;
}

// ===== Kalman updates voor current & voltage =====
float kalmanUpdateCurrent(float measurement) {
  kalmanErrorCurrent += kalmanQCurrent;
  float gain = kalmanErrorCurrent / (kalmanErrorCurrent + kalmanRCurrent);
  kalmanCurrent += gain * (measurement - kalmanCurrent);
  kalmanErrorCurrent *= (1 - gain);
  return kalmanCurrent;
}

float kalmanUpdateVoltage(float measurement) {
  kalmanErrorVoltage += kalmanQVoltage;
  float gain = kalmanErrorVoltage / (kalmanErrorVoltage + kalmanRVoltage);
  kalmanVoltage += gain * (measurement - kalmanVoltage);
  kalmanErrorVoltage *= (1 - gain);
  return kalmanVoltage;
}

// ===== CRC =====
uint16_t calcCRC(GaugeState s) {
  return (uint16_t)(s.soc*10) ^ s.raw ^ (uint16_t)s.learnedCap ^ 0xBEEF;
}

bool loadState(GaugeState &out) {
  EEPROM.get(EEPROM_ADDR,out);
  if(out.crc != calcCRC(out)) return false;
  if(out.soc<0||out.soc>100) return false;
  if(out.learnedCap<1000||out.learnedCap>20000) return false;
  return true;
}

void saveState(float soc,uint16_t raw,float capacity) {
  if(lastSavedSOC<0) lastSavedSOC=soc;
  if(!forceSave && fabs(soc-lastSavedSOC)<SOC_WRITE_DELTA && millis()-lastSave<SAVE_INTERVAL) return;

  GaugeState s;
  s.soc=soc;
  s.raw=raw;
  s.learnedCap=capacity;
  s.crc=calcCRC(s);

  EEPROM.put(EEPROM_ADDR,s);
  EEPROM.commit();
  lastSavedSOC=soc;
  lastSave=millis();
  forceSave=false;
  Serial.println("EEPROM saved");
}

// ===== voltage fallback =====
float estimateSOC(float v){
  if(v>=8.10) return 100;
  if(v>=8.00) return 95;
  if(v>=7.80) return 80;
  if(v>=7.60) return 65;
  if(v>=7.40) return 50;
  if(v>=7.20) return 35;
  if(v>=7.00) return 20;
  if(v>=6.80) return 10;
  return 5;
}

// ===== print time functie =====
void printTime(float hours){
  if(hours < 0){ 
    Serial.print("--:--:--"); 
    return; 
  }

  int h = (int)hours;
  float remainder = hours - h;
  int m = (int)(remainder * 60);
  int s = (int)(((remainder * 60) - m) * 60 + 0.5);

  if(s >= 60){ s -= 60; m += 1; }
  if(m >= 60){ m -= 60; h += 1; }

  if(h < 10) Serial.print('0'); 
  Serial.print(h); Serial.print(':');
  if(m < 10) Serial.print('0'); 
  Serial.print(m); Serial.print(':');
  if(s < 10) Serial.print('0'); 
  Serial.print(s);
}

// ===== SETUP =====
void setup(){
  Serial.begin(115200);
  Wire.begin();
  EEPROM.begin(128);

  Serial.println("\n=== SMART FUEL GAUGE + HEALTH ===");

  while(!gauge.begin()){
    Serial.println("LTC2944 niet gevonden");
    delay(2000);
  }

  gauge.setBatteryCapacity(DESIGN_CAPACITY_MAH);
  gauge.setADCMode(ADC_MODE_SLEEP);
  gauge.startMeasurement();

  delay(300);

  float voltage=gauge.getVoltage();
  float current=gauge.getCurrent();

  GaugeState saved;
  bool ok=loadState(saved);

  if(ok){
    totalRaw=saved.raw;
    lastRaw=saved.raw;
    learnedCapacity=saved.learnedCap;
    kalmanCurrent=current*1000;
    kalmanVoltage=voltage;
    Serial.println("EEPROM SOC + capaciteit geladen");
  } else {
    float soc;
    if(voltage>=FULL_VOLTAGE){
      gauge.setBatteryToFull(); totalRaw=65535; lastRaw=65535; soc=100; kalmanCurrent=current*1000;
    } else if(voltage<=EMPTY_VOLTAGE){
      gauge.setRawAccumulatedCharge(0); totalRaw=0; lastRaw=0; soc=0; kalmanCurrent=current*1000;
    } else {
      soc=estimateSOC(voltage); uint16_t raw=(soc/100.0)*65535.0;
      gauge.setRawAccumulatedCharge(raw); totalRaw=raw; lastRaw=raw; kalmanCurrent=current*1000;
    }
    Serial.println("Geen EEPROM &#8594; voltage fallback");
  }
}

// ===== LOOP =====
void loop(){
  uint16_t raw = gauge.getRawAccumulatedCharge();

  int32_t delta = raw - lastRaw;
  if(delta > 32767) delta -= 65536;
  if(delta < -32767) delta += 65536;

  totalRaw += delta;
  lastRaw = raw;
  if(totalRaw<0) totalRaw=0;
  if(totalRaw>65535) totalRaw=65535;

  float soc = (totalRaw/65535.0)*100.0;
  float remaining = (soc/100.0)*learnedCapacity;

  float voltage = gauge.getVoltage();
  float current = gauge.getCurrent()*1000; // mA
  float temp = gauge.getTemperature();

  float filteredCurrent = kalmanUpdateCurrent(current);
  float filteredVoltage = kalmanUpdateVoltage(voltage);

  // ===== TIMER BEREKENING MET SMOOTH =====
  const float CURRENT_THRESHOLD = 20.0; // mA drempel voor idle
  static float smoothEmpty = -1;
  static float smoothFull  = -1;

  float timeToEmpty = -1;
  float timeToFull  = -1;

  if(filteredCurrent < -CURRENT_THRESHOLD){
      timeToEmpty = remaining / -filteredCurrent;
      smoothEmpty = kalmanUpdateTimerEmpty(timeToEmpty);
      smoothFull = -1; // reset full timer
  } else if(filteredCurrent > CURRENT_THRESHOLD){
      timeToFull = (learnedCapacity - remaining) / filteredCurrent;
      // timer mag niet oplopen, alleen afnemen
      if(smoothFull < 0 || timeToFull < smoothFull){
          smoothFull = kalmanUpdateTimerFull(timeToFull);
      } else {
          smoothFull = smoothFull*0.9 + timeToFull*0.1;
      }
      smoothEmpty = -1; // reset empty timer
  } else {
      smoothEmpty = -1;
      smoothFull = -1;
  }

  // ===== interne weerstand =====
  static float prevVoltage = voltage;
  static float prevCurrent = current;
  float dV = prevVoltage - voltage;
  float dI = prevCurrent - current;
  float internalRes = (dI!=0) ? (dV/dI*1000.0f) : 0; // m&#937;
  if(fabs(internalRes)<1.0f) internalRes=1.0f;

  prevVoltage = voltage;
  prevCurrent = current;

  static float rintSmooth = internalRes;
  rintSmooth = rintSmooth*0.9 + internalRes*0.1;
  if(fabs(rintSmooth)<0.5) rintSmooth=0;

  // ===== battery health =====
  float batteryHealth = 100.0f - fmax(0.0f, fmin(100.0f, (rintSmooth-10.0f)*100.0f/40.0f));

  // ===== print =====
  Serial.print("SOC: "); Serial.print(soc,2); Serial.print("% | ");
  Serial.print(remaining,0); Serial.print("mAh | ");
  Serial.print("V:"); Serial.print(filteredVoltage,3);
  Serial.print(" I:"); Serial.print(filteredCurrent,0); Serial.print("mA | ");
  Serial.print("T:"); Serial.print(temp,1);
  Serial.print(" | ");

  if(smoothFull > 0){ Serial.print("FULL in "); printTime(smoothFull); }
  else if(smoothEmpty > 0){ Serial.print("EMPTY in "); printTime(smoothEmpty); }
  else { Serial.print("Idle"); }

  Serial.print(" | Rint:"); Serial.print(rintSmooth,1);
  Serial.print(" m&#937; | Health:"); Serial.print(batteryHealth,0); Serial.println("%");

  // ===== recalibratie full/empty + capaciteit leren =====
  static bool wasLow=false;
  if(soc<15) wasLow=true;

  if(voltage>FULL_VOLTAGE && fabs(filteredCurrent)<120){
    gauge.setBatteryToFull(); totalRaw=65535; forceSave=true;
    if(wasLow){
      float used=learnedCapacity*(100.0-soc)/100.0;
      learnedCapacity=learnedCapacity*0.9 + used*0.1;
      Serial.print("Nieuwe capaciteit geleerd: "); Serial.println(learnedCapacity);
      wasLow=false;
    }
  }

  if(voltage<EMPTY_VOLTAGE && fabs(filteredCurrent)<50){
    gauge.setRawAccumulatedCharge(0); totalRaw=0; forceSave=true;
  }

  saveState(soc,lastRaw,learnedCapacity);

  delay(1000);
}

#include <Wire.h>

#define ADDR 0x64   // LTC2944 7-bit address

uint16_t readWord(uint8_t reg) {
  Wire.beginTransmission(ADDR);
  Wire.write(reg);
  Wire.endTransmission(false);

  Wire.requestFrom(ADDR, 2);
  uint16_t msb = Wire.read();
  uint16_t lsb = Wire.read();

  return (msb << 8) | lsb;
}

uint8_t readByte(uint8_t reg) {
  Wire.beginTransmission(ADDR);
  Wire.write(reg);
  Wire.endTransmission(false);

  Wire.requestFrom(ADDR, 1);
  return Wire.read();
}

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

  Serial.println("\n--- LTC2944 RAW REGISTER TEST ---");

  // Lees status en control register
  uint8_t status  = readByte(0x00);
  uint8_t control = readByte(0x01);

  Serial.print("Status  (0x00): 0x"); Serial.println(status, HEX);
  Serial.print("Control (0x01): 0x"); Serial.println(control, HEX);

  // ACR (coulomb teller)
  uint16_t acr = readWord(0x02);
  Serial.print("ACR     (0x02): 0x"); Serial.println(acr, HEX);

  // Voltage, Current, Temp
  uint16_t volt = readWord(0x08);
  uint16_t curr = readWord(0x0E);
  uint16_t temp = readWord(0x14);

  Serial.print("Voltage raw (0x08): 0x"); Serial.println(volt, HEX);
  Serial.print("Current raw (0x0E): 0x"); Serial.println(curr, HEX);
  Serial.print("Temp    raw (0x14): 0x"); Serial.println(temp, HEX);

  Serial.println("\nHerhaal dit terwijl er stroom loopt.");
}

void loop() {
  // elke 5 sec opnieuw alleen ACR en current
  delay(5000);

  uint16_t acr  = readWord(0x02);
  uint16_t curr = readWord(0x0E);

  Serial.print("ACR: 0x"); Serial.print(acr, HEX);
  Serial.print("  Current: 0x"); Serial.println(curr, HEX);
}

19:56:31.012 -> --- LTC2944 RAW REGISTER TEST ---
19:56:31.012 -> Status  (0x00): 0x4
19:56:31.012 -> Control (0x01): 0x28
19:56:31.012 -> ACR     (0x02): 0xDBD2
19:56:31.012 -> Voltage raw (0x08): 0x1B01
19:56:31.012 -> Current raw (0x0E): 0x6120
19:56:31.012 -> Temp    raw (0x14): 0x92A0
19:56:31.012 -> 
19:56:31.012 -> Herhaal dit terwijl er stroom loopt.
19:56:36.009 -> ACR: 0xDBCD  Current: 0x6120
19:56:41.016 -> ACR: 0xDBC8  Current: 0x6120
19:56:46.020 -> ACR: 0xDBC3  Current: 0x6120
19:56:51.016 -> ACR: 0xDBBF  Current: 0x6120