ProSliderV2

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <WiFi.h>
#include <SPIFFS.h>
#include <ESPAsyncWebServer.h>
#include <WebSocketsServer.h>
#include <ArduinoJson.h>

boolean APturnOn = false;
// Constants
const char *APssid = "ProSlider";
const char *APpassword =  "";

const char* ssid = "2.4G-linksys";
const char* password = "adam1989";

const char *msg_toggle_led = "toggleLED";
const char *msg_get_led = "getLEDState";
const int dns_port = 53;
const int http_port = 80;
const int ws_port = 1337;
const int led_pin = 1;

LiquidCrystal_I2C lcd(0x27, 20, 4);
#define I2C_SDA 32
#define I2C_SCL 33

const int dirPinS = 4;  // was 2
const int dirPinP = 16; // was 3
const int dirPinT = 17; // was 4

const int stepPinS = 5; // was 5
const int stepPinP = 18; // was 6
const int stepPinT = 19; // was 7

const int encoderPinA = 25; // was A1
const int encoderPinB = 26; // was A2
const int encoderPinC = 35; // was A3
const int joyYInput = 34; // was A6
const int joyXInput = 39; // was A7
int encoderPinALast = LOW;
int encoderPinACurrent = LOW;
int encoderPinBCurrent = LOW;

// Globals
AsyncWebServer server(80);
WebSocketsServer webSocket = WebSocketsServer(1337);
char msg_buf[10];
int led_state = 0;

unsigned long nextStatRefresh = millis();

long globalSlide = 0;
long globalPan = 0;
long globalTilt = 0;
int globalTime = 15;
long pointAS, pointAP, pointAT, pointBS, pointBP, pointBT;
int moveMode = 0;  // 0 = none, 1 = slide, 2 = pan+tilt
int statsMode = 0; // 0 = none, 1 = show current pos, 2 = show point A pos, 3 = show point B pos, 4 = set time
bool statsDisplayed = false;

bool regenerateLcdRequired = true;
int regenerateLcdMode = 0;
// 0 = whole screen
// 1 = menu items
// 2 = menu arrow
int currentScreen = 0;
// 0 = home
// 10 = stats index
// 11 = show stats - current pos
// 12 = show stats - A point pos
// 13 = show stats - B point pos
// 20 = set point index
// 21 = set point A
// 22 = set point B
// 30 = go to point index
// 31 = going to point a
// 32 = goint to point b
int currentOptionSelected = 0; // LCD's line selected in menu

long microstepsSlide, microstepsPan, microstepsTilt;
long totalTime;
boolean goToPointA = false;
boolean goToPointB = false;
boolean isTransition = false;
long afterMoveGlobalSlide, afterMoveGlobalPan, afterMoveGlobalTilt;
long timeGapSlide, timeGapPan, timeGapTilt;
long nextMoveSlide, nextMovePan, nextMoveTilt;
int joyAppLeftValue, joyAppRightValue;
int joyPanLeftValue, joyPanRightValue, joyTiltUpValue, joyTiltDownValue, joySlideLeftValue, joySlideRightValue;
int lastConnectedClient;
boolean globalTimeWasUpdated, preventTransition;
//...................................................................................
//........SS.........................................................................
//....SSSSSSSSS.....EEEEEEEEEEEEEE.ETTTTTTTTTTTTTT.UUUUU.....UUUUU..PPPPPPPPPPPP.....
//...SSSSSSSSSSSS...EEEEEEEEEEEEEE.ETTTTTTTTTTTTTT.UUUUU.....UUUUU..PPPPPPPPPPPPP....
//..SSSSSSSSSSSSS...EEEEEEEEEEEEEE.ETTTTTTTTTTTTTT.UUUUU.....UUUUU..PPPPPPPPPPPPPP...
//..SSSSSSSSSSSSSS..EEEEEEEEEEEEEE.ETTTTTTTTTTTTTT.UUUUU.....UUUUU..PPPPPPPPPPPPPP...
//..SSSSS....SSSSS..EEEEE...............TTTTT......UUUUU.....UUUUU..PPPPP...PPPPPPP..
//..SSSS.....SSSSS..EEEEE...............TTTTT......UUUUU.....UUUUU..PPPPP.....PPPPP..
//..SSSSSSS.........EEEEE...............TTTTT......UUUUU.....UUUUU..PPPPP.....PPPPP..
//..SSSSSSSSSS......EEEEEEEEEEEEE.......TTTTT......UUUUU.....UUUUU..PPPPP....PPPPPP..
//..SSSSSSSSSSSSS...EEEEEEEEEEEEE.......TTTTT......UUUUU.....UUUUU..PPPPPPPPPPPPPP...
//...SSSSSSSSSSSSS..EEEEEEEEEEEEE.......TTTTT......UUUUU.....UUUUU..PPPPPPPPPPPPPP...
//.....SSSSSSSSSSS..EEEEEEEEEEEEE.......TTTTT......UUUUU.....UUUUU..PPPPPPPPPPPPPP...
//.........SSSSSSSS.EEEEE...............TTTTT......UUUUU.....UUUUU..PPPPPPPPPPPP.....
//.SSSSS.....SSSSSS.EEEEE...............TTTTT......UUUUU.....UUUUU..PPPPP............
//.SSSSSS.....SSSSS.EEEEE...............TTTTT......UUUUUU....UUUUU..PPPPP............
//..SSSSSS..SSSSSSS.EEEEEEEEEEEEEEE.....TTTTT......UUUUUUU.UUUUUUU..PPPPP............
//..SSSSSSSSSSSSSS..EEEEEEEEEEEEEEE.....TTTTT.......UUUUUUUUUUUUU...PPPPP............
//...SSSSSSSSSSSSS..EEEEEEEEEEEEEEE.....TTTTT.......UUUUUUUUUUUUU...PPPPP............
//....SSSSSSSSSSS...EEEEEEEEEEEEEEE.....TTTTT........UUUUUUUUUUU....PPPPP............
//......SSSSSSS.........................................UUUUU........................
//...................................................................................

