View Thread

/*

Arduino keys

0       Rx              - 

1       Tx              -

2   Int, PWM   Kbd1

3   Int, PWM   Kbd2

4              KbdCommon

5   PWM           Fan

6   PWM           Triac

7              Reserved

8              Reserved

9   PWM           RED LED

10   PWM           GREEN LED

11   PWM           BLUE LED

12              LED common

13              LCD D/C

A0   AIN           LCD DN

A1   AIN           LCD CLK

A2   AIN           LCD RST

A3   AIN              Thermo CLK

A4   AIN, I2C SDA   Thermo CS

A5   AIN, I2C SCL   Thermo DO

A6      AIN             -

A7      AIN             Fan voltage



*/



#include "max6675.h"

#include <LCD5110_Graph.h>

#include <PID_v1.h>



#define HEATING 1

#define STAGE1 2

#define STAGE2 3

#define STAGE3 4

#define COOLING 5

#define START 10



double Setpoint, Input, Output;

float P, I, D, feedbackFactor;

PID myPID(&Input, &Output, &Setpoint,P,I,D, DIRECT);



// LCD5110 myGLCD(CLK,DN,DC,RST);

LCD5110 myGLCD(A1,A0,13,A2);

extern uint8_t SmallFont[];



#define OFF 0

#define ON 1



struct profile {          // Profile structure

  char *name;             // Profile name

  int  Stage1Temp;        // Temperature of Stage 1

  int  Stage1Time;        // Duration of Stage 1

  int  Stage2Temp;        // Temperature of Stage 1

  int  Stage2Time;        // Duration of Stage 1

  int  Stage3Temp;        // Temperature of Stage 1

  int  Stage3Time;        // Duration of Stage 1  

  byte HeaterPower;       // Initial heater power (%)

  byte HeatFanPower;      // Initial cooler power (0..150)

  byte CoolPower;         // Fan power (0..150) in cooling stage

  byte CoolTime;          // Time to cool the beans after roasting (seconds)

  byte FinalTemp;         // Final temperature after cooling

};  



struct profile profiles[] = {                           // Array of all roast profiles

  {"  Preset #1   ",227,390,202,180,227,90, 100,100,120,120,45}, // iRoast Preset #1, total roast time: 11:30 min 

  {"  Preset #2   ",227,300,202,300,227,90, 100,100,120,120,45}, // iRoast Preset #2, total roast time: 11:30 min - shorter stage 1 time, longer middle stage, otherwise the same as preset 1.

  {"City/City plus",152,120,182,180,214,270,100,100,120,120,45}, // The roast curve Sweet Maria uses for almost all samples to get a City or City plus roast (which is considered a cupping roast I know and is probably lighter than most folks like) 

  {"Island Coffees",152,180,179,180,207,180,100,100,120,120,45}, // Coffees from Jamaica, Hawaii, and to a lesser degree Puerto Rico, have a lower bean density because these island coffees do not have the altitudes of such origins as Kenya. They benefit from a lower initial temperature during the warmup time. Here is the program I am currently using for a City roast: 

  {"BrazilEspresso",152,180,213,180,218,240,100,100,120,120,45}, // Like the Island coffees, Brazils come from lower elevations. They benefit from a slower warmup and a longer overall roast. For Northern Italian Espresso I like this program, and you can use it for other light espresso roasts too: 

  {" Test - Mest  ",50,5,60,10,70,15,100,100,120,10,45}          // test profile for debug

};



