//SFT MENU CODE =(COMMAND CONTROL)+(5/4 KEYPAD)+(IR REMOTE)+(WIRELESS TRANSFER)+(AC V-LIMIT & I-LIMIT)

//(PORT DETECTION)+(ISOLATION TR)

#include "CMBMenu.hpp"  // include CMBMenu

#include <Wire.h> // include I2C MODULE FOR LCD

#include <LiquidCrystal_I2C.h>  // include LCD

#include <IRremote.h>   // include IR

// Set up pins for STATUS LED
const char STATUS_LED_RED_OP = 2; 
const char STATUS_LED_BLUE_OP = 3; 
const char STATUS_LED_GREEN_OP = 4; 

// Set up pins for VSS
const char VSS_SUPPLY_OP = 5;

const char IPOP_VS3_R = 6;

const char IPOP_VS3_Y = 7;

const char IPOP_VS3_B = 8;

const char IPOP_VS4_R = 9;

const char IPOP_VS4_Y = 10;

const char IPOP_VS4_B = 11;

// Set up pins for IPOP MONITOR
const char IPOP_MONITOR = 12;

const char IPOP_MONITOR_RR = 14;
const char IPOP_MONITOR_RG = 15;

const char IPOP_MONITOR_YR = 16;
const char IPOP_MONITOR_YG = 18;

const char IPOP_MONITOR_BR = 19;
const char IPOP_MONITOR_BG = 22;

// Set up pins for PHS & PHS1
const char PHS_R_INPUT = 23;
const char PHS_Y_INPUT = 24;
const char PHS_B_INPUT = 25;

const char PHS_R_LED_RED_OP = 26;
const char PHS_R_LED_GREEN_OP = 27;

const char PHS_Y_LED_RED_OP = 28;
const char PHS_Y_LED_GREEN_OP = 29;

const char PHS_B_LED_RED_OP = 30;
const char PHS_B_LED_GREEN_OP = 31;

const char PHS1_R_INPUT = 32;
const char PHS1_Y_INPUT = 33;
const char PHS1_B_INPUT = 34;

const char PHS1_R_LED_RED_OP = 35;
const char PHS1_R_LED_GREEN_OP = 36;

const char PHS1_Y_LED_RED_OP = 37;
const char PHS1_Y_LED_GREEN_OP = 38;

const char PHS1_B_LED_RED_OP = 39;
const char PHS1_B_LED_GREEN_OP = 40;

const char IRinput_pin = 17;

IRrecv IR(IRinput_pin);

const char PHS_LED_ENABLE_IP = A0;

// Set up pins for pushButtons
const char Right_Button = A1;
const char Left_Button = A2; 
const char Enter_Button = A3;
const char Exit_Button = A4;

const char WIRELESS_12V_OP = A5;

const char WIRELESS_24V_OP = A6;

bool pressed = false;

bool PHS_DEACTIVATION_OP = false;    //FOR IP ACTIVATE PHASE FUNCTION
bool PHS1_DEACTIVATION_OP = false;  // FOR OP ACTIVATE PHASE FUNCTION

bool TRANSFER_VALUE_12V = true;

bool TRANSFER_VALUE_24V = false;

bool TRANSFER_VALUE_0V = false;

bool STATE_RED = false;

bool STATE_GREEN = false;

const long onDuration = 200;  // ON time for LED

const long offDuration = 2000;  // OFF time for LED

const long offDuration1 = 1000;  // OFF time for LED

unsigned long rememberTime = 0;  // this is used by the code

int LEDState = HIGH;  // initial state of LED

LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);  // Set the LCD I2C address

/************************************************************************************************************/
//                                      MENU LAYERS & DISPLAY TEXT
/************************************************************************************************************/

// define text to display

const char g_MenuCOMMAND_CONTROL_pc[] PROGMEM = {"  1.COMMAND CONTROL"};//1
const char g_MenuARTIFICIAL_MODE_pc[] PROGMEM = {" 1.1 ARTIFICIAL MODE"};//1.1
const char g_MenuMANUAL_MODE_pc[] PROGMEM = {" 1.2 MANUAL MODE"};//1.2

