Skip to content

B
brew
Commit 6eecd9b6 authored by João Lino's avatar João Lino
Browse files
Options

rough draft of the code for the new version. 

I'll call it 2.0.001
parent 959b24bc
Show whitespace changes
Inline Side-by-side
Showing with 1123 additions and 912 deletions
brew.ino
View file @ 6eecd9b6
// ######################### DECLARE #########################
// ++++++++++++++++++++++++ ERROR ++++++++++++++++++++++++
//#include "error.h"
// ++++++++++++++++++++++++ ERROR ++++++++++++++++++++++++
// ++++++++++++++++++++++++ Library - DHT ++++++++++++++++++++++++
//#include "DHT.h" //DHT humidity/temperature sensors
//#define DHTPIN 2 // What pin we're connected to
//#define DHTTYPE DHT11 // DHT 11
#define ponto1 A4//
//#define ponto2 A5//
//#define R1 99.45
//#define R2 100.2
//#define R3 100.05
//#define calibragem 12.709066573
//float amostra1;//
float temperatura, temperatura1;//
float tabela[] = {100.00, 100.39, 100.78, 101.17, 101.56, 101.95, 102.34, 102.73, 103.12, 103.51, 103.90, 104.29, 104.68, 105.07, 105.46, 105.85, 106.24, 106.63, 107.02, 107.40, 107.79, 108.18, 108.57, 108.96, 109.35, 109.73, 110.12, 110.51, 110.90, 111.29, 111.67, 112.06, 112.45, 112.83, 113.22, 113.61, 114.00, 114.38, 114.77, 115.15, 115.54, 115.93, 116.31, 116.70, 117.08, 117.47, 117.86, 118.24, 118.63, 119.01, 119.40, 119.78, 120.17, 120.55, 120.94, 121.32, 121.71, 122.09, 122.47, 122.86, 123.24, 123.63, 124.01, 124.39, 124.78, 125.16, 125.54, 125.93, 126.31, 126.69, 127.08, 127.46, 127.84, 128.22, 128.61, 128.99, 129.37, 129.75, 130.13, 130.52, 130.90, 131.28, 131.66, 132.04, 132.42, 132.80, 133.18, 133.57, 133.95, 134.33, 134.71, 135.09, 135.47, 135.85, 136.23, 136.61, 136.99, 137.37, 137.75, 138.13, 138.51, 138.88, 139.26, 139.64, 140.02, 140.40, 140.78, 141.16, 141.54, 141.91, 142.29, 142.67, 143.05, 143.43, 143.80, 144.18, 144.56, 144.94, 145.31, 145.69, 146.07, 146.44, 146.82, 147.20, 147.57, 147.95, 148.33, 148.70, 149.08, 149.46, 149.83, 150.21, 150.58, 150.96, 151.33, 151.71, 152.08, 152.46, 152.83, 153.21, 153.58, 153.96, 154.33, 154.71, 155.08, 155.46, 155.83, 156.20, 156.58, 156.95, 157.33, 157.70, 158.07, 158.45, 158.82, 159.19, 159.56, 159.94, 160.31, 160.68, 150.00, 160.00, 161.05, 161.43, 161.80, 162.17, 162.54, 162.91, 163.29, 163.66, 164.03, 164.40, 164.77, 165.14, 165.51, 165.89, 166.26, 166.63, 167.00, 167.37, 167.74, 168.11, 168.48, 168.85, 169.22, 169.59, 169.96, 170.33, 170.70, 171.07, 171.43, 171.80, 172.17, 172.54, 172.91, 173.28, 173.65, 174.02, 174.38, 174.75, 175.12, 175.49, 175.86, 176.22, 176.59, 176.96, 177.33, 177.69, 178.06, 178.43, 178.79, 179.16};
//float amostras[] = {630.00,630.00,630.00}; //,630.00,630.00,630.00,630.00,630.00,630.00,630.00,630.00,630.00,630.00,630.00,630.00,630.00,630.00,630.00,630.00,630.00};
float Vout;
float Rx;
#define DEBUG
/*
float amostra2;//
float diferenca;
float tensaoPorAmostra;
float Vg;
float Vs;
float a;
float Rx;
*/
// ++++++++++++++++++++++++ Library - DHT ++++++++++++++++++++++++
// ++++++++++++++++++++++++ Library - LiquidCrystal_I2C ++++++++++++++++++++++++
#include <Wire.h>
#include <LCD.h>
#include <LiquidCrystal_I2C.h>
#define LCD_I2C_ADDR 0x27 // <<----- Add your address here. Find it from I2C Scanner
#define LCD_X 16
#define LCD_Y 2
#define BACKLIGHT_PIN 3
#define En_pin 2
#define Rw_pin 1
#define Rs_pin 0
#define D4_pin 4
#define D5_pin 5
#define D6_pin 6
#define D7_pin 7
// ++++++++++++++++++++++++ Library - LiquidCrystal_I2C ++++++++++++++++++++++++
// ++++++++++++++++++++++++ Heating Element Relay ++++++++++++++++++++++++
#include <PID_v1.h>
#define HEATING_ELEMENT 24
// ######################### CONSTANTS #########################
// ######################### SETTINGS #########################
// ++++++++++++++++++++++++ Heating Element Relay ++++++++++++++++++++++++
#define HEATING_ELEMENT_DEFAULT_WINDOW_SIZE 1000
#define HEATING_ELEMENT_OUTPUT_PIN 24
#define HEATING_ELEMENT_MAX_HEAT_PWM_INTEGER 5
#define HEATING_ELEMENT_MAX_HEAT_PWM_FLOAT 5.0
#define HEATING_ELEMENT_MAX_WATTAGE 3000.0 // Minimum = 2000.0
#define HEATING_ELEMENT_AC_FREQUENCY_HZ 50.0
// ++++++++++++++++++++++++ Temperature ++++++++++++++++++++++++
#define TEMPERATURE_SENSOR_PIN 30
#define TEMPERATURE_MAX_POSITION 120
// ++++++++++++++++++++++++ Temperature ++++++++++++++++++++++++
// ++++++++++++++++++++++++ Mixer ++++++++++++++++++++++++
#define MIXER_PIN 12
#define MIXER_MAX_POSITION 255
#define PT100_BASE_INPUT_PIN A4
#define PT100_BASE_OUTPUT_PIN 30
#define PT100_BASE_TIME_BETWEEN_READINGS 100
#define PT100_UP_INPUT_PIN A5
#define PT100_UP_OUTPUT_PIN 31
#define PT100_UP_TIME_BETWEEN_READINGS 100
#define PT100_DOWN_INPUT_PIN A6
#define PT100_DOWN_OUTPUT_PIN 32
#define PT100_DOWN_TIME_BETWEEN_READINGS 100
#define PT100_BASE_DEFAULT_ADC_VMAX 1.081
#define PT100_BASE_DEFAULT_VS 4.87
#define PT100_BASE_DEFAULT_R1_RESISTENCE 606.0
#define PT100_BASE_DEFAULT_LINE_RESISTENCE 0.7
#define PT100_BASE_DEFAULT_OPERATION_RESISTENCE 0.0
#define PT100_UP_DEFAULT_ADC_VMAX 1.081
#define PT100_UP_DEFAULT_VS 4.87
#define PT100_UP_DEFAULT_R1_RESISTENCE 606.0
#define PT100_UP_DEFAULT_LINE_RESISTENCE 0.7
#define PT100_UP_DEFAULT_OPERATION_RESISTENCE 0.0
#define PT100_DOWN_DEFAULT_ADC_VMAX 1.081
#define PT100_DOWN_DEFAULT_VS 4.87
#define PT100_DOWN_DEFAULT_R1_RESISTENCE 606.0
#define PT100_DOWN_DEFAULT_LINE_RESISTENCE 0.7
#define PT100_DOWN_DEFAULT_OPERATION_RESISTENCE 0.0
// ++++++++++++++++++++++++ Mixer ++++++++++++++++++++++++
//#define MIXER_PIN 12
//#define MIXER_MAX_POSITION 255
// ++++++++++++++++++++++++ Rotary Encoder ++++++++++++++++++++++++
#define ROTARY_ENCODER_INTERRUPT_NUMBER 1 // On Mega2560 boards, interrupt 1 is on pin 3
#define ROTARY_ENCODER_CLK_PIN 3 // Used for generating interrupts using CLK signal
#define ROTARY_ENCODER_DT_PIN 22 // Used for reading DT signal
#define ROTARY_ENCODER_SW_PIN 23 // Used for the push button switch
#define ROTARY_ENCODER_DEBOUNCE_TIME 10 // Number of miliseconds to ignore new signals a signal is received
// ++++++++++++++++++++++++ State Machine ++++++++++++++++++++++++
#define SETTING_WELCOME_TIMEOUT 2000
#define SETTING_WELCOME_TIMEOUT 100
#define SETTING_MAX_INACTIVITY_TIME 3000
#define MENU_MAX_DEPTH 10
#define MENU_INIT_VALUES -1,-1,-1,-1,-1,-1,-1,-1,-1,-1
// ++++++++++++++++++++++++ State Machine ++++++++++++++++++++++++
// ######################### DECLARE #########################
#define MENU_SIZE_MAIN_MENU 16
#define SETTING_SERIAL_MONITOR_BAUD_RATE 9600
#define SETTING_SERIAL_MONITOR_WELCOME_MESSAGE "Let's start Brewing!"
// ######################### LIBRARIES #########################
// ++++++++++++++++++++++++ LiquidCrystal_I2C ++++++++++++++++++++++++
#include <Wire.h>
#include <LCD.h>
#include <LiquidCrystal_I2C.h>
// ######################### INITIALIZE #########################
// ++++++++++++++++++++++++ Library - DHT ++++++++++++++++++++++++
//DHT dht(DHTPIN, DHTTYPE);
// ++++++++++++++++++++++++ Library - DHT ++++++++++++++++++++++++
// ++++++++++++++++++++++++ Library - LiquidCrystal_I2C ++++++++++++++++++++++++
int n = 1;
LiquidCrystal_I2C lcd(LCD_I2C_ADDR,En_pin,Rw_pin,Rs_pin,D4_pin,D5_pin,D6_pin,D7_pin);
// ++++++++++++++++++++++++ Library - LiquidCrystal_I2C ++++++++++++++++++++++++
#define LCD_I2C_ADDR 0x27 // <<----- Add your address here. Find it from I2C Scanner
#define LCD_HORIZONTAL_RESOLUTION 16
#define LCD_VERTICAL_RESOLUTION 2
#define LCD_BACKLIGHT_PIN 3
#define LCD_EN_PIN 2
#define LCD_RW_PIN 1
#define LCD_RS_PIN 0
#define LCD_D4_PIN 4
#define LCD_D5_PIN 5
#define LCD_D6_PIN 6
#define LCD_D7_PIN 7
// ++++++++++++++++++++++++ PT100 +++++++++++++++++++++++++++++++++
#include <PT100.h>
// ######################### VARIABLES #########################
// ++++++++++++++++++++++++ Rotary Encoder ++++++++++++++++++++++++
volatile int rotaryEncoderVirtualPosition = 0;
volatile int rotaryEncoderVirtualPosition;
volatile int rotaryEncoderMaxPosition;
volatile int menuSize = 2;
const int PinCLK = 3; // Used for generating interrupts using CLK signal
const int PinDT = 22; // Used for reading DT signal
const int PinSW = 23; // Used for the push button switch
// ++++++++++++++++++++++++ Rotary Encoder ++++++++++++++++++++++++
volatile int rotaryEncoderMinPosition;
volatile int rotaryEncoderSingleStep;
volatile int rotaryEncoderMultiStep;
// ++++++++++++++++++++++++ Heating Element Relay ++++++++++++++++++++++++
//Define Variables we'll be connecting to
double Setpoint, Input, Output;
//Specify the links and initial tuning parameters
float Kp = 200;
float Ki = 50;
float Kd = 0;
//PID myPID(&Input, &Output, &Setpoint,Kp,Ki,Kd, DIRECT);
//PID myPID(&Input, &Output, &Setpoint,1000,50,0, DIRECT);
PID myPID(&Input, &Output, &Setpoint,200,50,0, DIRECT);
int WindowSize = 1000;
int WindowSize; // Time frame to operate in
unsigned long windowStartTime;
// ++++++++++++++++++++++++ Heating Element Relay ++++++++++++++++++++++++
// ++++++++++++++++++++++++ Mixer ++++++++++++++++++++++++
//const int mixerSpeed = 130;
// ++++++++++++++++++++++++ Mixer ++++++++++++++++++++++++
// ++++++++++++++++++++++++ Error ++++++++++++++++++++++++
enum sys_error {
no_error,
catastrofic_failure_sensor_temperature,
catastrofic_failure_program,
catastrofic_failure_logic_auto_manual
};
sys_error error = no_error;
// ++++++++++++++++++++++++ Error ++++++++++++++++++++++++
// ++++++++++++++++++++++++ State Machine ++++++++++++++++++++++++
unsigned long dWattPerPulse;
// ++++++++++++++++++++++++ State Machine ++++++++++++++++++++++++
// global
enum state_machine {
state_welcome,
state_menu,
state_manual_time,
state_manual_temperature,
state_manual_mode,
state_manual_mixer,
state_error
enum TRotaryEncoderMode {
eRotaryEncoderMode_Menu,
eRotaryEncoderMode_Time,
eRotaryEncoderMode_Generic,
eRotaryEncoderMode_Disabled
};
state_machine state = state_welcome;
TRotaryEncoderMode rotaryEncoderMode;
// menu
enum main_menu_list {
main_manual,
main_auto
enum eMainMenuOptions {
eMainMenu_GO,
eMainMenu_Presets,
eMainMenu_Malt,
eMainMenu_Startpoint,
eMainMenu_BetaGlucanase,
eMainMenu_Debranching,
eMainMenu_Proteolytic,
eMainMenu_BetaAmylase,
eMainMenu_AlphaAmylase,
eMainMenu_Mashout,
eMainMenu_Recirculation,
eMainMenu_Sparge,
eMainMenu_Boil,
eMainMenu_Hops,
eMainMenu_Cooling,
eMainMenu_Settings
};
eMainMenuOptions mainMenuOption;
enum ePresetsMenuOptions {
ePresetsMenu_Trigo,
ePresetsMenu_IPA,
ePresetsMenu_Belga,
ePresetsMenu_Red,
ePresetsMenu_APA,
ePresetsMenu_Back,
};
enum manual_menu_list {
manual_temperature,
manual_time,
manual_mode,
manual_mixer,
manual_start,
manual_back
ePresetsMenuOptions presetsMenuOption;
enum eMaltMenuOptions {
eMaltMenu_CastleMalting_Chteau_Pilsen_2RS,
eMaltMenu_CastleMalting_Wheat_Blanc,
eMaltMenu_Back,
};
enum auto_menu_list {
auto_recipe,
auto_start,
auto_back
eMaltMenuOptions maltMenuOption;
enum eSettingsMenuOptions {
eSettingsMenu_PT100_Element,
eSettingsMenu_PT100_Up,
eSettingsMenu_PT100_Down,
eSettingsMenu_Back,
};
int menu_position[MENU_MAX_DEPTH]= {MENU_INIT_VALUES};
eSettingsMenuOptions settingsMenuOption;
// cooking
enum cook_mode_list {
quick_start,
start_at_temperature
enum eCookingStages {
eCookingStage_Startpoint,
eCookingStage_BetaGlucanase,
eCookingStage_Debranching,
eCookingStage_Proteolytic,
eCookingStage_BetaAmylase,
eCookingStage_AlphaAmylase,
eCookingStage_Mashout,
eCookingStage_Recirculation,
eCookingStage_Sparge,
eCookingStage_Boil,
eCookingStage_Cooling,
eCookingStage_Done
};
int cookTime = 3600;
int cookTemperature = 36;
cook_mode_list cookMode = quick_start;
int cookMixerSpeed = 180; //0; //130;
// ++++++++++++++++++++++++ State Machine ++++++++++++++++++++++++
// ++++++++++++++++++++++++ Global Variables ++++++++++++++++++++++++
//float currentTemperatureCelsius;
//float targetTemperatureCelsius = -1;
eCookingStages cookingStage;
// ++++++++++++++++++++++++ Global Variables ++++++++++++++++++++++++
boolean cooking;
int clockStartTime;
int clockCounter;
int clockIgnore;
boolean clockStart;
boolean clockEnd;
int cookTime;
int cookTemperature;
//cook_mode_list cookMode;
//int cookMixerSpeed;
int cookHeatPWM;
int startpointTime;
int betaGlucanaseTime;
int debranchingTime;
int proteolyticTime;
int betaAmylaseTime;
int alphaAmylaseTime;
int mashoutTime;
int recirculationTime;
int spargeTime;
int boilTime;
int coolingTime;
int startpointTemperature;
int betaGlucanaseTemperature;
int debranchingTemperature;
int proteolyticTemperature;
int betaAmylaseTemperature;
int alphaAmylaseTemperature;
int mashoutTemperature;
int recirculationTemperature;
int spargeTemperature;
int boilTemperature;
int coolingTemperature;
//int menuSize;
int menu_position[MENU_MAX_DEPTH] = {MENU_INIT_VALUES};
boolean refresh;
boolean repaint;
// ++++++++++++++++++++++++ Interrupts ++++++++++++++++++++++++
static unsigned long lastInterruptTime;
// ######################### INITIALIZE #########################
// ++++++++++++++++++++++++ Library - LiquidCrystal_I2C ++++++++++++++++++++++++
LiquidCrystal_I2C lcd(LCD_I2C_ADDR, LCD_EN_PIN, LCD_RW_PIN, LCD_RS_PIN, LCD_D4_PIN, LCD_D5_PIN, LCD_D6_PIN, LCD_D7_PIN);
// +++++++++++++++++++++++ PT100 +++++++++++++++++++++++
PT100 basePT100(PT100_BASE_OUTPUT_PIN, PT100_BASE_INPUT_PIN, PT100_BASE_TIME_BETWEEN_READINGS, PT100_BASE_DEFAULT_ADC_VMAX, PT100_BASE_DEFAULT_VS, PT100_BASE_DEFAULT_R1_RESISTENCE, PT100_BASE_DEFAULT_LINE_RESISTENCE, PT100_BASE_DEFAULT_OPERATION_RESISTENCE);
PT100 upPT100(PT100_UP_OUTPUT_PIN, PT100_UP_INPUT_PIN, PT100_UP_TIME_BETWEEN_READINGS, PT100_UP_DEFAULT_ADC_VMAX, PT100_UP_DEFAULT_VS, PT100_UP_DEFAULT_R1_RESISTENCE, PT100_UP_DEFAULT_LINE_RESISTENCE, PT100_UP_DEFAULT_OPERATION_RESISTENCE);
PT100 downPT100(PT100_DOWN_OUTPUT_PIN, PT100_DOWN_INPUT_PIN, PT100_DOWN_TIME_BETWEEN_READINGS, PT100_DOWN_DEFAULT_ADC_VMAX, PT100_DOWN_DEFAULT_VS, PT100_DOWN_DEFAULT_R1_RESISTENCE, PT100_DOWN_DEFAULT_LINE_RESISTENCE, PT100_DOWN_DEFAULT_OPERATION_RESISTENCE);
// ######################### INTERRUPTS #########################
static unsigned long lastInterruptTime = 0;
void isr () { // Interrupt service routine is executed when a HIGH to LOW transition is detected on CLK
void xSetupRotaryEncoder( TRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep ) {
if( newMode >= 0 ) rotaryEncoderMode = newMode;
if( newPosition >= 0 ) rotaryEncoderVirtualPosition = newPosition;
if( newMaxPosition >= 0 ) rotaryEncoderMaxPosition = newMaxPosition;
if( newMinPosition >= 0 ) rotaryEncoderMinPosition = newMinPosition;
if( newSingleStep >= 0 ) rotaryEncoderSingleStep = newSingleStep;
if( newMultiStep >= 0 ) rotaryEncoderMultiStep = newMultiStep;
}
void isr () { // Interrupt service routine is executed when a HIGH to LOW transition is detected on CLK
repaint = true;
refresh = true;
unsigned long interruptTime = millis();
// If interrupts come faster than 5ms, assume it's a bounce and ignore
if ((interruptTime - lastInterruptTime) > 5) {
switch(state) {
// If interrupts come faster than [ROTARY_ENCODER_DEBOUNCE_TIME]ms, assume it's a bounce and ignore
if ((interruptTime - lastInterruptTime) > ROTARY_ENCODER_DEBOUNCE_TIME) {
switch(rotaryEncoderMode) {
// Input of rotay encoder controling menus
case state_manual_mode:
case state_menu: {
if (!digitalRead(PinDT)) {
rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition + 1);
// Input of rotary encoder controling menus
case eRotaryEncoderMode_Menu: {
if (!digitalRead(ROTARY_ENCODER_DT_PIN)) {
rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition + rotaryEncoderSingleStep);
}
else {
rotaryEncoderVirtualPosition = rotaryEncoderVirtualPosition - 1;
rotaryEncoderVirtualPosition = rotaryEncoderVirtualPosition - rotaryEncoderSingleStep;
}
if (rotaryEncoderVirtualPosition >= menuSize) {
rotaryEncoderVirtualPosition = 0;
if (rotaryEncoderVirtualPosition > rotaryEncoderMaxPosition) {
rotaryEncoderVirtualPosition = rotaryEncoderMinPosition;
}
if (rotaryEncoderVirtualPosition < 0) {
rotaryEncoderVirtualPosition = menuSize -1;
if (rotaryEncoderVirtualPosition < rotaryEncoderMinPosition) {
rotaryEncoderVirtualPosition = rotaryEncoderMaxPosition;
}
break;
}
// Input of rotay encoder controling time variables
case state_manual_time: {
if (!digitalRead(PinDT)) {
// Input of rotary encoder controling time variables
case eRotaryEncoderMode_Time: {
xDecodeRotaryEncoder();
if (!digitalRead(ROTARY_ENCODER_DT_PIN)) {
if(rotaryEncoderVirtualPosition >= 60) {
rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition + 30);
rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition + rotaryEncoderMultiStep);
}
else {
rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition + 1);
rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition + rotaryEncoderSingleStep);
}
}
else {
if(rotaryEncoderVirtualPosition == 0) {
if(rotaryEncoderVirtualPosition == rotaryEncoderMinPosition) {
rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition + 60);
}
else {
if(rotaryEncoderVirtualPosition >= 90) {
rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition - 30);
if(rotaryEncoderVirtualPosition >= (60 + rotaryEncoderMultiStep)) {
rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition - rotaryEncoderMultiStep);
}
else {
rotaryEncoderVirtualPosition = rotaryEncoderVirtualPosition - 1;
rotaryEncoderVirtualPosition = rotaryEncoderVirtualPosition - rotaryEncoderSingleStep;
}
}
}
if (rotaryEncoderVirtualPosition > 7200) {
rotaryEncoderVirtualPosition = 7200;
if (rotaryEncoderVirtualPosition > rotaryEncoderMaxPosition) {
rotaryEncoderVirtualPosition = rotaryEncoderMaxPosition;
}
if (rotaryEncoderVirtualPosition < 0) {
rotaryEncoderVirtualPosition = 0;
if (rotaryEncoderVirtualPosition < rotaryEncoderMinPosition) {
rotaryEncoderVirtualPosition = rotaryEncoderMinPosition;
}
break;
}
// Input of rotay encoder controling integer variables within a range between 0 and rotaryEncoderMaxPosition
case state_manual_mixer:
case state_manual_temperature: {
if (!digitalRead(PinDT)) {
if ((interruptTime - lastInterruptTime) < 10) {
rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition + 5);
// Input of rotary encoder controling generic integer variables within a range between rotaryEncoderMinPosition and rotaryEncoderMaxPosition
case eRotaryEncoderMode_Generic: {
if (!digitalRead(ROTARY_ENCODER_DT_PIN)) {
if ((interruptTime - lastInterruptTime) < ROTARY_ENCODER_DEBOUNCE_TIME) {
rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition + rotaryEncoderMultiStep);
}
else {
rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition + 1);
rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition + rotaryEncoderSingleStep);
}
}
else {
if ((interruptTime - lastInterruptTime) < 10) {
rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition - 5);
if ((interruptTime - lastInterruptTime) < ROTARY_ENCODER_DEBOUNCE_TIME) {
rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition - rotaryEncoderMultiStep);
}
else {
rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition - 1);
rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition - rotaryEncoderSingleStep);
}
}
if (rotaryEncoderVirtualPosition > rotaryEncoderMaxPosition) {
rotaryEncoderVirtualPosition = rotaryEncoderMaxPosition;
}
if (rotaryEncoderVirtualPosition < 0) {
rotaryEncoderVirtualPosition = 0;
if (rotaryEncoderVirtualPosition < rotaryEncoderMinPosition) {
rotaryEncoderVirtualPosition = rotaryEncoderMinPosition;
}
break;
......@@ -259,883 +328,1025 @@ void isr () { // Interrupt service routine is executed when
lastInterruptTime = interruptTime;
}
// ######################### INTERRUPTS #########################
// ######################### START #########################
void setup() {
// ++++++++++++++++++++++++ Library - DHT ++++++++++++++++++++++++
//dht.begin();
// ++++++++++++++++++++++++ Library - DHT ++++++++++++++++++++++++
// ++++++++++++++++++++++++ Library - LiquidCrystal_I2C ++++++++++++++++++++++++
lcd.begin (LCD_X,LCD_Y); // <<----- My LCD was 16x2
// Switch on the backlight
lcd.setBacklightPin(BACKLIGHT_PIN,POSITIVE);
lcd.setBacklight(HIGH);
// ++++++++++++++++++++++++ Library - LiquidCrystal_I2C ++++++++++++++++++++++++
// ++++++++++++++++++++++++ Rotary Encoder ++++++++++++++++++++++++
pinMode(PinCLK,INPUT);
pinMode(PinDT, INPUT);
pinMode(PinSW, INPUT);
attachInterrupt(1, isr, FALLING); // interrupt 0 is always connected to pin 2 on Arduino UNO
// ++++++++++++++++++++++++ Rotary Encoder ++++++++++++++++++++++++
// ++++++++++++++++++++++++ Heating Element Relay ++++++++++++++++++++++++
pinMode(HEATING_ELEMENT, OUTPUT);
digitalWrite(HEATING_ELEMENT,LOW);
void xSafeHardwarePowerOff() {
// analogWrite(MIXER_PIN, 0); // Turn mixer OFF for safety
digitalWrite(HEATING_ELEMENT_OUTPUT_PIN, LOW); // Turn heading element OFF for safety
//basePT100.xSafeHardwarePowerOff(); // Turn temperature sensor OFF for safety
}
void displayWelcome() {
lcdPrint(" Let's start", " Brewing!"); // Write welcome
delay(SETTING_WELCOME_TIMEOUT); // pause for effect
}
void setup() {
// ++++++++++++++++++++++++ Rotary Encoder ++++++++++++++++++++++++
pinMode (ROTARY_ENCODER_CLK_PIN,INPUT);
pinMode (ROTARY_ENCODER_DT_PIN, INPUT);
pinMode (ROTARY_ENCODER_SW_PIN, INPUT);
attachInterrupt (ROTARY_ENCODER_INTERRUPT_NUMBER, isr, FALLING);
// ++++++++++++++++++++++++ Heating Element Relay ++++++++++++++++++++++++
pinMode (HEATING_ELEMENT_OUTPUT_PIN, OUTPUT);
digitalWrite (HEATING_ELEMENT_OUTPUT_PIN, LOW);
windowStartTime = millis();
dWattPerPulse = HEATING_ELEMENT_MAX_WATTAGE / HEATING_ELEMENT_AC_FREQUENCY_HZ;
//initialize the variables we're linked to
Setpoint = 100;
myPID.SetOutputLimits (0, WindowSize); // tell the PID to range between 0 and the full window size
myPID.SetMode (AUTOMATIC); // turn the PID on
//tell the PID to range between 0 and the full window size
myPID.SetOutputLimits(0, WindowSize);
// ++++++++++++++++++++++++ Mixer ++++++++++++++++++++++++
// pinMode (MIXER_PIN, OUTPUT);
// analogWrite (MIXER_PIN, 0);
//turn the PID on
myPID.SetMode(AUTOMATIC);
// ++++++++++++++++++++++++ Heating Element Relay ++++++++++++++++++++++++
// ++++++++++++++++++++++++ Mixer ++++++++++++++++++++++++
pinMode(MIXER_PIN, OUTPUT);
analogWrite(MIXER_PIN, 0);
// ++++++++++++++++++++++++ Mixer ++++++++++++++++++++++++
// ++++++++++++++++++++++++ Temperature Sensor PT100 ++++++++++++++++++++++++
// analogReference(EXTERNAL);
analogReference(INTERNAL1V1);
// analogReference(INTERNAL2V56);
pinMode(TEMPERATURE_SENSOR_PIN, OUTPUT);
digitalWrite(TEMPERATURE_SENSOR_PIN, LOW);
// ++++++++++++++++++++++++ Temperature Sensor PT100 ++++++++++++++++++++++++
Serial.begin(9600);
Serial.println("Let's start Brewing!");
// ++++++++++++++++++++++++ Temperature Sensor PT100 ++++++++++++++++++++++++
//basePT100.setup();
/*
analogReference (INTERNAL1V1); // EXTERNAL && INTERNAL2V56 && INTERNAL1V1
pinMode (PT100_OUTPUT_PIN, OUTPUT); // setup temperature sensor input pin
digitalWrite (PT100_OUTPUT_PIN, LOW); // initialize sensor off
*/
// ++++++++++++++++++++++++ Serial Monitor ++++++++++++++++++++++++
Serial.begin(SETTING_SERIAL_MONITOR_BAUD_RATE); // setup terminal baud rate
Serial.println(SETTING_SERIAL_MONITOR_WELCOME_MESSAGE); // print a start message to the terminal
// ++++++++++++++++++++++++ Library - LiquidCrystal_I2C ++++++++++++++++++++++++
lcd.begin (LCD_HORIZONTAL_RESOLUTION,LCD_VERTICAL_RESOLUTION); // <<----- My LCD was 16x2
lcd.setBacklightPin(LCD_BACKLIGHT_PIN,POSITIVE); // Setup backlight pin
lcd.setBacklight(HIGH); // Switch on the backlight
// ######################### INITIALIZE #########################
// ++++++++++++++++++++++++ Rotary Encoder ++++++++++++++++++++++++
// set operation state | INPUT : TRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep
xSetupRotaryEncoder( eRotaryEncoderMode_Disabled, 0, 0, 0, 0, 0 );
// ++++++++++++++++++++++++ State Machine ++++++++++++++++++++++++
presetsMenuOption = ePresetsMenu_Trigo;
maltMenuOption = eMaltMenu_CastleMalting_Chteau_Pilsen_2RS;
settingsMenuOption = eSettingsMenu_PT100_Element;
cookingStage = eCookingStage_Startpoint;
// ++++++++++++++++++++++++ Global Variables ++++++++++++++++++++++++
cooking = false;
clockStartTime = 0;
clockCounter = 0;
clockIgnore = 0;
clockStart = false;
clockEnd = false;
cookTime = 3600;
cookTemperature = 25;
//cookMode = quick_start;
//cookMixerSpeed = 120;
cookHeatPWM = 5;
startpointTime = 120;
betaGlucanaseTime = 0;
debranchingTime = 0;
proteolyticTime = 0;
betaAmylaseTime = 3600;
alphaAmylaseTime = 1800;
mashoutTime = 300;
recirculationTime = 1200;
spargeTime = 1200;
boilTime = 5400;
coolingTime = 120;
startpointTemperature = 45;
betaGlucanaseTemperature = 40;
debranchingTemperature = 40;
proteolyticTemperature = 50;
betaAmylaseTemperature = 60;
alphaAmylaseTemperature = 70;
mashoutTemperature = 80;
recirculationTemperature = 80;
spargeTemperature = 80;
boilTemperature = 100;
coolingTemperature = 25;
refresh = true;
repaint = true;
// ++++++++++++++++++++++++ Interrupts ++++++++++++++++++++++++
lastInterruptTime = 0;
// ++++++++++++++++++++++++ PID ++++++++++++++++++++++++
WindowSize = HEATING_ELEMENT_DEFAULT_WINDOW_SIZE; // Time frame to operate in
// ######################### Code - Run Once #########################
xSafeHardwarePowerOff();
displayWelcome();
xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenu_GO, MENU_SIZE_MAIN_MENU - 1, 0, 1, 1 );
}
// ######################### START #########################
void loop() {
switch(state) {
case state_welcome: {
runWelcome();
unsigned long inactivityTime = millis() - lastInterruptTime;
break;
if(inactivityTime > SETTING_MAX_INACTIVITY_TIME) { // Inactivity check
if(refresh) {
repaint = true;
refresh = false;
}
case state_menu: {
runMenu();
break;
displayStatus();
}
/*case state_manual_time: {
//runManualTime();
break;
else {
displayMainMenu();
}
case state_manual_temperature: {
//runManualTemp();
break;
}
case state_manual_mixer: {
//runManualTemp();
operateMachine();
}
break;
}*/
case state_error: {
runError();
void xPaintStatusTemplate() {
// Clear LCD
lcd.clear();
break;
}
default: {
lcdPrint("Error", "The brewer has stoped working properly. Please shutdown NOW for your safety!");
state = state_error;
error = catastrofic_failure_program;
// Position the cursor at the begining of where the temperature template goes onto the screen
lcd.home();
// Print the target and measured temperature template
if(cooking) {
lcd.print("ON : 000*C/000*C");
}
else {
lcd.print("OFF: 000*C/000*C");
}
}
void runWelcome() {
// Write welcome
lcd.clear();
lcd.home (); // go home
lcd.print(" Let's start");
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print(" Brewing!");
delay(SETTING_WELCOME_TIMEOUT);
// Position the cursor at the begining of where the mode and time template goes onto the screen
lcd.setCursor (0,LCD_VERTICAL_RESOLUTION-1);
state = state_menu;
lcd.print("**** 00:00");
}
void runMenu() {
digitalWrite(HEATING_ELEMENT,LOW);
void displayStatus() {
switch(menu_position[0]) {
case main_manual: {
switch(menu_position[1]) {
case manual_temperature: {
// do work
cookTemperature = getTemperature(cookTemperature);
// Check whether a template repaint is required
if(repaint) {
// Repaint the LCD template
xPaintStatusTemplate();
menu_position[1] = -1;
rotaryEncoderVirtualPosition = manual_temperature;
// Reset the repaint flag after the repaint has been done
repaint = false;
}
break;
// Print positions with no numbers, before the measured temperature value
lcd.setCursor (3,0);
if (basePT100.getCurrentTemperature() < 10) {
lcd.print(" ");
}
else {
if (basePT100.getCurrentTemperature() < 100) {
lcd.print(" ");
}
}
case manual_time: {
// do work
cookTime = getTimer(cookTime);
menu_position[1] = -1;
rotaryEncoderVirtualPosition = manual_time;
// Print measured temperature value onto the LCD
lcd.print(basePT100.getCurrentTemperature(), 1);
break;
// Print positions with no numbers, before the target temperature value
lcd.setCursor (11,0);
if (cookTemperature < 10) {
lcd.print(" ");
}
else {
if (cookTemperature < 100) {
lcd.print(" ");
}
case manual_mode: {
// do work
int returnMode = getMode();
switch(returnMode) {
case quick_start: {
cookMode = quick_start;
break;
}
case start_at_temperature: {
cookMode = start_at_temperature;
break;
// Print target temperature value onto the LCD
lcd.print(cookTemperature);
// Calculate the numbers on the timer clock
int minutes = (clockCounter - clockIgnore) / 60;
int seconds = (clockCounter - clockIgnore) - minutes * 60;
// Position the cursor at the begining of where the timer goes onto the screen
lcd.setCursor (10, 1);
// Print the timer values onto the LCD
if (minutes < 10) {
lcd.print(" 0");
}
else {
if (minutes < 100) {
lcd.print(" ");
}
default: {
cookMode = quick_start;
}
lcd.print(minutes);
lcd.print(":");
if(seconds<10) {
lcd.print("0");
}
lcd.print(seconds);
}
menu_position[1] = -1;
rotaryEncoderVirtualPosition = manual_mode;
void displayMainMenu() {
switch(menu_position[0]) {
case eMainMenu_GO: {
MainMenu_GO();
menu_position[0] = -1;
// reset operation state | INPUT : TRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep
xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenu_GO, MENU_SIZE_MAIN_MENU - 1, 0, 1, 1 );
break;
}
case manual_mixer: {
// do work
cookMixerSpeed = getMixerSpeed(cookMixerSpeed);
case eMainMenu_Presets: {
MainMenu_Presets();
menu_position[1] = -1;
rotaryEncoderVirtualPosition = manual_time;
menu_position[0] = -1;
// reset operation state | INPUT : TRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep
xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenu_Presets, MENU_SIZE_MAIN_MENU - 1, 0, 1, 1 );
break;
}
case manual_start: {
// do work
runStart();
case eMainMenu_Malt: {
MainMenu_Malt();
menu_position[0] = -1;
menu_position[1] = -1;
rotaryEncoderVirtualPosition = manual_start;
// reset operation state | INPUT : TRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep
xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenu_Malt, MENU_SIZE_MAIN_MENU - 1, 0, 1, 1 );
break;
}
case manual_back: {
case eMainMenu_Startpoint: {
MainMenu_Startpoint();
menu_position[0] = -1;
menu_position[1] = -1;
rotaryEncoderVirtualPosition = manual_back;
// reset operation state | INPUT : TRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep
xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenu_Startpoint, MENU_SIZE_MAIN_MENU - 1, 0, 1, 1 );
break;
}
default: {
// reset menu variables
menuSize = 6;
case eMainMenu_BetaGlucanase: {
MainMenu_BetaGlucanase();
// display menu
lcd.clear();
lcd.home (); // go home
lcd.print("Manual Menu");
menu_position[0] = -1;
// reset operation state | INPUT : TRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep
xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenu_BetaGlucanase, MENU_SIZE_MAIN_MENU - 1, 0, 1, 1 );
while(true) {
switch(rotaryEncoderVirtualPosition) {
case manual_temperature: {
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print("-> Temperature ");
delay(100);
break;
}
case manual_time: {
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print("-> Time ");
delay(100);
case eMainMenu_Debranching: {
MainMenu_Debranching();
menu_position[0] = -1;
// reset operation state | INPUT : TRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep
xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenu_Settings, MENU_SIZE_MAIN_MENU - 1, 0, 1, 1 );
break;
}
case manual_mode: {
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print("-> Mode ");
delay(100);
case eMainMenu_Proteolytic: {
MainMenu_Proteolytic();
menu_position[0] = -1;
// reset operation state | INPUT : TRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep
xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenu_Proteolytic, MENU_SIZE_MAIN_MENU - 1, 0, 1, 1 );
break;
}
case manual_mixer: {
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print("-> Mixer Speed ");
delay(100);
case eMainMenu_BetaAmylase: {
MainMenu_BetaAmylase();
menu_position[0] = -1;
// reset operation state | INPUT : TRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep
xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenu_BetaAmylase, MENU_SIZE_MAIN_MENU - 1, 0, 1, 1 );
break;
}
case manual_start: {
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print("-> Start ");
delay(100);
case eMainMenu_AlphaAmylase: {
MainMenu_AlphaAmylase();
menu_position[0] = -1;
// reset operation state | INPUT : TRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep
xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenu_AlphaAmylase, MENU_SIZE_MAIN_MENU - 1, 0, 1, 1 );
break;
}
case manual_back: {
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print("-> Back ");
delay(100);
case eMainMenu_Mashout: {
MainMenu_Mashout();
menu_position[0] = -1;
// reset operation state | INPUT : TRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep
xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenu_Mashout, MENU_SIZE_MAIN_MENU - 1, 0, 1, 1 );
break;
}
default: {
//lcd.setCursor (0,1); // go to start of 2nd line
//lcd.print("*** Error ***");
rotaryEncoderVirtualPosition = 0;
}
}
case eMainMenu_Recirculation: {
MainMenu_Recirculation();
menu_position[0] = -1;
// reset operation state | INPUT : TRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep
xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenu_Recirculation, MENU_SIZE_MAIN_MENU - 1, 0, 1, 1 );
if (!(digitalRead(PinSW))) { // check if pushbutton is pressed
menu_position[1] = rotaryEncoderVirtualPosition;
while (!digitalRead(PinSW)) {} // wait til switch is released
delay(10); // debounce
break;
}
case eMainMenu_Sparge: {
MainMenu_Sparge();
menu_position[0] = -1;
// reset operation state | INPUT : TRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep
xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenu_Sparge, MENU_SIZE_MAIN_MENU - 1, 0, 1, 1 );
break;
}
}
}
case eMainMenu_Boil: {
MainMenu_Boil();
menu_position[0] = -1;
// reset operation state | INPUT : TRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep
xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenu_Boil, MENU_SIZE_MAIN_MENU - 1, 0, 1, 1 );
break;
}
case main_auto: {
switch(menu_position[1]) {
case auto_recipe: {
// do work
case eMainMenu_Hops: {
MainMenu_Hops();
menu_position[0] = -1;
menu_position[1] = -1;
rotaryEncoderVirtualPosition = auto_recipe;
// reset operation state | INPUT : TRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep
xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenu_Hops, MENU_SIZE_MAIN_MENU - 1, 0, 1, 1 );
break;
}
case auto_start: {
// do work
case eMainMenu_Cooling: {
MainMenu_Cooling();
menu_position[0] = -1;
menu_position[1] = -1;
rotaryEncoderVirtualPosition = auto_start;
// reset operation state | INPUT : TRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep
xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenu_Cooling, MENU_SIZE_MAIN_MENU - 1, 0, 1, 1 );
break;
}
case auto_back: {
// reset choces
case eMainMenu_Settings: {
MainMenu_Settings();
menu_position[0] = -1;
menu_position[1] = -1;
// set menu position
rotaryEncoderVirtualPosition = main_auto;
// reset operation state | INPUT : TRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep
xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenu_Settings, MENU_SIZE_MAIN_MENU - 1, 0, 1, 1 );
break;
}
default: {
// reset menu variables
//rotaryEncoderVirtualPosition = 0;
menuSize = 3;
if(repaint) {
// display menu
lcd.clear();
lcd.home (); // go home
lcd.print("Automatic Menu");
lcd.print("Brewery Menu");
while(true) {
switch(rotaryEncoderVirtualPosition) {
case auto_recipe: {
case eMainMenu_GO: {
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print("-> Recipe ");
delay(100);
lcd.print("-> GO ");
break;
}
case auto_start: {
case eMainMenu_Presets: {
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print("-> Start ");
delay(100);
lcd.print("-> Presets ");
break;
}
case auto_back: {
case eMainMenu_Malt: {
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print("-> Back ");
delay(100);
lcd.print("-> Malt ");
break;
}
default: {
//lcd.setCursor (0,1); // go to start of 2nd line
//lcd.print("*** Error ***");
rotaryEncoderVirtualPosition = 0;
case eMainMenu_Startpoint: {
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print("-> Startpoint ");
break;
}
case eMainMenu_BetaGlucanase: {
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print("-> BetaGlucanase");
break;
}
case eMainMenu_Debranching: {
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print("-> Debranching ");
break;
}
if (!(digitalRead(PinSW))) { // check if pushbutton is pressed
menu_position[1] = rotaryEncoderVirtualPosition;
while (!digitalRead(PinSW)) {} // wait til switch is released
delay(10); // debounce
case eMainMenu_Proteolytic: {
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print("-> Proteolytic ");
break;
}
case eMainMenu_BetaAmylase: {
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print("-> Beta Amylase ");
break;
}
case eMainMenu_AlphaAmylase: {
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print("-> Alpha Amylase");
break;
}
case eMainMenu_Mashout: {
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print("-> Mashout ");
break;
}
case eMainMenu_Recirculation: {
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print("-> Recirculation");
break;
}
default: {
// reset menu variables
//rotaryEncoderVirtualPosition = 0;
menuSize = 2;
// display menu
lcd.clear();
lcd.home (); // go home
lcd.print("Main Menu");
while(true) {
switch(rotaryEncoderVirtualPosition) {
case main_manual: {
case eMainMenu_Sparge: {
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print("-> Sparge ");
break;
}
case eMainMenu_Boil: {
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print("-> Manual ");
delay(100);
lcd.print("-> Boil ");
break;
}
case main_auto: {
case eMainMenu_Hops: {
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print("-> Automatic ");
delay(100);
lcd.print("-> Hops ");
break;
}
case eMainMenu_Cooling: {
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print("-> Cooling ");
break;
}
case eMainMenu_Settings: {
lcd.setCursor (0,1); // go to start of 2nd line
lcd.print("-> Settings ");
break;
}
default: {
//lcd.setCursor (0,1); // go to start of 2nd line
//lcd.print("*** Error ***");
rotaryEncoderVirtualPosition = 0;
// reset operation state | INPUT : TRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep
xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenu_GO, MENU_SIZE_MAIN_MENU - 1, 0, 1, 1 );
}
}
if (!(digitalRead(PinSW))) { // check if pushbutton is pressed
repaint = false;
}
if ((digitalRead(ROTARY_ENCODER_SW_PIN))) { // check if pushbutton is pressed
menu_position[0] = rotaryEncoderVirtualPosition;
while (!digitalRead(PinSW)) {} // wait til switch is released
while (digitalRead(ROTARY_ENCODER_SW_PIN)) {} // wait til switch is released
delay(10); // debounce
break;
}
}
}
}
}
int getTimer(int init) {
state_machine initialState = state;
void MainMenu_GO() {
startBrewing();
// set operation state
state = state_manual_time;
rotaryEncoderVirtualPosition = init;
backToStatus();
}
// initialize variables
int rotaryEncoderPreviousPosition = 0;
int minutes = 0;
int seconds = 0;
void MainMenu_Presets() {
// Setup Screen
lcd.clear();
lcd.home();
lcd.print("Set Time");
lcd.setCursor (0,LCD_Y-1);
lcd.print(" 0:00");
}
while(true) {
// Check for timer set
if (!(digitalRead(PinSW))) { // check if pushbutton is pressed
while (!digitalRead(PinSW)) {} // wait til switch is released
delay(10); // debounce
break;
}
void MainMenu_Malt() {
// display current timer
if (rotaryEncoderVirtualPosition != rotaryEncoderPreviousPosition) {
rotaryEncoderPreviousPosition = rotaryEncoderVirtualPosition;
minutes = rotaryEncoderVirtualPosition/60;
seconds = rotaryEncoderVirtualPosition-minutes*60;
}
lcd.setCursor (0,LCD_Y-1);
lcd.print(" ");
lcd.print(minutes);
lcd.print(":");
if(seconds<10) {
lcd.print("0");
}
lcd.print(seconds);
lcd.println(" ");
}
}
void MainMenu_Startpoint() {
startpointTime = getTimer( startpointTime );
state = initialState;
return rotaryEncoderVirtualPosition;
startpointTemperature = xSetGenericValue( startpointTemperature, 0, 120, "temperature", "*C" );
}
int getTemperature(int init) {
state_machine initialState = state;
void MainMenu_BetaGlucanase() {
betaGlucanaseTime = getTimer( betaGlucanaseTime );
// set operation state
state = state_manual_temperature;
rotaryEncoderVirtualPosition = init;
betaGlucanaseTemperature = xSetGenericValue( betaGlucanaseTemperature, 0, 120, "temperature", "*C" );
}
// initialize variables
int rotaryEncoderPreviousPosition = 0;
void MainMenu_Debranching() {
debranchingTime = getTimer( debranchingTime );
// Setup Screen
lcd.clear();
lcd.home();
lcd.print("Set Temperature");
lcd.setCursor (0,LCD_Y-1);
lcd.print(" 0 *C");
debranchingTemperature = xSetGenericValue( debranchingTemperature, 0, 120, "temperature", "*C" );
}
rotaryEncoderMaxPosition = TEMPERATURE_MAX_POSITION;
void MainMenu_Proteolytic() {
proteolyticTime = getTimer( proteolyticTime );
while(true) {
// Check for timer set
if (!(digitalRead(PinSW))) { // check if pushbutton is pressed
while (!digitalRead(PinSW)) {} // wait til switch is released
delay(10); // debounce
break;
}
proteolyticTemperature = xSetGenericValue( proteolyticTemperature, 0, 120, "temperature", "*C" );
}
// display current timer
if (rotaryEncoderVirtualPosition != rotaryEncoderPreviousPosition) {
rotaryEncoderPreviousPosition = rotaryEncoderVirtualPosition;
void MainMenu_BetaAmylase() {
betaAmylaseTime = getTimer( betaAmylaseTime );
lcd.setCursor (0,LCD_Y-1);
lcd.print(" ");
if(rotaryEncoderVirtualPosition<10) {
lcd.print(" ");
}
else {
if(rotaryEncoderVirtualPosition<100) {
lcd.print(" ");
}
}
lcd.print(rotaryEncoderVirtualPosition);
lcd.print(" *C");
lcd.println(" ");
}
}
betaAmylaseTemperature = xSetGenericValue( betaAmylaseTemperature, 0, 120, "temperature", "*C" );
}
state = initialState;
return rotaryEncoderVirtualPosition;
void MainMenu_AlphaAmylase() {
alphaAmylaseTime = getTimer( alphaAmylaseTime );
alphaAmylaseTemperature = xSetGenericValue( alphaAmylaseTemperature, 0, 120, "temperature", "*C" );
}
int getMode() {
state_machine initialState = state;
int initialMenuSize = menuSize;
void MainMenu_Mashout() {
mashoutTime = getTimer( mashoutTime );
// set operation state
state = state_manual_mode;
menuSize = 2;
rotaryEncoderVirtualPosition = cookMode;
mashoutTemperature = xSetGenericValue( mashoutTemperature, 0, 120, "temperature", "*C" );
}
// initialize variables
int rotaryEncoderPreviousPosition = 0;
void MainMenu_Recirculation() {
recirculationTime = getTimer( recirculationTime );
// Setup Screen
lcd.clear();
lcd.home();
lcd.print("Set Mode");
lcd.setCursor (0,LCD_Y-1);
lcd.print(" Quick Start");
recirculationTemperature = xSetGenericValue( recirculationTemperature, 0, 120, "temperature", "*C" );
}
while(true) {
// Check for timer set
if (!(digitalRead(PinSW))) { // check if pushbutton is pressed
while (!digitalRead(PinSW)) {} // wait til switch is released
delay(10); // debounce
break;
}
void MainMenu_Sparge() {
spargeTime = getTimer( spargeTime );
// display current timer
if (rotaryEncoderVirtualPosition != rotaryEncoderPreviousPosition) {
rotaryEncoderPreviousPosition = rotaryEncoderVirtualPosition;
spargeTemperature = xSetGenericValue( spargeTemperature, 0, 120, "temperature", "*C" );
}
lcd.setCursor (0,LCD_Y-1);
void MainMenu_Boil() {
boilTime = getTimer( boilTime );
switch(rotaryEncoderVirtualPosition) {
case quick_start: {
lcd.print(" Quick Start ");
boilTemperature = xSetGenericValue( boilTemperature, 0, 120, "temperature", "*C" );
}
break;
}
case start_at_temperature: {
lcd.print("Start After Temp");
void MainMenu_Hops() {
break;
}
default: {
lcd.print("*** error ***");
}
}
lcd.println(" ");
}
}
}
state = initialState;
menuSize = initialMenuSize;
return rotaryEncoderVirtualPosition;
void MainMenu_Coooling() {
coolingTime = getTimer( coolingTime );
coolingTemperature = xSetGenericValue( coolingTemperature, 0, 120, "temperature", "*C" );
}
int getMixerSpeed(int init) {
state_machine initialState = state;
void MainMenu_Settings() {
// set operation state
state = state_manual_mixer;
rotaryEncoderVirtualPosition = init;
}
// initialize variables
int rotaryEncoderPreviousPosition = 0;
int mixerSpeed = 0;
// Setup Screen
lcd.clear();
lcd.home();
lcd.print("Set Mixer Speed");
lcd.setCursor (0,LCD_Y-1);
lcd.print(" 000");
void xCountTheTime( int temperatureRange ) {
// Check if the machine is in the right temperature range, for the current mode,
if(!(basePT100.getCurrentTemperature() > (cookTemperature - temperatureRange) && basePT100.getCurrentTemperature() < (cookTemperature + temperatureRange))) {
clockIgnore += millis() - clockStartTime - clockCounter;
}
rotaryEncoderMaxPosition = MIXER_MAX_POSITION;
// Calculate the remaining time on the clock
clockCounter = cookTime - ((millis() - clockStartTime - clockIgnore) / 1000);
}
while(true) {
// Check for timer set
if (!(digitalRead(PinSW))) { // check if pushbutton is pressed
while (!digitalRead(PinSW)) {} // wait til switch is released
delay(10); // debounce
break;
bool isTimeLeft() {
if( clockCounter >= cookTime ) {
return false;
}
return true;
}
// display current timer
if (rotaryEncoderVirtualPosition != rotaryEncoderPreviousPosition) {
rotaryEncoderPreviousPosition = rotaryEncoderVirtualPosition;
unsigned long ulWattToWindowTime( unsigned long appliedWatts ) {
unsigned long ulPulsesRequired = ulAppliedWatts / dWattPerPulse;
return windowSize / 1000.0 * ulPulsesRequired;
}
lcd.setCursor (0,LCD_Y-1);
lcd.print(" ");
//lcd.print(minutes);
//lcd.print(":");
if(rotaryEncoderVirtualPosition<100) {
lcd.print("0");
if(rotaryEncoderVirtualPosition<10) {
lcd.print("0");
bool xRegulateTemperature() {
double diference = basePT100.getCurrentTemperature() - cookTemperature;
bool overTemperature = false;
unsigned long wattage = 0.0;
// Deviation between the cook temperature set and the cook temperature measured
if( diference < 0.0 ) {
diference = diference * (-1.0);
overTemperature = true;
}
// Calculate applied wattage, based on the distance from the target temperature
if( overTemperature ) {
// turn it off
wattage = 0.0;
} else {
if(diffrence <= 1) {
// turn it off
wattage = 0.0;
} else {
if(diffrence <= 3) {
// pulse lightly at 500 watt
wattage = 500.0;
} else {
if(diffrence <= 6) {
// pulse moderately at 1000 watt
wattage = 1000.0;
} else {
if(diffrence <= 9) {
// pulse hardly at 2000 watt
wattage = 2000.0;
} else {
//pulse constantly at HEATING_ELEMENT_MAX_WATTAGE watt
wattage = HEATING_ELEMENT_MAX_WATTAGE;
}
}
}
}
}
lcd.print(rotaryEncoderVirtualPosition);
lcd.println(" ");
// DEBUG
analogWrite(MIXER_PIN, rotaryEncoderVirtualPosition);
// Update the recorded time for the begining of the window, if the previous window has passed
while((millis() - windowStartTime) > WindowSize) { // Check if it's time to vary the pulse width modulation and if so do it by shifting the "Relay in ON" Window
windowStartTime += WindowSize;
}
// Apply wattage to the element at the right time
if( ulWattToWindowTime( wattage ) > (millis() - windowStartTime)) {
digitalWrite(HEATING_ELEMENT_OUTPUT_PIN,HIGH);
} else {
digitalWrite(HEATING_ELEMENT_OUTPUT_PIN,LOW);
}
}
state = initialState;
return rotaryEncoderVirtualPosition;
void xWarnClockEnded() {
/// TODO
}
void runStart() {
void xStageFirstRun( int stageTime, int stageTemperature ) {
// Set the clock
cookTime = stageTime;
// Working environment variables
float runCurrentTemperature;
long runTargetTemperature;
unsigned long runStartTime;
unsigned long runTargetTime;
cook_mode_list runCurrentMode;
unsigned long runMixerSpeed;
// Set the target temperature
cookTemperature = stageTemperature;
// Configure environment
boolean clockStart = false;
boolean clockEnd = false;
// Reset the clock
clockStartTime = millis();
clockIgnore = 0;
}
// Iterative work
while(true) {
void xTransitionIntoStage_GlobalVariables(eCookingStages nextStage) {
// Reset global stage variables
stageFirstRun = true;
cookingStage = nextStage;
}
// Build Instructions
switch(menu_position[0]) {
case main_manual: {
void xTransitionIntoStage(eCookingStages nextStage) {
// whenever changes are made to the cook variables, they must be applied to the running variables
runTargetTemperature = cookTemperature;
runTargetTime = cookTime;
runCurrentMode = cookMode;
runMixerSpeed = cookMixerSpeed;
// Turn off all hardware that can damage itself if the machine is not cooking
xSafeHardwarePowerOff();
// check if time ended and is time to stop and return to menu
if(clockStart && clockEnd) {
// Warn the user a stage has ended
xWarnClockEnded();
// Turn mixer OFF for safety
analogWrite(MIXER_PIN, 0);
// Reset global stage variables
xTransitionIntoStage_GlobalVariables( nextStage );
}
// Turn heading element OFF for safety
digitalWrite(HEATING_ELEMENT,LOW);
void xBasicStageOperation( int iStageTime, int iStageTemperature, int iStageTemperatureRange, eCookingStages nextStage ) {
if(stageFirstRun) {
// Don't run this again
stageFirstRun = false;
// Pause for efect
delay(1000);
// When the stage should be skipped
if( iStageTime == 0) {
// Continue to the next stage
xTransitionIntoStage_GlobalVariables( nextStage );
// There is nothing to do, in this stage
return;
} else {
// Set the clock, target temperature and Reset the clock
xStageFirstRun( iStageTime, iStageTemperature );
}
} else {
// Account for time spent at the target temperature | Input 1: range in ºC within which the target temperature is considered to be reached
xCountTheTime( iStageTemperatureRange );
break;
}
case main_auto: {
// get the next instruction
if( isTimeLeft() ) {
// Do temperature control
xRegulateTemperature();
// if it's time for a new instruction
} else {
// Continue to the next stage
xTransitionIntoStage( nextStage );
// if human interaction is required
// There is nothing to do, in this stage
return;
}
}
// There is nothing to do, in this iteration
return;
}
void xWarnCookEnded() {
/// TODO
}
// display message
bool stageFirstRun = true;
void operateMachine() {
// sound buzzer
// Measure temperature, for effect
basePT100.measure();
upPT100.measure();
downPT100.measure();
// check if rotary encoder press to continue
// If cooking is done, return (this is a nice place to double check safety and ensure the cooking parts aren't on.
if(!cooking) {
xSafeHardwarePowerOff();
// check what variables are afected
return;
}
// check what the new values are
// Operate the machine according to the current mode
switch(cookingStage) {
case eCookingStage_Startpoint: {
// A basic operation for a basic stage
xBasicStageOperation( startpointTime, startpointTemperature, 1, eCookingStage_BetaGlucanase );
// apply the values
// There is nothing to do, in this iteration
break;
}
case eCookingStage_BetaGlucanase: {
// A basic operation for a basic stage
xBasicStageOperation( betaGlucanaseTime, betaGlucanaseTemperature, 1, eCookingStage_Debranching );
// if it's NOT time for a new instruction
//delay(1000);
// There is nothing to do, in this iteration
break;
}
case eCookingStage_Debranching: {
// A basic operation for a basic stage
xBasicStageOperation( debranchingTime, debranchingTemperature, 1, eCookingStage_Proteolytic );
// There is nothing to do, in this iteration
break;
}
default: {
lcdPrint("Error", "The system has failed to be set into manual or automatic mode!");
state = state_error;
error = catastrofic_failure_logic_auto_manual;
return;
case eCookingStage_Proteolytic: {
// A basic operation for a basic stage
xBasicStageOperation( proteolyticTime, proteolyticTemperature, 1, eCookingStage_BetaAmylase );
// There is nothing to do, in this iteration
break;
}
case eCookingStage_BetaAmylase: {
// A basic operation for a basic stage
xBasicStageOperation( betaAmylaseTime, betaAmylaseTemperature, 1, eCookingStage_AlphaAmylase );
// There is nothing to do, in this iteration
break;
}
case eCookingStage_AlphaAmylase: {
// A basic operation for a basic stage
xBasicStageOperation( alphaAmylaseTime, alphaAmylaseTemperature, 1, eCookingStage_Mashout );
// ************ Run Instructions ************
// There is nothing to do, in this iteration
break;
}
case eCookingStage_Mashout: {
// A basic operation for a basic stage
xBasicStageOperation( mashoutTime, mashoutTemperature, 1, eCookingStage_Recirculation );
// Setup LCD
lcd.clear();
lcd.home();
lcd.print("Hot: 000*C/000*C");
//lcd.print("Cool:000*C/000*C");
lcd.setCursor (0,LCD_Y-1);
if(runCurrentMode == quick_start) {
lcd.print("Quick 00:00");
// There is nothing to do, in this iteration
break;
}
case eCookingStage_Recirculation: {
// A basic operation for a basic stage
xBasicStageOperation( recirculationTime, recirculationTemperature, 1, eCookingStage_Sparge );
clockStart = true;
runStartTime = millis();
// There is nothing to do, in this iteration
break;
}
else {
lcd.print("Wait 00:00");
case eCookingStage_Sparge: {
// A basic operation for a basic stage
xBasicStageOperation( spargeTime, spargeTemperature, 1, eCookingStage_Boil );
// There is nothing to do, in this iteration
break;
}
case eCookingStage_Boil: {
// A basic operation for a basic stage
xBasicStageOperation( boilTime, boilTemperature, 1, eCookingStage_Cooling );
float amostra1 = -1;
float amostraAnterior = -1;
unsigned long lastTemperatureRead = millis();
// There is nothing to do, in this iteration
break;
}
case eCookingStage_Cooling: {
// A basic operation for a basic stage
xBasicStageOperation( coolingTime, coolingTemperature, 1, eCookingStage_Done );
while(true) {
// There is nothing to do, in this iteration
break;
}
default : {
// Update state
cooking = false;
if(millis() - lastTemperatureRead >= 1000) {
amostraAnterior = amostra1;
digitalWrite(TEMPERATURE_SENSOR_PIN, HIGH);
//delay(20);
amostra1 = analogRead(ponto1);
digitalWrite(TEMPERATURE_SENSOR_PIN, LOW);
lastTemperatureRead = millis();
}
float Vs = 1.081; //4.9345;
float Vin = 4.87; //8.8345;
float adcStepCount = 1024.0;
float R1 = 606.0;
float Rl = 2.7; //2.9;
float R_OpTemp = 0; //19.7; //21.597; //24.37;
//Vout = amostra1 * Vs / adcStepCount;// + 0.0079816667;
Vout = (amostra1+amostraAnterior) / 2 * Vs / adcStepCount;// + 0.0079816667;
//Rx = 151.5 * Vout / ( 11.01 - Vout ) - 30;
Rx = R1 / ( Vin / Vout - 1.0) - Rl - R_OpTemp;
runCurrentTemperature = 1.08271 * pow(10.0, -13.0) * (3.12508 * pow(10.0, 16.0) - 5.65566 * pow(10.0, 6.0) * sqrt(3.51501 * pow(10.0, 19.0) - 4.61805 * pow(10.0, 16.0) * Rx));
/*
Serial.print("O valor das entradas sao: [");
Serial.print(amostra1);
Serial.print(", ");
Serial.print(amostra2);
Serial.print("]");
Serial.print("diferenca: [");
Serial.print(diferenca, 6);
Serial.print("] tensao por amortra: [");
Serial.print(tensaoPorAmostra, 6);
Serial.print("] Vg: [");
Serial.print(Vg, 6);
Serial.print("] Vs: [");
Serial.print(Vs);
Serial.print("] a: [");
Serial.print(a, 6);
Serial.print("] Rx: [");
Serial.print(Rx, 6);
*/
// Operate mixer
analogWrite(MIXER_PIN, runMixerSpeed);
// Operate the heating element
Input = runCurrentTemperature;
Setpoint = runTargetTemperature;
myPID.Compute();
// Get time and use as "date" of the sensor readings
unsigned long now = millis();
// Check if it's time to vary the pulse width modulation and if so do it by shifting the "Relay in ON" Window
if(now - windowStartTime>WindowSize)
{
windowStartTime += WindowSize;
// Warn the user that the cooking is done
xWarnCookEnded();
}
}
}
// Check if the "date" is inside the "Relay ON" window and turn it ON; if not, turn it OFF
if(Output > now - windowStartTime) {
digitalWrite(HEATING_ELEMENT,HIGH);
// #################################################### Helpers ##################################################################
if(Output != 0) {
Serial.print("O valor das entradas sao: [");
Serial.print(amostra1);
Serial.print("] Vout[");
Serial.print(Vout,6);
Serial.print("] Rx[");
Serial.print(Rx,6);
Serial.print("] Temperature[");
Serial.print(runCurrentTemperature,6);
Serial.print("] ");
void startBrewing() {
cooking = true;
}
Serial.print("+++ Diff: ");
Serial.print(now - windowStartTime);
Serial.print(" | Output: ");
Serial.println(Output);
void stopBrewing() {
cooking = false;
}
}
}
else {
digitalWrite(HEATING_ELEMENT,LOW);
void backToStatus() {
lastInterruptTime = millis() - SETTING_MAX_INACTIVITY_TIME - 1;
}
// #################################################### Helpers ##################################################################
if(Output != 0) {
Serial.print("O valor das entradas sao: [");
Serial.print(amostra1);
Serial.print("] Vout[");
Serial.print(Vout,6);
Serial.print("] Rx[");
Serial.print(Rx,6);
Serial.print("] Temperature[");
Serial.print(runCurrentTemperature,6);
Serial.print("] ");
// #################################################### Set Variables ##################################################################
int getTimer(int init) {
// set operation state | INPUT : TRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep
xSetupRotaryEncoder( eRotaryEncoderMode_Time, init, 7200, 0, 1, 30 );
Serial.print("--- Diff: ");
Serial.print(now - windowStartTime);
Serial.print(" | Output: ");
Serial.println(Output);
// initialize variables
int rotaryEncoderPreviousPosition = 0;
int minutes = 0;
int seconds = 0;
// Setup Screen
lcd.clear();
lcd.home();
lcd.print("Set Time");
lcd.setCursor (0,LCD_VERTICAL_RESOLUTION-1);
lcd.print(" 0:00");
while(true) {
// Check if pushbutton is pressed
if ((digitalRead(ROTARY_ENCODER_SW_PIN))) {
// Wait until switch is released
while (digitalRead(ROTARY_ENCODER_SW_PIN)) {}
// debounce
delay(10);
// Job is done, break the circle
break;
} else {
// Don't forget to keep an eye on the cooking
operateMachine();
}
else {
Serial.print("O valor das entradas sao: [");
Serial.print(amostra1);
Serial.print("] Vout[");
Serial.print(Vout,6);
Serial.print("] Rx[");
Serial.print(Rx,6);
Serial.print("] Temperature[");
Serial.print(runCurrentTemperature,6);
Serial.println("]");
}
}
// Print status to LCD
//if(runCurrentTemperature > 0) {
lcd.setCursor (5,0);
if (runCurrentTemperature < 10) {
lcd.print(" ");
}
else {
if (runCurrentTemperature < 100) {
lcd.print(" ");
}
}
lcd.print(runCurrentTemperature, 1);
lcd.setCursor (11,0);
if (runTargetTemperature < 10) {
// display current timer
if (rotaryEncoderVirtualPosition != rotaryEncoderPreviousPosition) {
rotaryEncoderPreviousPosition = rotaryEncoderVirtualPosition;
minutes = rotaryEncoderVirtualPosition/60;
seconds = rotaryEncoderVirtualPosition-minutes*60;
lcd.setCursor (0,LCD_VERTICAL_RESOLUTION-1);
lcd.print(" ");
lcd.print(minutes);
lcd.print(":");
if(seconds<10) {
lcd.print("0");
}
else {
if (runTargetTemperature < 100) {
lcd.print(" ");
lcd.print(seconds);
lcd.println(" ");
}
}
lcd.print(runTargetTemperature);
//}
// Check if the target temperature has been reached so the clock can move forward.
if(runCurrentTemperature == runTargetTemperature && clockStart == false) {
clockStart = true;
runStartTime = now;
}
backToStatus();
rotaryEncoderMode = initialState;
return rotaryEncoderVirtualPosition;
}
int getTemperature(int init) {
TRotaryEncoderMode initialState = rotaryEncoderMode;
// set operation state
rotaryEncoderMode = eRotaryEncoderMode_Generic;
rotaryEncoderVirtualPosition = init;
// initialize variables
int rotaryEncoderPreviousPosition = 0;
// If the clock can move forward, calculate it's display time; if not, set it to the total cooking time
int displayTime = 0;
if(clockStart) {
displayTime = runTargetTime - ((now - runStartTime) / 1000);
// Setup Screen
lcd.clear();
lcd.home();
lcd.print("Set Temperature");
lcd.setCursor (0,LCD_VERTICAL_RESOLUTION-1);
lcd.print(" 0 *C");
rotaryEncoderMaxPosition = TEMPERATURE_SETTING_MAX_VALUE;
while(true) {
// Check if pushbutton is pressed
if ((digitalRead(ROTARY_ENCODER_SW_PIN))) {
// Wait until switch is released
while (digitalRead(ROTARY_ENCODER_SW_PIN)) {}
if(displayTime <= 0) {
displayTime = 0;
clockEnd = true;
// debounce
delay(10);
// Job is done, break the circle
break;
}
}
else {
displayTime = runTargetTime;
} else {
// Don't forget to keep an eye on the cooking
operateMachine();
}
// Print the clock to the LCD
int minutes = displayTime/60;
int seconds = displayTime-minutes*60;
lcd.setCursor (10,1);
//lcd.print(" ");
if (minutes < 10) {
lcd.print(" 0");
// display current timer
if (rotaryEncoderVirtualPosition != rotaryEncoderPreviousPosition) {
rotaryEncoderPreviousPosition = rotaryEncoderVirtualPosition;
lcd.setCursor (0,LCD_VERTICAL_RESOLUTION-1);
lcd.print(" ");
if(rotaryEncoderVirtualPosition<10) {
lcd.print(" ");
}
else {
if (minutes < 100) {
if(rotaryEncoderVirtualPosition<100) {
lcd.print(" ");
}
}
lcd.print(minutes);
lcd.print(":");
if(seconds<10) {
lcd.print("0");
}
lcd.print(seconds);
lcd.print(rotaryEncoderVirtualPosition);
lcd.print(" *C");
lcd.println(" ");
}
}
backToStatus();
rotaryEncoderMode = initialState;
return rotaryEncoderVirtualPosition;
}
void runError() {
if(error != no_error) {
if (error == catastrofic_failure_sensor_temperature)
{
Serial.println("[Error] catastrofic_failure_sensor_temperature!");
int xSetGenericValue(int init, int min, int max, char *valueName, char *unit) {
// set operation state | INPUT : TRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep
xSetupRotaryEncoder( eRotaryEncoderMode_Generic, init, max, min, 1, 5 );
lcdPrint("ERROR", "A catastrofic failure was detected on the temperature sensor!");
/*
if (!isnan(dht.readTemperature())) { // Check if any reads failed and exit early (to try again).
error = no_error;
return;
}
*/
// initialize variables
int rotaryEncoderPreviousPosition = 0;
// Setup Screen
lcd.clear();
lcd.home();
lcd.print( "Set " );
lcd.print( valueName );
lcd.setCursor ( 0 , LCD_VERTICAL_RESOLUTION - 1 );
lcd.print( " 0 " );
lcd.print( unit );
rotaryEncoderMaxPosition = TEMPERATURE_SETTING_MAX_VALUE;
while(true) {
// Check if pushbutton is pressed
if ( digitalRead(ROTARY_ENCODER_SW_PIN) ) {
// Wait until switch is released
while ( digitalRead(ROTARY_ENCODER_SW_PIN) ) {}
// debounce
delay( 10 );
// Job is done, break the circle
break;
} else {
// Don't forget to keep an eye on the cooking
operateMachine();
}
// Check if there was an update by the rotary encoder
if( rotaryEncoderVirtualPosition != rotaryEncoderPreviousPosition ) {
rotaryEncoderPreviousPosition = rotaryEncoderVirtualPosition;
lcd.setCursor( 0, LCD_VERTICAL_RESOLUTION - 1 );
lcd.print( " " );
if( rotaryEncoderVirtualPosition < 10 ) {
lcd.print( " " );
}
else {
state = state_welcome;
if( rotaryEncoderVirtualPosition < 100 ) {
lcd.print( " " );
}
}
lcd.print( rotaryEncoderVirtualPosition );
lcd.print( " *C" );
lcd.println( " " );
}
}
return rotaryEncoderVirtualPosition;
}
// ###################### Set Variables ##################################################
void lcdPrint(String title, String message) {
int messageLength = message.length();
......@@ -1146,8 +1357,8 @@ void lcdPrint(String title, String message) {
lcd.print(title);
// print message
if(messageLength <= LCD_X) {
lcd.setCursor(0,LCD_Y-1);
if(messageLength <= LCD_HORIZONTAL_RESOLUTION) {
lcd.setCursor(0,LCD_VERTICAL_RESOLUTION-1);
lcd.print(message);
delay(1000);
}
......@@ -1164,8 +1375,8 @@ void lcdPrint(String title, String message) {
}
// print scrolling message
for (int cursor = 0; cursor < messageLength - LCD_X; cursor+=2) {
lcd.setCursor(0,LCD_Y-1);
for (int cursor = 0; cursor < messageLength - LCD_HORIZONTAL_RESOLUTION; cursor+=2) {
lcd.setCursor(0,LCD_VERTICAL_RESOLUTION-1);
lcd.print(output_message.substring(cursor, cursor+16));
delay(500);
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment