/* 
 Dronestrober with BMS and charger
 
 when running on 4.4 volt or less it will strobe leds
 when run on more it will charge the battery to (approx.) 4.2 volt, let it drop to 4.0 before recharge
 will cut off operation at cell voltage about 3 volts
 
 dji phantom pro 3 lower leg 9x7mm
 
 
 
 flashing status readout
 
 battery mode:
 Vcc x.x volts
 2 sec delay
 battery pin read, nonsense
 2 sec delay
 flashing operation starts.
 
 
 USB power mode:
 Vcc x.x volts, ususally 5 blinks then 3 sec delay (5 volts)
 at least 2 sec delay
 battery x.x volts, 1 sec delay is the decimal separator
 2 sec delay
 charging mode starts:
 flash every second: CHARGING
 flash every 5 seconds: CHARGING DONE
 
 */

 
 //sleep stuff
#include <avr/sleep.h>
#include <avr/wdt.h>
//#include <avr/power.h>
#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif

//for sleep mode watchdog timer
volatile boolean f_wdt = 1;
   
   
const int batpin = 3;     // D3 and A3 for charging ans sensing battery voltage.
const int ledpin = 4;     // LED pin -> mosfet -> LED
const int potpin = 1;     // analogue input 1 (pin 2) for strobe setting, read only first 60 secs. or something.
 
//battery data
const int batmax = 4080; //max battery charge voltage mV
const int batrecharge = 3950; //restart charge coltage mV
const int batmin = 3100; //min battery charge voltage mV
const int chargethreshold = 4400; //charge vs operation threshold
 
int voltage; //battery measured
int sensorValue; //temp readvalue
int debug; //debug

//variables will change:
int runmode=1;
int wdduration=5;
int blinks;
 
 int ond=20; //on delay for LED
 int itv; //interval 1 for LED sleepdelay
 int sitv; //interval 2 for LED sleepdelay
           
 void setup() {
   //internal voltage reference
   //analogReference( INTERNAL2V56_NO_CAP );
   //indicate on state
   digitalWrite(ledpin,HIGH);
   delay(10);
   digitalWrite(ledpin,LOW); 
   //sleep before sensing input voltage.
   setup_watchdog(8); // approximately 4 seconds sleep before starting operation. 
   system_sleep();
   
   delay(10);
   //show Vcc
   int bdebug=readVcc()/1000;
     int adebug=(readVcc()/100)-(bdebug*10);
     while (bdebug>0) {
      digitalWrite(ledpin, HIGH);
      delay(1);
      digitalWrite(ledpin, LOW);
      delay(400);
      bdebug--;
     }
     delay(1000);
     while (adebug>0) {
      digitalWrite(ledpin, HIGH);
      delay(1);
      digitalWrite(ledpin, LOW);
      delay(400);
      adebug--;
     }
     
     delay(2000);
   
   //read input voltage
   if (readVcc() > chargethreshold) {
       runmode=1; //runmode for charging.
       }
     else {
       runmode=2; //runmode for strobing
     }

   pinMode(batpin, INPUT);
   pinMode(ledpin, OUTPUT);
   pinMode(potpin, INPUT);
  
 }

 void loop(){
   
   if (f_wdt==1) {  // wait for timed out watchdog / flag is set when a watchdog timeout occurs
     f_wdt=0;       // reset flag
   }

   //check runmode
   //pinMode(batpin,INPUT);
   sensorValue = analogRead(batpin);
   voltage = (1000 * (sensorValue * (5.0 / 1023)));
   
   if (debug!= true) {
     int bdebug=voltage/1000;
     int adebug=(voltage/100)-(bdebug*10);
     while (bdebug>0) {
      digitalWrite(ledpin, HIGH);
      delay(1);
      digitalWrite(ledpin, LOW);
      delay(400);
      bdebug--;
     }
     delay(1000);
     while (adebug>0) {
      digitalWrite(ledpin, HIGH);
      delay(1);
      digitalWrite(ledpin, LOW);
      delay(400);
      adebug--;
     }
     
     delay(2000);
     debug=true;
   }
   
   
   if (runmode==1) { //charging
   
     if (voltage <= batmax) { // charge
         pinMode(batpin,OUTPUT);
         digitalWrite(batpin,HIGH);
         delay(1000);
         digitalWrite(ledpin,HIGH);
         delayMicroseconds(50);
         digitalWrite(ledpin,LOW);
         digitalWrite(batpin,LOW);
         pinMode(batpin,INPUT);
         delay(2);
       } else {
         runmode=3;
       }
     }
     
   if (runmode==2) { //flashing
     if (readVcc() > batmin) { // strobe
         
         if (blinks<250) { //stop measuring pot if over 250 blinks to lock blinkrate
           //read pot for sleeptimers
           blinks++;
           int pot = analogRead(potpin); //pot read value
           if (pot < 100) {itv=2;; sitv=0;}
           if (pot >= 100 && pot <=199) {itv=2;sitv=1;}
           if (pot >= 200 && pot <=299) {itv=2;sitv=2;}
           if (pot >= 300 && pot <=399) {itv=2;sitv=3;}
           if (pot >= 400 && pot <=499) {itv=3;sitv=1;}
           if (pot >= 500 && pot <=599) {itv=3;sitv=2;}
           if (pot >= 600 && pot <=699) {itv=3;sitv=3;}
           if (pot >= 700 && pot <=799) {itv=4;sitv=1;}
           if (pot >= 800 && pot <=899) {itv=4;sitv=2;}
           if (pot >= 900 && pot <=1024) {itv=4;sitv=3;}
         }
         //sleep
         if (wdduration==itv) {
             wdduration=itv+sitv;
           }
           else
           {
             wdduration=itv;
         }
         
         //blink
         digitalWrite(ledpin,HIGH);
         delay(ond);
         digitalWrite(ledpin,LOW);
         
       setup_watchdog(wdduration);
       system_sleep();
     }
     else { // else battery is dead
       setup_watchdog(9);
       system_sleep();
     }
   }
   if (runmode==3) {
     if (voltage <= batrecharge) { // charge
         runmode=1;
       }
       digitalWrite(ledpin,HIGH);
       delayMicroseconds(50);
       digitalWrite(ledpin,LOW);
       delay(5000);
     }
   }
 
 
 