const char g_MenuWIRELESS_TRANSFER_pc[] PROGMEM = {"2.WIRELESS TRANSFER"};//2
const char g_MenuON_OFF_TRANSFER_pc[] PROGMEM = {"2.1 ON/OFF TRANSFER"};//2.1

// define function IDs
enum MenuFID {
  MenuDummy,
  MenuCOMMAND_CONTROL,
  MenuARTIFICIAL_MODE,
  MenuMANUAL_MODE,
  MenuWIRELESS_TRANSFER,
  MenuON_OFF_TRANSFER,
};

// define key types
enum KeyType {
  KeyNone, // no key is pressed
  KeyLeft,
  KeyRight,
  KeyEnter,
  KeyExit
};

// ** menu **
// create global CMBMenu instance
// (here for maximum 100 menu entries)
CMBMenu<100> g_Menu;

/************************************************************************************************************/
//                                   CREATE CUSTOM CHARECTERS FOR MENU
/************************************************************************************************************/

byte customChar1[8] = {
  0b00000,
  0b01000,
  0b01100,
  0b01110,
  0b01111,
  0b01110,
  0b01100,
  0b01000
};

byte customChar2[8] = {
  0b00000,
  0b00010,
  0b00110,
  0b01110,
  0b11110,
  0b01110,
  0b00110,
  0b00010
};

byte customChar3[8] = {
  0b00000,
  0b00100,
  0b01110,
  0b11111,
  0b11111,
  0b01110,
  0b00100,
  0b00000
};

byte customChar4[8] = {
  0b00111,
  0b00001,
  0b00001,
  0b00101,
  0b01101,
  0b11111,
  0b01100,
  0b00100
};

const unsigned long eventInterval = 2000;

unsigned long previousTime = 0;

