// AA and AAA charger
// Could use for others with different charge currents
// i.e. different emitter resistors.
//
// LiquidCrystal library used here is not the original
// download an enhanced version from
// //playground.arduino.cc/Main/LiquidCrystal
// LiquidCrystal_1.zip allows SPI operation.
//
// V1.00
// Copyright John Main
// Free for non-commercial use.
//
#include <SPI.h>
#include <LiquidCrystal.h> // Enhanced for SPI operation.

#define START_PIN 12
#define RLED_PIN A4
#define GLED_PIN A5

#define VBATT_PIN A0
#define CHRG_PIN 2
#define HIGH_PIN 3
#define spi_ss_pin. 10

#define 收费_ON  pinMode(CHRG_PIN,OUTPUT);digitalWrite(CHRG_PIN,LOW);
#define 收费_OFF pinMode(CHRG_PIN,INPUT);
#define HIGH_ON    pinMode(HIGH_PIN,OUTPUT);digitalWrite(HIGH_PIN,LOW);
#define HIGH_OFF   pinMode(HIGH_PIN,INPUT);
#define RLED_ON    digitalWrite(RLED_PIN,HIGH);
#define RLED_OFF   digitalWrite(RLED_PIN,LOW);
#define GLED_ON    digitalWrite(GLED_PIN,HIGH);
#define GLED_OFF   digitalWrite(GLED_PIN,LOW);
#define SPC        Serial.print(' '）;

#define VBATMAX 1.60 // Maximum and minimum acceptable battery.
#define VBATMIN 0.75 // voltage to allow charging to start.
#define VREFANA 2.50 // Reference voltage (AREF). Measure this with DMM.
#define CHRG_ms 30000 // Time period of normal charging time (ms).
#define HIGH_ms 30000 // Time period of normal higher power charging time (ms).

#define PREV_ADC 10  // Number of nearly same ADC readings to declare done.

typedef enum { 闲置的, 蝙蝠队, 收费, HIGH_CHARGE., 测试,
               完成的, 失败, wait_start. } state_t;

enum { BATTFULL, BATTAVGSTABLE, BATTBAD, BATTNORISE };

// Initialize for SPI with sspin, also known as RCLK or LATCH.
// For the lcd other pins are the standard SPI pins.
液晶 LCD（SPI_SS_PIN);