/*

struct profile profiles[] = {                           // Array of all roast profiles

  {"  Preset #1   ",252,390,227,180,252,90, 100,100,100,120}, // iRoast Preset #1, total roast time: 11:30 min 

  {"  Preset #2   ",252,300,227,300,252,90, 100,100,100,120}, // iRoast Preset #2, total roast time: 11:30 min - shorter stage 1 time, longer middle stage, otherwise the same as preset 1.

  {"City/City plus",177,120,204,180,238,270,100,100,100,120}, // The roast curve Sweet Maria uses for almost all samples to get a City or City plus roast (which is considered a cupping roast I know and is probably lighter than most folks like) 

  {"Island Coffees",177,180,204,180,232,180,100,100,100,120}, // Coffees from Jamaica, Hawaii, and to a lesser degree Puerto Rico, have a lower bean density because these island coffees do not have the altitudes of such origins as Kenya. They benefit from a lower initial temperature during the warmup time. Here is the program I am currently using for a City roast: 

  {"BrazilEspresso",177,180,238,180,243,240,100,100,100,120}, // Like the Island coffees, Brazils come from lower elevations. They benefit from a slower warmup and a longer overall roast. For Northern Italian Espresso I like this program, and you can use it for other light espresso roasts too: 

  {" Test - Mest  ",50,5,60,10,70,15,100,100,10,120}  // test profile for debug

};

*/



byte profile=0, nprofiles=5;

unsigned int setTemperature=0, setDuration=0, ProcessTime=0;



unsigned long TriacSwitch=0, Tstart=0, currentmillis=0, previousmillis=0;  

// TriacSwitch - the moment when triac switches ON or OFF

// Tstart - the moment when the key was pressed

unsigned int CoolerDuration=15; // HeaterDuration+CoolDuration



int seconds = 0; // number of seconds since button was pushed

int count=0; // loop cycles counter



unsigned int state = OFF;

boolean PIDenable = OFF; // flag, when ON, PIDenable constant temperature

volatile boolean key1int_guard = false ;

volatile boolean key2int_guard = false ;



// define pin connections

// #define TriacPin 6

const byte TriacPin = 6;

const byte FAN_PWM = 5;



const byte redLED = 11;

const byte greenLED = 10;

const byte blueLED = 9;

const byte LEDcommonPin = 12;



const byte keyboardPin = 4;

const byte key1InterruptPin = 3;

const byte key2InterruptPin = 2;



const byte key1Interrupt = 1;

const byte key2Interrupt = 0;



// thermocouple pins

const byte thermoDO = A5;

const byte thermoCS = A4;

const byte thermoCLK = A3;

int mintemp=0, maxtemp=300;



const byte FanVoltagePin = A7;

int FanVoltage=0;



// screen

byte yres=48;

byte xres=84;



byte currentTriacPower = 0, currentFanPower=0;

int ONcycles=0, OFFcycles=0;

boolean TriacState=OFF;

boolean Abort=0;

float currentTemperature = 0.3, Temperature=0;



MAX6675 thermocouple(thermoCLK, thermoCS, thermoDO);



void Triac() {

  unsigned long T=currentmillis-TriacSwitch;



  if (currentTriacPower>100) currentTriacPower=100;

  if (currentTriacPower<0) currentTriacPower=0;

  

  ONcycles=currentTriacPower*10; 

  OFFcycles=1000-ONcycles;



  switch (TriacState){

      case OFF:

       if (T>=OFFcycles) {

          TriacState=ON;

          TriacSwitch=currentmillis;

       }

      break;

      case ON:

       if (T>=ONcycles) {

       TriacState=OFF;

       TriacSwitch=currentmillis;

       }

      break;

      }

  if (ONcycles==0) {TriacState=OFF;}

  if (OFFcycles==0) {TriacState=ON;}  

  LED(TriacState);

  digitalWrite(TriacPin, TriacState);

  

}



void setFanPower (int power) {

  if (power>255) power=255;

  if (power<0) power=0;

  analogWrite(FAN_PWM, power);

}



void toggle(int pinNum) {  // toggle the state on a pin



  int pinState = digitalRead(pinNum);

  pinState = !pinState;

  digitalWrite(pinNum, pinState); 

}



void LED(boolean state){

  digitalWrite(LEDcommonPin, state);

}



