#include <Servo.h>  // include servo libary

const byte PinSensor = A0;

Servo patterServo;
unsigned servoDown = 250;  // number to write to servo for it to be down.
unsigned servoUp = 10;     // number to write to servo for it to be up.

/*
int PatThresh = 100;  // when sensor is triggered
int PatHyst = 40;     // a sort of debouce
*/

//... these make it easier to see the hysteresis - change them for the real world
int PatThresh = 512;
int PatHyst = 128;

bool held;

enum State {
  IDLE,
  PATTED,
  RESET
};

//... add some strings to print 
const char *stateTags[] = {"idle", "patted", "reset"};

State state = IDLE;
unsigned long lastChange = 0;
const unsigned long interval = 200;


void setup() {

  Serial.begin(9600);
  patterServo.attach(9);
  held = false;
}

void loop() {

  unsigned long now = millis();
  int sensorVal = analogRead(PinSensor);


//... print the state if it has changed
{
  static State lastPrinted  = RESET;  // just not the first state
  static long counter = 100000;

  if (lastPrinted  != state) {
    Serial.print(counter); counter++;
    Serial.print (" state = ");
    Serial.println(stateTags[state]);

    lastPrinted  = state;
  }
}

  switch (state) {
    case IDLE:
      patterServo.write(servoUp);
//...      Serial.println("  IDLE");
//...      Serial.println(sensorVal);  need to figure this out
      if (!held && ((PatThresh + PatHyst) < sensorVal)) {  // Move to patted state if pat is sensed (but not if someone is just holding sensor.) 
        lastChange = now; 
        state = PATTED;
      }

      else if (held && (PatThresh - PatHyst) > sensorVal) {  // this switches it to being un held if someone was just holding the sensor
        held = false;
 //...       Serial.println("   release");
        state = IDLE;
      }
      break;

    case PATTED:
      patterServo.write(servoDown);  // in Patted state, move servo down to pat 
//...      Serial.println("  PATTED");
      held = true;
      if (now - lastChange >= interval) { // wait for servo to get there and move to state reset
        state = RESET;
        lastChange = now;
      }
      break;
    case RESET:
      patterServo.write(servoUp); // Move servo back to starting position
//...      Serial.println("  RESET");
      if (now - lastChange >= interval) { // wait for servo to get there
        state = IDLE;
        lastChange = now;
      }
      break;
  }
}


/*
# include <Servo.h>

Servo patterServo;
unsigned servoPat = 250;

// unsigned int?
unsigned servoUp  =  10;

//... added
unsigned servoDown = 170;
unsigned servoWaiting = 90;

bool pat;
bool isUp;          // pat sensor triggered

const byte PinSensor = A0;
int PatThresh = 512;
int PatHyst = 128;

const unsigned long PatMsec = 250;
unsigned long msec0;

//... added
unsigned long servoTimer;    // for automatic return to neutral
const unsigned long servoPeriod = 1007;    // time until auto return

void setup () {
    Serial.begin (9600);
    patterServo.attach (9);
}

void loop ()
{
    unsigned long now = millis ();

    int sensorVal = analogRead (PinSensor);

    if (!isUp && (PatThresh + PatHyst) < sensorVal) {
        isUp = true;
        servoTimer = now;
        patterServo.write (servoUp);
        Serial.println (" pat up");
    }
    else if (isUp && (PatThresh - PatHyst) > sensorVal) {
        isUp = false;
        servoTimer = now;
        patterServo.write(servoDown);
        Serial.println (" pat down");
    }

    if (now - servoTimer >= servoPeriod) {
        patterServo.write (servoWaiting);
// spams. deal with it        Serial.println ("          return to neutral");
    }
}
*/