Final Project Code

/*
 * Britney Beatey
 * Final Project Code
 * 6/30/17
 */

#include <Button.h>
#include <LiquidCrystal.h>
#include <FSM.h>

const byte liquidVal = 2;
const byte measurementVal = 2;

//I/O
LiquidCrystal lcd (12,6,5,4,3,2);
int pumpControlPin = A1;
int scaleVoltagePin = 11;
int stimulatorPin = 7;

//Control Buttons
int backButtonPin = 9;
Button backButton = Button(backButtonPin, PULLUP);

int forwardButtonPin = 10;
Button forwardButton = Button(forwardButtonPin, PULLUP);

int acknowledgeButtonPin = 13;
Button ackButton = Button(acknowledgeButtonPin, PULLUP);

int activateButtonPin = 7;
Button activateButton = Button(activateButtonPin, PULLUP);

int cancelButtonPin = 11;
Button cancelButton = Button(cancelButtonPin, PULLUP);

//Finite State Machine
State Nav = State(empty, navUpdate, cleanDisplay);

State LiquidDispenseSelect = State(cleanBottomLine, liquidDispenseSelectUpdate, empty);
State LiquidMeasurementSelect = State(empty, liquidMeasurementSelectUpdate, cleanDisplay);
State LiquidAmountSelect = State(empty, liquidAmountSelectUpdate, cleanDisplay);
State LiquidStart = State(empty, liquidStartUpdate, empty);

FSM measureMachine = FSM(Nav);

char liquids[2][18] = {"      Water   ->"};


char measurements[2][18] = {"      Cups    ->",
                            "      Tbls    ->"};

char tbls[6][18] = {"    1/8 tsp   ->",
                    "    1/4 tsp   ->",
                    "    1/2 tsp   ->",
                    "    1 tsp     ->",
                    "    1/2 tbls  ->",
                    "    1 tbls    ->"};

double tblsEquiv[6] = {0.41,
                          0.83,
                          0.16,
                          0.33,
                          0.5,
                          1};

int liquidIdx = 0;
int liqMeasureIdx = 0;
int tblsIdx = 0;
int liqStartTime;
double liqEndTime;
double liqAmount = 0.0;
bool liquidActive = false;
bool pumping = false;
bool stimulating = false;


void setup() {
  Serial.begin(9600);
  pinMode(pumpControlPin, OUTPUT);
  pinMode(scaleVoltagePin, INPUT);
  pinMode(stimulatorPin, OUTPUT);

  //LCD Initialization
  lcd.begin(16, 2);
  lcd.clear();
}

void loop() {
  dispenseLiquid();
  measureMachine.update();
}

//Utility Functions
void navUpdate() {
  if(forwardButton.uniquePress()) {
    measureMachine.transitionTo(LiquidDispenseSelect);
  }
  lcd.setCursor(0,0);
  lcd.print(" Measuring Liquid");
  lcd.setCursor(0,1);
  lcd.print("Water");
}

void empty() {
}

void reset() {
  liqAmount = 0.0;
  liquidIdx = 0;
  liqMeasureIdx = 0;
  cleanDisplay();
}

/***********************************
*              LIQUID
***********************************/

/////////LIQUID DISPENSE SELECT
void liquidDispenseSelectUpdate() {
  if(cancelButton.uniquePress()) {
    reset();
    measureMachine.transitionTo(Nav);
  }

  if(backButton.uniquePress()) {
    liquidIdx = --liquidIdx % liquidVal;
  }

  if(forwardButton.uniquePress()) {
    liquidIdx = ++liquidIdx % liquidVal;
  }

  if(ackButton.uniquePress()) {
    measureMachine.transitionTo(LiquidMeasurementSelect);
  }

  lcd.setCursor(0,0);
  lcd.print(liquids[liquidIdx]);
}


//////////LIQUID MEASUREMENT SELECT
void liquidMeasurementSelectUpdate() {
  if(cancelButton.uniquePress()) {
    reset();
    measureMachine.transitionTo(Nav);
  }

  if(backButton.uniquePress()) {
    liqMeasureIdx = --liqMeasureIdx % measurementVal;
  }

  if(forwardButton.uniquePress()) {
    liqMeasureIdx = ++liqMeasureIdx % measurementVal;
  }

  if(ackButton.uniquePress()) {
    measureMachine.transitionTo(LiquidAmountSelect);
  }

  lcd.setCursor(0,1);
  lcd.print(measurements[liqMeasureIdx]);
}

