/* Lithium battery tester

   Tests how the internal resistance of a small 3.6 V lithium battery varies over time when loaded.
   
   Written by Per Magnusson, http://www.axotron.se
   v 0.2 2015-07-06
   This program is public domain.
*/

static const float loadCur = 5.0e-3;  // Target load current
static const unsigned int switchPeriod = 1000; // On/off time
static const byte doPulse = 0; // Whether to pulse the current

static const float Rtop = 1817;       // Top resistor of divider, ohms
static const float Rbot = 8170;       // Bottom resistor of divider, ohms
static const float Gdiv = 1/(Rtop+Rbot); // Voltage divider conductance
static const float Rs = 32.8;         // Current sense resistor, ohms
static const float Rb = 995;          // Base resistor, ohms
static const float Vref = 3.28;        // ADC reference voltage, volts
static const int ADCbits = 12;
static const int DACbits = 12;
static const float voltPerADC = Vref/((1<<ADCbits) - 1.0); // Factor to convert ADC codes to volts
static const float batVoltPerADC = voltPerADC * (Rtop+Rbot)/Rbot; // Factor to convert ADC codes to batteyy voltage
static const float baseCurPerADC = voltPerADC/Rb;          // Factor to convert DAC codes to base current
static const float emitCurPerADC = voltPerADC/Rs;          // Factor to convert DAC codes to emitter current
static const float voltPerDAC = Vref/((1<<DACbits) - 1.0); // Factor to convert DAC codes to volts
static const float DACperVolt = 1/voltPerDAC;              // Factor to convert volts to DAC codes
static const float DACperAmp = DACperVolt*Rs;              // Approximate factor to convert amps to DAC codes
static const float detectLimit = 0.8; // Limit for detecting battery 
static const float curLim = 35.0e-3;  // Maximum test current in A
static const int maxIter = 10;        // Number of iterations to reach target current

static const int vsensePin = A0;      // Voltage sense pin
static const int curSensePin = A1;    // Emitter current sense pin
static const int baseSenseHiPin = A2; // High base current sense pin
static const int baseSenseLoPin = A3; // Low base current sense pin
static const int dacPin = A14;        // Current control pin
static const int ledPin = 13;         // LED for debug

static const byte sWaitNoBat = 0;
static const byte sWaitBat = 1;

byte state;
unsigned long nextTime;
float batteryVoltage; // Used as return value from readBattery()
float batteryCurrent; // Used as return value from readBattery()

void setup() {
  Serial.begin(57600);
  analogWriteResolution(DACbits);
  analogReadResolution(ADCbits);
  analogWrite(dacPin, 0);
  pinMode(ledPin, OUTPUT);
  state = sWaitNoBat;
  Serial.println("Battery tester");
  digitalWrite(ledPin, HIGH);     // turn  LED on
  delay(3000);
  digitalWrite(ledPin, LOW);     // turn  LED off
  Serial.println("Waiting for a battery to be connected...");
  nextTime = millis();
}


void readBattery() {
  // Measure the voltage and current of the battery. Store the values in the global variables
  // batteryVoltage and batteryCurrent.
  float baseCur;
  
  // Measure the battery voltage
  batteryVoltage =  analogRead(vsensePin) * batVoltPerADC; 
  // Measure the base current
  baseCur = (analogRead(baseSenseHiPin) - analogRead(baseSenseLoPin))*baseCurPerADC;
  // Measure emitter current and calculate total battery current
  batteryCurrent = analogRead(curSensePin)*emitCurPerADC - baseCur + batteryVoltage*Gdiv;
}


