КОНТРОллер ветрогенератора

#include <LiquidCrystal_I2C.h>
#include "Ticker.h"
#include "OneButton.h"
#include <EEPROM.h>

#define PWMpin 11
#define FANpin PD2
#define redPWMpin PD5
#define greenPWMpin PD6
#define buttonpin PD7

enum cStates : uint8_t{SNOOZ=0, BULK=1, FLOAT=2};
cStates cState = SNOOZ;
const char* cStatesNames[3]={"SNOOZ","BULK ","FLOAT"};

enum mStates : uint8_t{noMENU=0, MenuVFloat=1,MenuBLTimer=2, MenuI0Calib=3,\
MenuVInCalib=4, MenuVBattCalib=5, MenuClearPM=6, MenuReset=7};
mStates mState = noMENU;

enum dStates : uint8_t{DISP1 = 0, DISP2 = 1};
dStates dState = DISP1;

float vBatt=12.0;
float vIn;
float iIn;
float pIn, pCharge;
uint8_t blTimer=20;
float vFloat = 13.8;
uint16_t iShift = 509;
float iScale = 0.0264;
float vInScale = 14.333;
float vBattScale = 6.458;
uint8_t backCounter;
uint8_t PWM=255;

void Tick1s();
void Tick5s();
void Tick10s();
void TickBL();
void stopMenu();
void SaveData();
void Display1();
void Display2();

LiquidCrystal_I2C lcd(0x27,16,2);
OneButton leftButton(PD7, true);
Ticker timer1s(Tick1s, 1000,0, MILLIS);
Ticker timer5s(Tick5s, 5000,0, MILLIS);
Ticker timer10s(Tick10s, 10000,0, MILLIS);
Ticker timerBL(TickBL, blTimer*1000,1, MILLIS);
Ticker timerMenu(stopMenu, 5000,1, MILLIS);
Ticker timer1h(SaveData, 60*60*1000,0, MILLIS);

void LoadFromEEProm(){
   int eeAddress = 0;
   uint8_t firstByte;
   EEPROM.get(eeAddress, firstByte);
   if (firstByte==17){
     lcd.clear();
     lcd.print("LOADING");
     lcd.setCursor(0,1);
     lcd.print("FROM EEPROM");
     delay(1000);
     eeAddress+=sizeof(uint8_t);
     EEPROM.get(eeAddress,pCharge);
     eeAddress+=sizeof(float);
     EEPROM.get(eeAddress,blTimer);
     eeAddress+=sizeof(uint8_t);
     EEPROM.get(eeAddress,vFloat);
     eeAddress+=sizeof(float);
     EEPROM.get(eeAddress,iShift);
     eeAddress+=sizeof(uint16_t);
     EEPROM.get(eeAddress,vInScale);
     eeAddress+=sizeof(float);
     EEPROM.get(eeAddress,vBattScale);
   }
   else{
     lcd.clear();
     lcd.print("RESETTING");
     lcd.setCursor(0,1);
     lcd.print("TO DEFAULT");
     delay(2000);
     blTimer=20;
     vFloat=13.8;
     iShift=509;
     vInScale=14.333;
     vBattScale=6.458;
     SaveToEEProm();
   }
}

void SaveToEEProm(){
   int eeAddress = 0;
   uint8_t firstByte = 17;
   lcd.clear();
   lcd.print("SAVING");
   lcd.setCursor(0,1);
   lcd.print("TO EEPROM");
   delay(2000);
   EEPROM.put(eeAddress, firstByte);
   eeAddress+=sizeof(uint8_t);
   EEPROM.put(eeAddress,pCharge);
   eeAddress+=sizeof(float);
   EEPROM.put(eeAddress,blTimer);
   eeAddress+=sizeof(uint8_t);
   EEPROM.put(eeAddress,vFloat);
   eeAddress+=sizeof(float);
   EEPROM.put(eeAddress,iShift);
   eeAddress+=sizeof(uint16_t);
   EEPROM.put(eeAddress,vInScale);
   eeAddress+=sizeof(float);
   EEPROM.put(eeAddress,vBattScale);
}

void SaveData(){
   int eeAddress = 0;
   uint8_t firstByte = 17;
   EEPROM.put(eeAddress, firstByte);
   eeAddress+=sizeof(uint8_t);
   EEPROM.put(eeAddress,pCharge);
}

void Tick5s()
{
  if (dState==DISP1){
  dState=DISP2;
  }
  else{
  dState=DISP1;
  }
}

void Tick10s()
{
pCharge+=(pIn/360);
}

void TickBL()
{
  lcd.noBacklight();
  timerBL.stop();
}

void ClearRow(uint8_t row){
  lcd.setCursor(0,row);
  lcd.print("                ");
}

