87

Microcontroller Unit program

Arduino Program

#include <Streaming.h>
#include <Metro.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Streaming.h>
#include <EEPROM.h>
#include <OneWire.h>
#include "max6675.h"
#include <Servo.h>
#include <EEPROM.h>

int thermoDO[3] = {51, 48, 45};

int thermoCS[3] = {52, 49, 46};
int thermoCLK[3] = {53, 50, 47};

MAX6675 thermocouple0(thermoCLK[0], thermoCS[0],

thermoDO[0]);
MAX6675 thermocouple1(thermoCLK[1], thermoCS[1],
thermoDO[1]);
MAX6675 thermocouple2(thermoCLK[2], thermoCS[2],
thermoDO[2]);

Servo servo[2]; //flour, secret ingredient

LiquidCrystal_I2C lcd(0x3F,20,4);
Metro checkMetro = Metro(2000);
Metro timeMetro = Metro(1000);
Metro cutterMetro = Metro(5000);

Metro heaterMetro[3] = {Metro(2000) ,Metro(2000),

Metro(2000)};

int fasttime = A3;

int countdown = 60;
int vibmotor = 16;
int potoffset = 2;

int dir = 34;

int actuator = 35;
int conveyor[2] = {36, 37};
int door[2] = {38, 39};
int pm[2] = {6, 7}; //0-on, 1 -f/r
int buzzer = 13;
 88

int valve = A7;

int bdiff, odiff, fdiff;

int actlimit[2] = {22, 23}; //0-up, 1-down

int doorlimit[4] = {11, 12, 4, 5}; //0-1down, 1-2down, 2-
1up, 3-2up
int conlimit[4] ={24, 25, 26, 27}; //0-left, 1-right, 2-
middle1, 3-middle2

int button[2] = {A0, A2}; //start, stop

//int toggle[5] = {44, 30, 31, 32, 33}; //molding, forming,
boiling, oven, frying
int toggle[6] = {43, 44, 30, 31, 32, 33}; //dispenser,
molding, forming, boiling, oven, frying

int cutter = 14;

int hallcutter = 15;

int pot[5] = {A11, A12, A13, A14, A15, };

int temppot[3] = {A8, A9, A10};
int dispenserpot[3] = {A4, A5, A6};

int millingTime, moldingTime, boilingTime, ovenTime,

fryingTime, boilingTemp, ovenTemp, fryingTemp , oilTime,
flourTime, secTime;
int millingTime_, moldingTime_, boilingTime_, ovenTime_,
fryingTime_, boilingTemp_, ovenTemp_, fryingTemp_, oilTime_,
flourTime_, secTime_;
int heater[3] = {8, 9, 10}; // boiling, oven, frying

int SmillingTime, SmoldingTime, SboilingTime, SovenTime,

SfryingTime;
int SboilingTemp, SovenTemp, SfryingTemp;
int SoilTime, SflourTime;

int temp[3];

int ctr = 0, page = 0;

int subpage = 0;
int timerScreen = 0;

unsigned long TimeH, TimeM, TimeS, TimeSet = 3661;

boolean movmiddle = false;

boolean noselect = false;
boolean firsttime = true;
boolean heatstat[3] = {false, false, false};
 89

boolean limitlock = false;

void setup(){
[Link](9600);
[Link](100);
//I2CADD();
[Link]();
[Link]();

// for(int i = 0; i < 5; i++) [Link](i, 5); //time in

minutes, molding, forming, boiling, oven, frying
// for(int i = 10; i < 13; i++) [Link](i, 60);
//temperature - boiling, oven, frying
// [Link](20, 1); //oil seconds
// [Link](21, 2); //grams*100 currently 200grams

SmillingTime = [Link](0);
SmoldingTime = [Link](1);
SboilingTime = [Link](2);
SovenTime = [Link](3);
SfryingTime = [Link](4);

SboilingTemp = [Link](10);
SovenTemp = [Link](11);
SfryingTemp = [Link](12);

SoilTime = [Link](20);
SflourTime = [Link](21);

for(int i = 0; i < 2; i++) pinMode(conveyor[i], OUTPUT),

digitalWrite(conveyor[i], HIGH), pinMode(door[i], OUTPUT),
digitalWrite(door[i], HIGH), pinMode(pm[i], OUTPUT),
digitalWrite(pm[i], HIGH);
for(int i = 0; i < 3; i++) pinMode(heater[i], OUTPUT),
digitalWrite(heater[i], LOW);

pinMode(cutter, OUTPUT);
pinMode(hallcutter, INPUT_PULLUP);

digitalWrite(cutter, HIGH);

for(int i = 0; i < 2; i++) pinMode(actlimit[i],

INPUT_PULLUP), pinMode(button[i], INPUT_PULLUP);
for(int i = 0; i < 4; i++) pinMode(conlimit[i],
INPUT_PULLUP), pinMode(doorlimit[i], INPUT_PULLUP);
for(int i = 0; i < 5; i++) pinMode(toggle[i],
INPUT_PULLUP);
 90

pinMode(buzzer, OUTPUT), digitalWrite(buzzer, LOW);

pinMode(valve, OUTPUT), digitalWrite(valve, LOW);
pinMode(dir, OUTPUT), digitalWrite(dir, HIGH);
pinMode(actuator, OUTPUT), digitalWrite(actuator, HIGH);
pinMode(fasttime, INPUT_PULLUP);
pinMode(vibmotor, OUTPUT), digitalWrite(vibmotor, HIGH);;

// servo[0].attach(2);
// servo[1].attach(3);

Serial << "device started" << endl;

[Link](0,0), lcd << "====================";
[Link](0,1), lcd << " Fried Miki Maker ";
[Link](0,2), lcd << " BS CPE Batch 2018 ";
[Link](0,3), lcd << "====================";
BEEP(2, 500);

delay(2000);
// SERVOOPEN(0);
// SERVOOPEN(1);
//
// delay(10000);
}