void setup() {
  WiFi.mode(WIFI_STA);

  // DynamicJsonDocument doc(2048);

  // Init LED and turn off
  pinMode(led_pin, OUTPUT);
  digitalWrite(led_pin, LOW);

  // Start Serial port
  Serial.begin(115200);

  pinMode(dirPinS,OUTPUT);
  pinMode(dirPinP,OUTPUT);
  pinMode(dirPinT,OUTPUT);

  pinMode(stepPinS,OUTPUT);
  pinMode(stepPinP,OUTPUT);
  pinMode(stepPinT,OUTPUT);

  pinMode(encoderPinA, INPUT); // was A1
  pinMode(encoderPinB, INPUT); // was A2
  pinMode(encoderPinC, INPUT); // was A3
  pinMode(12, INPUT); // was A6
  pinMode(14, INPUT); // was A7

  Wire.begin(I2C_SDA,I2C_SCL);

  lcd.init();
  lcd.backlight();
  lcd.setCursor(0,0);
  lcd.print("--------------------");
  lcd.setCursor(0,1);
  lcd.print("|    PRO SLIDER    |");
  lcd.setCursor(0,2);
  lcd.print("| 3 axis movement  |");
  lcd.setCursor(0,3);
  lcd.print("--------------------");
  delay(1500);
  lcd.clear();


  // Make sure we can read the file system
  if( !SPIFFS.begin()){
    Serial.println("Error mounting SPIFFS");
    while(1);
  }
 if(APturnOn) {
  // Start access point
  WiFi.softAP(APssid, APpassword);
  // Print our IP address
  Serial.println();
  Serial.println("AP running");
  Serial.print("My IP address: ");
  Serial.println(WiFi.softAPIP());
 } else {
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  while(WiFi.waitForConnectResult() != WL_CONNECTED) {
    Serial.print(".");
    delay(500);
  }
  Serial.println("");
  Serial.print("Connected to ");
  Serial.println(ssid);
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
 }

  server.on("/", HTTP_GET, onIndexRequest);
  server.on("/style.css", HTTP_GET, onCSSRequest);
  server.on("/script.js", HTTP_GET, onJSRequest);
  server.on("/joy.js", HTTP_GET, onJSJoyRequest);
  server.onNotFound(onPageNotFound);
  server.begin();

  // Start WebSocket server and assign callback
  webSocket.begin();
  webSocket.onEvent(onWebSocketEvent);

}

int getJoyValue(long value, bool direction) {
  // if direction == 0, analyse lower half of values (eg. left, bottom),
  // if direction == 1, analyse higher half of values (eg right, top)

  if(value >= 2000 && direction == 1) {
    return map(value, 2000, 4096, 0, 100);
  } else if(value <= 1500 && direction == 0) {
    return map(value, 1500, 0, 0, 100);
  } else {
    return 0;
  }
}

//......................................................................
//.......................OO.................OO..........................
//.LLLLL..............OOOOOOOOO.........OOOOOOOOO......PPPPPPPPPPPP.....
//.LLLLL............OOOOOOOOOOOO......OOOOOOOOOOOOO....PPPPPPPPPPPPP....
//.LLLLL...........OOOOOOOOOOOOOO.....OOOOOOOOOOOOOO...PPPPPPPPPPPPPP...
//.LLLLL...........OOOOOOOOOOOOOOO...OOOOOOOOOOOOOOO...PPPPPPPPPPPPPP...
//.LLLLL..........OOOOOO....OOOOOO...OOOOOO....OOOOOO..PPPPP...PPPPPPP..
//.LLLLL..........OOOOO......OOOOOO.OOOOOO......OOOOO..PPPPP.....PPPPP..
//.LLLLL..........OOOOO.......OOOOO.OOOOO.......OOOOO..PPPPP.....PPPPP..
//.LLLLL.........LOOOO........OOOOO.OOOOO.......OOOOO..PPPPP....PPPPPP..
//.LLLLL.........LOOOO........OOOOO.OOOOO........OOOOO.PPPPPPPPPPPPPP...
//.LLLLL.........LOOOO........OOOOO.OOOOO........OOOOO.PPPPPPPPPPPPPP...
//.LLLLL.........LOOOO........OOOOO.OOOOO........OOOOO.PPPPPPPPPPPPPP...
//.LLLLL..........OOOOO.......OOOOO.OOOOO.......OOOOO..PPPPPPPPPPPP.....
//.LLLLL..........OOOOO......OOOOOO.OOOOOO......OOOOO..PPPPP............
//.LLLLL..........OOOOOO.....OOOOOO.OOOOOO.....OOOOOO..PPPPP............
//.LLLLLLLLLLLLLL.OOOOOOOOOOOOOOOO...OOOOOOO.OOOOOOOO..PPPPP............
//.LLLLLLLLLLLLLL..OOOOOOOOOOOOOO.....OOOOOOOOOOOOOO...PPPPP............
//.LLLLLLLLLLLLLL...OOOOOOOOOOOOO.....OOOOOOOOOOOOO....PPPPP............
//.LLLLLLLLLLLLLL....OOOOOOOOOOO.......OOOOOOOOOOO.....PPPPP............
//.....................OOOOOOO...........OOOOOOO........................
//......................................................................