// set system into the sleep state
// system wakes up when wtchdog is timed out
void system_sleep() {
  cbi(ADCSRA,ADEN);                    // switch Analog to Digitalconverter OFF
   
  set_sleep_mode(SLEEP_MODE_PWR_DOWN); // sleep mode is set here
  sleep_enable();
   
  sleep_mode();                        // System sleeps here
   
  sleep_disable();                     // System continues execution here when watchdog timed out
  sbi(ADCSRA,ADEN);                    // switch Analog to Digitalconverter ON
}
 
// 0=16ms, 1=32ms,2=64ms,3=128ms,4=250ms,5=500ms
// 6=1 sec,7=2 sec, 8=4 sec, 9= 8sec
void setup_watchdog(int ii) {
   
  byte bb;
  int ww;
  if (ii > 9 ) ii=9;
  bb=ii & 7;
  if (ii > 7) bb|= (1<<5);
  bb|= (1<<WDCE);
  ww=bb;
   
  MCUSR &= ~(1<<WDRF);
  // start timed sequence
  WDTCR |= (1<<WDCE) | (1<<WDE);
  // set new watchdog timeout value
  WDTCR = bb;
  WDTCR |= _BV(WDIE);
}
 
// Watchdog Interrupt Service / is executed when watchdog timed out
ISR(WDT_vect) {
  f_wdt=1;  // set global flag
}

long readVcc() {
  // Read 1.1V reference against AVcc
  // set the reference to Vcc and the measurement to the internal 1.1V reference
  #if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
    ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
  #elif defined (__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
    ADMUX = _BV(MUX5) | _BV(MUX0);
  #elif defined (__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)
    ADMUX = _BV(MUX3) | _BV(MUX2);
  #else
    ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
  #endif  
 
  delay(2); // Wait for Vref to settle
  ADCSRA |= _BV(ADSC); // Start conversion
  while (bit_is_set(ADCSRA,ADSC)); // measuring
 
  uint8_t low  = ADCL; // must read ADCL first - it then locks ADCH  
  uint8_t high = ADCH; // unlocks both
 
  long result = (high<<8) | low;
 
  result = 1125300L / result; // Calculate Vcc (in mV); 1125300 = 1.1*1023*1000
  //result = 1100000L / result; // Calculate Vcc (in mV); 1125300 = 1.1*1023*1000
  return result; // Vcc in millivolts
}