// include the library code:
#include <Wire.h>
#include <EEPROM.h>
#include <LiquidCrystal_I2C.h>
#include <Menu.h>
#include <LCDMenu2.h>
//#include <stdio.h>
//#include <stdlib.h>


#include <Keypad.h>

#define CONFIG_START 32


#define CMD_ZEIT 1
#define CMD_PMP 2
#define CMD_SAN 3
#define CMD_START_IMP 4
#define CMD_STOP_IMP 5
#define CMD_END 6



const byte ROWS = 4; //four rows
const byte COLS = 3; //tree columns
//define the cymbols on the buttons of the keypads
char  hexaKeys[ROWS][COLS] = {
{'p','u','m'},
{'l','e','r'},
{'b','d','#'},
{'1','2','3'}
};

//# Own Chars
//# ==================================
    uint8_t arrow_up[8]    = {0x4,0xE,0x15,0x4,0x4,0x4,0x0};
    uint8_t arrow_down[8]  = {0x0,0x4,0x4,0x4,0x15,0xE,0x4};

byte rowPins[ROWS] = {5, 4, 3, 2}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {6, 7, 8}; //connect to the column pinouts of the keypad

boolean sysStatus = false;


 


// Programme Declaration

boolean pUpload = false;

struct structCMD{
int Befehl;
int param1;
int param2;
} cmdP = {
0, 0 ,0 
};   

structCMD CMD[30];
int anzCMD = 0;





struct StoreStruct{
    float impPause;
    float impDauer;
} storage = {
0, 0  
};  

int adrProgMem = sizeof(storage)+1;

boolean state_imp = false;

//initialize an instance of class NewKeypad
Keypad keypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);


/*-----( Declare Constants )-----*/
/*-----( Declare objects )-----*/
LiquidCrystal_I2C lcd(0x27,20,4); // set the LCD address to 0x27
/*-----( Declare Variables )-----*/

const int pumpe = 9;
const int injektor = 10;
const int v_pneumatik = 12;
const int v_leer = 11;
const int startposX = 5;


long pMillis = 0;        // speichert wie viele Sekunden seit derletzten Änderung vergangen sind
long intervall_imp = 0;           // Interval zwischen zwei Änderungen

    Menu top("Root");

    // menu, lcd, rows, cols, arrow_up_pos, arrow_down_pos
    LCDMenu2 Root(top, lcd , 4, 20, 0, 1);

    Menu Item1("Jobs");
    Menu Item11("Job 01");
    Menu Item12("Job 02");
    Menu Item13("Job 03");
    Menu Item14("Job 04");
    Menu Item15("Job 05");
    Menu Item2("Einstellungen");
    Menu Item21("Impulse");
    Menu Item211("Pause");
    Menu Item212("IMP-Dauer");
    Menu Item22("Uhr");
    Menu Item23("Auto-Aus");


    Menu    mnuProg[20];
    uint8_t usedMnu = 0;
            
  
String strPumpe = "PMP";
String strSanosil = "SAN";
String strPneumatik = "IMP";

String tmpString = "";
int i=0;




String aktMenu = "main";
int menuPos = 0;
int mAnzMain = 3;
int mAnzSetup = 3;

boolean tmpFF = false;

char strA[15][15];
String p1,p2 = "";


void setup() {
    Serial.begin(9600);
    
  loadData();
  
  // setup Relais
  pinMode(pumpe, OUTPUT);
  pinMode(injektor, OUTPUT);
  pinMode(v_pneumatik, OUTPUT);
  pinMode(v_leer, OUTPUT);
  
  warten(500);
  lcd.init(); // initialize the lcd
  //lcd.backlight();

        lcd.createChar(0, arrow_up);
        lcd.createChar(1, arrow_down);  
  
  menuinit();

  keypad.addEventListener(keypadEvent); //add an event listener for this keypad
               
}




    //## Menu Init
void menuinit()
{
    top.addChild(Item1);
          Item1.addChild(Item11);

          Item1.addChild(Item12);
          Item1.addChild(Item13);
          Item1.addChild(Item14);
          Item1.addChild(Item15);
        top.addChild(Item2);
          Item2.addChild(Item21);
            Item21.addChild(Item211);
            Item21.addChild(Item212);
          Item2.addChild(Item22);
          Item2.addChild(Item23);
 
}    


void p_pulse(int ps, int dauer){
  digitalWrite(v_pneumatik, HIGH);  
  aktStatus();
  warten(dauer);
  digitalWrite(v_pneumatik, LOW);  
  aktStatus();
  warten(ps);
}

