//Z limit low for 10 seconds with Z- movment

const byte XPotPin = A1;  // Left-Right control
const byte YPotPin = A2;  // Up-Down control
const byte ZPotPin = A3;  // Z axis control
const byte QuadratureOutputXAPin = 4;
const byte QuadratureOutputXBPin = 5;
const byte QuadratureOutputYAPin = 6;
const byte QuadratureOutputYBPin = 7;
const byte QuadratureOutputZAPin = 8;
const byte QuadratureOutputZBPin = 9;

const byte DIPSwitch1Pin = 11;
const byte DIPSwitch2Pin = 12;
const byte ZLimitOutputPin = 10;  // NEW: Z limit output

const int XCentered = 512;
const int YCentered = 512;
const int ZCentered = 512;
const int DEAD_ZONE = 100;

int MinDelay = 1;
int MaxDelay = 500;

byte QuadratureStateX = 0;
byte QuadratureStateY = 0;
byte QuadratureStateZ = 0;

const boolean QuadratureStatesA[4] = {1, 1, 1, 0};
const boolean QuadratureStatesB[4] = {0, 1, 1, 1};

unsigned long zLimitActivatedTime = 0;     // NEW: track last activation
bool zLimitHeld = false;                   // NEW: hold state

void XPlus() {
  QuadratureStateX = (QuadratureStateX + 1) % 4;
  digitalWrite(QuadratureOutputXAPin, QuadratureStatesA[QuadratureStateX]);
  digitalWrite(QuadratureOutputXBPin, QuadratureStatesB[QuadratureStateX]);
}

void XMinus() {
  QuadratureStateX = (QuadratureStateX - 1 + 4) % 4;
  digitalWrite(QuadratureOutputXAPin, QuadratureStatesA[QuadratureStateX]);
  digitalWrite(QuadratureOutputXBPin, QuadratureStatesB[QuadratureStateX]);
}

void YPlus() {
  QuadratureStateY = (QuadratureStateY + 1) % 4;
  digitalWrite(QuadratureOutputYAPin, QuadratureStatesA[QuadratureStateY]);
  digitalWrite(QuadratureOutputYBPin, QuadratureStatesB[QuadratureStateY]);
}

void YMinus() {
  QuadratureStateY = (QuadratureStateY - 1 + 4) % 4;
  digitalWrite(QuadratureOutputYAPin, QuadratureStatesA[QuadratureStateY]);
  digitalWrite(QuadratureOutputYBPin, QuadratureStatesB[QuadratureStateY]);
}

void ZPlus() {
  QuadratureStateZ = (QuadratureStateZ + 1) % 4;
  digitalWrite(QuadratureOutputZAPin, QuadratureStatesA[QuadratureStateZ]);
  digitalWrite(QuadratureOutputZBPin, QuadratureStatesB[QuadratureStateZ]);
}

void ZMinus() {
  QuadratureStateZ = (QuadratureStateZ - 1 + 4) % 4;
  digitalWrite(QuadratureOutputZAPin, QuadratureStatesA[QuadratureStateZ]);
  digitalWrite(QuadratureOutputZBPin, QuadratureStatesB[QuadratureStateZ]);
}

void updateDelays() {
  bool switch1 = digitalRead(DIPSwitch1Pin) == LOW;
  bool switch2 = digitalRead(DIPSwitch2Pin) == LOW;

  if (!switch1 && !switch2) {
    MinDelay = 1;
    MaxDelay = 1000;
  } else if (switch1 && !switch2) {
    MinDelay = 2;
    MaxDelay = 500;
  } else if (!switch1 && switch2) {
    MinDelay = 3;
    MaxDelay = 250;
  } else {
    MinDelay = 4;
    MaxDelay = 125;
  }
}

void setup() {
  pinMode(QuadratureOutputXAPin , OUTPUT);
  pinMode(QuadratureOutputXBPin , OUTPUT);
  pinMode(QuadratureOutputYAPin , OUTPUT);
  pinMode(QuadratureOutputYBPin , OUTPUT);
  pinMode(QuadratureOutputZAPin , OUTPUT);
  pinMode(QuadratureOutputZBPin , OUTPUT);

  pinMode(DIPSwitch1Pin, INPUT_PULLUP);
  pinMode(DIPSwitch2Pin, INPUT_PULLUP);
  pinMode(ZLimitOutputPin, OUTPUT);
  digitalWrite(ZLimitOutputPin, HIGH); // Default HIGH
}

void loop() {
  updateDelays();

  int xInput = analogRead(XPotPin);
  int yInput = analogRead(YPotPin);
  int zInput = analogRead(ZPotPin);

  if (xInput < XCentered - DEAD_ZONE) {
    XMinus();
    delay(map(xInput, 0, XCentered, MinDelay, MaxDelay));
  }

  if (xInput > XCentered + DEAD_ZONE) {
    XPlus();
    delay(map(xInput, XCentered, 1024, MaxDelay, MinDelay));
  }

  if (yInput > YCentered + DEAD_ZONE) {
    YPlus();
    delay(map(yInput, YCentered, 1024, MaxDelay, MinDelay));
  }

  if (yInput < YCentered - DEAD_ZONE) {
    YMinus();
    delay(map(yInput, 0, YCentered, MinDelay, MaxDelay));
  }

  if (zInput < ZCentered - DEAD_ZONE) {
    ZMinus();
    delay(map(zInput, 0, ZCentered, MinDelay, MaxDelay));

    digitalWrite(ZLimitOutputPin, LOW);
    zLimitActivatedTime = millis();
    zLimitHeld = true;
  }

  if (zLimitHeld && millis() - zLimitActivatedTime >= 10000) {
    digitalWrite(ZLimitOutputPin, HIGH);
    zLimitHeld = false;
  }

  if (zInput > ZCentered + DEAD_ZONE) {
    ZPlus();
    delay(map(zInput, ZCentered, 1024, MaxDelay, MinDelay));
  }
}