#include <SPI.h>
#include <stdlib.h>

/* Settings Descriptions
 *  Temps are in deg C and can be accurate to 0.25 degrees
 *  Ramp and Hold times are in minutes
 *  
 *  Ramp times are time taken to reach temperature, eg
 *  with the following settings 
 * int   PorfileASteps   =  5;
 * float ProfileATemps[] = {10.1, 20.2, 30.3, 20.2, 10.1};
 * int   ProfileARamps[] = {5,    2,    1,    2,    5};
 * int   ProfileAHolds[] = {1,    2,    1,    1,    1};
 * 
 * Arduino will start by taking 5 minutes to ramp to 10.1 degrees, and hold that temp
 * for 1 minute, then it will take 2 minutes to ramp to 20.2 and hold for 2 minutes, etc
 * 
 * Arduino will wait untill oven temperature matches controller temperature before ending cycle       
 * 
 */

// Profile A Settings - Bottom Button - First Cure - green
int   ProfileASteps   =  1;
float ProfileATemps[] = { 60};
float ProfileARamps[] = {  5};
int   ProfileAHolds[] = {130};
#define ProfileAFinish 60
#define buttonA 6
#define ledA 10

// Profile B Settings - Top button - blue
int   ProfileBSteps   =  3;
float ProfileBTemps[] = {20, 40, 80};
float ProfileBRamps[] = {1, 5, 15};
int   ProfileBHolds[] = {30, 10, 60};
#define ProfileBFinish 80
#define buttonB 7
#define ledB 11

// Other Settings
#define fanRelay  8
#define heatRelay 9

#define fanOn()   digitalWrite(fanRelay, LOW)
#define fanOff()  digitalWrite(fanRelay, HIGH);

#define heatOn()  digitalWrite(heatRelay, LOW);
#define heatOff() digitalWrite(heatRelay, HIGH);

// Default connection is using software SPI, but comment and uncomment one of
// the two examples below to switch between software SPI and hardware SPI:

#define MAXDO   3
#define MAXCS   4
#define MAXCLK  5

class Adafruit_MAX31855 {
 public:
  Adafruit_MAX31855(int8_t SCLK, int8_t CS, int8_t MISO);
  Adafruit_MAX31855(int8_t CS);

  double readInternal(void);
  double readCelsius(void);
  double readFarenheit(void);
  double readFahrenheit(void);
  uint8_t readError();

 private:
  int8_t sclk, miso, cs, hSPI;
  uint32_t spiread32(void);
  uint32_t hspiread32(void);
};

// initialize the Thermocouple
Adafruit_MAX31855 thermocouple(MAXCLK, MAXCS, MAXDO);

int stage = 0;   // Stage of profile
int runTimeMinute = 0; // Time spent ramping in minutes
int runTimeSecond = 0;
double ovenTemp = 0;
long lastMillisMinute = 0;
long lastMillisSecond = 0;

enum {
  Idle,
  RunARamping,
  RunAHolding,
  RunAEnding,
  RunBRamping,
  RunBHolding,
  RunBEnding
} ovenStatus;

int refresh = 1000;

//#define DEBUG
//#define DEBUGTiming
//#define DEBUGCalc

float calculateTarget (float prevTemp, int runTimeMinute, float rampTime, float targetTemp)
{
  float delta = targetTemp - prevTemp ;
  float interpolation = (runTimeMinute+1)/rampTime;
  float target = (delta*interpolation) + prevTemp;
#ifdef DEBUGCalc
  Serial.print(" target - ");
  Serial.print(target);
  Serial.print(" delta - ");
  Serial.print(delta);
  Serial.print(" interpolation - ");
  Serial.print(interpolation);
#endif
  return target;
}

void checkHeater (float targetTemp)
{
  if (ovenTemp <= targetTemp)
  {
    if ((lastMillisSecond + 1000) < millis())
    {
      runTimeSecond++;
      lastMillisSecond = millis();
    }
    Serial.print(" runTimeSecond: ");
    Serial.print(runTimeSecond);
    float delta = targetTemp-(ovenTemp-1);
    delta = (delta / 10); // If greater that 10deg difference then just have it on all the time
    delta = delta * 30; // 30 second modulation, as we approach our target the time the heater will be on goes down
    Serial.print(" checkHeater delta: ");
    Serial.print(delta);
    if ((delta > runTimeSecond) && (30 >= runTimeSecond))
    {
      Serial.print(" heat on");
        heatOn();
    }
    else if (30 > runTimeSecond) // if runTimeSecond is between delta and 30 seconds
    {
      Serial.print(" heat off");
      heatOff();
    }
    else
    {
      Serial.print(" heat off - Reset");
      heatOff();
      runTimeSecond = 0;
    }
    
  }
  else
  {
    Serial.print(" heat off");
    heatOff();
    runTimeSecond = 0;
  } 
}

