const byte XPotPin = A1;  // Left-Right control
const byte YPotPin = A2;  // Up-Down control
const byte ZPotPin=A3;
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 int XCentered = 512;
const int YCentered = 512;
const int ZCentered = 512;
const int DEAD_ZONE = 100;

const int MinDelay = 1; // 1000 steps per second with joystick at the limits.
const int MaxDelay = 500; // 2 steps per second with the joystick near the center.

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};

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

void XMinus()
{
  QuadratureStateX = (QuadratureStateX - 1) % 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;
  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;
  digitalWrite(QuadratureOutputZAPin, QuadratureStatesA[QuadratureStateZ]);
  digitalWrite(QuadratureOutputZBPin, QuadratureStatesB[QuadratureStateZ]);
}
void setup()
{
  pinMode(QuadratureOutputXAPin , OUTPUT);
  pinMode(QuadratureOutputXBPin , OUTPUT);
  pinMode(QuadratureOutputYAPin , OUTPUT);
  pinMode(QuadratureOutputYBPin , OUTPUT);
  pinMode(QuadratureOutputZAPin , OUTPUT);
  pinMode(QuadratureOutputZBPin , OUTPUT); 
}

void loop()
{
  int xInput = analogRead(XPotPin); // Left/Right
  int yInput = analogRead(YPotPin); // Up/Down
  int zInput = analogRead(ZPotPin); // Z axis up down

  // Check for X left of the dead zone
  if (xInput < XCentered - DEAD_ZONE)
  {
    XMinus();
    delay(map(xInput, 0, XCentered, MinDelay, MaxDelay));
  }

  // Check for X right of the dead zone
  if (xInput > XCentered + DEAD_ZONE)
  {
    XPlus();
    delay(map(xInput, XCentered, 1024, MaxDelay, MinDelay));
  }

  // Check for Y above the dead zone
  if (yInput > YCentered + DEAD_ZONE)
  {
    YPlus();
    delay(map(yInput, YCentered, 1024, MaxDelay, MinDelay));
  }
  
  // Check for Y below the dead zone
  if (yInput < YCentered - DEAD_ZONE)
  {
    YMinus();
    delay(map(yInput, 0, YCentered, MinDelay, MaxDelay));
    
  }
  // Check for Z left of the dead zone
  if (zInput < ZCentered - DEAD_ZONE)
  {
    ZMinus();
    delay(map(zInput, 0, ZCentered, MinDelay, MaxDelay));
  }

  // Check for Z right of the dead zone
  if (zInput > ZCentered + DEAD_ZONE)
  {
    ZPlus();
    delay(map(zInput, ZCentered, 1024, MaxDelay, MinDelay));
  }

}