void INIT(){
ctr = 0, page = 0;
subpage = 0;
timerScreen = 0;

TimeH = 0, TimeM = 0, TimeS = 0, TimeSet = 0;

movmiddle = false;
noselect = false;
firsttime = true;
for(int i = 0; i < 3; i++) heatstat[i] = false;
limitlock = false;
}

void CHECKPOT(){
millingTime = constrain(map(analogRead(pot[0]),0, 1023,
-2, 65), 1, 60);
moldingTime = constrain(map(analogRead(pot[1]),0, 1023,
-2, 65), 1, 60);
boilingTime = constrain(map(analogRead(pot[2]),0, 1023,
-2, 65), 1, 60);
ovenTime = constrain(map(analogRead(pot[3]),0, 1023, -2,
65), 1, 60);
 91

fryingTime = constrain(map(analogRead(pot[4]),0, 1023, -1,

12), 1, 10);
boilingTemp = constrain(map(analogRead(temppot[0]),0,
1023, 35, 95), 35, 90);
ovenTemp = constrain(map(analogRead(temppot[1]),0, 1023,
35, 95), 35, 90);
fryingTemp = constrain(map(analogRead(temppot[2]),0, 1023,
35, 255), 35, 250);

oilTime = constrain(map(analogRead(dispenserpot[0]),0,
1023, -4, 25), 1, 20);
flourTime = constrain(map(analogRead(dispenserpot[1]),0,
1023, -4, 25), 1, 20);
secTime = constrain(map(analogRead(dispenserpot[2]),0,
1023, -4, 25), 1, 20);

// Serial << "***************************************Time"

<< endl;
// Serial << "Milling: " << millingTime;
// Serial << ", Molding: " << moldingTime;
// Serial << ", Drying: " << boilingTime;
// Serial << ", Oven: " << ovenTime;
// Serial << ", Frying: " << fryingTime;
// Serial << ", boilingTemp: " << boilingTemp;
// Serial << ", ovenTemp: " << ovenTemp;
// Serial << ", fryingTemp: " << fryingTemp;
//
// Serial << endl;
// Serial << "***************************************" <<
endl;

void CHECKALL(){
// Serial << "tmolding: " << digitalRead(toggle[0]) << ",
tforming: " << digitalRead(toggle[1]) << ", tboiling: " <<
digitalRead(toggle[2]) << ", toven: " <<
digitalRead(toggle[3]) << ", tfrying: " <<
digitalRead(toggle[4]);
// Serial << "**********************" << endl;
// Serial << "btnstart: " << digitalRead(button[0]) << ",
btnstop: " << digitalRead(button[1]) << endl;
// Serial << "**********************" << endl;
// Serial << "lmtup: " << digitalRead(limit[0]) << ",
lmtdown: " << digitalRead(limit[1]) << ", lmtleft: " <<
digitalRead(limit[2]);
 92

//// Serial << ", lmtmiddle: " << digitalRead(limit[3]) <<

", lmtright: " << digitalRead(limit[4]) << endl;
// Serial << "**********************" << endl;
// Serial << "pot: " << analogRead(0) << ", boilheat: " <<
digitalRead(heater[0]) << ", ovenheat: " <<
digitalRead(heater[1])<< ", fryheat: " <<
digitalRead(heater[2]) << endl;
// Serial << "**********************" << endl;
// Serial << "dir: " << digitalRead(dir) << ", conveyor: "
<< digitalRead(conveyor) << ", actuator: " <<
digitalRead(actuator) << endl;
// Serial << "doorlimit0: " << digitalRead(doorlimit[0]) <<
", doorlimit1: " << digitalRead(doorlimit[1]) << ",
doorlimit2: " << digitalRead(doorlimit[2]) << ", doorlimit3:
" << digitalRead(doorlimit[3]) << endl;
Serial << "conlimit1: " << digitalRead(conlimit[0]) << ",
conlimit2: " << digitalRead(conlimit[1]) << endl;

SECCONVERT();
}

void SERCOM(){
String inData = [Link]();
if([Link]("o") > - 1) SERVOOPEN(0);
else if([Link]("c") > - 1) SERVOCLOSE(0);

void SERVOOPEN(int x){

Serial << "Servo open-" << x << endl;
if(!x){

servo[x].attach(2+x);
delay(100);
servo[x].write(100);
delay(500);
servo[x].detach();
delay(500);
}
else{
servo[x].attach(2+x);
delay(100);
servo[x].write(107);
delay(500);
servo[x].detach();
delay(500);
}
 93

void SERVOCLOSE(int x){

Serial << "Servo close-" << x << endl;
if(!x){
servo[x].attach(2+x);
delay(100);
servo[x].write(0);
delay(500);
servo[x].detach();
delay(500);
}
else{
servo[x].attach(2+x);
delay(100);
servo[x].write(10);
delay(500);
servo[x].detach();
delay(500);
}
}

void VALVEOPEN(){
Serial << "valve open" << endl;
digitalWrite(valve, HIGH);
}

void VALVECLOSE(){
Serial << "valve close" << endl;
digitalWrite(valve, LOW);
}

void GETTEMP(){
//CHECKPOT();

temp[0] = [Link](); //bpiler

temp[1] = [Link](); //dryer
temp[2] = [Link](); //fryer

bdiff = SboilingTemp - temp[0];

odiff = SovenTemp - temp[1];
fdiff = SfryingTemp - temp[2];

Serial << "boiler temp: " << temp[0] << ", sp: " <<
boilingTemp << ", bdiff: " << bdiff << endl;
Serial << "oven temp: " << temp[1] << ", sp: " << ovenTemp
<< ", odiff: " << odiff << endl;
 94

Serial << "fryer temp: " << temp[2] << ", sp: " <<
fryingTemp << ", fdiff: " << fdiff << endl;
Serial <<
"***********************************************************
*" << endl;
}

void loop(){
if([Link]() && page == 4){
digitalWrite(cutter, LOW);
delay(200);
[Link]();
}

if(!digitalRead(cutter) && !digitalRead(hallcutter))

digitalWrite(cutter, HIGH);

if([Link]()){
if(page == 8) BEEP(1, 500);
CHECKALL();
GETTEMP();
[Link]();
// if(page == 1){
// if(!digitalRead(toggle[2]) && !
digitalRead(toggle[4])){
// digitalWrite(heater[0], !
digitalRead(heater[2]));
// digitalWrite(heater[2], !
digitalRead(heater[0]));
// }
// else{
// if(!digitalRead(toggle[2])){
// digitalWrite(heater[0], !
digitalRead(heater[0]));
// }
// if(!digitalRead(toggle[4])){
// digitalWrite(heater[2], !
digitalRead(heater[2]));
// }
// }
// }
}