void loop() {
  webSocket.loop();
  if (goToPointA) {
    goToPoint(0);
  } else if (goToPointB) {
    goToPoint(1);
  }

  long joyY = analogRead(joyYInput); // was 6
  long joyX = analogRead(joyXInput); // was 7

   // bool values - flags if button, encoder of joystick was used
  bool button = analogRead(encoderPinC) < 50;
  bool encLeft = false;
  bool encRight = false;
  bool joyLeft = joyX < 1710;
  bool joyRight = joyX > 1910;
  bool joyUp = joyY > 1910;
  bool joyDown = joyY < 1710;

   // int values for joystick input - from 0 to 100 for each direction
  int joyLeftValue, joyRightValue, joyUpValue, joyDownValue;
  joyUpValue = getJoyValue(joyY, 0);
  joyDownValue = getJoyValue(joyY, 1);

  if (joyAppLeftValue > 0) {
    joyLeftValue = joyAppLeftValue;
  } else {
    joyLeftValue = getJoyValue(joyX, 1);
  }

  if (joyAppRightValue > 0) {
    joyRightValue = joyAppRightValue;
  } else {
    joyRightValue = getJoyValue(joyX, 0);
  }

  // handling of encoder rotations
  encoderPinACurrent = digitalRead(encoderPinA);
  encoderPinBCurrent = digitalRead(encoderPinB);
  if (encoderPinALast != encoderPinACurrent && encoderPinACurrent == LOW) {
    if (encoderPinBCurrent != encoderPinACurrent) {
      encRight = true;
    } else {
      encLeft = true;
    }
  }
  encoderPinALast = encoderPinACurrent;

  // if LCD refreshing was requested, proceed
  if(regenerateLcdRequired) {
    regenerateLcd();
  }

  // if button or encoder was used, handle click or menu option change
  if(button || encLeft || encRight) {
    // exclude few screens from encoder move (arrow up/down) handler
    bool disableEncoder;
    if(
      currentScreen == 11 ||  // show current pos. screen
      currentScreen == 12 ||  // show point A pos. screen
      currentScreen == 13 ||  // show point B pos. screen
      currentScreen == 40 ||  // set time screen
      currentScreen == 210 || // set slide of A screen
      currentScreen == 211 || // set pan/tilt of A screen
      currentScreen == 220 || // set slide of B screen
      currentScreen == 221    // set pan/tilt of B screen
    ) {
      disableEncoder = true;
    } else {
      disableEncoder = false;
    }
    if(button) {
      handleEnterClick();
      delay(400); // anti double-click
    } else if (encLeft && !disableEncoder) {
      if (currentOptionSelected > 0) {
        currentOptionSelected--;
        regenerateLcdRequired = true;
        regenerateLcdMode = 2;
      }
    } else if (encRight && !disableEncoder) {
      if (currentOptionSelected < 3) {
        currentOptionSelected++;
        regenerateLcdRequired = true;
        regenerateLcdMode = 2;
      }
    } else if(statsMode = 4) {
     //handle encoder move for setting movement time
    if (encLeft && globalTime > 5) {
      globalTime--;
      updateTimeInput();
    } else if(encRight && globalTime < 600) {
        globalTime++;
        updateTimeInput();
      }
      statsDisplayed = false; // set to let stats screen render again with new time
    }
  }

  // if manual move flag is set and joystick is in sure, proceed with movement
  if(moveMode > 0) {
    if (
      (moveMode == 1 && (joyLeftValue > 0 || joyRightValue > 0)) ||
      (moveMode == 2 && (joyLeftValue > 0 || joyRightValue > 0 || joyUpValue > 0 || joyDownValue > 0))
    ) {
        handleManualMove(joyLeftValue, joyRightValue, joyUpValue, joyDownValue);
    } else if (
      (moveMode == 3 && (joyPanLeftValue > 0 || joyPanRightValue > 0 || joyTiltUpValue > 0 || joyTiltDownValue > 0 || joySlideLeftValue > 0 || joySlideRightValue > 0))
    ) {
      appHandleManualMove(joyPanLeftValue, joyPanRightValue, joyTiltUpValue, joyTiltDownValue, joySlideLeftValue, joySlideRightValue);
    } else if (nextStatRefresh < millis()) {
      lcd.setCursor(0,1);
      lcd.print("Slide " + String(globalSlide) + "     ");
      lcd.setCursor(0,2);
      lcd.print("Pan   " + String(globalPan) + "     ");
      lcd.setCursor(0,3);
      lcd.print("Tilt  " + String(globalTilt) + "     ");
      nextStatRefresh = millis() + 300;
    }
  }

  if(statsMode > 0 && !statsDisplayed) {
    lcd.clear();
    if(statsMode == 1) {
      lcd.setCursor(0,0);
      lcd.print("Current position");
      lcd.setCursor(0,1);
      lcd.print("Slide " + String(globalSlide));
      lcd.setCursor(0,2);
      lcd.print("Pan   " + String(globalPan));
      lcd.setCursor(0,3);
      lcd.print("Tilt  " + String(globalTilt));
    } else if(statsMode == 2) {
      lcd.setCursor(0,0);
      lcd.print("Point A position");
      lcd.setCursor(0,1);
      lcd.print("Slide " + String(pointAS));
      lcd.setCursor(0,2);
      lcd.print("Pan   " + String(pointAP));
      lcd.setCursor(0,3);
      lcd.print("Tilt  " + String(pointAT));
    } else if(statsMode == 3) {
      lcd.setCursor(0,0);
      lcd.print("Point B position");
      lcd.setCursor(0,1);
      lcd.print("Slide " + String(pointBS));
      lcd.setCursor(0,2);
      lcd.print("Pan   " + String(pointBP));
      lcd.setCursor(0,3);
      lcd.print("Tilt  " + String(pointBT));
    } else if(statsMode == 4) {
      lcd.setCursor(0,0);
      lcd.print("Set movement time");
      lcd.setCursor(0,1);
      lcd.print(String(globalTime) + " s.");
    }
    statsDisplayed = true; // set true so it won't be rendered again in next loop iterations
  }
}