void menu(){
  lcd.clear();
  Root.display();


}


// Aktualisiert de Status in der linken Spalte
void aktStatus(){
    lcd.setCursor(0,0);
    if(digitalRead(pumpe)==HIGH) {lcd.print(strPumpe);} else {lcd.print("    ");};
    lcd.setCursor(0,1);
    if(digitalRead(injektor)==HIGH) {lcd.print(strSanosil);} else {lcd.print("    ");};
    lcd.setCursor(0,2);
    if(digitalRead(v_pneumatik)==HIGH) {lcd.print(strPneumatik);} else {lcd.print("    ");};
}  





Menu* allocateMenu()
{
  if( usedMnu >= 20 ) return NULL;        
  return &mnuProg[usedMnu++];
}


void mnuAddCMD(char *n)
{
  Menu* newMenu = allocateMenu();

  if( newMenu == NULL )  
  {
    // da ist wohl was schief gelaufen
    Serial.println("newMenu = NULL");
    return;
  }
  
  newMenu->name = n;
  

  Item11.addChild(*newMenu);
}


void FtoChar( float f, char* chr)
{
  int vk = (int)f;
  int nk = abs((f - (int)f) * 100);
  //if(vk==NULL) vk = 0;

  char cVK[5], cNK[5];
  itoa(vk, cVK, 10);
  itoa(nk, cNK, 10);

  strcpy(chr, cVK);
  strcat(chr, ".");
  strcat(chr, cNK);

}    


void loadProg()
{
  // Befehl Anzahl aus dem EEprom laden
  int adrIP = adrProgMem;    
  *((int*)&anzCMD) = EEPROM.read(adrIP);
  
  adrIP++;
  for (int iP=0; iP<anzCMD; iP++)
  {
    for (unsigned int t=0; t<sizeof(cmdP); t++) 
    {
      *((char*)&CMD[iP] + t) = EEPROM.read(adrIP + (iP * sizeof(cmdP)) +t);
    }
  }      

      
  
  int an = 0;
  for (int iP=0; iP<anzCMD; iP++)
  {                
 
                   char pp1[10], pp2[10];
                   if (CMD[iP].Befehl == CMD_START_IMP)
                   {
                     float fp1 = (float)CMD[iP].param1/ (float)1000;
                     float fp2 = (float)CMD[iP].param2/ (float)1000;

                     FtoChar(fp1, pp1);
                     FtoChar(fp2, pp2);
                   }
                   else
                   {
                     itoa(CMD[iP].param1,pp1,10);
                     itoa(CMD[iP].param2,pp2,10);
                   }  
                   
 
 
                                
                   if (CMD[iP].Befehl == CMD_ZEIT)
                   {
                      strcpy(strA[iP], "zeit(");
                      strcat(strA[iP], pp1);
                      strcat(strA[iP], ");");
                      mnuAddCMD(strA[iP]);
                   }
                   else if (CMD[iP].Befehl == CMD_PMP)
                   {
                      if(pp1 == "1") strcpy(pp1,"an"); else if(pp1=="0") strcpy(pp1,"aus");
                     
                      strcpy(strA[iP], "pmp(");
                      strcat(strA[iP], pp1);
                      strcat(strA[iP], ");");
                      mnuAddCMD(strA[iP]);
                   }
                   else if (CMD[iP].Befehl == CMD_SAN)
                   {
                      if(pp1 == "1") strcpy(pp1,"an"); else if(pp1=="0") strcpy(pp1,"aus");
                      
                      strcpy(strA[iP], "san(");
                      strcat(strA[iP], pp1);
                      strcat(strA[iP], ");");
                      mnuAddCMD(strA[iP]);
                   }
                   else if (CMD[iP].Befehl == CMD_START_IMP)
                   {
                      
                      strcpy(strA[iP], "start_imp(");
                      strcat(strA[iP], pp1);
                      strcat(strA[iP], ",");
                      strcat(strA[iP], pp2);
                      strcat(strA[iP], ");");
                      mnuAddCMD(strA[iP]);
                   }
                   else if (CMD[iP].Befehl == CMD_STOP_IMP)
                   {
                      
                      strcpy(strA[iP], "stop_imp()");
                      mnuAddCMD(strA[iP]);
                   }
                   else if (CMD[iP].Befehl == CMD_END)
                   {
                      
                      strcpy(strA[iP], "end;");
                      mnuAddCMD(strA[iP]);
                   }
             
      
     
   }
 
 
    Root.goMenu(Item11);

}