/************************************************************************************************************/
//                                           MAIN setup & PINMODES
/************************************************************************************************************/
void setup()
{
   pinMode(STATUS_LED_RED_OP, OUTPUT);
   pinMode(STATUS_LED_BLUE_OP, OUTPUT);
   pinMode(STATUS_LED_GREEN_OP, OUTPUT);

   pinMode(VSS_SUPPLY_OP, OUTPUT);
   
   pinMode(IPOP_VS3_R, OUTPUT);

   pinMode(IPOP_VS3_Y, OUTPUT);

   pinMode(IPOP_VS3_B, OUTPUT);
   
   pinMode(IPOP_VS4_R, OUTPUT);

   pinMode(IPOP_VS4_Y, OUTPUT);
 
   pinMode(IPOP_VS4_B, OUTPUT);

  // Set up pinMode for IPOP MONITOR
   pinMode(IPOP_MONITOR, OUTPUT);

   pinMode(IPOP_MONITOR_RR, OUTPUT);
   pinMode(IPOP_MONITOR_RG, OUTPUT);

   pinMode(IPOP_MONITOR_YR, OUTPUT);
   pinMode(IPOP_MONITOR_YG, OUTPUT);

   pinMode(IPOP_MONITOR_BR, OUTPUT);
   pinMode(IPOP_MONITOR_BG, OUTPUT);

  // Set up pins for PHS & PHS1
   
   pinMode(PHS_R_INPUT, INPUT_PULLUP);
   pinMode(PHS_Y_INPUT, INPUT_PULLUP);
   pinMode(PHS_B_INPUT, INPUT_PULLUP);

   pinMode(PHS_R_LED_RED_OP, OUTPUT);
   pinMode(PHS_R_LED_GREEN_OP, OUTPUT);

   pinMode(PHS_Y_LED_RED_OP, OUTPUT);
   pinMode(PHS_Y_LED_GREEN_OP, OUTPUT);

   pinMode(PHS_B_LED_RED_OP, OUTPUT);
   pinMode(PHS_B_LED_GREEN_OP, OUTPUT);

   pinMode(PHS1_R_INPUT, INPUT_PULLUP);
   pinMode(PHS1_Y_INPUT, INPUT_PULLUP);
   pinMode(PHS1_B_INPUT, INPUT_PULLUP);

   pinMode(PHS1_R_LED_RED_OP, OUTPUT);
   pinMode(PHS1_R_LED_GREEN_OP, OUTPUT);

   pinMode(PHS1_Y_LED_RED_OP, OUTPUT);
   pinMode(PHS1_Y_LED_GREEN_OP, OUTPUT);

   pinMode(PHS1_B_LED_RED_OP, OUTPUT);
   pinMode(PHS1_B_LED_GREEN_OP, OUTPUT);

  // Set up pinmode PHS LED ENABLE IP
  pinMode(PHS_LED_ENABLE_IP, INPUT_PULLUP);
  
  // Set up pinmode NAVIGATION
  pinMode(Left_Button, INPUT_PULLUP);
  pinMode(Right_Button, INPUT_PULLUP);
  pinMode(Enter_Button, INPUT_PULLUP);
  pinMode(Exit_Button, INPUT_PULLUP);

  pinMode(WIRELESS_12V_OP, OUTPUT);

  pinMode(WIRELESS_24V_OP, OUTPUT);

  digitalWrite(PHS_R_LED_RED_OP,HIGH);
  digitalWrite(PHS_R_LED_GREEN_OP,HIGH);

  digitalWrite(PHS_Y_LED_RED_OP,HIGH);
  digitalWrite(PHS_Y_LED_GREEN_OP,HIGH);

  digitalWrite(PHS_B_LED_RED_OP,HIGH);
  digitalWrite(PHS_B_LED_GREEN_OP,HIGH);
  

  digitalWrite(PHS1_R_LED_RED_OP,HIGH);
  digitalWrite(PHS1_R_LED_GREEN_OP,HIGH);

  digitalWrite(PHS1_Y_LED_RED_OP,HIGH);
  digitalWrite(PHS1_Y_LED_GREEN_OP,HIGH);

  digitalWrite(PHS1_B_LED_RED_OP,HIGH);
  digitalWrite(PHS1_B_LED_GREEN_OP,HIGH);

  
  digitalWrite(IPOP_VS3_R,HIGH);
  digitalWrite(IPOP_VS3_Y,HIGH);
  digitalWrite(IPOP_VS3_B,HIGH);

  digitalWrite(IPOP_VS4_R,HIGH);
  digitalWrite(IPOP_VS4_Y,HIGH);
  digitalWrite(IPOP_VS4_B,HIGH);


  Serial.begin(9600);
  lcd.begin(20,4);
  
      lcd.clear();
      lcd.setCursor(6,0);
      lcd.print("WELCOME");
      lcd.setCursor(3,2);
      lcd.print("INSPIRE INDIA");
      lcd.setCursor(5,3);
      lcd.print("INSTITUTE");

      delay(1500);
      
      lcd.clear();
      lcd.setCursor(2,1);
      lcd.print("INDUSTRIAL PSLC");
      lcd.setCursor(1,2);
      lcd.print("POWER CONTROL UNIT");

    delay(15500);// MAIN DELAY
    
    digitalWrite(VSS_SUPPLY_OP,HIGH);

    delay(100);

    digitalWrite(IPOP_VS3_R,LOW);
    delay(250);
    digitalWrite(IPOP_VS3_Y,LOW);
    delay(250);
    digitalWrite(IPOP_VS3_B,LOW);

    delay(500);

    digitalWrite(IPOP_VS4_R,LOW);
    delay(250);
    digitalWrite(IPOP_VS4_Y,LOW);
    delay(250);
    digitalWrite(IPOP_VS4_B,LOW);

    delay(500);

    digitalWrite(IPOP_MONITOR,HIGH);

    delay(3250);

    digitalWrite(VSS_SUPPLY_OP,LOW);
    digitalWrite(IPOP_MONITOR,LOW);

      lcd.clear();
      lcd.setCursor(6,0);
      lcd.print("WELCOME");
      lcd.setCursor(4,2);
      lcd.print("SYSTEM READY");

      delay(100);

  lcd.createChar(1, customChar1); 
  lcd.createChar(2, customChar2); 
  lcd.createChar(3, customChar3); 
  lcd.createChar(4, customChar4); 
   
  IR.enableIRIn ();

  Serial.println("===========================");
  Serial.println("PROTECTION SEGMENT");
  Serial.println("===========================");
  Serial.println("");
  Serial.println("l: left, r: right, e: enter, x: exit");
  Serial.println("");

  // ** MENU LAYERS**
  // add nodes to menu (layer, string, function ID)
  g_Menu.addNode(0, g_MenuCOMMAND_CONTROL_pc , MenuCOMMAND_CONTROL);
  g_Menu.addNode(1, g_MenuARTIFICIAL_MODE_pc , MenuARTIFICIAL_MODE);
  g_Menu.addNode(1, g_MenuMANUAL_MODE_pc , MenuMANUAL_MODE);

  g_Menu.addNode(0, g_MenuWIRELESS_TRANSFER_pc , MenuWIRELESS_TRANSFER);
  g_Menu.addNode(1, g_MenuON_OFF_TRANSFER_pc, MenuON_OFF_TRANSFER);

  // *****MENU*****
  // build menu and print menu
  // (see terminal for output)
  const char* info;
  g_Menu.buildMenu(info);
  g_Menu.printMenu();

  // ** menu **
  // print current menu entry
    printMenuEntry(info);

    
}