void RGB(byte red, byte green, byte blue) {

  analogWrite(redLED, 255-red);  

  analogWrite(greenLED, 255-green);  

  analogWrite(blueLED, 255-blue);  

}



void key1pressed () {

  if (!key1int_guard) return;

  if (state==0) {  

  state = START;

  key1int_guard=false;

  key2int_guard=false;

  }

}



void key2pressed () {

  if (!key2int_guard)return;

  if (state==0) {  

  profile++;

  if (profile>nprofiles) profile=0;

  key2int_guard=false;

  } else state=OFF;

}



void MaintainTemperature() {

  Input=currentTemperature*feedbackFactor;

  Setpoint=setTemperature;

  myPID.Compute();

  currentTriacPower=Output/2.55;

}



void updateScreen(){

      int tmp1=floor(currentTemperature);

      int tmp2=floor(10*(currentTemperature-tmp1));

      String temp=String("Temp=")+tmp1+String(".")+tmp2+String("~C");

      myGLCD.clrScr();

      myGLCD.print("Coffee Roaster", CENTER, 0);

      myGLCD.invertText(true);

      myGLCD.print(profiles[profile].name, CENTER, 10);

      myGLCD.invertText(false);

      myGLCD.print(temp, CENTER, 20);

      temp=String("Time=")+seconds+String("s");

      if(state) myGLCD.print(temp, CENTER, 30);

      temp=String("Stage: ")+state;

      if(state) myGLCD.print(temp, CENTER, 40);

      myGLCD.update();      

      RGB(tmp1,25,25);

}



void sendSerial(){

      String temp=seconds+String("\t")+(int)currentTemperature+String("\t")+setTemperature+String("\t")+currentFanPower+String("\t")+currentTriacPower;

      Serial.println(temp);

}



void updateTime_and_Temp(){

    currentmillis=millis();

    if(currentmillis-previousmillis>1000){

      previousmillis=currentmillis;

      currentTemperature=thermocouple.readCelsius();

      updateScreen();

      if (state) { 

        seconds++;

        sendSerial(); 

      } else key2int_guard=true;

      if (PIDenable) MaintainTemperature();

    }

}



void setup() {

  Serial.begin(9600);

// initialize the keyboard  

  pinMode(keyboardPin, OUTPUT);

  digitalWrite(keyboardPin, LOW); // connect button pin to ground



  pinMode(key1InterruptPin, INPUT);

  digitalWrite(key1InterruptPin, HIGH); // pull up

  pinMode(key2InterruptPin, INPUT);

  digitalWrite(key2InterruptPin, HIGH); // pull up  

  attachInterrupt(key1Interrupt, key1pressed, FALLING);

  attachInterrupt(key2Interrupt, key2pressed, FALLING);

  key1int_guard=true;

  key2int_guard=true;

  

  pinMode(FanVoltagePin, INPUT);

  analogReference(DEFAULT);

  

// initialize LEDs  

  pinMode(redLED, OUTPUT);

  analogWrite(redLED, 255);

  pinMode(greenLED, OUTPUT);

  analogWrite(greenLED, 255);  

  pinMode(blueLED, OUTPUT);

  analogWrite(blueLED, 255);  

  pinMode(LEDcommonPin, OUTPUT);

  digitalWrite(LEDcommonPin, LOW);

  

//  pinMode(8, OUTPUT);



//initialize control pins  

  pinMode(TriacPin, OUTPUT); 

  digitalWrite(TriacPin, LOW);



  pinMode(FAN_PWM, OUTPUT);

  analogWrite(FAN_PWM, 0);



  state = OFF;

  

//turn the PID on

  myPID.SetMode(AUTOMATIC);



// wait for MAX chip to stabilize

//  delay(500);

// blink LED 3 times to indicate ready state

  RGB(50, 50, 50); 

  for (byte i=0; i<=6; i++){

    toggle(LEDcommonPin); delay(120); 

  }  

  // currentTemperature=thermocouple.readCelsius();  

  // Serial.print("Start temperature = "); Serial.println(currentTemperature);

  P=3; I=0.4; D=0.1; feedbackFactor=1;

  Serial.print("P=");  Serial.print(P);  Serial.print("\tI=");  Serial.print(I);  Serial.print("\tD=");Serial.println(D);

  Serial.println("Time\tTemp\tSetting\tFanPower\tTriacPower");



  myGLCD.InitLCD(65);

  myGLCD.setFont(SmallFont);



  TriacSwitch=millis();

  profile=2; 

}