void loop() {
  int dacVal;
  float voltNoLoad;
  float curNoLoad;
  float res;
  byte testBat;
  byte iter;
  byte onOffState;
  unsigned long startTime;
  unsigned long elapsedTime;
  unsigned long lastSwitchTime;
  
  testBat = false;
  // See if the battery is connected
  readBattery();
  if(state == sWaitNoBat) {
    // We are waiting for a battery to be connected
    if(batteryVoltage > detectLimit) {
      // A battery was connected
      testBat = true; // Proceed to test it
    }
  } else if(state == sWaitBat) {
    // We are waiting for a battery to be disconnected
    if(batteryVoltage < detectLimit) {
      // A battery was disconnected
      Serial.println("\nWaiting for a battery to be connected...");
      delay(1000); // Delay to not react on glitches while the battery is being disconnected
      state = sWaitNoBat;
    }
  }
  
  if(!testBat) {
    // Not in a situation that a battery should be tested
    return;
  }

  // Test the battery
  Serial.println("Battery connected, waiting for connection to stabilize.");
  delay(1000); // Wait for the connection to stabilize
  readBattery();
  if(batteryVoltage < detectLimit) {
    // The battery is gone, it was just a glitch
    state = sWaitNoBat;
    Serial.println("Battery removed, aborting.");
    Serial.println("Waiting for a battery to be connected...");
    return;
  }
  digitalWrite(ledPin, HIGH);     // turn  LED on
  Serial.println("Testing battery.");

  voltNoLoad = batteryVoltage;
  curNoLoad = voltNoLoad*Gdiv; // "No load" current
  
  Serial.println("");
  Serial.print("Unloaded voltage: ");
  Serial.print(voltNoLoad);
  Serial.print(" V (current = ");
  Serial.print(curNoLoad*1000);
  Serial.println(" mA)");
  
  dacVal = 0.66*DACperVolt;       // Base drive starting value, 0.66 V, low current
  analogWrite(dacPin, dacVal);    // Drive the base of the transistor
  readBattery();
  
  // Loop to adjust DAC current
  for(int ii=0; ii<maxIter; ii++) {
    // Adjust DAC value to get closer to the target battery current
    dacVal += (loadCur - batteryCurrent)*DACperAmp;
    analogWrite(dacPin, dacVal);    // Drive the base of the transistor
    readBattery();
    Serial.print(millis());
    Serial.print(" DAC: ");
    Serial.print(dacVal);
    Serial.print(" Current: ");
    Serial.print(batteryCurrent*1000);
    Serial.print(" mA");
    Serial.print(" Voltage: ");
    Serial.println(batteryVoltage);
  }
  Serial.println("\nTime (ms)\tVoltage(V)\tCurrent(mA)\tResistance(ohm)\tDAC value");

  // Loop to keep the load current the same while monitoring the battery voltage
  startTime = millis();
  nextTime = startTime;
  lastSwitchTime = startTime;
  onOffState = 1;
  while(1) {
    while(millis()<nextTime)
      ;
    elapsedTime = nextTime - startTime;
    // Measure more frequently in the beginning
    if(elapsedTime < 1000) {
      nextTime += 2;
    } else if(elapsedTime < 3000) {
      nextTime += 5;
    } else if(elapsedTime < 10000) {
      nextTime += 20;
    } else if(elapsedTime < 30000) {
      nextTime += 100;
    } else {
      nextTime += 100;
    }      
      
    if(dacVal >= (1<<DACbits)) {
      // The DAC value is too big, exit from loop
      Serial.print("Warning: Above maximum DAC setting (");
      Serial.print(dacVal);
      Serial.println("), exiting");
      break;
    }

    if(doPulse && (elapsedTime - lastSwitchTime > switchPeriod)) {
      onOffState = 1-onOffState;
      lastSwitchTime = elapsedTime;
    }
    if(onOffState) {
      analogWrite(dacPin, dacVal);                 // Drive the base of the transistor
    } else {
      analogWrite(dacPin, 0);                      // Turn off the base drive of the transistor
    }
    readBattery();

    if(batteryVoltage < detectLimit) {
      // The voltage is too low (maybe the battery was removed), exit from loop
      Serial.print("Warning: Below minimum battery voltage (");
      Serial.print(batteryVoltage);
      Serial.println(" V), exiting");
      break;
    }

    if((batteryCurrent - curNoLoad) > 0) {
      res = (voltNoLoad - batteryVoltage)/(batteryCurrent - curNoLoad); // Calculate internal resistance
    } else {
      res = 0; // Avoid dividing by zero
    }
    
    // Print result
    Serial.print(elapsedTime);
    Serial.print("\t");
    Serial.print(batteryVoltage, 4);
    Serial.print("\t");
    Serial.print(batteryCurrent*1000);
    Serial.print("\t");
    Serial.print(res);
    Serial.print("\t");
    Serial.println(dacVal);
    

    if(onOffState) {
      // Make a small adjustment to stay close to the target current
      if(batteryCurrent < loadCur) {
        dacVal++;
      } else {
        dacVal--;
      }
    }
  }
  // Cleanup after loop
  analogWrite(dacPin, 0);        // Stop the battery current drain
  digitalWrite(ledPin, LOW);     // turn  LED off
  state = sWaitBat;
  Serial.println("Done");
}