/************************************************************************************************************/
//                                             MAIN LOOP
/************************************************************************************************************/
void loop()
{ 

  if (STATE_RED == true) {


    if (LEDState == HIGH) {

      if ((millis() - rememberTime) >= onDuration) {
        LEDState = LOW;           // change the state of LED
        rememberTime = millis();  // remember Current millis() time
      }
    }
    else {
      if ((millis() - rememberTime) >= offDuration1) {
        LEDState = HIGH;          // change the state of LED
        rememberTime = millis();  // remember Current millis() time
      }
    }

    digitalWrite(STATUS_LED_RED_OP, LEDState);  //GREEN

  }

  if (STATE_GREEN == true) {


    if (LEDState == HIGH) {

      if ((millis() - rememberTime) >= onDuration) {
        LEDState = LOW;           // change the state of LED
        rememberTime = millis();  // remember Current millis() time
      }
    }
    else {
      if ((millis() - rememberTime) >= offDuration1) {
        LEDState = HIGH;          // change the state of LED
        rememberTime = millis();  // remember Current millis() time
      }
    }

    digitalWrite(STATUS_LED_GREEN_OP, LEDState);  //GREEN

  }
   
/************************************************************************************************************/
//                                          PHS CONTROL SEGMENT
/************************************************************************************************************/
     
     bool PHS_R_INPUT_currentState = digitalRead(PHS_R_INPUT);
     bool PHS_Y_INPUT_currentState = digitalRead(PHS_Y_INPUT);
     bool PHS_B_INPUT_currentState = digitalRead(PHS_B_INPUT);

     bool PHS_LED_ENABLE_IP_currentState = digitalRead(PHS_LED_ENABLE_IP);


/*************************************************************************************************************/
//                              PHS RYB PRESSED - LED -INDICATION 
/*************************************************************************************************************/

if(PHS_LED_ENABLE_IP_currentState==LOW){

   if(PHS_DEACTIVATION_OP == false){
  
      if(PHS_R_INPUT_currentState==LOW){
  
  digitalWrite(PHS_R_LED_RED_OP, HIGH);
  digitalWrite(PHS_R_LED_GREEN_OP, LOW);

  }

  else{
    digitalWrite(PHS_R_LED_RED_OP, LOW);
    digitalWrite(PHS_R_LED_GREEN_OP, LOW);
  }
    
  if(PHS_Y_INPUT_currentState==LOW){
  
  digitalWrite(PHS_Y_LED_RED_OP, HIGH);
  digitalWrite(PHS_Y_LED_GREEN_OP, LOW);

  }

  else{
    digitalWrite(PHS_Y_LED_RED_OP, LOW);
    digitalWrite(PHS_Y_LED_GREEN_OP, LOW);
  }
  
  if(PHS_B_INPUT_currentState==LOW){
  
  digitalWrite(PHS_B_LED_RED_OP, HIGH);
  digitalWrite(PHS_B_LED_GREEN_OP, LOW);

  }

  else{
    digitalWrite(PHS_B_LED_RED_OP, LOW);
    digitalWrite(PHS_B_LED_GREEN_OP, LOW);
  }
 }

 else{
  
    digitalWrite(PHS_R_LED_RED_OP, LOW);
    digitalWrite(PHS_R_LED_GREEN_OP, HIGH);

    digitalWrite(PHS_Y_LED_RED_OP, LOW);
    digitalWrite(PHS_Y_LED_GREEN_OP, HIGH);

    digitalWrite(PHS_B_LED_RED_OP, LOW);
    digitalWrite(PHS_B_LED_GREEN_OP, HIGH);
  }
} 

else{
  
    digitalWrite(PHS_R_LED_RED_OP, HIGH);
    digitalWrite(PHS_R_LED_GREEN_OP, HIGH);

    digitalWrite(PHS_Y_LED_RED_OP, HIGH);
    digitalWrite(PHS_Y_LED_GREEN_OP, HIGH);

    digitalWrite(PHS_B_LED_RED_OP, HIGH);
    digitalWrite(PHS_B_LED_GREEN_OP, HIGH);
  }
/************************************************************************************************************/
//                                          PHS1 CONTROL SEGMENT
/************************************************************************************************************/
     
     bool PHS1_R_INPUT_currentState = digitalRead(PHS1_R_INPUT);
     bool PHS1_Y_INPUT_currentState = digitalRead(PHS1_Y_INPUT);
     bool PHS1_B_INPUT_currentState = digitalRead(PHS1_B_INPUT);


/*************************************************************************************************************/
//                              PHS1 RYB PRESSED - LED -INDICATION 
/*************************************************************************************************************/

if(PHS_LED_ENABLE_IP_currentState==LOW){

   if(PHS1_DEACTIVATION_OP == false){
  
      if(PHS1_R_INPUT_currentState==LOW){
  
  digitalWrite(PHS1_R_LED_RED_OP, HIGH);
  digitalWrite(PHS1_R_LED_GREEN_OP, LOW);

  }

  else{
    digitalWrite(PHS1_R_LED_RED_OP, LOW);
    digitalWrite(PHS1_R_LED_GREEN_OP, LOW);
  }
    
  if(PHS1_Y_INPUT_currentState==LOW){
  
  digitalWrite(PHS1_Y_LED_RED_OP, HIGH);
  digitalWrite(PHS1_Y_LED_GREEN_OP, LOW);

  }

  else{
    digitalWrite(PHS1_Y_LED_RED_OP, LOW);
    digitalWrite(PHS1_Y_LED_GREEN_OP, LOW);
  }
  
  if(PHS1_B_INPUT_currentState==LOW){
  
  digitalWrite(PHS1_B_LED_RED_OP, HIGH);
  digitalWrite(PHS1_B_LED_GREEN_OP, LOW);

  }

  else{
    digitalWrite(PHS1_B_LED_RED_OP, LOW);
    digitalWrite(PHS1_B_LED_GREEN_OP, LOW);
  }
 }

 else{
  
    digitalWrite(PHS1_R_LED_RED_OP, LOW);
    digitalWrite(PHS1_R_LED_GREEN_OP, HIGH);

    digitalWrite(PHS1_Y_LED_RED_OP, LOW);
    digitalWrite(PHS1_Y_LED_GREEN_OP, HIGH);

    digitalWrite(PHS1_B_LED_RED_OP, LOW);
    digitalWrite(PHS1_B_LED_GREEN_OP, HIGH);
  }
} 

else{
  
    digitalWrite(PHS1_R_LED_RED_OP, HIGH);
    digitalWrite(PHS1_R_LED_GREEN_OP, HIGH);

    digitalWrite(PHS1_Y_LED_RED_OP, HIGH);
    digitalWrite(PHS1_Y_LED_GREEN_OP, HIGH);

    digitalWrite(PHS1_B_LED_RED_OP, HIGH);
    digitalWrite(PHS1_B_LED_GREEN_OP, HIGH);
  }
     
/*************************************************************************************************************/
//                               VSS-IPOP MONITOR ENABLE SEGMENT
/*************************************************************************************************************/
   if(PHS_LED_ENABLE_IP_currentState==LOW){
     
     digitalWrite(VSS_SUPPLY_OP,HIGH);
    
     digitalWrite(IPOP_MONITOR,HIGH);
     
   }
 else{
  
    digitalWrite(VSS_SUPPLY_OP,LOW);
    
    digitalWrite(IPOP_MONITOR,LOW);
 
  }
   
  
/* ***********************************************************************************************************/
//                               TEMPERTURE & HUMIDITY FUNCTION LOOP
/* **********************************************************************************************************/ 
  

/*************************************************************************************************************/
//                                        IR LOOP FUNCTIONS
/************************************************************************************************************/ 






/*************************************************************************************************************/
//                                      MENU CASE'S & NAVIGATION KEY          
/************************************************************************************************************/ 

  // function ID
  int fid = 0;

  // info text from menu
  const char* info;

  // go to deeper or upper layer?
  bool layerChanged=false;

  // determine pressed key
  KeyType key = getKey();

  // ** menu **
  // call menu methods regarding pressed key
  switch(key) {
    case KeyExit:
      g_Menu.exit();
      digitalWrite(WIRELESS_12V_OP, LOW);
      digitalWrite(WIRELESS_24V_OP, LOW);
      STATE_RED = false;
      STATE_GREEN = false;
      blinkLedIR();
      break;
    case KeyEnter:
      g_Menu.enter(layerChanged);
      blinkLedIR();
      break;
    case KeyRight:
      g_Menu.right();
      blinkLedIR();
      break;
    case KeyLeft:
      g_Menu.left();
      blinkLedIR();
      break;
    default:
      break;
  }

  // ** menu **
  // pint/update menu when key was pressed
  // and get current function ID "fid"
  if (KeyNone != key) {
    fid = g_Menu.getInfo(info);
    printMenuEntry(info);
  }

  // ** menu **
  // do action regarding function ID "fid"
  if ((0 != fid) && (KeyEnter == key) && (!layerChanged)) {
    switch (fid) {

      case MenuON_OFF_TRANSFER:
        WIRELESS_TRANSFER();
        break;
      
      default:
        break;
   }
  }
}

