/*
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);

#include<Keypad.h>
char customKey=0;
const byte ROWS = 4; //four rows
const byte COLS = 4; //four columns
char hexaKeys[ROWS][COLS] = {
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
byte rowPins[ROWS] = {A15, A14, A13, A12}; //row pinouts of the keypad
byte colPins[COLS] = {A11, A10, A9, A8}; //column pinouts of the keypad

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

const byte IN4 = 4;
const byte IN5 = 5;
const byte IN6 = 6;
const byte LockInd = 13;
const unsigned long shortWaitTime = 75;
const unsigned long longWaitTime  = 150;

struct pressButtonType {
  byte Pin;
  unsigned long lastChange;
  int lastState;
  int state;
  boolean pressed();
};

boolean pressButtonType::pressed() {
  int state = digitalRead(pressButtonType::Pin);
  if (state != pressButtonType::lastState) {
    pressButtonType::lastChange = millis();
    pressButtonType::lastState = state;
  }
  if (state != pressButtonType::state && millis() - pressButtonType::lastChange > 50) {
    pressButtonType::state     = state;
  };
  return !pressButtonType::state;
}

enum CountStates {idle, COUNTUP, COUNTDOWN, COUNTUPDEC, COUNTDOWNDEC};

CountStates actState  = idle;
CountStates lastState = idle;

signed long count = 0;                    // Changed to 0 so that COUNTUP starts with 1
signed long StartCountUpDec   = 1;        // Used by COUNTUPDEC when the counting limit has been reached
signed long StartCountDownDec = 444;      // Used by COUNTDOWNDEC when the counting limit has been reached
pressButtonType but4 = {IN4, 0, HIGH};
pressButtonType but5 = {IN5, 0, HIGH};
pressButtonType but6 = {IN6, 0, HIGH};





void setup() {
  lcd.init();
  lcd.backlight();
  Serial.begin(9600);
  Serial.println("Start");
  pinMode(but4.Pin, INPUT_PULLUP);
  pinMode(but5.Pin, INPUT_PULLUP);
  pinMode(but6.Pin, INPUT_PULLUP);
  actState = idle;
  lcd.setCursor(0,0);
  lcd.print("Start ... ");
  delay(1000);  // Just to allow to read the "Start" on LCD ...
  
}




void loop() 
{
  StateMachine();
  PrintCounter();
  HandleKeyPad();
}



void HandleKeyPad(){
  char key = customKeypad.getKey();
  if (key != NO_KEY) {
    Serial.println(key);
  }
}

void PrintCounter(){
  static signed long OldCount = 0; 
  if (OldCount != count) {
    Serial.println(count);
    OldCount = count;
    lcd.setCursor(0,0);
    lcd.print("Counting");
    lcd.setCursor(0,1);
    lcd.print("          ");  // Deleting previous data in row 2
    lcd.setCursor(0,1);
    lcd.print(count);
  }
}




void StateMachine(){
  static unsigned long lastActionTime = 0;
  static unsigned long WaitTime = longWaitTime;
   switch (actState) 
   {
     case idle : if (but4.pressed())
                  { 
                      actState = COUNTUP;
                  };

                 if (but5.pressed())
                 { 
                    actState = COUNTDOWN;
                 };

                 if (but6.pressed() && but4.pressed())
                  { 
                      actState = COUNTUPDEC;
                      StartCountUpDec = (count % 10);     // Sets the COUNTUPDEC start value to actual (count modulo 10) 
                  };                                      // Which is the last decimal of count (e.g. 8 for 18)

                  if (but6.pressed() && but5.pressed())
                { 
                    actState = COUNTDOWNDEC;

                    StartCountDownDec =  444 + (count % 20); 

                    if (count - 10 <= 1)// && count >= 444) 
                    count = StartCountDownDec;


                };
                 WaitTime       = longWaitTime;
              break;



     case COUNTUP : 
                 if (but5.pressed()) WaitTime = shortWaitTime;   
                    else WaitTime = longWaitTime;
                 if (but4.pressed()  && millis()-lastActionTime >= WaitTime)
                  {
                   lastActionTime = millis();
                   if(count<444)
                   {
                   count=count+1;
                   }
                   else
                   {
                    count=1;
                   }
                   //Serial.println(count);

                  }
                 if (!but4.pressed() && !but5.pressed()) actState = idle;
              break;


     case COUNTDOWN : 
                 if (but4.pressed()) WaitTime = shortWaitTime;
                                else WaitTime = longWaitTime;

                 if (but5.pressed() && millis()-lastActionTime >= WaitTime) 
                 {
                   lastActionTime = millis();

                   if(count>1)
                   {
                   count=count-1;
                   }
                   else
                   {
                    count=444;
                   }
                   //Serial.println(count);

                 }
                 if (!but4.pressed() && !but5.pressed()) actState = idle;
              break;

//*
    case COUNTUPDEC : 
                 if (but5.pressed()) WaitTime = shortWaitTime;
                                else WaitTime = longWaitTime;

                 if (but4.pressed() && millis()-lastActionTime >= WaitTime)
                  {
                   lastActionTime = millis();
                   //if(count+10<100)           // Added (+10) do avoid counting over 100
                   if(count+10<=444)
                   {
                   count=count+10;
                   }
                   
                   else 
                   {
                    count=StartCountUpDec;              // Reset count           
                   }
                   //Serial.println(count);

                   }
                 if (!but4.pressed() && !but5.pressed()) actState = idle;
              break;

   case COUNTDOWNDEC : 
                 if (but4.pressed()) WaitTime = shortWaitTime;
                                else WaitTime = longWaitTime;

                 if (but5.pressed() && millis()-lastActionTime >= WaitTime)
                  {
                   lastActionTime = millis();

                   if(count>=1 && count<=444)
                   {
                   count=count-10;
                   }

                   else 
                   {
                    //count=StartCountDownDec;
                    count=444;                // Reset count           
                   }
                   //Serial.println(count);                   
                   }

                 if (!but4.pressed() && !but5.pressed()) actState = idle;
              break;

              default : actState = idle;
              break;         
   }

}


*/













