//make sure the ct variable.

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Keypad.h>

const byte ROWS = 2;
const byte COLS = 2;

char hexaKeys[ROWS][COLS] = {
  {'2', '1'},
  {'4', '3'},
};

byte rowPins[ROWS] = {16, 17};
byte colPins[COLS] = {23, 25};

Keypad customKeypad = Keypad(makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);
LiquidCrystal_I2C lcd(0x27, 16, 2);

//char btn;
int cntTime;
//int Index;
char gkey; // button input
//int s_ct; //spin revolution
//int x1_ct,x2_ct,y1_ct,y2_ct,z_ct;
// '1' cmd position(x1,y2), 2(x2,y2), 3(x1,y1), 4(x2,y1)
uint32_t x2_ct = 4000;
uint32_t x1_ct = 51000;
uint32_t y1_ct = 35000;
uint32_t y2_ct = 88000;

// z move
int z_ct = 16000;
// s_ct
int s_ct = 5500; //1TURN

const int EenablePin = 24;
const int EstepPin = 26;
const int EdirPin = 28;

const int XenablePin = 38;
const int XstepPin = A0;
const int XdirPin = A1;

const int YenablePin = A2;
const int YstepPin = A6;
const int YdirPin = A7;

const int ZenablePin = A8;
const int ZstepPin = 46;
const int ZdirPin = 48;


void setup() {
  Serial.begin(9600);
  lcd.backlight();
  lcd.init();
  lcd.setCursor(5, 0);
  lcd.print("Select");
  lcd.setCursor(3, 1);
  lcd.print("Your Choice");

  pinMode(EenablePin, OUTPUT);
  pinMode(EstepPin, OUTPUT);
  pinMode(EdirPin, OUTPUT);
  digitalWrite(EenablePin, LOW);

  pinMode(XenablePin, OUTPUT);
  pinMode(XstepPin, OUTPUT);
  pinMode(XdirPin, OUTPUT);
  digitalWrite(XenablePin, LOW);

  pinMode(YenablePin, OUTPUT);
  pinMode(YstepPin, OUTPUT);
  pinMode(YdirPin, OUTPUT);
  digitalWrite(YenablePin, LOW);

  pinMode(ZenablePin, OUTPUT);
  pinMode(ZstepPin, OUTPUT);
  pinMode(ZdirPin, OUTPUT);
  digitalWrite(ZenablePin, LOW);
}

void loop() {
  char gKey = customKeypad.getKey();

  if (gKey) {
    Serial.println(gkey);
    lcd.clear();
    lcd.setCursor(2, 1);
    lcd.print(gKey);
    lcd.setCursor(4, 1);
    lcd.print("Selected");
  }

  switch (gKey) {
    case '1': {
        // going to x1,y2
        pDir(x1_ct, XdirPin, XstepPin);  // 1. x (home)
        pDir(y2_ct, YdirPin, YstepPin);  // 2. y
        pDir(z_ct, ZdirPin, ZstepPin);   // 3. z

        pDir(s_ct, EdirPin, EstepPin);   // 4. spin

        mDir(z_ct, ZdirPin, ZstepPin);   // 5. -z
        mDir(y2_ct, YdirPin, YstepPin);  // 6. -y
        mDir(x1_ct, XdirPin, XstepPin);  // 7. -x (home)
        break;
      }
    case '2': {
        // going to x2,y2
        pDir(x2_ct, XdirPin, XstepPin);  // 1. x (home)
        pDir(y2_ct, YdirPin, YstepPin);  // 2. y
        pDir(z_ct, ZdirPin, ZstepPin);   // 3. z

        pDir(s_ct, EdirPin, EstepPin);   // 4. spin

        mDir(z_ct, ZdirPin, ZstepPin);   // 5. -z
        mDir(y2_ct, YdirPin, YstepPin);  // 6. -y
        mDir(x2_ct, XdirPin, XstepPin);  // 7. -x(home)
        break;
      }
    case '3': {
        // going to x1,y1
        pDir(x1_ct, XdirPin, XstepPin);   // 1. x(home)
        pDir(y1_ct, YdirPin, YstepPin);   // 2. y
        pDir(z_ct, ZdirPin, ZstepPin);    // 3. z

        pDir(s_ct, EdirPin, EstepPin);    // 4. spin

        mDir(z_ct, ZdirPin, ZstepPin);    // 5. -z
        mDir(y1_ct, YdirPin, YstepPin);   // 6. -y
        mDir(x1_ct, XdirPin, XstepPin);   // 7. -x(home)
        break;
      }
    case '4': {
        // going to x1,y2
        pDir(x1_ct, XdirPin, XstepPin);    // 1. x(home)
        pDir(y2_ct, YdirPin, YstepPin);    // 2. y
        pDir(z_ct, ZdirPin, ZstepPin);     // 3. z

        pDir(s_ct, EdirPin, EstepPin);     // 4. spin

        mDir(z_ct, ZdirPin, ZstepPin);     // 5. -z
        mDir(y2_ct, YdirPin, YstepPin);    // 6. -y
        mDir(x1_ct, XdirPin, XstepPin);    // 7. -x(home)
        break;
      }
    default : break;
  }
}

// foward run X-direction, Y-direction
void pDir(uint32_t ct, int p_dir, int p_step) {

  digitalWrite(p_dir, LOW);
  for (uint32_t index = 0; index < ct; index++) //time
  {
    digitalWrite(p_step, HIGH);
    delayMicroseconds(100);
    digitalWrite(p_step, LOW);
    delayMicroseconds(100);
  }
  delay(1000);
} // EOF foward

//backward run X-direction, Y - direction
void mDir(uint32_t ct, int m_dir, int m_step) {
  digitalWrite(m_dir, HIGH);
  for (uint32_t index = 0; index < ct; index++) //time
  {
    digitalWrite(m_step, HIGH);
    delayMicroseconds(100);
    digitalWrite(m_step, LOW);
    delayMicroseconds(100);
  }
  delay(1000);
}