/*************************************************************************************************************/
//                               LOOP ENDS & Void clearData for ATHENTICATION
/*************************************************************************************************************/



/*************************************************************************************************************/
//                                        MENU PRINT & LCD MAIN PRINT
/*************************************************************************************************************/

void printMenuEntry(const char* f_Info)
{
  String info_s;
  MBHelper::stringFromPgm(f_Info, info_s);

  // when using LCD: add/replace here code to
  // display info on LCD
  Serial.flush();
  Serial.println("----------------");
  Serial.println(info_s);
  Serial.println("----------------");

  // print on LCD
  
  lcd.clear();
  lcd.setCursor(6,0);
  lcd.print("WELCOME");
  lcd.setCursor(0,2);
  lcd.print(info_s);
  lcd.setCursor(9,3);
  lcd.write((byte)2);  // print the custom char at (3, 3)
  lcd.setCursor(12,3);
  lcd.write((byte)1);  // print the custom char at (8, 3)
  lcd.setCursor(15,3);
  lcd.write((byte)3);  // print the custom char at (13, 3)
  lcd.setCursor(18,3);
  lcd.write((byte)4);  // print the custom char at (18, 3)
  
  // you can print here additional infos into second line of LCD
  // g_Lcd.setCursor(0, 1);
  // g_Lcd.print("my text");
}