void loop() {

  switch (state) {

    case HEATING: 

           if (profile==5 && seconds>8) currentTemperature=profiles[profile].Stage1Temp+2;

           if (currentTemperature>=(profiles[profile].Stage1Temp-10)) {

             state = 2;

             ProcessTime=seconds;

             setTemperature=profiles[profile].Stage1Temp;

             setDuration=profiles[profile].Stage1Time;

             myPID.SetTunings(P, I, D);

             Serial.println("\t\t\t\t\tHeating complete");

           }

           break;

    case STAGE1: 

           if (seconds>ProcessTime+profiles[profile].Stage1Time) {

             ProcessTime=seconds;

             state=3;

             setTemperature=profiles[profile].Stage2Temp;

             setDuration=profiles[profile].Stage2Time;

             P=3;

             myPID.SetTunings(P, I, D);

             Serial.println("\t\t\t\t\tStage 1 complete");

           }

           break;

    case STAGE2: 

           if (seconds>ProcessTime+profiles[profile].Stage2Time) {

             ProcessTime=seconds;

             state=4;

             setTemperature=profiles[profile].Stage3Temp;

             setDuration=profiles[profile].Stage3Time;

             myPID.SetTunings(P, I, D);             

             Serial.println("\t\t\t\t\tStage 2 complete");

           }

           break;

    case STAGE3: 

           if (seconds>ProcessTime+profiles[profile].Stage3Time) {

             ProcessTime=seconds;

             state=5;

             currentTriacPower=0;

             currentFanPower=profiles[profile].CoolPower;

             setFanPower(currentFanPower);

             CoolerDuration=profiles[profile].CoolTime;

             setTemperature=0;

             PIDenable=false;

             Serial.println("\t\t\t\t\tStage 3 complete");

           }

           break;

    case COOLING: 

           if (currentTemperature<=profiles[profile].FinalTemp || seconds>ProcessTime+profiles[profile].CoolTime) {

             state=OFF;

             LED(OFF);

             seconds=0;

             key1int_guard=true;

             key2int_guard=true;

             Serial.println("\t\t\t\t\tCooling complete");

           }

           break;

    case START: // if key was pressed 

             // send the settings data

             Serial.print("Profile:"); Serial.println(profiles[profile].name);             

             Serial.print("Stage1: "); Serial.println(profiles[profile].Stage1Temp);

             Serial.print("Stage2: "); Serial.println(profiles[profile].Stage2Temp);

             Serial.print("Stage3: "); Serial.println(profiles[profile].Stage3Temp);

             

             currentFanPower=profiles[profile].HeatFanPower;

             setFanPower(currentFanPower);

             currentTriacPower=profiles[profile].HeaterPower;

             setTemperature=profiles[profile].Stage1Temp;

             setDuration=profiles[profile].Stage1Time;

             PIDenable=true;

             P=2;

             myPID.SetTunings(P, I, D);                          

             seconds=0;

             Tstart=millis();

             state=1;

           break;

    default:

             currentTriacPower=0;

             currentFanPower=0;

             setFanPower(currentFanPower);

             PIDenable=false;

  }

  

  if (Abort) {

     state=OFF;

     key1int_guard=true;

     Serial.println("Abort!");

   }  

   

   updateTime_and_Temp();

   Triac();

}