//////////AMOUNT SELECT
void liquidAmountSelectUpdate() {
  if(cancelButton.uniquePress()) {
    reset();
    measureMachine.transitionTo(Nav);
  }

  if(ackButton.uniquePress()) {
    measureMachine.transitionTo(LiquidStart);
  }

  lcd.setCursor(0,0);
  lcd.print("How much?");

  switch(liqMeasureIdx) {
    //Cups
    case 0:
      if(backButton.uniquePress()) {
        if(liqAmount > 0) {
          liqAmount -= 0.25;
        }
      }

      if(forwardButton.uniquePress()) {
        if(liqAmount < 2) {
          liqAmount += 0.25;
        }
      }

      lcd.setCursor(0,1);
      lcd.print(liqAmount);
    break;

    //Spoons
    case 1:
      if(backButton.uniquePress()) {
        if(liqAmount > 0) {
          liqAmount -= 1;
        }
      }

      if(forwardButton.uniquePress()) {
        if(liqAmount < 6) {
          liqAmount += 1;
        }
      }
      lcd.setCursor(0,1);
      lcd.print(tbls[(int)liqAmount]);
    break;
  }
}

//////////AMOUNT SELECT
void liquidStartUpdate() {
  if(cancelButton.uniquePress()) {
    reset();
    measureMachine.transitionTo(Nav);
  }

  if(activateButton.uniquePress()) {
    liquidActive = true;
    measureMachine.transitionTo(Nav);
  }

  lcd.setCursor(0,0);
  lcd.print("Press Green Btn ");
  lcd.setCursor(0,1);
  lcd.print("to begin");
}


/***********************************
*              UTILITY
***********************************/
void cleanBottomLine() {
  lcd.setCursor(0,1);
  lcd.print("               ");
}

void cleanDisplay() {
  lcd.clear();
}

/***********************************
*            DISPENSING
***********************************/

void dispenseLiquid() {
  double tbls;
  switch(liqMeasureIdx) {
    //Cups
    case 0:
      beginLiquidDispenseCups(liqAmount);
    break;

    //Spoons
    case 1:
      tbls = tblsEquiv[(int)liqAmount];
      beginLiquidDispenseSpoons(tbls);
    break;
  }
}

void beginLiquidDispenseCups(double amountIn) {
  if(liquidActive) {
    double dispenseAmount = amountIn;
    if(!pumping) {
      startTimingLiquid();
      calculateEndTimeLiquidCups(dispenseAmount);
      digitalWrite(pumpControlPin, HIGH);
    } else {
      if(millis() - liqStartTime >= liqEndTime) {
        pumping = false;
        digitalWrite(pumpControlPin, LOW);
        liquidActive = false;
      }
    }
  } else {
    digitalWrite(pumpControlPin, LOW);
  }
}

void beginLiquidDispenseSpoons(double amountIn) {
  if(liquidActive) {
    double dispenseAmount = amountIn;
    if(!pumping) {
      startTimingLiquid();
      calculateEndTimeLiquidSpoons(dispenseAmount);
      digitalWrite(pumpControlPin, HIGH);
    } else {
      if(millis() - liqStartTime >= liqEndTime) {
        pumping = false;
        digitalWrite(pumpControlPin, LOW);
        liquidActive = false;
      }
    }
  } else {
    digitalWrite(pumpControlPin, LOW);
  }
}
void startTimingLiquid() {
  liqStartTime = millis();
  pumping = true;
}

void calculateEndTimeLiquidCups(double amountIn) {
  double duration = (amountIn * 237)/(1.21);
  Serial.println(duration);
  duration = duration * 1000;
  liqEndTime = duration;
  Serial.println(liqEndTime);
}

void calculateEndTimeLiquidSpoons(double amountIn) {
  double duration = (amountIn * 14)/(1.21);
  duration = duration * 1000;
  Serial.println(duration);
  liqEndTime = duration;
  Serial.println(liqEndTime);
}