/*************************************************************************************************************/
//                                   MENU NAVIGATION KEY & IR NAVIGATION
/*************************************************************************************************************/
KeyType getKey()
{
  KeyType key = KeyNone;

  // here for demonstration: get "pressed" key from terminal
  // replace code when using push buttons 11D9609F
     bool Left_currentState = digitalRead(Left_Button);
     bool Right_currentState = digitalRead(Right_Button);
     bool Enter_currentState = digitalRead(Enter_Button);
     bool Exit_currentState = digitalRead(Exit_Button);
    
  if (IR.decode()) {
          int res = IR.results.value; //IR value to res
   switch (res) {
            case 0x11D9609F:
               key = KeyEnter;
               Serial.println("OK");
              break;
            case 0x11D958A7:
               key = KeyLeft; // left
               Serial.println("LEFT");
              break;
            case 0x11D948B7:
               key = KeyRight; // Right
               Serial.println("RIGHT");
              break;
            case 0x11D9708F:
               key = KeyLeft; // left
               Serial.println("UP");
              break;
            case 0x11D950AF:
               key = KeyRight; // Right
               Serial.println("DOWN");
              break;  
            case 0x11D908F7:
               key = KeyExit;
               Serial.println("Exit");
              break;
            default: 
              break;
          }
   
          IR.resume(); // get the next val
      }
      
     if(Left_currentState == pressed){
  
      key = KeyLeft; // left
      Serial.println("<left>");
      delay(500);
      while(digitalRead(Left_Button) == pressed){  
      } 
    } 
    
    else if(Right_currentState == pressed){
  
      key = KeyRight; // Right
      Serial.println("<Right>");
      delay(500);
      while(digitalRead(Right_Button) == pressed){
      } 
    } 

    else if(Enter_currentState == pressed){
  
      key = KeyEnter;
      Serial.println("<Enter>");
      delay(500);
      while(digitalRead(Enter_Button) == pressed){
      } 
    } 

    else if(Exit_currentState == pressed){
  
      key = KeyExit;
      Serial.println("<Exit>");
      delay(500);
      while(digitalRead(Exit_Button) == pressed){
      } 
    } 
 return key;
}