//....................................................................
//.FFFFFFFFFFFFFF.UUUUU.....UUUUU..NNNNN......NNNN......CCCCCCCCC.....
//.FFFFFFFFFFFFFF.UUUUU.....UUUUU..NNNNNN.....NNNN.....CCCCCCCCCCC....
//.FFFFFFFFFFFFFF.UUUUU.....UUUUU..NNNNNNN....NNNN....CCCCCCCCCCCCC...
//.FFFFFFFFFFFFFF.UUUUU.....UUUUU..NNNNNNN....NNNN...CCCCCCCCCCCCCCC..
//.FFFFF..........UUUUU.....UUUUU..NNNNNNNN...NNNN..NCCCCCC...CCCCCC..
//.FFFFF..........UUUUU.....UUUUU..NNNNNNNN...NNNN..NCCCCC.....CCCCC..
//.FFFFF..........UUUUU.....UUUUU..NNNNNNNNN..NNNN..NCCCC......CCCCC..
//.FFFFFFFFFFFFF..UUUUU.....UUUUU..NNNNNNNNN..NNNN..NCCCC.............
//.FFFFFFFFFFFFF..UUUUU.....UUUUU..NNNNNNNNNN.NNNN..NCCCC.............
//.FFFFFFFFFFFFF..UUUUU.....UUUUU..NNNNNNNNNNNNNNN..NCCCC.............
//.FFFFFFFFFFFFF..UUUUU.....UUUUU..NNNNN.NNNNNNNNN..NCCCC.............
//.FFFFF..........UUUUU.....UUUUU..NNNNN..NNNNNNNN..NCCCC......CCCCC..
//.FFFFF..........UUUUU.....UUUUU..NNNNN..NNNNNNNN..NCCCC......CCCCC..
//.FFFFF..........UUUUUU....UUUUU..NNNNN...NNNNNNN..NCCCCC....CCCCCC..
//.FFFFF..........UUUUUUU.UUUUUUU..NNNNN...NNNNNNN...CCCCCCCCCCCCCCC..
//.FFFFF...........UUUUUUUUUUUUU...NNNNN....NNNNNN...CCCCCCCCCCCCCC...
//.FFFFF...........UUUUUUUUUUUUU...NNNNN....NNNNNN....CCCCCCCCCCCC....
//.FFFFF............UUUUUUUUUUU....NNNNN.....NNNNN.....CCCCCCCCCC.....
//.....................UUUUU.............................CCCCCCC......
//....................................................................

void updateTimeInput() {
  StaticJsonDocument<200> req;
  String reqMsg;
  req["time"] = globalTime;
  serializeJson(req, reqMsg);
  webSocket.sendTXT(lastConnectedClient, reqMsg);
}

void updatePoints(String point) {
  StaticJsonDocument<200> req;
  String reqMsg;
  req["action"] = "updatePoints";
  req["point"] = point;
  if (point == "A") {
    req["slide"] = pointAS;
    req["pan"] = pointAP;
    req["tilt"] = pointAT;
  } else {
    req["slide"] = pointBS;
    req["pan"] = pointBP;
    req["tilt"] = pointBT;
  }
  serializeJson(req, reqMsg);
  webSocket.sendTXT(lastConnectedClient, reqMsg);
}

void updateCurrentPosition() {
  StaticJsonDocument<200> req;
  String reqMsg;
  req["action"] = "updateCurrentPosition";
  req["slide"] = globalSlide;
  req["pan"] = globalPan;
  req["tilt"] = globalTilt;
  serializeJson(req, reqMsg);
  webSocket.sendTXT(lastConnectedClient, reqMsg);
}

void debugger(String text) {
  StaticJsonDocument<200> req;
  String reqMsg;
  req["debuggerMsg"] = text;
  serializeJson(req, reqMsg);
  webSocket.sendTXT(lastConnectedClient, reqMsg);
}

void setPointA() {
  pointAS = globalSlide;
  pointAP = globalPan;
  pointAT = globalTilt;
  updatePoints("A");
}

void setPointB() {
  pointBS = globalSlide;
  pointBP = globalPan;
  pointBT = globalTilt;
  updatePoints("B");
}