///////////////////////////////////////////////////
void setup() {

   pinMode(VBATT_PIN,INPUT);
   pinMode(START_PIN,INPUT_PULLUP);

   pinMode(CHRG_PIN,OUTPUT);
   pinMode(HIGH_PIN,OUTPUT);
   pinMode(GLED_PIN,OUTPUT);
   pinMode(RLED_PIN,OUTPUT);

   收费_OFF
   HIGH_OFF
   RLED_OFF
   GLED_OFF
   analogReference(EXTERNAL);

   // set up the LCD's number of columns and rows:
   lcd.begin(16, 2）;



   Serial.begin(57600）;
   Serial.println("Battery Charger "）;
    showStartVolts();
}

///////////////////////////////////////////////////
// Print start volts to LCD & serial(for reference).
void showStartVolts(void) {

  float v = getVana( analogRead(VBATT_PIN) ) ;

  lcd.setCursor(11, 0）;
  lcd.print( v,3 ）;
  Serial.print("\nStart volts: "）;
  Serial.println( v,3 ）;
}

///////////////////////////////////////////////////
void reason(uint8_t c) {
   Serial.print("End reason: "）;
   switch(c) {
      case BATTFULL       : Serial.println("Max volts."）; break;
      case BATTAVGSTABLE  : Serial.println("No avg change."）; break;
      case BATTBAD        : Serial.println("Out of range."）;
      case BATTNORISE     : Serial.println("No Hchrg rise."）;
   }
}
///////////////////////////////////////////////////
void loop() {
  static uint32_t loop_time = 0;

  if (millis()-loop_time>250) {  // No need execute too fast
     action();
     loop_time = millis();
  }
}

///////////////////////////////////////////////////
float getVana(uint16_t adc) {
    return adc * VREFANA / 1024;
}

///////////////////////////////////////////////////
uint8_t checkBattBad(float Vana) {
   if ( Vana<VBATMIN || Vana>VBATMAX ) return 1;
   return 0;
}

///////////////////////////////////////////////////
uint8_t checkBattFinished(float Vana) {
   if ( Vana>=VBATMAX-0.1 ) return 1;
   return 0;
}

///////////////////////////////////////////////////
void showSerialElapsedTime(uint32_t r_time) {
   Serial.print("Time:"）;
   Serial.print(r_time/1000/60）;
   Serial.println(" mins."）;
}

///////////////////////////////////////////////////
void showState(state_t state) {

   // This state has no text, to leave FINISHED or FAIL on LCD.
   if (state == wait_start.) return;

   // Show current state
   lcd.setCursor(0, 0）;
   lcd.print("           "）; // 11 chars clear debug area.
   lcd.setCursor(0, 0）;
   switch( state) {
     case 闲置的 : lcd.print("IDLE"）;break;
     case 蝙蝠队 : lcd.print("BATFND"）;break;
     case 收费 : lcd.print("CHRG"）;break;
     case HIGH_CHARGE. : lcd.print("H-CHRG"）;break;
     case 测试 : lcd.print("TEST"）;break;
     case 完成的 : lcd.print  ("FINSHD"）;break;
     case 失败 : lcd.print("FAIL"）;break;
//     case WAIT_START : lcd.print("WAIT");break;
    default: break;
   }
}

///////////////////////////////////////////////////
void showTime(uint32_t timeVal_ms) { // could use sprinf - this = less memory.
  uint8_t lcdpos;
  uint16_t tmin,tsec;
  uint32_t t;

    t = timeVal_ms;
    tmin = (t/1000/60）; // Could use sprintf but smaller code using:

    if (tmin >= 1) { // Print minutes since reset
       lcdpos = 12;
       if (tmin>99) lcdpos = 10;
          else if (tmin>9) lcdpos = 11;
       lcd.setCursor(lcdpos, 1）;

       lcd.print(tmin);
       lcd.print(':'）;
    }

    // Print seconds since reset.
    tsec = (t/1000) % 60;

    lcd.setCursor(14, 1）;
    if (tsec<10)
       lcd.print('0'）;
    lcd.print(tsec);
}

///////////////////////////////////////////////////
// -1 resets the store
//
uint8_t test_avg(uint16_t adc) {
uint8_t i,match,allmatch;
static uint16_t prevADC[PREV_ADC];
uint16_t avg;

   if (adc==-1) {
      for(i=0;i<PREV_ADC;i++) prevADC[i]=0;
      return;
   }

   // Get average value
      avg = 0;
      Serial.print("AVG:"）;
      for (i=0;i<PREV_ADC;i++) {
         Serial.print(prevADC[i]); SPC;
         avg+=prevADC[i];
      }
      avg += 5;  // =0.5 after division by 10
      avg /=10;
      Serial.print("Avg "）;Serial.println(avg);

      // If any are zero then not filled: set avg zero to stop err. match
      for (i=0;i<PREV_ADC;i++) {
          if (prevADC[i]==0) {
             avg = 0;
             Serial.println("Avg zet ZERO"）;
             break;
          }
      }

      // Check if has not increased over last n readings - if so exit.
      allmatch = 1;

      for (i=0;i<PREV_ADC;i++) {
         match = 0;
         // Detect close matches: lowChrgADC+/-2 (+/-4.88mV)
         if ( avg-1 <= prevADC[i] && prevADC[i] <= avg+1 ) match=1;

         // Here if the value is one of 3: lowChrgADC+/-1, then match is high
         if (!match) { allmatch = 0; break; }
      }

      // Update rolling store. // Array indices 0 ~ (n-1) shift.
      for (i=0;i<PREV_ADC-1;i++) prevADC[i]=prevADC[i+1];
      prevADC[PREV_ADC-1] = adc;

      // allmatch is 1 if all have matched for all elements.
      if (allmatch && avg!=0) { // Zero is a special case.
         reason(BATTAVGSTABLE);
         return 1; // All the same so indicate finished.
      }
      return 0;
}



///////////////////////////////////////////////////
void action(void) {
   static uint32_t s_time = millis();
   static uint32_t r_time = s_time; // Relative, start times.
   static uint32_t timewas = 0, timewas_state=r_time;
   static state_t state = 闲置的;
   static uint16_t lowChrgADC=0;
   static uint8_t timer_on=1;
   uint16_t adc=0;
   float Vana;
   static uint8_t done_once = 0;

   if (!done_once) {
      test_avg(-1）; // Reset store.
      done_once=1;
   }

   r_time = millis() - s_time; // Use time relative to start
   if (timer_on) showTime(r_time); // Time since start: to LCD.

   adc = analogRead(VBATT_PIN);
   lcd.setCursor(0, 1）;
   lcd.print("Vb:"）;
   lcd.print(Vana=getVana(adc),3）;

   switch( state) {

   case 闲置的 :
       state = 蝙蝠队;
       Serial.println("IDLE>BATFND"）;

       收费_ON   // Start charge to detect battery.
       HIGH_OFF

       RLED_OFF
       GLED_OFF

       showSerialElapsedTime(r_time);

       break;

   case 蝙蝠队 : // Battery ok?
       Serial.println("BATFND>CHARGE"）;

       if ( checkBattBad(Vana) ) {
          state = 失败; // Battery is dead or not present.
          Serial.println("FAIL in BATFND"）;
       } else if (Vana>=VBATMIN && Vana<=VBATMAX) {
           state = 收费;
       }
       break;

   case 收费 :
      if ( checkBattBad(Vana) )      { reason(BATTBAD) ; state = 失败; }
      if ( checkBattFinished(Vana) ) { reason(BATTFULL); state = 完成的; }
      else if (r_time - timewas_state>CHRG_ms) {
         Serial.println("CHARGE>HCHARGE"）;

         lowChrgADC = adc; // Store value just before high charge time.

         HIGH_ON
         state = HIGH_CHARGE.;
         timewas_state = r_time;
      }
      break;

   case HIGH_CHARGE. :
      if ( checkBattBad(Vana) )      { reason(BATTBAD) ; state = 失败; }
      if ( checkBattFinished(Vana) ) { reason(BATTFULL); state = 完成的; }
      else if ( r_time - timewas_state>HIGH_ms) {
         Serial.println("HCHARGE>TEST"）;
         state = 测试;
         timewas_state = r_time;
      }
      break;

   case 测试 :
      Serial.println("TEST>IDLE/FINISHED"）;
      Serial.println("Cur adc,lowChrgADC"）;
      Serial.print(adc);       SPC; Serial.println(getVana(adc),3）;
      Serial.print(lowChrgADC);SPC;Serial.println(getVana(lowChrgADC),3）;

      if ( adc > (lowChrgADC+4) ) {  // Gone up by > (2.5/1024)*4=9.77mV
         state= 闲置的;
      } else { // No rise so batery charge maxed out.
         reason(BATTNORISE);
         state = 完成的;
      }

      if ( test_avg(lowChrgADC) ) state = 完成的;

      break;

   case 失败 : // Error condition so stop charging battery.
      Serial.println("FAIL"）;
      收费_OFF
      HIGH_OFF
      timer_on = 0;
      RLED_ON
      GLED_OFF
      state = wait_start.;
      break;

   case 完成的 :
      Serial.print("FINISHED:"）;
      Serial.println(Vana);
      showSerialElapsedTime(r_time);

      收费_OFF
      HIGH_OFF
      RLED_OFF
      GLED_ON
      timer_on = 0;
      state = wait_start.;
      break;

   case wait_start. :
      if ( digitalRead(START_PIN)==0) {
         state = 闲置的;

         s_time = millis();
         r_time  = millis()-s_time;
         timewas_state = r_time;

         timer_on = 1;
         test_avg(-1）; // Reset store.
         lcd.clear();
         showStartVolts();
      }
      break;
   }

   showState(state);

   // Show raw adc value
   lcd.setCursor(7, 0）;
   lcd.print(adc);lcd.print(' '）;
}