void setup() {
  Serial.begin(115200);
  
  Serial.println("ArcLamp Curing Oven Controller");

  ovenStatus = Idle;
    
  // Initialise Ports
  Serial.println("Initialising Ports");
  pinMode(buttonA, INPUT);
  pinMode(buttonB, INPUT);
  pinMode(fanRelay, OUTPUT);
  pinMode(heatRelay, OUTPUT);
  pinMode(ledA, OUTPUT);
  pinMode(ledB, OUTPUT);

  digitalWrite(fanRelay, HIGH);
  digitalWrite(heatRelay, HIGH);
  digitalWrite(buttonA, HIGH);
  digitalWrite(buttonB, HIGH);
  digitalWrite(ledA, HIGH);
  digitalWrite(ledB, HIGH);
  
  Serial.println("Current Profiles: ");
  Serial.print("Profile A - Stages: ");
  Serial.println(ProfileASteps);

  for(int i = 0; i < ProfileASteps; i++)
  {
    Serial.print("Stage ");
    Serial.print(i);
    Serial.print(" - Temp: ");
    Serial.print(ProfileATemps[i]);
    Serial.print(" Ramp Time: ");
    Serial.print(ProfileARamps[i]);
    Serial.print(" Hold Time: ");
    Serial.println(ProfileAHolds[i]);
  }

  Serial.print("Profile B - Stages: ");
  Serial.println(ProfileBSteps);

  for(int i = 0; i < ProfileBSteps; i++)
  {
    Serial.print("Stage ");
    Serial.print(i);
    Serial.print(" - Temp: ");
    Serial.print(ProfileBTemps[i]);
    Serial.print(" Ramp Time: ");
    Serial.print(ProfileBRamps[i]);
    Serial.print(" Hold Time: ");
    Serial.println(ProfileBHolds[i]);
  }

  lastMillisMinute = millis();
}

bool checkCancel (void)
{
  if (digitalRead(buttonB))
      {
        heatOff();
        fanOff();
        ovenStatus=Idle;
        digitalWrite(ledA, HIGH);
        digitalWrite(ledB, HIGH);
        while(digitalRead(buttonB))
        {
          // Do nothing
        }
        return true;
      }
      if (digitalRead(buttonA))
      {
        heatOff();
        fanOff();
        ovenStatus=Idle;
        digitalWrite(ledA, HIGH);
        digitalWrite(ledB, HIGH);
        while(digitalRead(buttonA))
        {
          // Do nothing
        }
        return true;
      }
      return false;
}