void goToPoint(bool point) {
  if (isTransition == false) {
    if (point == 0) {
      microstepsSlide = globalSlide - pointAS;
      microstepsPan = globalPan - pointAP;
      microstepsTilt = globalTilt - pointAT;
      afterMoveGlobalSlide = pointAS;
      afterMoveGlobalPan = pointAP;
      afterMoveGlobalTilt = pointAT;

      if(pointAS < globalSlide) {
        digitalWrite(dirPinS, LOW);
      } else {
        digitalWrite(dirPinS, HIGH);
      }
      if(pointAP < globalPan) {
        digitalWrite(dirPinP, LOW);
      } else {
        digitalWrite(dirPinP, HIGH);
      }
      if(pointAT < globalTilt) {
        digitalWrite(dirPinT, LOW);
      } else {
        digitalWrite(dirPinT, HIGH);
      }

    } else if (point == 1) {
      microstepsSlide = globalSlide - pointBS;
      microstepsPan = globalPan - pointBP;
      microstepsTilt = globalTilt - pointBT;
      afterMoveGlobalSlide = pointBS;
      afterMoveGlobalPan = pointBP;
      afterMoveGlobalTilt = pointBT;
      if(pointBS < globalSlide) {
        digitalWrite(dirPinS, LOW);
      } else {
        digitalWrite(dirPinS, HIGH);
      }
      if(pointBP < globalPan) {
        digitalWrite(dirPinP, LOW);
      } else {
        digitalWrite(dirPinP, HIGH);
      }
      if(pointBT < globalTilt) {
        digitalWrite(dirPinT, LOW);
      } else {
        digitalWrite(dirPinT, HIGH);
      }
    }

    totalTime = globalTime * 1000000;

    microstepsSlide = abs(microstepsSlide);
    microstepsPan = abs(microstepsPan);
    microstepsTilt = abs(microstepsTilt);

    if (microstepsSlide > 0) {
      timeGapSlide = totalTime / microstepsSlide;
    }
    if (microstepsPan > 0) {
      timeGapPan = totalTime / microstepsPan;
    }
    if (microstepsTilt > 0) {
      timeGapTilt = totalTime / microstepsTilt;
    }

    // 2s to start moving.....
    delay(2000);

    nextMoveSlide = micros();
    nextMovePan = micros();
    nextMoveTilt = micros();
  }
  if (
    (microstepsSlide > 0 ||
    microstepsPan > 0 ||
    microstepsTilt > 0) &&
    !preventTransition
  ) {
    bool doSlideMove = 0;
    bool doPanMove = 0;
    bool doTiltMove = 0;
    isTransition = true;

    if (microstepsSlide > 0) {
      if (nextMoveSlide < micros()) {
        doSlideMove = 1;
        microstepsSlide = microstepsSlide - 1;
        nextMoveSlide = nextMoveSlide + timeGapSlide;

        if (goToPointA) {
          if (pointAS < globalSlide) {
            globalSlide--;
          } else {
            globalSlide++;
          }
        } else {
          if (pointBS < globalSlide) {
            globalSlide--;
          }
          else {
            globalSlide++;
          }
        }
      }
    }

    if (microstepsPan > 0) {
      if (nextMovePan < micros()) {
        doPanMove = 1;
        microstepsPan = microstepsPan - 1;
        nextMovePan = nextMovePan + timeGapPan;

        if (goToPointA) {
          if (pointAP < globalPan) {
            globalPan--;
          } else {
            globalPan++;
          }
        } else {
          if (pointBP < globalPan) {
            globalPan--;
          }
          else {
            globalPan++;
          }
        }
      }
    }

    if (microstepsTilt > 0) {
      if (nextMoveTilt < micros()) {
        doTiltMove = 1;
        microstepsTilt = microstepsTilt - 1;
        nextMoveTilt = nextMoveTilt + timeGapTilt;

        if (goToPointA) {
          if (pointAT < globalTilt) {
            globalTilt--;
          } else {
            globalTilt++;
          }
        } else {
          if (pointBT < globalTilt) {
            globalTilt--;
          }
          else {
            globalTilt++;
          }
        }
      }
    }

    if(doSlideMove) { digitalWrite(stepPinS, HIGH); }
    if(doPanMove) { digitalWrite(stepPinP, HIGH); }
    if(doTiltMove) { digitalWrite(stepPinT, HIGH); }

    if(doSlideMove) { digitalWrite(stepPinS, LOW); }
    if(doPanMove) { digitalWrite(stepPinP, LOW); }
    if(doTiltMove) { digitalWrite(stepPinT, LOW); }

  } else {
    // Move FINISHED!
    goToPointA = false;
    goToPointB = false;
    isTransition = false;
    preventTransition = false;
    updateCurrentPosition();
  }
}

void regenerateLcd() {
  if(regenerateLcdMode == 0) {
    currentOptionSelected = 0;
    lcd.clear();
    regenerateLcdMenuItems();
    regenerateLcdMenuArrow();
  } else if(regenerateLcdMode == 1) {
    regenerateLcdMenuItems();
  } else if(regenerateLcdMode == 2) {
    regenerateLcdMenuArrow();
  }
  regenerateLcdRequired = false;
}

void regenerateLcdMenuItems() {
  if(currentScreen == 0) {
    char menuOptions[4][18] = {
      "Show current data",
      "Set target points",
      "Go to point",
      "Set Time"
    };
    drawMenuOptions(menuOptions);
  } else if(currentScreen == 10) {
    char menuOptions[4][18] = {
      "Show current pos.",
      "Show point A pos.",
      "Show point B pos.",
      "Return"
    };
    drawMenuOptions(menuOptions);
  } else if(currentScreen == 20) {
    char menuOptions[4][18] = {
      "Set point A",
      "Set point B",
      "",
      "Return"
    };
    drawMenuOptions(menuOptions);
  } else if(currentScreen == 21) {
    char menuOptions[4][18] = {
      "Set SLIDE of A",
      "Set PAN/TILT of A",
      "",
      "Save"
    };
    drawMenuOptions(menuOptions);
  } else if(currentScreen == 210) {
    lcd.clear();
    lcd.setCursor(1,0);
    lcd.print("Set SLIDE of A");
  } else if(currentScreen == 211) {
    lcd.clear();
    lcd.setCursor(1,0);
    lcd.print("Set PAN/TILT of A");
  } else if(currentScreen == 22) {
    char menuOptions[4][18] = {
      "Set SLIDE of B",
      "Set PAN/TILT of B",
      "",
      "Save"
    };
    drawMenuOptions(menuOptions);
  } else if(currentScreen == 220) {
    lcd.clear();
    lcd.setCursor(1,0);
    lcd.print("Set SLIDE of B");
  } else if(currentScreen == 221) {
    lcd.clear();
    lcd.setCursor(1,0);
    lcd.print("Set PAN/TILT of B");
  } else if(currentScreen == 30) {
    char menuOptions[4][18] = {
      "Go to point A",
      "Go to point B",
      "",
      "Return"
    };
    drawMenuOptions(menuOptions);
  } else if(
    currentScreen == 11 ||
    currentScreen == 12 ||
    currentScreen == 13 ||
    currentScreen == 14 ||
    currentScreen == 40
  ) {
    // no handling here, but empty handler needed to not redrawing menu options (instruction below)
  } else {
    char menuOptions[4][18] = { "", "", "", ""};
    drawMenuOptions(menuOptions);
  }
}