if(!digitalRead(fasttime)){
[Link](50);
}
else{
 95

[Link](1000);
}

for(int i = 0; i < 3; i++){

if(heaterMetro[i].check()){
if(heatstat[i]){
Serial << "heatstat: " << i << endl;
GETTEMP();
if(i == 0){
if(bdiff > 10) SSRON(i);
else if(bdiff > 3) digitalWrite(heater[i], !
digitalRead(heater[i])), heaterMetro[i].interval(1000);
else SSROFF(i);
}
else if(i == 1){
if(odiff > 10) SSRON(i);
else if(odiff > 3) digitalWrite(heater[i], !
digitalRead(heater[i])), heaterMetro[i].interval(1000);
else SSROFF(i);
}
else if(i == 2){
if(fdiff > 10) SSRON(i);
else if(fdiff > 3) digitalWrite(heater[i], !
digitalRead(heater[i])), heaterMetro[i].interval(1000);
else SSROFF(i);
}

}
heaterMetro[i].reset();
}
}

if([Link]()){
if(page > 1){
TimeSet--;
SECCONVERT();
}
[Link]();
}
if([Link]()) SERCOM();

switch(page){
case 0:
//[Link]();
[Link](0,0), lcd << "====================";
[Link](0,1), lcd << " Initializing ";
[Link](0,2), lcd << " Please Wait... ";
[Link](0,3), lcd << "====================";
 96

for(int i = 0; i < 2; i++) SERVOCLOSE(i);

Serial << "moveup..." << millis() << endl;

while(digitalRead(actlimit[0])) MOVEUP();
STOPALL(), BEEP(2, 50);

Serial << "doors open..." << millis() << endl;

digitalWrite(dir, LOW);
limitlock = false;

[Link](0,0), lcd << "====================";

[Link](0,1), lcd << " Opening Oven Doors ";
[Link](0,2), lcd << " Please Wait... ";
[Link](0,3), lcd << "====================";

while(!limitlock){
if(digitalRead(doorlimit[0])) digitalWrite(door[0],
LOW);
else digitalWrite(door[0], HIGH);

if(digitalRead(doorlimit[1])) digitalWrite(door[1],
LOW);
else digitalWrite(door[1], HIGH);

ctr = 0;
for(int i = 0; i < 50; i++){
if(!digitalRead(doorlimit[0]) && !
digitalRead(doorlimit[1])) ctr++;
if(ctr > 40) limitlock = true;
}
}

STOPALL(), BEEP(2, 50);

[Link](0,0), lcd << "====================";

[Link](0,1), lcd << " Moving Conveyor ";
[Link](0,2), lcd << " Please Wait.. ";
[Link](0,3), lcd << "====================";

Serial << "moveleft..." << millis() << endl;

MOVEL();

while(digitalRead(conlimit[0])) ;
STOPALL(), BEEP(2, 50);
page = 1;
timerScreen = 50;
BEEP(2, 500);
 97

[Link]();
firsttime = true;
break;

case 1:
CHECKPOT();
for(int i = 0; i < 3; i++) heatstat[i] = false;

if(oilTime > oilTime_ + 2 || oilTime < oilTime_ - 2){

timerScreen = 20;
}
else if(flourTime > flourTime_ + 2 || flourTime <
flourTime_ - potoffset){
timerScreen = 21;
}
// else if(secTime > secTime_ + potoffset || secTime <
secTime_ - potoffset){
// timerScreen = 10;
// }

else if(millingTime > millingTime_ + potoffset ||

millingTime < millingTime_ - potoffset){
timerScreen = 0;
}
else if(moldingTime > moldingTime_ + potoffset ||
moldingTime < moldingTime_ - potoffset){
timerScreen = 1;
}
else if(boilingTime_ > boilingTime_ + potoffset ||
boilingTime < boilingTime_ - potoffset){
timerScreen = 2;
}
else if(ovenTime > ovenTime_ + potoffset || ovenTime <
ovenTime_ - potoffset){
timerScreen = 3;
}
else if(fryingTime > fryingTime_ + potoffset ||
fryingTime < fryingTime_ - potoffset){
timerScreen = 4;
}
else if(boilingTemp > boilingTemp_ + potoffset ||
boilingTemp < boilingTemp_ - potoffset){
timerScreen = 10;
}
else if(ovenTemp > ovenTemp_ + potoffset || ovenTemp <
ovenTemp_ - potoffset){
timerScreen = 11;
 98

}
else if(fryingTemp > fryingTemp_ + potoffset ||
fryingTemp < fryingTemp_ - potoffset){
timerScreen = 12;
}

if(firsttime){
firsttime = false;
timerScreen = 50;
}

switch(timerScreen){
case 0:
[Link](0,0), lcd << " Settings ";
[Link](0,1), lcd << "Process: Milling ";
[Link](0,2), lcd << "Time(min): " <<
SmillingTime << " ";
[Link](0,3), lcd << "Time Set(min): " <<
millingTime << " ";

if(!digitalRead(button[1])){ //set button

BEEP(1, 10);
while(!digitalRead(button[1])) ;
[Link](timerScreen, millingTime);
SmillingTime = [Link](timerScreen);
BEEP(2, 100);
}
break;
case 1:
[Link](0,0), lcd << " Settings ";
[Link](0,1), lcd << "Process: Forming ";
[Link](0,2), lcd << "Time(min): " <<
SmoldingTime << " ";
[Link](0,3), lcd << "Time Set(min): " <<
moldingTime << " ";

if(!digitalRead(button[1])){ //set button

BEEP(1, 10);
while(!digitalRead(button[1])) ;
[Link](timerScreen, moldingTime);
SmoldingTime = [Link](timerScreen);
BEEP(2, 100);
}
break;
case 2:
[Link](0,0), lcd << " Settings ";
 99

[Link](0,1), lcd << "Process: Boiling ";

[Link](0,2), lcd << "Time(min): " <<
SboilingTime << " ";
[Link](0,3), lcd << "Time Set(min): " <<
boilingTime << " ";

if(!digitalRead(button[1])){ //set button

BEEP(1, 10);
while(!digitalRead(button[1])) ;
[Link](timerScreen, boilingTime);
SboilingTime = [Link](timerScreen);
BEEP(2, 100);
}
break;
case 3:
[Link](0,0), lcd << " Settings ";
[Link](0,1), lcd << "Process: Drying ";
[Link](0,2), lcd << "Time(min): " <<
SovenTime << " ";
[Link](0,3), lcd << "Time Set(min): " <<
ovenTime << " ";

if(!digitalRead(button[1])){ //set button

BEEP(1, 10);
while(!digitalRead(button[1])) ;
[Link](timerScreen, ovenTime);
SovenTime = [Link](timerScreen);
BEEP(2, 100);
}
break;
case 4:
[Link](0,0), lcd << " Settings ";
[Link](0,1), lcd << "Process: Frying ";
[Link](0,2), lcd << "Time(min): " <<
SfryingTime << " ";
[Link](0,3), lcd << "Time Set(min): " <<
fryingTime << " ";

if(!digitalRead(button[1])){ //set button

BEEP(1, 10);
while(!digitalRead(button[1])) ;
[Link](timerScreen, fryingTime);
SfryingTime = [Link](timerScreen);
BEEP(2, 100);
}
break;
case 10:
 100

[Link](0,0), lcd << " Settings ";

[Link](0,1), lcd << "Process: Boiling ";
[Link](0,2), lcd << "Temp("<< char(223) <<
"C): " << SboilingTemp << " ";
[Link](0,3), lcd << "Temp Set("<< char(223)
<< "C): " << boilingTemp << " ";

if(!digitalRead(button[1])){ //set button

BEEP(1, 10);
while(!digitalRead(button[1])) ;
[Link](timerScreen, boilingTemp);
SboilingTemp = [Link](timerScreen);
BEEP(2, 100);
}
break;
case 11:
[Link](0,0), lcd << " Settings ";
[Link](0,1), lcd << "Process: Oven ";
[Link](0,2), lcd << "Temp("<< char(223) <<
"C): " << SovenTemp << " ";
[Link](0,3), lcd << "Temp Set("<< char(223)
<< "C): " << ovenTemp << " ";

if(!digitalRead(button[1])){ //set button

BEEP(1, 10);
while(!digitalRead(button[1])) ;
[Link](timerScreen, ovenTemp);
SovenTemp = [Link](timerScreen);
BEEP(2, 100);
}
break;
case 12:
[Link](0,0), lcd << " Settings ";
[Link](0,1), lcd << "Process: Frying ";
[Link](0,2), lcd << "Temp("<< char(223) <<
"C): " << SfryingTemp << " ";
[Link](0,3), lcd << "Temp Set("<< char(223)
<< "C): " << fryingTemp << " ";

if(!digitalRead(button[1])){ //set button

BEEP(1, 10);
while(!digitalRead(button[1])) ;
[Link](timerScreen, fryingTemp);
SfryingTemp = [Link](timerScreen);
BEEP(2, 100);
}
break;
 101

case 20:
[Link](0,0), lcd << " Settings ";
[Link](0,1), lcd << "Ingredient: Water ";
[Link](0,2), lcd << "Unit("<< "" << "): "
<< SoilTime << " ";
[Link](0,3), lcd << "Unit Set(ml): " <<
oilTime*100 << " ";

if(!digitalRead(button[1])){ //set button

BEEP(1, 10);
while(!digitalRead(button[1])) ;
[Link](timerScreen, oilTime);
SoilTime = [Link](timerScreen);
BEEP(2, 100);
}
break;
case 21:
[Link](0,0), lcd << " Settings ";
[Link](0,1), lcd << "Ingredient: Flour ";
[Link](0,2), lcd << "Weight("<< "g" << "):
" << SflourTime*100 << " ";
[Link](0,3), lcd << "Weight Set(g): " <<
flourTime*100 << " ";

if(!digitalRead(button[1])){ //set button

BEEP(1, 10);
while(!digitalRead(button[1])) ;
[Link](timerScreen, flourTime);
SflourTime = [Link](timerScreen);
BEEP(2, 100);
}
break;
case 50:
[Link](0,0), lcd << "====================";
[Link](0,1), lcd << " Press ";
[Link](0,2), lcd << " Start... ";
[Link](0,3), lcd << "====================";
break;
}

millingTime_ = millingTime;
moldingTime_ = moldingTime;
boilingTime_ = boilingTime;
ovenTime_ = ovenTime;
fryingTime_ = fryingTime;
boilingTemp_ = boilingTemp;
ovenTemp_ = ovenTemp;
 102

fryingTemp_ = fryingTemp;
oilTime_ = oilTime;
flourTime_ = flourTime;
//secTime_ = secTime;
if(!digitalRead(button[0])){
noselect = false;
ctr = 0;
for(int i = 0; i < 50; i++){
if(!digitalRead(button[0])) ctr++;
}
if(ctr > 30){
//startprocess
noselect = true;
Serial << "button start pressed..." << endl;
for(int i = 0; i < 6; i++){
if(!digitalRead(toggle[i])){
page = i + 2;
noselect = false;
SSROFF(0);
SSROFF(2);
firsttime = true;
break;
}

}
if(noselect){
[Link](0,0), lcd <<
"====================";
[Link](0,1), lcd << " No Process
";
[Link](0,2), lcd << " Selected...
";
[Link](0,3), lcd <<
"====================";
BEEP(30, 10);
delay(3000);
}
else{
TimeH = 0, TimeM = 0, TimeS = 0;
GETETA();
BEEP(2, 500);
}
}
}

break;
 103

case 2: //ingredient
[Link](0,0), lcd << " System Status ";
[Link](0,1), lcd << "====================";
[Link](0,2), lcd << " Dispense Flour ";
digitalWrite(vibmotor, LOW);
Serial << "flourtime: " << SflourTime << endl;
for(int i = 0; i < SflourTime; i++){
SERVOOPEN(0), delay(2500), SERVOCLOSE(0); //flour
dispenser
SERVOOPEN(1), delay(1000), SERVOCLOSE(1);
delay(2500); //flour dispenser
[Link](0,3), lcd << (i + 1)*100 << " g ";
Serial << "dispense 100g" << endl;
}
digitalWrite(vibmotor, HIGH);
delay(500);

[Link](0,2), lcd << " Dispense Water ";

if(!digitalRead(toggle[1])) MOLDON();
for(int i = 0; i < oilTime; i++){

VALVEOPEN();
delay(1000);
[Link](0,3), lcd << (i + 1)*100 << " ml ";
VALVECLOSE(); //oil dispenser
}

//SERVOOPEN(1), delay(secTime*1000), SERVOCLOSE(1);

//while(true);
TimeSet = 0;
SECCONVERT();
ENDPROCESS();
break;

case 3: //milling
[Link](0,0), lcd << " System Status ";
[Link](0,1), lcd << "====================";
[Link](0,2), lcd << "Milling Please Wait ";
[Link](0,3), lcd << "Time: " << TimeH << ":" <<
TimeM << ":" << TimeS << " ";

MOLDON();
ENDPROCESS();

if(!digitalRead(toggle[2])) heatstat[0] = true;

else if(digitalRead(toggle[2])) heatstat[0] = false;
 104

break;

case 4: //forming
[Link](0,0), lcd << " System Status ";
[Link](0,1), lcd << "====================";
[Link](0,2), lcd << "Forming Please Wait ";
[Link](0,3), lcd << "Time: " << TimeH << ":" <<
TimeM << ":" << TimeS << " ";

FORMON();
ENDPROCESS();

// if(TimeM < 10 && !digitalRead(toggle[2]))

heatstat[0] = true;
// else if(digitalRead(toggle[2])) heatstat[0] = false;
//
// if(TimeM < 5 && !digitalRead(toggle[3])) heatstat[1]
= true;
// else if(digitalRead(toggle[3])) heatstat[1] = false;

break;

case 5: //boiling
if(firsttime){
SSRON(0);
if(!digitalRead(toggle[3])){ // preparation for oven
if(digitalRead(doorlimit[2])) CLOSEDOOR(1);
while(digitalRead(doorlimit[2])){
// Serial << digitalRead(doorlimit[2]) << endl;
[Link](0,0), lcd <<
"====================";
[Link](0,1), lcd << " Closing Oven Door
2";
[Link](0,2), lcd << " Please Wait
";
[Link](0,3), lcd <<
"====================";
}
}

STOPALL();
GETTEMP();
BEEP(1, 200);
[Link]();
while(temp[0] < SboilingTemp - 1){
SSRON(0);
 105

GETTEMP();
[Link](0,0), lcd << " System Status ";
[Link](0,1), lcd << " Preheating Boiler ";
[Link](0,2), lcd << "Temp Sp: " <<
SboilingTemp << " " << char(223) << "C ";
[Link](0,3), lcd << "Temp: " << temp[0] <<
" " << char(223) << "C ";
delay(100);
}

if(digitalRead(actlimit[1])) MOVEDOWN();
while(digitalRead(actlimit[1])){
[Link](0,0), lcd << "====================";
[Link](0,1), lcd << " Submersing ";
[Link](0,2), lcd << " Please Wait ";
[Link](0,3), lcd << "====================";

}
STOPALL();
BEEP(1, 200);
firsttime = false;
GETETA();
[Link]();
[Link]();
}

[Link](0,0), lcd << " System Status ";

[Link](0,1), lcd << "Boiling Please Wait ";
[Link](0,2), lcd << "Temp: " << temp[0] << " "
<< char(223) << "C ";
[Link](0,3), lcd << "Time: " << TimeH << ":" <<
TimeM << ":" << TimeS << " ";
if(!TimeM && TimeS <= 10) heatstat[0] = false;
else heatstat[0] = true;

if(TimeM < 10 && !digitalRead(toggle[3])) heatstat[1]

= true;
else if(digitalRead(toggle[3])) heatstat[1] = false;

if(!TimeM && TimeS < 3){

MOVEUP();
while(digitalRead(actlimit[0])){
[Link](0,0), lcd << "====================";
[Link](0,1), lcd << " Hinahango ";
 106

[Link](0,2), lcd << " Please Wait ";

[Link](0,3), lcd << "====================";
}
STOPALL();

while(true){
SSRON(1);
[Link](0,0), lcd << "====================";
[Link](0,1), lcd << " Draining... ";
[Link](0,2), lcd << " Please Wait ";
[Link](0,3), lcd << "====================";
delay(60000);

TimeM = 0, TimeH = 0, TimeS = 0;

ENDPROCESS();

break;
}

// if(TimeM < 5 && !digitalRead(toggle[4])) heatstat[2]

= true;
// else if(digitalRead(toggle[4])) heatstat[2] = false;
//ENDPROCESS();
break;

case 6: //oven
if(firsttime){
SSRON(1);
SSRON(2);
// MOVEUP();
// while(digitalRead(actlimit[0])){
// [Link](0,0), lcd <<
"====================";
// [Link](0,1), lcd << " Hinahango
";
// [Link](0,2), lcd << " Please Wait
";
// [Link](0,3), lcd <<
"====================";
// }
// STOPALL();

OPENDOOR(0);
while(digitalRead(doorlimit[0])){
[Link](0,0), lcd <<
"====================";
 107

[Link](0,1), lcd << " Opening Oven Door

1";
[Link](0,2), lcd << " Please Wait
";
[Link](0,3), lcd <<
"====================";
}
STOPALL();

CLOSEDOOR(1);
while(digitalRead(doorlimit[2])){
[Link](0,0), lcd <<
"====================";
[Link](0,1), lcd << " Closing Oven Door
2";
[Link](0,2), lcd << " Please Wait
";
[Link](0,3), lcd <<
"====================";
}
STOPALL();

MOVER();

[Link](0,0), lcd << "====================";

[Link](0,1), lcd << " Moving to Oven ";
[Link](0,2), lcd << " Please Wait ";
[Link](0,3), lcd << "====================";

while(digitalRead(conlimit[2]));

// if(digitalRead(conlimit[3]))
digitalWrite(conveyor[1], LOW);
// else digitalWrite(conveyor[1], HIGH);

STOPALL();

if(digitalRead(doorlimit[3])) CLOSEDOOR(0);
while(digitalRead(doorlimit[3])){
[Link](0,0), lcd <<
"====================";
[Link](0,1), lcd << " Closing Oven Door
1";
[Link](0,2), lcd << " Please Wait
";
[Link](0,3), lcd <<
"====================";
}
 108

STOPALL();

BEEP(1, 200);
firsttime = false;
GETETA();
[Link]();
[Link]();

while(temp[1] < SovenTemp - 1){

SSRON(1);
GETTEMP();
[Link](0,0), lcd << " System Status
";
[Link](0,1), lcd << " Preheating Oven
";
[Link](0,2), lcd << "Temp Sp: " <<
SovenTemp << " " << char(223) << "C ";
[Link](0,3), lcd << "Temp: " << temp[1]
<< " " << char(223) << "C ";
delay(100);

}
[Link](0,0), lcd << " System Status ";
[Link](0,1), lcd << " Drying Please Wait ";
[Link](0,2), lcd << "Temp: " << temp[1] << " "
<< char(223) << "C ";
[Link](0,3), lcd << "Time: " << TimeH << ":" <<
TimeM << ":" << TimeS << " ";

if(!TimeM && TimeS <= 5) heatstat[1] = false;

else heatstat[1] = true;

if(!digitalRead(toggle[4])) heatstat[2] = true;

else if(digitalRead(toggle[4])) heatstat[2] = false;
//SSRON(1);
ENDPROCESS();
break;

case 7: //frying
if(firsttime){

//SSRON(2);

Serial << digitalRead(conlimit[1]) << endl;

if(digitalRead(doorlimit[1])) OPENDOOR(1);
 109

while(digitalRead(doorlimit[1])){
[Link](0,0), lcd <<
"====================";
[Link](0,1), lcd << " Opening Oven Door
2";
[Link](0,2), lcd << " Please Wait
";
[Link](0,3), lcd <<
"====================";

}
STOPALL();
if(digitalRead(conlimit[1])) MOVER();
while(digitalRead(conlimit[1])){
[Link](0,0), lcd <<
"====================";
[Link](0,1), lcd << " Moving to Fryer
";
[Link](0,2), lcd << " Please Wait
";
[Link](0,3), lcd <<
"====================";
}
STOPALL();

while(temp[2] < SfryingTemp - 1){

SSRON(2);
GETTEMP();
delay(100);
[Link](0,0), lcd << " System Status
";
[Link](0,1), lcd << " Heating Oil ...
";
[Link](0,2), lcd << "Temp Sp: " <<
SfryingTemp << " " << char(223) << "C ";
[Link](0,3), lcd << "Temp: " << temp[2]
<< " " << char(223) << "C ";
delay(100);
}

if(digitalRead(actlimit[1])) MOVEDOWN();
while(digitalRead(actlimit[1])){
[Link](0,0), lcd <<
"====================";
[Link](0,1), lcd << " Submersing
";
 110

[Link](0,2), lcd << " Please Wait

";
[Link](0,3), lcd <<
"====================";
}
STOPALL();

BEEP(1, 200);
firsttime = false;
GETETA();
[Link]();
[Link]();
}
[Link](0,0), lcd << " System Status ";
[Link](0,1), lcd << " Frying Please Wait ";
[Link](0,2), lcd << "Temp: " << temp[2] << " "
<< char(223) << "C ";
[Link](0,3), lcd << "Time: " << TimeH << ":" <<
TimeM << ":" << TimeS << " ";

if(!TimeM && TimeS <= 5) heatstat[2] = false;

else heatstat[2] = true;
//SSRON(2);

if(!TimeM && TimeS < 3){

MOVEUP();
while(digitalRead(actlimit[0])){
[Link](0,0), lcd << "====================";
[Link](0,1), lcd << " Hinahango ";
[Link](0,2), lcd << " Please Wait ";
[Link](0,3), lcd << "====================";
}
STOPALL();

while(true){

[Link](0,0), lcd << "====================";

[Link](0,1), lcd << " Draining... ";
[Link](0,2), lcd << " Please Wait ";
[Link](0,3), lcd << "====================";
delay(60000);

BEEP(2, 100);

[Link](0,0), lcd << "====================";

[Link](0,1), lcd << " Picking... ";
[Link](0,2), lcd << " Please Wait ";
 111

[Link](0,3), lcd << "====================";

delay(30000);

TimeM = 0, TimeH = 0, TimeS = 0;

ENDPROCESS();
break;
}

break;

case 8: //finish
[Link](0,0), lcd << "====================";
[Link](0,1), lcd << " Process ";
[Link](0,2), lcd << " Finished... ";
[Link](0,3), lcd << "====================";

while(true){
if(!digitalRead(button[1])){
page = 0;
BEEP(3, 500);
INIT();
break;

}
}
break;
}

void ENDPROCESS(){

if(!TimeH && !TimeM && TimeS <= 0){

STOPALL();
BEEP(2, 800);
if(page == 7){

if(digitalRead(actlimit[0])) MOVEUP();
while(digitalRead(actlimit[0])){
[Link](0,0), lcd << "====================";
[Link](0,1), lcd << " Hinahango ";
[Link](0,2), lcd << " Please Wait ";
[Link](0,3), lcd << "====================";
}
STOPALL();
 112

page = 8;
[Link]();
}
else{
for(int i = (page-1); i < 6; i++){
if(!digitalRead(toggle[i])){
firsttime = true;
page = i + 2;
[Link]();
break;
}
else{
noselect = true;
STOPALL();
page = 8;
[Link]();
}
}

GETETA();
firsttime = true;
}

BEEP(2, 500);
}
}

void BEEP(int x, int y){

for(int i = 0; i < x; i++){
digitalWrite(buzzer, HIGH);
delay(y);
digitalWrite(buzzer, LOW);
delay(y/5);
}
}

void MOVEL(){
Serial << "moving left" << endl;
digitalWrite(dir, LOW);
delay(200);
for(int i = 0; i < 2; i++) digitalWrite(conveyor[i], LOW);
movmiddle = false;
}

void MOVER(){
Serial << "moving right" << endl;
 113

digitalWrite(dir, HIGH);
delay(200);
for(int i = 0; i < 2; i++) digitalWrite(conveyor[i], LOW);

movmiddle = false;
}

void MOVEM(){
Serial << "moving middle" << endl;
if(!digitalRead(conlimit[2]) || !digitalRead(conlimit[3]))
{
//do nothing, already in middle
}
else if(!digitalRead(conlimit[0])){
//move to right

MOVER();
movmiddle = true;
}
else if(!digitalRead(conlimit[1])){
//move to left

MOVEL();
movmiddle = true;
}
}

void CHECKMOTOR(){
if(!digitalRead(dir) && !digitalRead(actuator) && !
digitalRead(actlimit[0])) STOPALL(); //actuator up
if(digitalRead(dir) && !digitalRead(actuator) && !
digitalRead(actlimit[1])) STOPALL(); //actuator down
if(digitalRead(dir) && !digitalRead(conveyor[0]) && !
digitalRead(conveyor[1]) && !digitalRead(conlimit[1]))
STOPALL(); //conveyor right
if(!digitalRead(dir) && !digitalRead(conveyor[0]) && !
digitalRead(conveyor[1]) && !digitalRead(conlimit[0]))
STOPALL(); //conveyor left
if(movmiddle && !digitalRead(conveyor[0]) && !
digitalRead(conlimit[2])) STOPMOTOR(0);
if(movmiddle && !digitalRead(conveyor[1]) && !
digitalRead(conlimit[3])) STOPMOTOR(1);
}

void MOLDON(){
//Serial << "molder on" << endl;
digitalWrite(pm[0], LOW);
 114

digitalWrite(pm[1], HIGH);
}

void FORMON(){
//Serial << "former on" << endl;
digitalWrite(pm[0], LOW);
digitalWrite(pm[1], LOW);
}

void MOVEUP(){
//Serial << "actuator up" << endl;
digitalWrite(dir, LOW);
delay(200);
digitalWrite(actuator, LOW);
}

void MOVEDOWN(){
//Serial << "actuator down" << endl;
digitalWrite(dir, HIGH);
delay(200);
digitalWrite(actuator, LOW);
}

void SSRON(int x){

digitalWrite(heater[x], HIGH);
}

void SSROFF(int x){

digitalWrite(heater[x], LOW);
}

void OPENDOOR(int x){

Serial << "open door - " << x << endl;
digitalWrite(dir, LOW);
delay(100);
digitalWrite(door[x], LOW);
}

void CLOSEDOOR(int x){

Serial << "close door - " << x << endl;
digitalWrite(dir, HIGH);
delay(100);
digitalWrite(door[x], LOW);
}

void STOPALL(){
Serial << "stop all" << endl;
 115

digitalWrite(dir, HIGH);
digitalWrite(actuator, HIGH);
digitalWrite(conveyor[0], HIGH);
digitalWrite(conveyor[1], HIGH);
digitalWrite(door[0], HIGH);
digitalWrite(door[1], HIGH);
digitalWrite(pm[0], HIGH);
digitalWrite(pm[1], HIGH);
for(int i = 0; i < 3; i++) SSROFF(i);
}

void STOPMOTOR(int x){

Serial << "stop motor - " << x << endl;
digitalWrite(conveyor[x], HIGH);
}

void I2CADD(){
[Link]();
byte error, address;
int nDevices;

[Link]("Scanning...");

nDevices = 0;
for(address = 1; address < 127; address++ )
{
// The i2c_scanner uses the return value of
// the [Link] to see if
// a device did acknowledge to the address.
[Link](address);
error = [Link]();

if (error == 0)
{
[Link]("I2C device found at address 0x");
if (address<16)
[Link]("0");
[Link](address,HEX);
[Link](" !");

nDevices++;
}
else if (error==4)
{
[Link]("Unknown error at address 0x");
if (address<16)
[Link]("0");
 116

[Link](address,HEX);
}
}
if (nDevices == 0)
[Link]("No I2C devices found\n");
else
[Link]("done\n");

while(true) ;
}

void GETETA(){
CHECKPOT();
switch(page){
case 2:
TimeSet = 0;
break;
case 3:
TimeSet = SmillingTime*60;
break;

case 4:
TimeSet = SmoldingTime*60;
break;

case 5:
TimeSet = SboilingTime*60;
break;

case 6:
TimeSet = SovenTime*60;
break;

case 7:
TimeSet = SfryingTime*60;
break;

}
}

void SECCONVERT(){
unsigned long x, y = 0;

TimeH = TimeSet/3600L;
x = TimeSet - (TimeH*3600L);
//Serial << "x: " << x << endl;
x /= 60;
 117

TimeM = x;
TimeS = TimeSet - (TimeH*3600L) - (TimeM*60L);
//Serial << ">> " << TimeH << ":" << TimeM << ":" << TimeS
<< " <<" << endl;