void loop() {
  // basic readout test, just print the current temp
  float ambientTemp = thermocouple.readInternal();
  Serial.print("Ambient: ");
  Serial.print(ambientTemp);
  Serial.print(" dC  ");

  ovenTemp = thermocouple.readCelsius();
  if (isnan(ovenTemp)) {
    Serial.println("Something wrong with thermocouple!");
    fanOff();
    heatOff();
  } else {
    Serial.print("Oven: "); 
    Serial.print(ovenTemp);
    Serial.print(" dC  ");
  }

#ifdef DEBUGTiming
  Serial.print("lastMillisMinute: ");
  Serial.print(lastMillisMinute);
#endif
#ifdef DEBUG
  if ((lastMillisMinute + 2000) < millis())
#else
  if ((lastMillisMinute + 60000) < millis())
#endif
  {
    runTimeMinute++;
    lastMillisMinute = millis();
  }

  switch (ovenStatus)
  {
    case Idle:
      heatOff();
      fanOff();
      Serial.print(" Idle");
      digitalWrite(ledA, HIGH);
      digitalWrite(ledB, HIGH);
      if (digitalRead(buttonA))
      {
        fanOn();
        // Button A pushed, we need to start
        ovenStatus = RunARamping;
        // First stage is to ramp from ambient to stage 0 so
        stage = 0;
        runTimeMinute = 0;
        digitalWrite(ledA, LOW);
        while(digitalRead(buttonA))
        {
          // Do nothing
        }
      }
      if (digitalRead(buttonB))
      {
        fanOn();
        // Button B pushed, we need to start
        ovenStatus = RunBRamping;
        // First stage is to ramp from ambient to stage 0 so
        stage = 0;
        runTimeMinute = 0;
        digitalWrite(ledB, LOW);
        while(digitalRead(buttonB))
        {
          // Do nothing
        }
      }
      break;

    case RunARamping:
      
      Serial.print("RampA runTimeMinute: ");
      Serial.print(runTimeMinute);
      Serial.print(" stage: ");
      Serial.print(stage);
      if(checkCancel())
      {
        break;
      }
      if(0 == stage)
      {
        float target = calculateTarget(ambientTemp, runTimeMinute, ProfileARamps[stage], ProfileATemps[stage]);
        Serial.print(" Target: ");
        Serial.print(target);
        checkHeater(target);
      }
      else
      {
        
        float target = calculateTarget(ProfileATemps[stage-1], runTimeMinute, ProfileARamps[stage], ProfileATemps[stage]);
        Serial.print(" Target: ");
        Serial.print(target);
        checkHeater(target);
      }
      if(ProfileARamps[stage] <= (runTimeMinute-1))
      {
        ovenStatus = RunAHolding;
        runTimeMinute = 0;
      }
      break;

    case RunAHolding:
      Serial.print("HoldA runTimeMinute: ");
      Serial.print(runTimeMinute);
      Serial.print(" stage: ");
      Serial.print(stage);
      Serial.print(" Target: ");
      Serial.print(ProfileATemps[stage]);
      if(checkCancel())
      {
        break;
      }
      checkHeater(ProfileATemps[stage]);
    
      if(ProfileAHolds[stage] < runTimeMinute)
      {
        ovenStatus = RunARamping;
        stage++;
        if( ProfileASteps <= stage)
        {
          stage = 0;
          ovenStatus = RunAEnding;
        }
        runTimeMinute = 0;
      }
      break;

    case RunAEnding:
      Serial.print("End A runTimeMinute: ");
      Serial.print(runTimeMinute);
      Serial.print(" Target: ");
      Serial.print(ambientTemp+10);
      if (ovenTemp < ProfileAFinish)
      {
        if(checkCancel())
        {
          break;
        }
        if ((lastMillisSecond + 1000) < millis())
        {
          runTimeSecond++;
          lastMillisSecond = millis();
        }
        Serial.print(" runTimeSecond: ");
        Serial.print(runTimeSecond);
        if (1 > runTimeSecond) // if runTimeSecond is between delta and 30 seconds
        {
          fanOn();
          digitalWrite(ledA, LOW);
        }
        else if (2 > runTimeSecond)
        {
          fanOff();
          digitalWrite(ledA, HIGH);
        }
        else
        {
          fanOn();
          digitalWrite(ledA, LOW);
          runTimeSecond = 0;
        }
        heatOff();
      }
      else
      {
        fanOn();
        digitalWrite(ledA, LOW);
        heatOff();
      }
      if(ovenTemp < (ambientTemp+10))
      {
        fanOff();
        heatOff();
        digitalWrite(ledA, HIGH);
        ovenStatus = Idle;
      }
      break;
      
    case RunBRamping:
   
      Serial.print("RampB runTimeMinute: ");
      Serial.print(runTimeMinute);
      Serial.print(" stage: ");
      Serial.print(stage);
      if(checkCancel())
      {
        break;
      }
      if(0 == stage)
      {
        float target = calculateTarget(ambientTemp, runTimeMinute, ProfileBRamps[stage], ProfileBTemps[stage]);
        Serial.print(" Target: ");
        Serial.print(target);
        checkHeater(target);
      }
      else
      {
        
        float target = calculateTarget(ProfileBTemps[stage-1], runTimeMinute, ProfileBRamps[stage], ProfileBTemps[stage]);
        Serial.print(" Target: ");
        Serial.print(target);
        checkHeater(target);
      }
      if(ProfileBRamps[stage] <= runTimeMinute)
      {
        ovenStatus = RunBHolding;
        runTimeMinute = 0;
      }
      break;
      
    case RunBHolding:
      Serial.print("HoldB runTimeMinute: ");
      Serial.print(runTimeMinute);
      Serial.print(" stage: ");
      Serial.print(stage);
      Serial.print(" Target: ");
      Serial.print(ProfileBTemps[stage]);
      if(checkCancel())
      {
        break;
      }
      checkHeater(ProfileBTemps[stage]);
      
      if(ProfileBHolds[stage] < runTimeMinute)
      {
        ovenStatus = RunBRamping;
        stage++;
        if( ProfileBSteps <= stage)
        {
          stage = 0;
          ovenStatus = RunBEnding;
        }
        runTimeMinute = 0;
      }
      break;
      
    case RunBEnding:
      Serial.print("End B runTimeMinute: ");
      Serial.print(runTimeMinute);
      Serial.print(" Target: ");
      Serial.print(ambientTemp+10);
      if (ovenTemp < ProfileBFinish)
      {
        if(checkCancel())
        {
          break;
        }
        if ((lastMillisSecond + 1000) < millis())
        {
          runTimeSecond++;
          lastMillisSecond = millis();
        }
        Serial.print(" runTimeSecond: ");
        Serial.print(runTimeSecond);
        if (1 > runTimeSecond) // if runTimeSecond is between delta and 30 seconds
        {
          fanOn();
          digitalWrite(ledB, LOW);
        }
        else if (2 > runTimeSecond)
        {
          fanOff();
          digitalWrite(ledB, HIGH);
        }
        else
        {
          fanOn();
          digitalWrite(ledB, LOW);
          runTimeSecond = 0;
        }
        heatOff();
      }
      else
      {
        fanOn();
        digitalWrite(ledB, LOW);
        heatOff();
      }
      if(ovenTemp < (ambientTemp+10))
      {
        fanOff();
        heatOff();
        digitalWrite(ledB, HIGH);
        ovenStatus = Idle;
      }
      break;

    default:
      fanOff();
      heatOff();
      break;
  }
  


   
   Serial.println();
}