void regenerateLcdMenuArrow() {
  for(int i=0; i<=3; i++) {
    lcd.setCursor(0, i);
    if(i == currentOptionSelected) {
      lcd.print(">");
    } else {
      lcd.print(" ");
    }
  }
}

void drawMenuOptions(char lines[4][18]) {
  for (int i=0; i<=3; i++) {
    lcd.setCursor(2,i);
    lcd.print(String(lines[i]));
  }
}

void handleEnterClick() {
  regenerateLcdMode = 0; // just in case if regenerate LCD will be requested
  if(currentScreen == 0) {
    // home screen links:
    if(currentOptionSelected == 0) {
      currentScreen = 10;
      regenerateLcdRequired = true;
    } else if(currentOptionSelected == 1) {
      currentScreen = 20;
      regenerateLcdRequired = true;
    } else if(currentOptionSelected == 2) {
      currentScreen = 30;
      regenerateLcdRequired = true;
    } else if(currentOptionSelected == 3) {
      currentScreen = 40;
      statsMode = 4;
      statsDisplayed = false;
    }
  } else if(currentScreen == 10) {
    // stats index screen
    if(currentOptionSelected == 0) {
      currentScreen = 11;
      statsMode = 1;
      statsDisplayed = false;
    } else if(currentOptionSelected == 1) {
      currentScreen = 12;
      statsMode = 2;
      statsDisplayed = false;
    } else if(currentOptionSelected == 2) {
      currentScreen = 13;
      statsMode = 3;
      statsDisplayed = false;
    } else if(currentOptionSelected == 3) {
      currentScreen = 0;
      regenerateLcdRequired = true;
    }
  } else if(currentScreen == 11) {
    currentScreen = 10;
    statsMode = 0;
    regenerateLcdRequired = true;
  } else if(currentScreen == 12) {
    currentScreen = 10;
    statsMode = 0;
    regenerateLcdRequired = true;
  } else if(currentScreen == 13) {
    currentScreen = 10;
    statsMode = 0;
    regenerateLcdRequired = true;
  } else if(currentScreen == 20) {
    // set point index screen
    if(currentOptionSelected == 0) {
      currentScreen = 21;
      regenerateLcdRequired = true;
    } else if(currentOptionSelected == 1) {
      currentScreen = 22;
      regenerateLcdRequired = true;
    } else if(currentOptionSelected == 3) {
      currentScreen = 0;
      regenerateLcdRequired = true;
    }
  } else if(currentScreen == 21) {
    // set point A screen
    if(currentOptionSelected == 0) {
      currentScreen = 210;
      moveMode = 1;
      regenerateLcdRequired = true;
    } else if(currentOptionSelected == 1) {
      currentScreen = 211;
      moveMode = 2;
      regenerateLcdRequired = true;
    } else if(currentOptionSelected == 3) {
      currentScreen = 20;
      setPointA();
      regenerateLcdRequired = true;
    }
  } else if(currentScreen == 210) {
    moveMode = 0;
    currentScreen = 21;
    regenerateLcdRequired = true;
  } else if(currentScreen == 211) {
    moveMode = 0;
    currentScreen = 21;
    regenerateLcdRequired = true;
  } else if(currentScreen == 22) {
    // set point B screen
    if(currentOptionSelected == 0) {
      currentScreen = 220;
      moveMode = 1;
      regenerateLcdRequired = true;
    } else if(currentOptionSelected == 1) {
      currentScreen = 221;
      moveMode = 2;
      regenerateLcdRequired = true;
    } else if(currentOptionSelected == 3) {
      setPointB();
      currentScreen = 20;
      regenerateLcdRequired = true;
    }
  } else if(currentScreen == 220) {
    moveMode = 0;
    currentScreen = 22;
    regenerateLcdRequired = true;
  } else if(currentScreen == 221) {
    moveMode = 0;
    currentScreen = 22;
    regenerateLcdRequired = true;
  } else if(currentScreen == 30) {
    // go to point index screen
    if(currentOptionSelected == 0) {
      goToPointA = true;
    } else if(currentOptionSelected == 1) {
      goToPointB = true;
    } else if(currentOptionSelected == 3) {
      currentScreen = 0;
      regenerateLcdRequired = true;
    }
  } else if(currentScreen == 40) {
    currentScreen = 0;
    regenerateLcdRequired = true;
  }
}