void Display1(){
  lcd.setCursor(0,0);
  lcd.print("Vb:      ");
  lcd.setCursor(3,0);
  lcd.print(String(vBatt,1)+"V");
  lcd.setCursor(9,0);
  lcd.print(cStatesNames[cState]);
  lcd.setCursor(0,1);
  lcd.print(" I:      ");
  lcd.setCursor(3,1);
  lcd.print(String(iIn,2)+"A");
  lcd.setCursor(9,1);
  lcd.print("P:      ");
  lcd.setCursor(11,1);
  lcd.print(String(pIn,1)+"W");
}

void Display2(){
  lcd.setCursor(0,0);
  lcd.print("CHARGED:        ");
  lcd.setCursor(9,0);
  lcd.print(String(pCharge,0)+"Wh");
  lcd.setCursor(0,1);
  lcd.print("LOADPWM:        ");
  lcd.setCursor(9,1);
  lcd.print(String(255-PWM,DEC));
}

void DisplayMenu1(){
  lcd.setCursor(0,0);
  lcd.print("FLOAT VOLTAGE:  ");
  ClearRow(1);
  lcd.setCursor(0,1);
  lcd.print((String(vFloat,1))+" V");
  timerMenu.start();  
}

void DisplayMenu2(){
  lcd.setCursor(0,0);
  lcd.print("BACKLIT TIMEOUT:");
  ClearRow(1);
  lcd.setCursor(0,1);
  lcd.print((String(blTimer))+" s");
  timerMenu.start();  
}

void DisplayMenu3(){
  lcd.setCursor(0,0);
  lcd.print("ZERO CURRENT:   ");
  ClearRow(1);
  lcd.setCursor(0,1);
  lcd.print((String(iIn,2))+" A, dI:"+String(iShift));
  timerMenu.start();  
}

void DisplayMenu4(){
  lcd.setCursor(0,0);
  lcd.print("INPUT VOLTG CAL:");
  ClearRow(1);
  lcd.setCursor(0,1);
  lcd.print((String(vIn,3))+" V:"+String(vInScale,3));
  timerMenu.start();  
}

void DisplayMenu5(){
  lcd.setCursor(0,0);
  lcd.print("BATTERY VLTG CAL");
  ClearRow(1);
  lcd.setCursor(0,1);
  lcd.print((String(vBatt,3))+" V:"+String(vBattScale,3));
  timerMenu.start();  
}

void DisplayMenu6(){
  lcd.setCursor(0,0);
  lcd.print("CLEAR PWR METER ");
  ClearRow(1);
  lcd.setCursor(0,1);
  lcd.print(String(backCounter,DEC));
}

void DisplayMenu7(){
  lcd.setCursor(0,0);
  lcd.print("RESET TO DEFAULT");
  ClearRow(1);
  lcd.setCursor(0,1);
  lcd.print(String(backCounter,DEC));
}

void startMenu(){
  timer5s.stop();
  timerBL.stop();
  lcd.backlight();
  mState=MenuVFloat;
  DisplayMenu1();
}

void stopMenu(){
  timer1s.stop();
  lcd.clear();
  switch(mState){
    case MenuClearPM:{
      lcd.print("CLEARING");
      lcd.setCursor(0,1);
      lcd.print("POWER METER");
      delay(1000);
      pCharge=0.0;
      SaveToEEProm();
      mState=noMENU;
      timer1s.start();
      timer5s.start();
      timerBL.setInterval(blTimer*1000);  
      if(blTimer>0){timerBL.start();}
      break;
    }
    case MenuReset:{
      lcd.print("RESETTING");
      lcd.setCursor(0,1);
      lcd.print("TO DEFAULT");
      delay(1000);
      uint8_t firstByte = 0;
      EEPROM.put(0,firstByte);
      LoadFromEEProm();
      SaveToEEProm();
      mState=noMENU;
      timer1s.start();
      timer5s.start();
      timerBL.setInterval(blTimer*1000);  
      if(blTimer>0){timerBL.start();}
      break;
    }
  }
  mState=noMENU;
  SaveToEEProm();
  timer1s.start();
  timer5s.start();
  timerBL.setInterval(blTimer*1000);  
  if(blTimer>0){timerBL.start();}
}

void Tick1s(){
  switch(mState){
    case noMENU:{
      switch (dState){ 
        case DISP1:{Display1();break;}
        case DISP2:{Display2();break;}
        }break;
      }
    case MenuClearPM: {backCounter-=1;DisplayMenu6();break;}
    case MenuReset: {backCounter-=1;DisplayMenu7();break;}
    }
}

void lbClick(){
  switch(mState){
  case noMENU:{
    lcd.backlight();  
    if(blTimer>0){timerBL.start();}
    break;}
  case MenuVFloat:{if(vFloat>0.0){vFloat-=0.1;DisplayMenu1();break;}}  
  case MenuBLTimer:{
    if (blTimer!=0){
      blTimer--;
      DisplayMenu2(); 
      break; 
    }
    break;
    }  
  case MenuI0Calib:{
    if (iShift>0){iShift--;}
    DisplayMenu3();
    break;  
    }
  case MenuVInCalib:{
    if(vInScale>=0.001){vInScale-=0.001;}
    DisplayMenu4();
    break;  
    }
  case MenuVBattCalib:{
    if(vBattScale>=0.001){vBattScale-=0.001;}
    DisplayMenu5();
    break;  
    }
  }
}