Adafruit_MAX31855::Adafruit_MAX31855(int8_t SCLK, int8_t CS, int8_t MISO) {
  sclk = SCLK;
  cs = CS;
  miso = MISO;
  hSPI = 0;

  //define pin modes
  pinMode(cs, OUTPUT);
  pinMode(sclk, OUTPUT); 
  pinMode(miso, INPUT);

  digitalWrite(cs, HIGH);
}

Adafruit_MAX31855::Adafruit_MAX31855(int8_t CS) {
  cs = CS;
  hSPI = 1;

  //define pin modes
  pinMode(cs, OUTPUT);
  
  //start and configure hardware SPI
  SPI.begin();
  SPI.setBitOrder(MSBFIRST);
  SPI.setDataMode(SPI_MODE0);
  SPI.setClockDivider(SPI_CLOCK_DIV4);
  
  digitalWrite(cs, HIGH);
}

double Adafruit_MAX31855::readInternal(void) {
  uint32_t v;

  v = spiread32();

  // ignore bottom 4 bits - they're just thermocouple data
  v >>= 4;

  // pull the bottom 11 bits off
  float internal = v & 0x7FF;
  // check sign bit!
  if (v & 0x800) {
    // Convert to negative value by extending sign and casting to signed type.
    int16_t tmp = 0xF800 | (v & 0x7FF);
    internal = tmp;
  }
  internal *= 0.0625; // LSB = 0.0625 degrees
  //Serial.print("\tInternal Temp: "); Serial.println(internal);
  return internal;
}

double Adafruit_MAX31855::readCelsius(void) {

  int32_t v;

  v = spiread32();

  //Serial.print("0x"); Serial.println(v, HEX);

  /*
  float internal = (v >> 4) & 0x7FF;
  internal *= 0.0625;
  if ((v >> 4) & 0x800) 
    internal *= -1;
  Serial.print("\tInternal Temp: "); Serial.println(internal);
  */

  if (v & 0x7) {
    // uh oh, a serious problem!
    return NAN; 
  }

  if (v & 0x80000000) {
    // Negative value, drop the lower 18 bits and explicitly extend sign bits.
    v = 0xFFFFC000 | ((v >> 18) & 0x00003FFFF);
  }
  else {
    // Positive value, just drop the lower 18 bits.
    v >>= 18;
  }
  //Serial.println(v, HEX);
  
  double centigrade = v;

  // LSB = 0.25 degrees C
  centigrade *= 0.25;
  return centigrade;
}

uint8_t Adafruit_MAX31855::readError() {
  return spiread32() & 0x7;
}

double Adafruit_MAX31855::readFahrenheit(void) {  //'fahrenheit' is spelled right.
  return readFarenheit();
}

double Adafruit_MAX31855::readFarenheit(void) {  //'farenheit' is spelled wrong.
  float f = readCelsius();
  f *= 9.0;
  f /= 5.0;
  f += 32;
  return f;
}

uint32_t Adafruit_MAX31855::spiread32(void) { 
  int i;
  uint32_t d = 0;

  if(hSPI) {
    return hspiread32();
  }

  digitalWrite(sclk, LOW);
  delay(1);
  digitalWrite(cs, LOW);
  delay(1);

  for (i=31; i>=0; i--)
  {
    digitalWrite(sclk, LOW);
    delay(1);
    d <<= 1;
    if (digitalRead(miso)) {
      d |= 1;
    }

    digitalWrite(sclk, HIGH);
    delay(1);
  }

  digitalWrite(cs, HIGH);
  //Serial.println(d, HEX);
  return d;
}

uint32_t Adafruit_MAX31855::hspiread32(void) {
  int i;
  // easy conversion of four uint8_ts to uint32_t
  union bytes_to_uint32 {
    uint8_t bytes[4];
    uint32_t integer;
  } buffer;
  
  digitalWrite(cs, LOW);
  delay(1);
  
  for (i=3;i>=0;i--) {
    buffer.bytes[i] = SPI.transfer(0x00);
  }
  
  digitalWrite(cs, HIGH);
  
  return buffer.integer;
  
}