//Loop schleife nur für Keypadabfrage
void loop() {
  char key = keypad.getKey();
  if (state_imp) {pmp_isr();};
  
  check_serial();
}



void check_serial()
{
         
         char letra;
         String progName = "";
         
             
         while(Serial.available() > 0)
         {
                        
             
               // get incoming byte:
                letra = Serial.read();
                tmpString += String(letra);
                      

                // CMD ende
                if (letra == 59) 
                {
                  
                  tmpString = tmpString.trim(); 
                   Serial.println(tmpString);
                   
                   //Serial.println("#" + tmpString + "#");                   
                   if (tmpString.substring(0,5) == "pname")
                   {
                     pUpload = true;
                     progName = tmpString.substring(6,(tmpString.length() - 7));
                   } 
                   
                   
                   if (tmpString.substring(0,3) == "end")
                   {
                     
                     addPZeile(CMD_END,i);
                     pUpload = false;
                     pUploaded();   
                                      
                   } 
                   
                   
                   String tmpCMD = tmpString.substring(0, tmpString.indexOf("("));
                   if (tmpCMD == "zeit")
                   {
                      addPZeile(CMD_ZEIT,i);
                   }
                   else if (tmpCMD == "pmp")
                   {
                      addPZeile(CMD_PMP,i);
                   }
                   else if (tmpCMD == "san")
                   {
                      addPZeile(CMD_SAN,i);
                   }
                   else if (tmpCMD == "imp")
                   {
                      addPZeile(CMD_START_IMP,i);
                   }
                   else if (tmpCMD == "stop_imp")
                   {
                      addPZeile(CMD_STOP_IMP,i);
                   }

                   
                   int ka, kz, k = 0;
                   ka = tmpString.indexOf("(");
                   k = tmpString.indexOf(",");
                   kz = tmpString.indexOf(")");
                   p1 = "";
                   p2 = "";
                    
                   if (ka > 0 & kz > 0)
                   {
                     
                     if((tmpString.substring(ka + 1, kz)).length() > 0)
                     {
                           if (k > 0)
                           {
                             p1 = tmpString.substring(ka + 1, k);                           
                             p2 = tmpString.substring(k + 1, kz);
                           }
                           else
                           {
                             p1 = tmpString.substring(ka + 1, kz);                           
                           }
                            
                           if (p1=="an") p1="1"; else if(p1=="aus") p1="0";
                           if (p2=="an") p2="1"; else if(p2=="aus") p2="0";
      
                           
                           CMD[i-1].param1 = p1.toInt();
                           CMD[i-1].param2 = p2.toInt();
                             
                     }                   
                   } 
                   
                   i++; 
                   tmpString="";
                   
                   
                }
             
         }
        
        
}


void addPZeile(int bef, int ind)
{
    CMD[ind].Befehl = bef;
    anzCMD++;
}

void pUploaded()
{

    int adrIP = adrProgMem;    
    EEPROM.write(adrIP, *((int*)&anzCMD));
   
    adrIP++;    
    for (int iP=0; iP<anzCMD; iP++)
    {
      for (unsigned int t=0; t<sizeof(cmdP); t++) 
      {
        EEPROM.write(adrIP +(iP * sizeof(cmdP))+ t, *((char*)&CMD[iP] + t));
        
      }
    }  
}






void einschalten(){
  loadData();
  
  sysStatus = true;
  lcd.init(); // initialize the lcd
  lcd.backlight();

  lcd.clear();
  lcd.setCursor(startposX,0);
  lcd.print("IMP_Cleaner 1.0");
  lcd.setCursor(startposX,1);
  lcd.print("Copyrigth by:");
  lcd.setCursor(startposX,2);
  lcd.print("A.Frauenstein");
  lcd.setCursor(startposX,3);
  lcd.print("Init....");
  
  warten(5);
  
  menu();
  
  Root.goMenu(top);
 
}  


void loadData() {
  unsigned int adrIP =0;
  for (unsigned int t=0; t<sizeof(storage); t++)
  {
      *((char*)&storage + t) = EEPROM.read(CONFIG_START + t);
      adrIP = t;
  }

  
  
}


void saveData() {
  
  unsigned int adrIP =0;
  for (unsigned int t=0; t<sizeof(storage); t++)
  {
      EEPROM.write(CONFIG_START + t, *((char*)&storage + t));
      adrIP = t;
  }
 
}