void lbDoubleClick(){
  switch(mState){
  case MenuVFloat:{vFloat+=0.1;DisplayMenu1();break;}  
  case MenuBLTimer:{
    if (blTimer<30){
      blTimer++;
      DisplayMenu2(); 
      break; 
    }
    break;
    }  
  case MenuI0Calib:{
    if (iShift<1023){iShift++;}
    DisplayMenu3();
    break;  
    }
  case MenuVInCalib:{
    vInScale+=0.001;
    DisplayMenu4();
    break;  
    }
  case MenuVBattCalib:{
    vBattScale+=0.001;
    DisplayMenu5();
    break;  
    }
  }
}

void lbLongPressStart(){
  switch(mState){
  case noMENU:{startMenu();break;}  
  case MenuVFloat:{mState=MenuBLTimer; DisplayMenu2();break;}
  case MenuBLTimer:{mState=MenuI0Calib; DisplayMenu3();break;}
  case MenuI0Calib:{mState=MenuVInCalib; DisplayMenu4();break;}
  case MenuVInCalib:{mState=MenuVBattCalib; DisplayMenu5();break;}
  case MenuVBattCalib:{mState=MenuClearPM; backCounter=5; DisplayMenu6();break;}
  case MenuClearPM:{mState=MenuReset; backCounter=5; DisplayMenu7();break;}
  case MenuReset:{mState=MenuVFloat; DisplayMenu1();break;}  
  }
}

void lbLongPressStop(){
  switch(mState){
  case noMENU:{startMenu();break;} 
  } 
}

void setGreenLED(){
  if (iIn>0.05){
    int greenPWM = (iIn-0.05)*200;
    if (greenPWM>255) {greenPWM=255;}
    analogWrite(greenPWMpin,greenPWM);
  }
  else{
    analogWrite(greenPWMpin,0);
    
  }
}

void setPWM(){
  analogWrite(PWMpin,PWM);
  analogWrite(redPWMpin,(255-PWM)/4);
}

void doSNOOZ(){
  cState=SNOOZ;
  digitalWrite(FANpin,LOW);
  PWM=255;
  setPWM();  
}

void doBULK(){
  cState=BULK;
  digitalWrite(FANpin,LOW);
  PWM=255;
  setPWM();  
}

void doFLOAT(){
  cState=FLOAT;
  digitalWrite(FANpin,HIGH);
  PWM=255;
  setPWM();  
}

void setup()
{
  lcd.init();
  lcd.backlight();
  LoadFromEEProm();
  leftButton.attachClick(lbClick);
  leftButton.attachDoubleClick(lbDoubleClick);
  leftButton.attachLongPressStart(lbLongPressStart);
  leftButton.attachLongPressStop(lbLongPressStop);
  mState=noMENU;
  timer1s.start();
  timer5s.start();
  timer10s.start();
  timerBL.setInterval(blTimer*1000);  
  if(blTimer>0){timerBL.start();}
  timer1h.start();
  pinMode(FANpin, OUTPUT);
  doSNOOZ();
}

void loop(){
  timer1s.update();
  timer5s.update();
  timer10s.update();
  timerBL.update();
  timerMenu.update();
  timer1h.update();
  leftButton.tick();
  int average = 0;
  average=0;
  for(int i = 0; i < 10; i++) {
    average += analogRead(A0)-iShift;
    delay(1);
  }
  iIn=average*0.00264; 
  if (iIn<0){iIn=0;};

//  average=0;
//  for(int i = 0; i < 10; i++) {
//    average += analogRead(A1);
//    delay(1);
//  }
 // vIn=average;
 // vIn=vInScale*average*0.000323558162267839687194525904203;
  average=0;
  for(int i = 0; i < 10; i++) {
    average += analogRead(A2);
    delay(1);
  } 
  vBatt=vBattScale*average*0.000323558162267839687194525904203;
  pIn=vBatt*iIn;
  setGreenLED();
  // switch states here:
  switch(cState){
    case SNOOZ:{
      if (iIn>=0.05){
        doBULK();
        break;
      }
      break;
    }
    case BULK:{
      if (iIn<0.05){
        doSNOOZ();
        break;      
    } 
      if (vBatt>=vFloat){
        doFLOAT();
        break; 
      }
      break;
    }
    case FLOAT:{
      if (vBatt>=vFloat){if (PWM>0){PWM--;setPWM();break;}}
      else{if (PWM<255){PWM++;setPWM();break;} 
        else{if (PWM==255){doBULK();break;}}
        break;} 
      }
  }       
}