void handleManualMove(int joyLeftValue, int joyRightValue, int joyUpValue, int joyDownValue) {
  bool doSlideMove = false;
  bool doPanMove = false;
  bool doTiltMove = false;
  long timeGapSlide = 0;
  long timeGapPan = 0;
  long timeGapTilt = 0;
  bool dirS, dirP, dirT;
  bool slideMoveSet = false;
  bool panMoveSet = false;
  bool tiltMoveSet = false;

  if(moveMode == 1 && (joyLeftValue || joyRightValue) ) {
    if(joyLeftValue > 0) {
      digitalWrite(dirPinS, HIGH);
      dirS = 1;
      slideMoveSet = true;
      timeGapSlide = map(joyLeftValue, 0, 100, 2000, 40);
    } else {
      digitalWrite(dirPinS, LOW);
      dirS = 0;
      slideMoveSet = true;
      timeGapSlide = map(joyRightValue, 0, 100, 2000, 40);
    }
    if (slideMoveSet && nextMoveSlide < micros()) {
      doSlideMove = 1;
      nextMoveSlide = micros() + timeGapSlide;
    }
  } else if(moveMode == 2) {
    if(joyLeftValue > 0) {
      digitalWrite(dirPinP, HIGH);
      dirP = 1;
      panMoveSet = true;
      timeGapPan = map(joyLeftValue, 0, 100, 10000, 3000);
    } else if(joyRightValue > 0) {
      digitalWrite(dirPinP, LOW);
      dirP = 0;
      panMoveSet = true;
      timeGapPan = map(joyRightValue, 0, 100, 10000, 3000);
    }
    if(joyUpValue > 0) {
      digitalWrite(dirPinT, HIGH);
      dirT = 1;
      tiltMoveSet = true;
      timeGapTilt = map(joyUpValue, 0, 100, 10000, 3000);
    } else if(joyDownValue > 0) {
      digitalWrite(dirPinT, LOW);
      dirT = 0;
      tiltMoveSet = true;
      timeGapTilt = map(joyDownValue, 0, 100, 10000, 3000);
    }
    if (panMoveSet && nextMovePan < micros()) {
      doPanMove = 1;
      nextMovePan = micros() + timeGapPan;
    }
    if (tiltMoveSet && nextMoveTilt < micros()) {
      doTiltMove = 1;
      nextMoveTilt = micros() + timeGapTilt;
    }
  }

  if(doSlideMove) { digitalWrite(stepPinS, HIGH); }
  if(doPanMove) { digitalWrite(stepPinP, HIGH); }
  if(doTiltMove) { digitalWrite(stepPinT, HIGH); }

  if(doSlideMove) {
    digitalWrite(stepPinS, LOW);
    if(dirS) {
      globalSlide++;
    } else {
      globalSlide--;
    }
  }
  if(doPanMove) {
    digitalWrite(stepPinP, LOW);
    if(dirP) {
      globalPan++;
    } else {
      globalPan--;
    }
  }
  if(doTiltMove) {
    digitalWrite(stepPinT, LOW);
    if(dirT) {
      globalTilt++;
    } else {
      globalTilt--;
    }
  }
}

void appHandleManualMove(int joyPanLeftValue, int joyPanRightValue, int joyTiltUpValue, int joyTiltDownValue, int joySlideLeftValue, int joySlideRightValue) {
  bool doSlideMove = false;
  bool doPanMove = false;
  bool doTiltMove = false;
  long timeGapSlide = 0;
  long timeGapPan = 0;
  long timeGapTilt = 0;
  bool dirS, dirP, dirT;
  bool slideMoveSet = false;
  bool panMoveSet = false;
  bool tiltMoveSet = false;

  if(joyPanLeftValue > 0) {
    digitalWrite(dirPinP, HIGH);
    dirP = 1;
    panMoveSet = true;
    timeGapPan = map(joyPanLeftValue, 0, 100, 10000, 3000);
  } else if(joyPanRightValue > 0) {
    digitalWrite(dirPinP, LOW);
    dirP = 0;
    panMoveSet = true;
    timeGapPan = map(joyPanRightValue, 0, 100, 10000, 3000);
  }
  if(joyTiltUpValue > 0) {
    digitalWrite(dirPinT, HIGH);
    dirT = 1;
    tiltMoveSet = true;
    timeGapTilt = map(joyTiltUpValue, 0, 100, 10000, 3000);
  } else if(joyTiltDownValue > 0) {
    digitalWrite(dirPinT, LOW);
    dirT = 0;
    tiltMoveSet = true;
    timeGapTilt = map(joyTiltDownValue, 0, 100, 10000, 3000);
  }
  if (panMoveSet && nextMovePan < micros()) {
    doPanMove = 1;
    nextMovePan = micros() + timeGapPan;
  }
  if (tiltMoveSet && nextMoveTilt < micros()) {
    doTiltMove = 1;
    nextMoveTilt = micros() + timeGapTilt;
  }
  if(joySlideLeftValue > 0) {
    digitalWrite(dirPinS, HIGH);
    dirS = 1;
    slideMoveSet = true;
    timeGapSlide = map(joySlideLeftValue, 0, 100, 2000, 40);
  } else if (joySlideRightValue > 0) {
    digitalWrite(dirPinS, LOW);
    dirS = 0;
    slideMoveSet = true;
    timeGapSlide = map(joySlideRightValue, 0, 100, 2000, 40);
  }
  if (slideMoveSet && nextMoveSlide < micros()) {
    doSlideMove = 1;
    nextMoveSlide = micros() + timeGapSlide;
  }
  if(doSlideMove) { digitalWrite(stepPinS, HIGH); }
  if(doPanMove) { digitalWrite(stepPinP, HIGH); }
  if(doTiltMove) { digitalWrite(stepPinT, HIGH); }

  if(doSlideMove) {
    digitalWrite(stepPinS, LOW);
    if(dirS) {
      globalSlide++;
    } else {
      globalSlide--;
    }
  }
  if(doPanMove) {
    digitalWrite(stepPinP, LOW);
    if(dirP) {
      globalPan++;
    } else {
      globalPan--;
    }
  }
  if(doTiltMove) {
    digitalWrite(stepPinT, LOW);
    if(dirT) {
      globalTilt++;
    } else {
      globalTilt--;
    }
  }
}