void ausschalten(){
state_imp=false;
digitalWrite(injektor, LOW);
digitalWrite(pumpe, LOW);
digitalWrite(v_pneumatik, LOW); 

  aktStatus();
  saveData();
  sysStatus = false;
  lcd.noBacklight(); 
}


void aktPause()
{
     lcd.clear();
     lcd.setCursor(startposX,0);
     lcd.print("Pause");
     lcd.setCursor(startposX,1);
     lcd.print(storage.impPause);
}

void aktDauer()
{
     lcd.clear();
     lcd.setCursor(startposX,0);
     lcd.print("Dauer");
     lcd.setCursor(startposX,1);
     lcd.print(storage.impDauer);
}

    //## Function Check
    boolean funccheck(int action)
    {
           tmpFF = false;
              
            if(Root.curfuncname == "Pause") {
              if (action==1) {
                aktPause();
              };
              tmpFF = true; 
            }
            else if(Root.curfuncname == "IMP-Dauer") {
              if (action==1) {
                aktDauer();
              };
              tmpFF = true; 
            }            
            else if(Root.curfuncname == "Job 01") {
              if (action==1) {
                loadProg();
              };
              tmpFF = false; 
            }
           
    }


void pmp_isr() 
{
  byte value = digitalRead(v_pneumatik);
     
  if (value == LOW)
  {
    intervall_imp = (storage.impPause * 1000);
  }
  else
  {
    intervall_imp = (storage.impDauer * 1000);
  }
 if (millis() - pMillis > intervall_imp) {
    pMillis = millis();   // aktuelle Zeit abspeichern

    // LED Zustand wecheln.
    if (value == LOW)
      value = HIGH;
    else
      value = LOW;
// Wert auf den Ausgang schreiben
    digitalWrite(v_pneumatik, value);
    aktStatus();
  }  
}

void warten(long zeit)
{
    long aWert = millis();
    while(millis() < (aWert + zeit))
    {
        char key = keypad.getKey();
    }
}


//take care of some special events
void keypadEvent(KeypadEvent key){
  int mAnz;

if (aktMenu == "main")
{
      mAnz = mAnzMain;
}
else if(aktMenu == "Setup")
{
      mAnz = mAnzSetup;
};  

  
  switch (keypad.getState()){
    case PRESSED:
      switch (key){
        case 'p': 
          if(sysStatus) {ausschalten();} else{einschalten();}; 
     
        break;

        case 'u': 
          if(tmpFF) 
          {
            if (Root.curfuncname == "Pause") 
            {
              storage.impPause = storage.impPause + 0.1;
              aktPause();
            }
            else if (Root.curfuncname == "IMP-Dauer")
            {
              storage.impDauer = storage.impDauer + 0.1;
              aktDauer();
            };
            
          } 
          else 
          {
            Root.goUp();
            aktStatus();          
          };
        break;
        case 'd': 
          if(tmpFF) 
          {
            if (Root.curfuncname == "Pause") 
            {
              storage.impPause = storage.impPause - 0.1;
              aktPause();
            }
            else if (Root.curfuncname == "IMP-Dauer")
            {
              storage.impDauer = storage.impDauer - 0.1;
              aktDauer();
            };
            
          } 
          else 
          {
            Root.goDown();
            aktStatus();          
          };
        break;
        case 'm': 
          Root.goMenu(top);
          aktStatus();          
        break;

        case '1':
          if(digitalRead(pumpe) == HIGH) {digitalWrite(pumpe, LOW);} else{digitalWrite(pumpe, HIGH);};
          aktStatus();          
        break;
        case '2':
          if(digitalRead(injektor) == HIGH) {digitalWrite(injektor, LOW);} else{digitalWrite(injektor, HIGH);};
          aktStatus();          
        break;
        case '3':
          if(state_imp) {
          state_imp=false;
          digitalWrite(v_pneumatik, LOW);
         aktStatus();  
        } else{
        state_imp=true;
      };
                    
        break;
        case 'b':
          tmpFF = false;
          Root.goBack();
          
          aktStatus();          
        break;
        case 'e':
          Root.goEnter();
          funccheck(1);
          aktStatus();                  
       break;
      }
    break;
    case RELEASED:
      switch (key){
        case '*': 
        break;
      }
    break;
    case HOLD:
      switch (key){
        case '*': 
        
        break;
      }
    break;
  }
}