/*************************************************************************************************************/
//                                      2.1 WIRELESS TRANSFER
/*************************************************************************************************************/
void WIRELESS_TRANSFER()
{
  
  if(TRANSFER_VALUE_12V == true){

    TURN_ON_12V_TRANSFER();

  }

  else if(TRANSFER_VALUE_0V == true){

    TURN_OFF_TRANSFER();

  }
  
      
}

void TURN_ON_12V_TRANSFER(){

      digitalWrite(WIRELESS_12V_OP, HIGH);
      digitalWrite(WIRELESS_24V_OP, LOW);

      lcd.clear();
      lcd.setCursor(3,0);
      lcd.print("WIRELESS POWER");
      lcd.setCursor(0,1);
      lcd.print("--------------------");
      lcd.setCursor(0,2);
      lcd.print("STATE: ACTIVATED");
      lcd.setCursor(0,3);
      lcd.print("RANGE: 60cm 40W 24V");

      TRANSFER_VALUE_12V = false;
      TRANSFER_VALUE_0V = true;
      STATE_RED = true;

}

void TURN_ON_24V_TRANSFER(){
      
      digitalWrite(WIRELESS_24V_OP, HIGH);

      lcd.clear();
      lcd.setCursor(3,0);
      lcd.print("WIRELESS POWER");
      lcd.setCursor(0,1);
      lcd.print("--------------------");
      lcd.setCursor(0,2);
      lcd.print("STATE: ACTIVATED");
      lcd.setCursor(0,3);
      lcd.print("RANGE: 60cm 40W 24V");

      TRANSFER_VALUE_12V = false;
      TRANSFER_VALUE_24V = false;
      TRANSFER_VALUE_0V = true;
      STATE_GREEN = false;
      STATE_RED = true;

}

void TURN_OFF_TRANSFER(){

      digitalWrite(WIRELESS_12V_OP, LOW);
      digitalWrite(WIRELESS_24V_OP, LOW);
  
      lcd.clear();
      lcd.setCursor(3,0);
      lcd.print("WIRELESS POWER");
      lcd.setCursor(0,1);
      lcd.print("--------------------");
      lcd.setCursor(0,2);
      lcd.print("STATE: DEACTIVATED");
      lcd.setCursor(0,3);
      lcd.print("RANGE: 0cm 0W - OFF");

      TRANSFER_VALUE_12V = true;
      STATE_RED = false;
      STATE_GREEN = false;

}

void blinkLedIR() {

  digitalWrite(STATUS_LED_GREEN_OP, HIGH);
  digitalWrite(STATUS_LED_BLUE_OP, HIGH);
  delay(100);
  digitalWrite(STATUS_LED_GREEN_OP, LOW);
  digitalWrite(STATUS_LED_BLUE_OP, LOW);
}
/*===========================================================================================================*/
// naming convention
// prefix:
//   g  : global variable
//   f  : function/method variable
//   m  : private member of class
//      : without prefix: public member of class
//
//
/*===========================================================================================================*/