boolean compareJson(const char* property,  const char* value) {
  return property && (strcmp(property, value) == 0);
}
//....................................................
//.WWWWW....WWWWW....WWWWWiiiii..FFFFFFFFFFFFFF.iiii..
//.WWWWW....WWWWW....WWWWWiiiii..FFFFFFFFFFFFFF.iiii..
//.WWWWW...WWWWWW...WWWWWWiiiii..FFFFFFFFFFFFFF.iiii..
//.WWWWWW..WWWWWWW..WWWWW.iiiii..FFFFFFFFFFFFFF.iiii..
//..WWWWW..WWWWWWW..WWWWW..iiii..FFFFF..........iiii..
//..WWWWW..WWWWWWW..WWWWW.iiiii..FFFFF..........iiii..
//..WWWWW..WWWWWWW..WWWW..iiiii..FFFFF..........iiii..
//...WWWWWWWWWWWWW.WWWWW..iiiii..FFFFFFFFFFFFF..iiii..
//...WWWWWWWWWWWWWWWWWWW..iiiii..FFFFFFFFFFFFF..iiii..
//...WWWWWWWWW.WWWWWWWWW..iiiii..FFFFFFFFFFFFF..iiii..
//...WWWWWWWWW.WWWWWWWW...iiiii..FFFFFFFFFFFFF..iiii..
//....WWWWWWWW.WWWWWWWW...iiiii..FFFFF..........iiii..
//....WWWWWWW..WWWWWWWW...iiiii..FFFFF..........iiii..
//....WWWWWWW..WWWWWWW....iiiii..FFFFF..........iiii..
//.....WWWWWW...WWWWWW....iiiii..FFFFF..........iiii..
//.....WWWWWW...WWWWWW....iiiii..FFFFF..........iiii..
//.....WWWWWW...WWWWWW....iiiii..FFFFF..........iiii..
//.....WWWWW....WWWWW.....iiiii..FFFFF..........iiii..
//....................................................

void onWebSocketEvent(
  uint8_t client_num,
  WStype_t type,
  uint8_t * payload,
  size_t length) {


  if (type == WStype_DISCONNECTED) {
    Serial.printf("[%u] Disconnected!\n", client_num);
  }

  if (type == WStype_CONNECTED) {
    IPAddress ip = webSocket.remoteIP(client_num);
    Serial.printf("[%u] Connection from ", client_num);
    Serial.println(ip.toString());
    lastConnectedClient = client_num;

    updatePoints("A");
    updatePoints("B");
    updateCurrentPosition();
    updateTimeInput();
  }

  if (type == WStype_TEXT) {
    // Serial.printf("[%u] Received text: %s\n", client_num, (char*)payload);

    StaticJsonDocument<200> res;
    DeserializationError error = deserializeJson(res, (char*)payload);

    // if (error) {
    //   Serial.print(F("deserializeJson() failed: "));
    //   Serial.println(error.f_str());
    //   return;
    // }

    if (compareJson(res["transitionTo"], "setPointAView")) {
      currentScreen = 210;
      moveMode = 3;
      statsMode = 4;
      regenerateLcdRequired = true;
    }

    if (compareJson(res["transitionTo"], "setPointBView")) {
      currentScreen = 220;
      moveMode = 3;
      statsMode = 4;
      regenerateLcdRequired = true;
    }

    if (compareJson(res["transitionTo"], "mainPageView")) {
      currentScreen = 0;
      moveMode = 0;
      regenerateLcdRequired = true;
    }

    if (compareJson(res["action"], "savePositionA")) {
      setPointA();
    }

    if (compareJson(res["action"], "savePositionB")) {
      setPointB();
    }

    if (compareJson(res["action"], "goToPointA")) {
      goToPointA = true;
    }

    if (compareJson(res["action"], "goToPointB")) {
      goToPointB = true;
    }

    if (res["time"]) {
      statsMode = 4;
      statsDisplayed = false;
      globalTime = res["time"];
    }

    if (compareJson(res["action"], "movementAxis")) {

      if (strcmp(res["slide"]["direction"], "left") == 0 ) {
        joyAppLeftValue = res["slide"]["value"];
        joySlideLeftValue = res["slide"]["value"];
        joySlideRightValue = 0;
        joyAppRightValue = 0;
      } else {
        joyAppRightValue = res["slide"]["value"];
        joySlideRightValue = res["slide"]["value"];
        joySlideLeftValue = 0;
        joyAppLeftValue = 0;
      }

      if (strcmp(res["pan"]["direction"], "left") == 0 ) {
        joyPanLeftValue = res["pan"]["value"];
        joyPanRightValue = 0;
      } else {
        joyPanRightValue = res["pan"]["value"];
        joyPanLeftValue = 0;
      }

      if (strcmp(res["tilt"]["direction"], "left") == 0 ) {
        joyTiltUpValue = res["tilt"]["value"];
        joyTiltDownValue = 0;
      } else {
        joyTiltDownValue = res["tilt"]["value"];
        joyTiltUpValue = 0;
      }

      updateCurrentPosition();
    }

    if (compareJson(res["action"], "cancel")) {
      preventTransition = true;
    }
  }

}

// Callback: send homepage
void onIndexRequest(AsyncWebServerRequest *request) {
  Serial.println("Remote IP fetching");
  IPAddress remote_ip = request->client()->remoteIP();
  Serial.println("[" + remote_ip.toString() +
                  "] HTTP GET request of " + request->url());
  request->send(SPIFFS, "/index.html", "text/html");
}

// Callback: send style sheet
void onCSSRequest(AsyncWebServerRequest *request) {
  IPAddress remote_ip = request->client()->remoteIP();
  Serial.println("[" + remote_ip.toString() +
                  "] HTTP GET request of " + request->url());
  request->send(SPIFFS, "/style.css", "text/css");
}

// Callback: send javascript
void onJSRequest(AsyncWebServerRequest *request) {
  IPAddress remote_ip = request->client()->remoteIP();
  Serial.println("[" + remote_ip.toString() +
                  "] HTTP GET request of " + request->url());
  request->send(SPIFFS, "/script.js", "application/javascript");
}

void onJSJoyRequest(AsyncWebServerRequest *request) {
  IPAddress remote_ip = request->client()->remoteIP();
  Serial.println("[" + remote_ip.toString() +
                  "] HTTP GET request of " + request->url());
  request->send(SPIFFS, "/joy.js", "application/javascript");
}

// Callback: send 404 if requested file does not exist
void onPageNotFound(AsyncWebServerRequest *request) {
  IPAddress remote_ip = request->client()->remoteIP();
  Serial.println("[" + remote_ip.toString() +
                  "] HTTP GET request of " + request->url());
  request->send(404, "text/plain", "Not found");
}