#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);

#include<Keypad.h>
char customKey=0;
const byte ROWS = 4; //four rows
const byte COLS = 4; //four columns
char hexaKeys[ROWS][COLS] = {
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
byte rowPins[ROWS] = {A15, A14, A13, A12}; //row pinouts of the keypad
byte colPins[COLS] = {A11, A10, A9, A8}; //column pinouts of the keypad

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

const byte IN4 = 4;
const byte IN5 = 5;
const byte IN6 = 6;
const byte LockInd = 13;
const unsigned long shortWaitTime = 75;
const unsigned long longWaitTime  = 150;

struct pressButtonType 
{
  byte Pin;
  unsigned long lastChange;
  int lastState;
  int state;
  boolean pressed();
};

boolean pressButtonType::pressed() 
{
  int state = digitalRead(pressButtonType::Pin);
  if (state != pressButtonType::lastState) {
    pressButtonType::lastChange = millis();
    pressButtonType::lastState = state;
  }
  if (state != pressButtonType::state && millis() - pressButtonType::lastChange > 50) {
    pressButtonType::state     = state;
  };
  return !pressButtonType::state;
}

enum CountStates {idle, COUNTUP, COUNTDOWN, COUNTUPDEC, COUNTDOWNDEC};

CountStates actState  = idle;
CountStates lastState = idle;

signed long count = 0;                    // Changed to 0 so that COUNTUP starts with 1
signed long StartCountUpDec   = 1;        // Used by COUNTUPDEC when the counting limit has been reached
signed long StartCountDownDec = 444;      // Used by COUNTDOWNDEC when the counting limit has been reached
pressButtonType but4 = {IN4, 0, HIGH};
pressButtonType but5 = {IN5, 0, HIGH};
pressButtonType but6 = {IN6, 0, HIGH};





void setup() 
{
  lcd.init();
  lcd.backlight();
  Serial.begin(9600);
  Serial.println("Start");
  pinMode(but4.Pin, INPUT_PULLUP);
  pinMode(but5.Pin, INPUT_PULLUP);
  pinMode(but6.Pin, INPUT_PULLUP);
  actState = idle;
  lcd.setCursor(0,0);
  lcd.print("Start ... ");
  delay(1000);  // Just to allow to read the "Start" on LCD ..
}


/*

void HandleKeyPad()
{
  
  static String StartNo = "";
  char key = customKeypad.getKey();
  if (key != NO_KEY) 
  
  {
   lcd.setCursor(0,1);      // Displaying the key pressed value
   lcd.print(StartNo+key);

   switch(key) {

        
                      

        case '*' :  if (StartNo.length()<4)
                    {
                    count = StartNo.toInt();     // Press * to apply and clear StartNo
                                                 // Note that here is NO break; so 
                                                 // the next lines until the break; below
                                                 // case 'C' will also be executed
                    lcd.setCursor(0,1);
                    lcd.print("     ");
                    lcd.setCursor(11,1);
                    lcd.print(StartNo);
                    }

        case '#' :  StartNo = "";                // Press # to clear StarNo
                    Serial.println();
                    lcd.setCursor(0,1);
                    lcd.print("     ");
             //break;
        case 'B' :   if (StartNo.length() >= 1)
                      {
                      StartNo.remove(StartNo.length()-1);
                      lcd.setCursor(StartNo.length(), 1); // move cursor to the last added character
                      //lcd.print(' ');  // Replace it with a blank
                      }
              break;
        case 'C' :                               // These all do nothing yet       
        case 'D' : 
        //case '*' :                                
              break;
        default : StartNo = StartNo+key;         // All keys except those mentioned above appended to StartNo
                  Serial.print(key);             // Print the new key 
              break;    
    }
  }
  */
  




String ActStartNo = String(count);
boolean Error = false;


void loop() 
{

  HandleKeyPad();
  PrintData();
  StateMachine();

}

  /*

  static signed long OldCount = 0;

  if (OldCount != count) 
  {
    Serial.println(count);
    OldCount = count;
    lcd.setCursor(0,0);
    lcd.print("Counting");
    lcd.setCursor(11,1);
    lcd.print("          ");  // Deleting previous data in row 2
    lcd.setCursor(11,1);
    lcd.print(count);
  }


  */



void HandleKeyPad()

{
  static String StartNo = "";
  char key = customKeypad.getKey();
  if (key != NO_KEY) {
   switch(key) {
                    // lcd.setCursor(0,1);
                    // lcd.print(ActStartNo);

        case '*' :                               // As we limit the no of digits already in default now
                                                 // we do not need the if here anymore
                    count = StartNo.toInt();     // Press * to apply and clear StartNo
                                                 // Note that here is NO break; so 
                                                 // the next lines until the break; below
                                                 // case 'C' will also be executed
                    if (count > StartCountDownDec)  count = StartCountDownDec;  // Check for the given maximum!!
                    // lcd.setCursor(0,1);
                    // lcd.print(ActStartNo);
        case '#' :  StartNo = "";                // Press # to clear StartNo
               break;                            // break required, otherwise it runs into next "case"  
        case 'A' :  StartCountDownDec = StartNo.toInt(); // Press A to set new StartCountDownDec
               break;                            // break required, otherwise it runs into next "case"  
        case 'B' :   if (StartNo.length() >= 1) {
                         StartNo.remove(StartNo.length()-1);
                      }
              break;
        case 'C' :                               // As long as A is not separately handled, it must be here!       
        case 'D' :                               // because these all be ignored now!!!       
              break;
        default : if (StartNo.length() < 3){
                    StartNo = StartNo+key;         // All keys except those mentioned above appended to StartNo
                   } else {
                     Error = true;
                   } 
              break;    
    }
    ActStartNo = StartNo;  // Set the global to the actual state of StartNo so that it can be printed in loop)()
  }
}








void PrintData()
{
  static signed long OldCount = 0; 
  static String OldStartNo = "";
  static signed long OldStartCountDownDec = 0;  
  static unsigned long lastError = 0;
  static boolean RemoveError = false;
  static boolean RefreshMax = true;
  if (OldCount != count) {
    Serial.println(count);
    OldCount = count;
    lcd.setCursor(0,0);
    lcd.print("Counting");
    lcd.setCursor(11,1);
    lcd.print("     ");  // Deleting previous data in row 2 on the left side only!
    lcd.setCursor(11,1);
    lcd.print(count);
  }
  if (OldStartNo != ActStartNo){
    OldStartNo = ActStartNo;
    Serial.println(ActStartNo);
    lcd.setCursor(0,1);
    lcd.print("     ");  // Deleting previous data in row 2 on the left side only!
    // lcd.setCursor(0,1);
    // lcd.print(ActStartNo);
  }
  if (Error) {
    Serial.println("Maximum Digits reached ... Apply, Remove or Clear!");
    lcd.setCursor(11,0);
    lcd.print("Error");
    Error = false;
    RemoveError = true;
    RefreshMax = false;
    lastError = millis();
  }
  if (RemoveError && millis() - lastError > 1000) {
    RemoveError = false;
    RefreshMax  = true;
    OldStartCountDownDec = 0; // To force an update!
  }
  if (RefreshMax && OldStartCountDownDec != StartCountDownDec) {
    OldStartCountDownDec = StartCountDownDec;
    lcd.setCursor(11,0);
    lcd.print("      ");
    //lcd.setCursor(11,0);
    //lcd.print(StartCountDownDec);
  }
}












void StateMachine()

{
  static unsigned long lastActionTime = 0;
  static unsigned long WaitTime = longWaitTime;

  switch (actState) 
   {
     case idle : if (but4.pressed())
                  { 
                      actState = COUNTUP;
                  };

                 if (but5.pressed())
                 { 
                    actState = COUNTDOWN;
                 };

                 if (but6.pressed() && but4.pressed())
                  { 
                      actState = COUNTUPDEC;
                      StartCountUpDec = (count % 10);     // Sets the COUNTUPDEC start value to actual (count modulo 10) 
                  };                                      // Which is the last decimal of count (e.g. 8 for 18)

                  if (but6.pressed() && but5.pressed())
                { 
                    actState = COUNTDOWNDEC;

                    StartCountDownDec =  444 + (count % 20); 

                    if (count - 10 <= 1)// && count >= 444) 
                    count = StartCountDownDec;


                };
                 WaitTime       = longWaitTime;
              break;



     case COUNTUP : 
                 if (but5.pressed()) WaitTime = shortWaitTime;   
                    else WaitTime = longWaitTime;
                 if (but4.pressed()  && millis()-lastActionTime >= WaitTime)// || case 'C')
                  {
                   lastActionTime = millis();
                   if(count<444)
                   {
                   count=count+1;
                   }
                   else
                   {
                    count=1;
                   }
                   //Serial.println(count);

                  }
                 if (!but4.pressed() && !but5.pressed()) actState = idle;
              break;


     case COUNTDOWN : 
                 if (but4.pressed()) WaitTime = shortWaitTime;
                                else WaitTime = longWaitTime;

                 if (but5.pressed() && millis()-lastActionTime >= WaitTime) 
                 {
                   lastActionTime = millis();

                   if(count>1)
                   {
                   count=count-1;
                   }
                   else
                   {
                    count=444;
                   }
                   //Serial.println(count);

                 }
                 if (!but4.pressed() && !but5.pressed()) actState = idle;
              break;

//*
    case COUNTUPDEC : 
                 if (but5.pressed()) WaitTime = shortWaitTime;
                                else WaitTime = longWaitTime;

                 if (but4.pressed() && millis()-lastActionTime >= WaitTime)
                  {
                   lastActionTime = millis();
                   //if(count+10<100)           // Added (+10) do avoid counting over 100
                   if(count+10<=444)
                   {
                   count=count+10;
                   }
                   
                   else 
                   {
                    count=StartCountUpDec;              // Reset count           
                   }
                   //Serial.println(count);

                   }
                 if (!but4.pressed() && !but5.pressed()) actState = idle;
              break;

   case COUNTDOWNDEC : 
                 if (but4.pressed()) WaitTime = shortWaitTime;
                                else WaitTime = longWaitTime;

                 if (but5.pressed() && millis()-lastActionTime >= WaitTime)
                  {
                   lastActionTime = millis();

                   if(count>=1 && count<=444)
                   {
                   count=count-10;
                   }

                   else 
                   {
                    //count=StartCountDownDec;
                    count=444;                // Reset count           
                   }
                   //Serial.println(count);                   
                   }

                 if (!but4.pressed() && !but5.pressed()) actState = idle;
              break;

              default : actState = idle;
              break;         
   }

//}

  //PrintCounter();
  //HandleKeyPad();
}