From d5ea03fdacbbe758c5768c0f65612ef4c5aa8bcc Mon Sep 17 00:00:00 2001 From: jlino Date: Thu, 22 Jun 2017 18:51:40 +0100 Subject: [PATCH] menu system restructure - initial commit menu system restructure --- CustomDataStructures.h | 6 +- brew.h | 25 + brew.ino | 2021 ++++++++++++++++++++-------------------- config.h | 37 + 4 files changed, 1075 insertions(+), 1014 deletions(-) diff --git a/CustomDataStructures.h b/CustomDataStructures.h index f5b848e..6b69bb8 100644 --- a/CustomDataStructures.h +++ b/CustomDataStructures.h @@ -6,6 +6,8 @@ #ifndef CustomDataStructures_h #define CustomDataStructures_h +#define SYS_MAX_MENU_ELEMENTS 16 + enum eRotaryEncoderMode { eRotaryEncoderMode_Menu, eRotaryEncoderMode_Time, @@ -111,10 +113,10 @@ enum eBeerProfile { }; typedef struct menuData_ { - char *_title; + const char *_title; + const char *_dialog[ SYS_MAX_MENU_ELEMENTS ]; int _position; int _selection; - char **_dialog; bool _repaint; } MenuData; diff --git a/brew.h b/brew.h index 9906c23..bbe5b58 100644 --- a/brew.h +++ b/brew.h @@ -1,6 +1,31 @@ #ifndef __BREW #define __BREW + +// ++++++++++++++++++++++++ LiquidCrystal_I2C ++++++++++++++++++++++++ +#include +#include +#include + +// ++++++++++++++++++++++++ PT100 +++++++++++++++++++++++++++++++++ +//#include + +// ++++++++++++++++++++++++ Defines +++++++++++++++++++++++++++++++++ +#define NELEMS(x) (sizeof(x) / sizeof((x)[0])) + +// ++++++++++++++++++++++++ OTHER +++++++++++++++++++++++++++++++++ +#include "CustomDataStructures.h" +#include "debug.h" + +#include "config.h" + +#include "Melody.h" +#include "Display.h" +#include "Temperature.h" +#include "Profiles.h" + +// ++++++++++++++++++++++++ FUNCTIONS +++++++++++++++++++++++++++++++++ + void xSetupRotaryEncoder( eRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep ); // ######################### START ######################### diff --git a/brew.ino b/brew.ino index cda151d..4c821e3 100644 --- a/brew.ino +++ b/brew.ino @@ -7,27 +7,6 @@ #define DEBUG // ######################### LIBRARIES ######################### - -// ++++++++++++++++++++++++ LiquidCrystal_I2C ++++++++++++++++++++++++ -#include -#include -#include - -// ++++++++++++++++++++++++ PT100 +++++++++++++++++++++++++++++++++ -//#include - -// ++++++++++++++++++++++++ OTHER +++++++++++++++++++++++++++++++++ -#include "debug.h" - -#include "config.h" - -#include "CustomDataStructures.h" - -#include "Melody.h" -#include "Display.h" -#include "Temperature.h" -#include "Profiles.h" - #include "brew.h" // ######################### VARIABLES ######################### @@ -39,15 +18,15 @@ eBeerProfile beerProfile; eMenuType eMenuType; -MenuData mdMainMenu; -MenuData mdStartFromStageMenu; -MenuData mdBeerProfileMenu; -MenuData mdStageMenu; -MenuData mdMaltMenu; -MenuData mdSettingsMenu; +MenuData mdMainMenu = { ._title = MENU_MAIN_TITLE, ._dialog = MENU_MAIN_DIALOG, ._position = MENU_MAIN_INIT_POSITION, ._selection = MENU_MAIN_INIT_SELECTION, ._repaint = MENU_MAIN_INIT_REPAINT }; +MenuData mdStartFromStageMenu = { ._title = MENU_START_TITLE, ._dialog = MENU_START_DIALOG, ._position = MENU_START_INIT_POSITION, ._selection = MENU_START_INIT_SELECTION, ._repaint = MENU_START_INIT_REPAINT }; +MenuData mdBeerProfileMenu = { ._title = MENU_PROFILE_TITLE, ._dialog = MENU_PROFILE_DIALOG, ._position = MENU_PROFILE_INIT_POSITION, ._selection = MENU_PROFILE_INIT_SELECTION, ._repaint = MENU_PROFILE_INIT_REPAINT }; +MenuData mdStageMenu = { ._title = MENU_STAGE_TITLE, ._dialog = MENU_STAGE_DIALOG, ._position = MENU_STAGE_INIT_POSITION, ._selection = MENU_STAGE_INIT_SELECTION, ._repaint = MENU_STAGE_INIT_REPAINT }; +MenuData mdMaltMenu = { ._title = MENU_MALT_TITLE, ._dialog = MENU_MALT_DIALOG, ._position = MENU_MALT_INIT_POSITION, ._selection = MENU_MALT_INIT_SELECTION, ._repaint = MENU_MALT_INIT_REPAINT }; +MenuData mdSettingsMenu = { ._title = MENU_SETTINGS_TITLE, ._dialog = MENU_SETTINGS_DIALOG, ._position = MENU_SETTINGS_INIT_POSITION, ._selection = MENU_SETTINGS_INIT_SELECTION, ._repaint = MENU_SETTINGS_INIT_REPAINT }; -eMainMenuOptions eMainMenuPosition; -eMainMenuOptions eMainMenuSelection; +//eMainMenuOptions eMainMenuPosition; +//eMainMenuOptions eMainMenuSelection; eStageMenuOptions eStartFromStageMenuPosition; eStageMenuOptions eStartFromStageMenuSelection; eBeerProfileMenuOptions eBeerProfileMenuPosition; @@ -55,7 +34,7 @@ eBeerProfileMenuOptions eBeerProfileMenuSelection; eStageMenuOptions eStageMenuPosition; eStageMenuOptions eStageMenuSelection; eMaltMenuOptions eMaltMenuPosition; -eMaltMenuOptions eMaltMenuSelection; +eMaltMenuOptions eMaltMenuSelection; eSettingsMenuOptions eSettingsMenuPosition; eSettingsMenuOptions eSettingsMenuSelection; @@ -74,7 +53,7 @@ int cookTemperature; //cook_mode_list cookMode; //int cookMixerSpeed; int finalYield; - + unsigned long startpointTime; unsigned long betaGlucanaseTime; unsigned long debranchingTime; @@ -87,7 +66,7 @@ unsigned long spargeTime; unsigned long boilTime; unsigned long coolingTime; unsigned long cleaningTime; - + int startpointTemperature; int betaGlucanaseTemperature; int debranchingTemperature; @@ -133,117 +112,117 @@ int iPumpSpeed; // Time frame to operate in 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); // +++++++++++++++++++++++ Temperature +++++++++++++++++++++++ -Temperature basePT100("base", - PT100_BASE_OUTPUT_PIN, - PT100_BASE_INPUT_PIN, - PT100_BASE_TIME_BETWEEN_READINGS, - 2.0298, 2.0259, 665.24, 662.17); -Temperature upPT100("up", - PT100_UP_OUTPUT_PIN, - PT100_UP_INPUT_PIN, - PT100_UP_TIME_BETWEEN_READINGS, - 2.0274, 2.0245, 659.43, 656.72); -Temperature downPT100("down", - PT100_DOWN_OUTPUT_PIN, - PT100_DOWN_INPUT_PIN, - PT100_DOWN_TIME_BETWEEN_READINGS, - 2.0309, 2.0288, 658.15, 655.35); +Temperature basePT100("base", + PT100_BASE_OUTPUT_PIN, + PT100_BASE_INPUT_PIN, + PT100_BASE_TIME_BETWEEN_READINGS, + 2.0298, 2.0259, 665.24, 662.17); +Temperature upPT100("up", + PT100_UP_OUTPUT_PIN, + PT100_UP_INPUT_PIN, + PT100_UP_TIME_BETWEEN_READINGS, + 2.0274, 2.0245, 659.43, 656.72); +Temperature downPT100("down", + PT100_DOWN_OUTPUT_PIN, + PT100_DOWN_INPUT_PIN, + PT100_DOWN_TIME_BETWEEN_READINGS, + 2.0309, 2.0288, 658.15, 655.35); // ######################### INTERRUPTS ######################### void isr () { // Interrupt service routine is executed when a HIGH to LOW transition is detected on CLK unsigned long interruptTime = millis(); unsigned long diff = interruptTime - lastInterruptTime; - + // If interrupts come faster than [ROTARY_ENCODER_DEBOUNCE_TIME]ms, assume it's a bounce and ignore if (diff > ROTARY_ENCODER_DEBOUNCE_TIME) { lastInterruptTime = interruptTime; - - switch(rotaryEncoderMode) { + + switch (rotaryEncoderMode) { // Input of rotary encoder controling menus case eRotaryEncoderMode_Menu: { - if (!digitalRead(ROTARY_ENCODER_DT_PIN)) { + if (!digitalRead(ROTARY_ENCODER_DT_PIN)) { rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition + rotaryEncoderSingleStep); - } - else { + } + else { rotaryEncoderVirtualPosition = rotaryEncoderVirtualPosition - rotaryEncoderSingleStep; - } - if (rotaryEncoderVirtualPosition > rotaryEncoderMaxPosition) { + } + if (rotaryEncoderVirtualPosition > rotaryEncoderMaxPosition) { rotaryEncoderVirtualPosition = rotaryEncoderMinPosition; - } - if (rotaryEncoderVirtualPosition < rotaryEncoderMinPosition) { + } + if (rotaryEncoderVirtualPosition < rotaryEncoderMinPosition) { rotaryEncoderVirtualPosition = rotaryEncoderMaxPosition; + } + + break; } - - break; - } - + // Input of rotary encoder controling time variables case eRotaryEncoderMode_Time: { - if (!digitalRead(ROTARY_ENCODER_DT_PIN)) { - if(rotaryEncoderVirtualPosition >= 60) { - rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition + rotaryEncoderMultiStep); - } - else { - rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition + rotaryEncoderSingleStep); - } - } - else { - if(rotaryEncoderVirtualPosition == rotaryEncoderMinPosition) { - rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition + 60); + if (!digitalRead(ROTARY_ENCODER_DT_PIN)) { + if (rotaryEncoderVirtualPosition >= 60) { + rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition + rotaryEncoderMultiStep); + } + else { + rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition + rotaryEncoderSingleStep); + } } else { - if(rotaryEncoderVirtualPosition >= (60 + rotaryEncoderMultiStep)) { - rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition - rotaryEncoderMultiStep); + if (rotaryEncoderVirtualPosition == rotaryEncoderMinPosition) { + rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition + 60); } else { - rotaryEncoderVirtualPosition = rotaryEncoderVirtualPosition - rotaryEncoderSingleStep; + if (rotaryEncoderVirtualPosition >= (60 + rotaryEncoderMultiStep)) { + rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition - rotaryEncoderMultiStep); + } + else { + rotaryEncoderVirtualPosition = rotaryEncoderVirtualPosition - rotaryEncoderSingleStep; + } } } - } - if (rotaryEncoderVirtualPosition > rotaryEncoderMaxPosition) { + if (rotaryEncoderVirtualPosition > rotaryEncoderMaxPosition) { rotaryEncoderVirtualPosition = rotaryEncoderMaxPosition; - } - if (rotaryEncoderVirtualPosition < rotaryEncoderMinPosition) { + } + if (rotaryEncoderVirtualPosition < rotaryEncoderMinPosition) { rotaryEncoderVirtualPosition = rotaryEncoderMinPosition; + } + + break; } - - break; - } - + // Input of rotary encoder controling generic integer variables within a range between rotaryEncoderMinPosition and rotaryEncoderMaxPosition case eRotaryEncoderMode_Generic: { - if (!digitalRead(ROTARY_ENCODER_DT_PIN)) { - rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition + rotaryEncoderSingleStep); - } - else { - rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition - rotaryEncoderSingleStep); - } - if (rotaryEncoderVirtualPosition > rotaryEncoderMaxPosition) { + if (!digitalRead(ROTARY_ENCODER_DT_PIN)) { + rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition + rotaryEncoderSingleStep); + } + else { + rotaryEncoderVirtualPosition = (rotaryEncoderVirtualPosition - rotaryEncoderSingleStep); + } + if (rotaryEncoderVirtualPosition > rotaryEncoderMaxPosition) { rotaryEncoderVirtualPosition = rotaryEncoderMaxPosition; - } - if (rotaryEncoderVirtualPosition < rotaryEncoderMinPosition) { + } + if (rotaryEncoderVirtualPosition < rotaryEncoderMinPosition) { rotaryEncoderVirtualPosition = rotaryEncoderMinPosition; + } + + break; } - - break; - } default: { - - } + + } } - + repaint = true; refresh = true; } } void xSetupRotaryEncoder( eRotaryEncoderMode 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; + 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; } // ######################### START ######################### @@ -276,9 +255,11 @@ void xWelcomeUser() { //#endif } +const char *_dialogs[] = {"", "b"}; + void setup() { // ++++++++++++++++++++++++ Rotary Encoder ++++++++++++++++++++++++ - pinMode (ROTARY_ENCODER_CLK_PIN,INPUT); + 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); @@ -307,8 +288,8 @@ void setup() { 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.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 ######################### @@ -320,11 +301,8 @@ void setup() { // ++++++++++++++++++++++++ State Machine ++++++++++++++++++++++++ eMenuType = eMenuType_Main; - mdMainMenu._position = eMainMenu_GO; - mdMainMenu._selection = eMainMenu_NULL; - - eMainMenuPosition = eMainMenu_GO; - eMainMenuSelection = eMainMenu_NULL; + //eMainMenuPosition = MENU_MAIN_INIT_POSITION; + //eMainMenuSelection = MENU_MAIN_INIT_SELECTION; eBeerProfileMenuPosition = eBeerProfileMenu_Basic; eBeerProfileMenuSelection = eBeerProfileMenu_NULL; eStageMenuPosition = eStageMenu_Startpoint; @@ -346,7 +324,7 @@ void setup() { clockIgnore = 0; clockStart = false; clockEnd = false; - + cookTime = 3600; cookTemperature = 25; //cookMode = quick_start; @@ -391,7 +369,7 @@ void setup() { // ######################### Code - Run Once ######################### xSafeHardwarePowerOff (); xWelcomeUser (); - + xSetupRotaryEncoder ( eRotaryEncoderMode_Menu, eMainMenu_GO, MENU_SIZE_MAIN_MENU - 1, 1, 1, 0 ); } @@ -400,8 +378,8 @@ void setup() { void loop() { unsigned long inactivityTime = getInactivityTime(); - if( inactivityTime > SETTING_MAX_INACTIVITY_TIME ) { // Inactivity check - if(refresh) { + if ( inactivityTime > SETTING_MAX_INACTIVITY_TIME ) { // Inactivity check + if (refresh) { repaint = true; refresh = false; } @@ -410,542 +388,550 @@ void loop() { else { runMenu(); } - + xManageMachineSystems(); } // ######################### FUNCTIONS ######################## void runMenu() { - #ifdef DEBUG_OFF +#ifdef DEBUG_OFF boolean debug_go = repaint; - if(debug_go) { + if (debug_go) { debugPrintFunction("runMenu"); debugPrintVar("repaint", repaint); debugPrintVar("eMenuType", eMenuType); debugPrintVar("rotaryEncoderVirtualPosition", rotaryEncoderVirtualPosition); } - #endif +#endif - switch(eMenuType) { + switch (eMenuType) { case eMenuType_Main: { - eMainMenuPosition = static_cast(rotaryEncoderVirtualPosition); + //eMainMenuPosition = static_cast(rotaryEncoderVirtualPosition); + mdMainMenu._position = rotaryEncoderVirtualPosition; - repaint = displayMainMenu( &lcd, eMainMenuPosition, repaint ); + mdMainMenu._repaint = repaint; + repaint = displayGenericMenu( &lcd, &mdMainMenu ); + //repaint = displayMainMenu( &lcd, eMainMenuPosition, repaint ); - if ( gotButtonPress( ROTARY_ENCODER_SW_PIN ) ) { - eMainMenuSelection = eMainMenuPosition; - } + if ( gotButtonPress( ROTARY_ENCODER_SW_PIN ) ) { + mdMainMenu._selection = mdMainMenu._position; + //eMainMenuSelection = eMainMenuPosition; + } - runMainMenuSelection(); + runMainMenuSelection(); - break; - } + break; + } case eMenuType_StartFromStage: { - eStartFromStageMenuPosition = static_cast(rotaryEncoderVirtualPosition); - - repaint = displayStageMenu( &lcd, eStartFromStageMenuPosition, repaint ); + eStartFromStageMenuPosition = static_cast(rotaryEncoderVirtualPosition); - if ( gotButtonPress( ROTARY_ENCODER_SW_PIN ) ) { - eStartFromStageMenuSelection = eStartFromStageMenuPosition; - } + repaint = displayStageMenu( &lcd, eStartFromStageMenuPosition, repaint ); - runStartFromStageSelection(); - - break; - } - case eMenuType_BeerProfile: { - eBeerProfileMenuPosition = static_cast(rotaryEncoderVirtualPosition); - - repaint = displayBeerProfileMenu( &lcd, eBeerProfileMenuPosition, repaint ); + if ( gotButtonPress( ROTARY_ENCODER_SW_PIN ) ) { + eStartFromStageMenuSelection = eStartFromStageMenuPosition; + } + + runStartFromStageSelection(); - if ( gotButtonPress( ROTARY_ENCODER_SW_PIN ) ) { - eBeerProfileMenuSelection = eBeerProfileMenuPosition; + break; } + case eMenuType_BeerProfile: { + eBeerProfileMenuPosition = static_cast(rotaryEncoderVirtualPosition); - runBeerProfileSelection(); - - break; - } - case eMenuType_Stage: { - eStageMenuPosition = static_cast(rotaryEncoderVirtualPosition); - - repaint = displayStageMenu( &lcd, eStageMenuPosition, repaint ); + repaint = displayBeerProfileMenu( &lcd, eBeerProfileMenuPosition, repaint ); + + if ( gotButtonPress( ROTARY_ENCODER_SW_PIN ) ) { + eBeerProfileMenuSelection = eBeerProfileMenuPosition; + } - if ( gotButtonPress( ROTARY_ENCODER_SW_PIN ) ) { - eStageMenuSelection = eStageMenuPosition; + runBeerProfileSelection(); + + break; } + case eMenuType_Stage: { + eStageMenuPosition = static_cast(rotaryEncoderVirtualPosition); - runStageSelection(); - - break; - } - case eMenuType_Malt: { - eMaltMenuPosition = static_cast(rotaryEncoderVirtualPosition); - - repaint = displayMaltMenu( &lcd, eMaltMenuPosition, repaint ); + repaint = displayStageMenu( &lcd, eStageMenuPosition, repaint ); + + if ( gotButtonPress( ROTARY_ENCODER_SW_PIN ) ) { + eStageMenuSelection = eStageMenuPosition; + } - if ( gotButtonPress( ROTARY_ENCODER_SW_PIN ) ) { - eMaltMenuSelection = eMaltMenuPosition; + runStageSelection(); + + break; } + case eMenuType_Malt: { + eMaltMenuPosition = static_cast(rotaryEncoderVirtualPosition); - runMaltSelection(); - - break; - } - case eMenuType_Settings: { - eSettingsMenuPosition = static_cast(rotaryEncoderVirtualPosition); - - repaint = displaySettingsMenu( &lcd, eSettingsMenuPosition, repaint ); + repaint = displayMaltMenu( &lcd, eMaltMenuPosition, repaint ); - if ( gotButtonPress( ROTARY_ENCODER_SW_PIN ) ) { - eSettingsMenuSelection = eSettingsMenuPosition; + if ( gotButtonPress( ROTARY_ENCODER_SW_PIN ) ) { + eMaltMenuSelection = eMaltMenuPosition; + } + + runMaltSelection(); + + break; } + case eMenuType_Settings: { + eSettingsMenuPosition = static_cast(rotaryEncoderVirtualPosition); - runSettingsSelection(); - - break; - } + repaint = displaySettingsMenu( &lcd, eSettingsMenuPosition, repaint ); + + if ( gotButtonPress( ROTARY_ENCODER_SW_PIN ) ) { + eSettingsMenuSelection = eSettingsMenuPosition; + } + + runSettingsSelection(); + + break; + } } - #ifdef DEBUG_OFF - if(debug_go) { +#ifdef DEBUG_OFF + if (debug_go) { debugPrintVar("repaint", repaint); } - #endif +#endif } void runSettingsSelection() { - switch(eSettingsMenuSelection) { + switch (eSettingsMenuSelection) { case eSettingsMenu_Pump: { - // Stuff - if( xSetGenericValue( iPumpSpeed?0:1, 0, 1, "pump", "bool" ) ) { - iPumpSpeed = PUMP_SPEED_MAX_MOSFET; - } else { - iPumpSpeed = PUMP_SPEED_STOP_MOSFET; - } - analogWrite(PUMP_PIN, iPumpSpeed); + // Stuff + if ( xSetGenericValue( iPumpSpeed ? 0 : 1, 0, 1, "pump", "bool" ) ) { + iPumpSpeed = PUMP_SPEED_MAX_MOSFET; + } else { + iPumpSpeed = PUMP_SPEED_STOP_MOSFET; + } + analogWrite(PUMP_PIN, iPumpSpeed); - backToStatus(); - - break; - } + backToStatus(); + + break; + } case eSettingsMenu_PT100_Element: { - // Stuff + // Stuff - backToStatus(); - - break; - } + backToStatus(); + + break; + } case eSettingsMenu_PT100_Up: { - // Stuff + // Stuff - backToStatus(); - - break; - } + backToStatus(); + + break; + } case eSettingsMenu_PT100_Down: { - // Stuff + // Stuff - backToStatus(); - - break; - } + backToStatus(); + + break; + } case eSettingsMenu_Back: { - eMenuType = eMenuType_Main; - repaint = true; - - // reset operation state | INPUT : eRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep - xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenuPosition, MENU_SIZE_MAIN_MENU - 1, 1, 1, 0 ); + eMenuType = eMenuType_Main; + repaint = true; - break; - } + // reset operation state | INPUT : eRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep + //xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenuPosition, MENU_SIZE_MAIN_MENU - 1, 1, 1, 0 ); + xSetupRotaryEncoder( eRotaryEncoderMode_Menu, mdMainMenu._position, MENU_SIZE_MAIN_MENU - 1, 1, 1, 0 ); + + break; + } default: { - } + } } eSettingsMenuSelection = eSettingsMenu_NULL; } void runMaltSelection() { - switch(eMaltMenuSelection) { + switch (eMaltMenuSelection) { case eMaltMenu_CastleMalting_Chteau_Pilsen_2RS: { - // Stuff + // Stuff - backToStatus(); - - break; - } + backToStatus(); + + break; + } case eMaltMenu_CastleMalting_Wheat_Blanc: { - // Stuff + // Stuff - backToStatus(); - - break; - } + backToStatus(); + + break; + } case eMaltMenu_Back: { - eMenuType = eMenuType_Main; - repaint = true; - - // reset operation state | INPUT : eRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep - xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenuPosition, MENU_SIZE_MAIN_MENU - 1, 1, 1, 0 ); + eMenuType = eMenuType_Main; + repaint = true; - break; - } + // reset operation state | INPUT : eRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep + //xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenuPosition, MENU_SIZE_MAIN_MENU - 1, 1, 1, 0 ); + xSetupRotaryEncoder( eRotaryEncoderMode_Menu, mdMainMenu._position, MENU_SIZE_MAIN_MENU - 1, 1, 1, 0 ); + + break; + } default: { - } + } } eMaltMenuSelection = eMaltMenu_NULL; } void runStageSelection() { - switch(eStageMenuSelection) { + switch (eStageMenuSelection) { case eStageMenu_Startpoint: { - startpointTime = getTimer( startpointTime ); - - startpointTemperature = xSetGenericValue( startpointTemperature, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); + startpointTime = getTimer( startpointTime ); - backToStatus(); - - break; - } + startpointTemperature = xSetGenericValue( startpointTemperature, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); + + backToStatus(); + + break; + } case eStageMenu_BetaGlucanase: { - betaGlucanaseTime = getTimer( betaGlucanaseTime ); - - betaGlucanaseTemperature = xSetGenericValue( betaGlucanaseTemperature, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); + betaGlucanaseTime = getTimer( betaGlucanaseTime ); - backToStatus(); - - break; - } + betaGlucanaseTemperature = xSetGenericValue( betaGlucanaseTemperature, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); + + backToStatus(); + + break; + } case eStageMenu_Debranching: { - debranchingTime = getTimer( debranchingTime ); - - debranchingTemperature = xSetGenericValue( debranchingTemperature, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); + debranchingTime = getTimer( debranchingTime ); - backToStatus(); - - break; - } + debranchingTemperature = xSetGenericValue( debranchingTemperature, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); + + backToStatus(); + + break; + } case eStageMenu_Proteolytic: { - proteolyticTime = getTimer( proteolyticTime ); - - proteolyticTemperature = xSetGenericValue( proteolyticTemperature, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); + proteolyticTime = getTimer( proteolyticTime ); - backToStatus(); - - break; - } + proteolyticTemperature = xSetGenericValue( proteolyticTemperature, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); + + backToStatus(); + + break; + } case eStageMenu_BetaAmylase: { - betaAmylaseTime = getTimer( betaAmylaseTime ); - - betaAmylaseTemperature = xSetGenericValue( betaAmylaseTemperature, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); + betaAmylaseTime = getTimer( betaAmylaseTime ); - backToStatus(); - - break; - } + betaAmylaseTemperature = xSetGenericValue( betaAmylaseTemperature, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); + + backToStatus(); + + break; + } case eStageMenu_AlphaAmylase: { - alphaAmylaseTime = getTimer( alphaAmylaseTime ); - - alphaAmylaseTemperature = xSetGenericValue( alphaAmylaseTemperature, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); + alphaAmylaseTime = getTimer( alphaAmylaseTime ); - backToStatus(); - - break; - } + alphaAmylaseTemperature = xSetGenericValue( alphaAmylaseTemperature, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); + + backToStatus(); + + break; + } case eStageMenu_Mashout: { - mashoutTime = getTimer( mashoutTime ); - - mashoutTemperature = xSetGenericValue( mashoutTemperature, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); + mashoutTime = getTimer( mashoutTime ); - backToStatus(); - - break; - } + mashoutTemperature = xSetGenericValue( mashoutTemperature, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); + + backToStatus(); + + break; + } case eStageMenu_Recirculation: { - recirculationTime = getTimer( recirculationTime ); - - recirculationTemperature = xSetGenericValue( recirculationTemperature, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); + recirculationTime = getTimer( recirculationTime ); - backToStatus(); - - break; - } + recirculationTemperature = xSetGenericValue( recirculationTemperature, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); + + backToStatus(); + + break; + } case eStageMenu_Sparge: { - spargeTime = getTimer( spargeTime ); - - spargeTemperature = xSetGenericValue( spargeTemperature, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); + spargeTime = getTimer( spargeTime ); - backToStatus(); - - break; - } + spargeTemperature = xSetGenericValue( spargeTemperature, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); + + backToStatus(); + + break; + } case eStageMenu_Boil: { - boilTime = getTimer( boilTime ); - - boilTemperature = xSetGenericValue( boilTemperature, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); + boilTime = getTimer( boilTime ); - backToStatus(); - - break; - } + boilTemperature = xSetGenericValue( boilTemperature, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); + + backToStatus(); + + break; + } case eStageMenu_Cooling: { - coolingTime = getTimer( coolingTime ); - - coolingTemperature = xSetGenericValue( coolingTemperature, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); + coolingTime = getTimer( coolingTime ); - backToStatus(); - - break; - } + coolingTemperature = xSetGenericValue( coolingTemperature, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); + + backToStatus(); + + break; + } case eStageMenu_Back: { - eMenuType = eMenuType_Main; - repaint = true; - - // reset operation state | INPUT : eRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep - xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenuPosition, MENU_SIZE_MAIN_MENU - 1, 1, 1, 0 ); + eMenuType = eMenuType_Main; + repaint = true; - break; - } + // reset operation state | INPUT : eRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep + //xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenuPosition, MENU_SIZE_MAIN_MENU - 1, 1, 1, 0 ); + xSetupRotaryEncoder( eRotaryEncoderMode_Menu, mdMainMenu._position, MENU_SIZE_MAIN_MENU - 1, 1, 1, 0 ); + + break; + } default: { - } + } } eStageMenuSelection = eStageMenu_NULL; } void runBeerProfileSelection() { - switch(eBeerProfileMenuSelection) { + switch (eBeerProfileMenuSelection) { case eBeerProfileMenu_Basic: { - beerProfile = eBeerProfile_Basic; - - startpointTime = PROFILE_BASIC_STARTPOINT_TIME; - betaGlucanaseTime = PROFILE_BASIC_BETAGLUCANASE_TIME; - debranchingTime = PROFILE_BASIC_DEBRANCHING_TIME; - proteolyticTime = PROFILE_BASIC_PROTEOLYTIC_TIME; - betaAmylaseTime = PROFILE_BASIC_BETAAMYLASE_TIME; - alphaAmylaseTime = PROFILE_BASIC_ALPHAAMYLASE_TIME; - mashoutTime = PROFILE_BASIC_MASHOUT_TIME; - recirculationTime = PROFILE_BASIC_RECIRCULATION_TIME; - spargeTime = PROFILE_BASIC_SPARGE_TIME; - boilTime = PROFILE_BASIC_BOIL_TIME; - coolingTime = PROFILE_BASIC_COOLING_TIME; - - startpointTemperature = PROFILE_BASIC_STARTPOINT_TEMPERATURE; - betaGlucanaseTemperature = PROFILE_BASIC_BETAGLUCANASE_TEMPERATURE; - debranchingTemperature = PROFILE_BASIC_DEBRANCHING_TEMPERATURE; - proteolyticTemperature = PROFILE_BASIC_PROTEOLYTIC_TEMPERATURE; - betaAmylaseTemperature = PROFILE_BASIC_BETAAMYLASE_TEMPERATURE; - alphaAmylaseTemperature = PROFILE_BASIC_ALPHAAMYLASE_TEMPERATURE; - mashoutTemperature = PROFILE_BASIC_MASHOUT_TEMPERATURE; - recirculationTemperature = PROFILE_BASIC_RECIRCULATION_TEMPERATURE; - spargeTemperature = PROFILE_BASIC_SPARGE_TEMPERATURE; - boilTemperature = PROFILE_BASIC_BOIL_TEMPERATURE; - coolingTemperature = PROFILE_BASIC_COOLING_TEMPERATURE; - - backToStatus(); - - break; - } + beerProfile = eBeerProfile_Basic; + + startpointTime = PROFILE_BASIC_STARTPOINT_TIME; + betaGlucanaseTime = PROFILE_BASIC_BETAGLUCANASE_TIME; + debranchingTime = PROFILE_BASIC_DEBRANCHING_TIME; + proteolyticTime = PROFILE_BASIC_PROTEOLYTIC_TIME; + betaAmylaseTime = PROFILE_BASIC_BETAAMYLASE_TIME; + alphaAmylaseTime = PROFILE_BASIC_ALPHAAMYLASE_TIME; + mashoutTime = PROFILE_BASIC_MASHOUT_TIME; + recirculationTime = PROFILE_BASIC_RECIRCULATION_TIME; + spargeTime = PROFILE_BASIC_SPARGE_TIME; + boilTime = PROFILE_BASIC_BOIL_TIME; + coolingTime = PROFILE_BASIC_COOLING_TIME; + + startpointTemperature = PROFILE_BASIC_STARTPOINT_TEMPERATURE; + betaGlucanaseTemperature = PROFILE_BASIC_BETAGLUCANASE_TEMPERATURE; + debranchingTemperature = PROFILE_BASIC_DEBRANCHING_TEMPERATURE; + proteolyticTemperature = PROFILE_BASIC_PROTEOLYTIC_TEMPERATURE; + betaAmylaseTemperature = PROFILE_BASIC_BETAAMYLASE_TEMPERATURE; + alphaAmylaseTemperature = PROFILE_BASIC_ALPHAAMYLASE_TEMPERATURE; + mashoutTemperature = PROFILE_BASIC_MASHOUT_TEMPERATURE; + recirculationTemperature = PROFILE_BASIC_RECIRCULATION_TEMPERATURE; + spargeTemperature = PROFILE_BASIC_SPARGE_TEMPERATURE; + boilTemperature = PROFILE_BASIC_BOIL_TEMPERATURE; + coolingTemperature = PROFILE_BASIC_COOLING_TEMPERATURE; + + backToStatus(); + + break; + } case eBeerProfileMenu_Trigo: { - beerProfile = eBeerProfile_Trigo; - - startpointTime = PROFILE_TRIGO_STARTPOINT_TIME; - betaGlucanaseTime = PROFILE_TRIGO_BETAGLUCANASE_TIME; - debranchingTime = PROFILE_TRIGO_DEBRANCHING_TIME; - proteolyticTime = PROFILE_TRIGO_PROTEOLYTIC_TIME; - betaAmylaseTime = PROFILE_TRIGO_BETAAMYLASE_TIME; - alphaAmylaseTime = PROFILE_TRIGO_ALPHAAMYLASE_TIME; - mashoutTime = PROFILE_TRIGO_MASHOUT_TIME; - recirculationTime = PROFILE_TRIGO_RECIRCULATION_TIME; - spargeTime = PROFILE_TRIGO_SPARGE_TIME; - boilTime = PROFILE_TRIGO_BOIL_TIME; - coolingTime = PROFILE_TRIGO_COOLING_TIME; - - startpointTemperature = PROFILE_TRIGO_STARTPOINT_TEMPERATURE; - betaGlucanaseTemperature = PROFILE_TRIGO_BETAGLUCANASE_TEMPERATURE; - debranchingTemperature = PROFILE_TRIGO_DEBRANCHING_TEMPERATURE; - proteolyticTemperature = PROFILE_TRIGO_PROTEOLYTIC_TEMPERATURE; - betaAmylaseTemperature = PROFILE_TRIGO_BETAAMYLASE_TEMPERATURE; - alphaAmylaseTemperature = PROFILE_TRIGO_ALPHAAMYLASE_TEMPERATURE; - mashoutTemperature = PROFILE_TRIGO_MASHOUT_TEMPERATURE; - recirculationTemperature = PROFILE_TRIGO_RECIRCULATION_TEMPERATURE; - spargeTemperature = PROFILE_TRIGO_SPARGE_TEMPERATURE; - boilTemperature = PROFILE_TRIGO_BOIL_TEMPERATURE; - coolingTemperature = PROFILE_TRIGO_COOLING_TEMPERATURE; - - backToStatus(); - - break; - } + beerProfile = eBeerProfile_Trigo; + + startpointTime = PROFILE_TRIGO_STARTPOINT_TIME; + betaGlucanaseTime = PROFILE_TRIGO_BETAGLUCANASE_TIME; + debranchingTime = PROFILE_TRIGO_DEBRANCHING_TIME; + proteolyticTime = PROFILE_TRIGO_PROTEOLYTIC_TIME; + betaAmylaseTime = PROFILE_TRIGO_BETAAMYLASE_TIME; + alphaAmylaseTime = PROFILE_TRIGO_ALPHAAMYLASE_TIME; + mashoutTime = PROFILE_TRIGO_MASHOUT_TIME; + recirculationTime = PROFILE_TRIGO_RECIRCULATION_TIME; + spargeTime = PROFILE_TRIGO_SPARGE_TIME; + boilTime = PROFILE_TRIGO_BOIL_TIME; + coolingTime = PROFILE_TRIGO_COOLING_TIME; + + startpointTemperature = PROFILE_TRIGO_STARTPOINT_TEMPERATURE; + betaGlucanaseTemperature = PROFILE_TRIGO_BETAGLUCANASE_TEMPERATURE; + debranchingTemperature = PROFILE_TRIGO_DEBRANCHING_TEMPERATURE; + proteolyticTemperature = PROFILE_TRIGO_PROTEOLYTIC_TEMPERATURE; + betaAmylaseTemperature = PROFILE_TRIGO_BETAAMYLASE_TEMPERATURE; + alphaAmylaseTemperature = PROFILE_TRIGO_ALPHAAMYLASE_TEMPERATURE; + mashoutTemperature = PROFILE_TRIGO_MASHOUT_TEMPERATURE; + recirculationTemperature = PROFILE_TRIGO_RECIRCULATION_TEMPERATURE; + spargeTemperature = PROFILE_TRIGO_SPARGE_TEMPERATURE; + boilTemperature = PROFILE_TRIGO_BOIL_TEMPERATURE; + coolingTemperature = PROFILE_TRIGO_COOLING_TEMPERATURE; + + backToStatus(); + + break; + } case eBeerProfileMenu_IPA: { - beerProfile = eBeerProfile_IPA; - - startpointTime = PROFILE_IPA_STARTPOINT_TIME; - betaGlucanaseTime = PROFILE_IPA_BETAGLUCANASE_TIME; - debranchingTime = PROFILE_IPA_DEBRANCHING_TIME; - proteolyticTime = PROFILE_IPA_PROTEOLYTIC_TIME; - betaAmylaseTime = PROFILE_IPA_BETAAMYLASE_TIME; - alphaAmylaseTime = PROFILE_IPA_ALPHAAMYLASE_TIME; - mashoutTime = PROFILE_IPA_MASHOUT_TIME; - recirculationTime = PROFILE_IPA_RECIRCULATION_TIME; - spargeTime = PROFILE_IPA_SPARGE_TIME; - boilTime = PROFILE_IPA_BOIL_TIME; - coolingTime = PROFILE_IPA_COOLING_TIME; - - startpointTemperature = PROFILE_IPA_STARTPOINT_TEMPERATURE; - betaGlucanaseTemperature = PROFILE_IPA_BETAGLUCANASE_TEMPERATURE; - debranchingTemperature = PROFILE_IPA_DEBRANCHING_TEMPERATURE; - proteolyticTemperature = PROFILE_IPA_PROTEOLYTIC_TEMPERATURE; - betaAmylaseTemperature = PROFILE_IPA_BETAAMYLASE_TEMPERATURE; - alphaAmylaseTemperature = PROFILE_IPA_ALPHAAMYLASE_TEMPERATURE; - mashoutTemperature = PROFILE_IPA_MASHOUT_TEMPERATURE; - recirculationTemperature = PROFILE_IPA_RECIRCULATION_TEMPERATURE; - spargeTemperature = PROFILE_IPA_SPARGE_TEMPERATURE; - boilTemperature = PROFILE_IPA_BOIL_TEMPERATURE; - coolingTemperature = PROFILE_IPA_COOLING_TEMPERATURE; - - backToStatus(); + beerProfile = eBeerProfile_IPA; + + startpointTime = PROFILE_IPA_STARTPOINT_TIME; + betaGlucanaseTime = PROFILE_IPA_BETAGLUCANASE_TIME; + debranchingTime = PROFILE_IPA_DEBRANCHING_TIME; + proteolyticTime = PROFILE_IPA_PROTEOLYTIC_TIME; + betaAmylaseTime = PROFILE_IPA_BETAAMYLASE_TIME; + alphaAmylaseTime = PROFILE_IPA_ALPHAAMYLASE_TIME; + mashoutTime = PROFILE_IPA_MASHOUT_TIME; + recirculationTime = PROFILE_IPA_RECIRCULATION_TIME; + spargeTime = PROFILE_IPA_SPARGE_TIME; + boilTime = PROFILE_IPA_BOIL_TIME; + coolingTime = PROFILE_IPA_COOLING_TIME; + + startpointTemperature = PROFILE_IPA_STARTPOINT_TEMPERATURE; + betaGlucanaseTemperature = PROFILE_IPA_BETAGLUCANASE_TEMPERATURE; + debranchingTemperature = PROFILE_IPA_DEBRANCHING_TEMPERATURE; + proteolyticTemperature = PROFILE_IPA_PROTEOLYTIC_TEMPERATURE; + betaAmylaseTemperature = PROFILE_IPA_BETAAMYLASE_TEMPERATURE; + alphaAmylaseTemperature = PROFILE_IPA_ALPHAAMYLASE_TEMPERATURE; + mashoutTemperature = PROFILE_IPA_MASHOUT_TEMPERATURE; + recirculationTemperature = PROFILE_IPA_RECIRCULATION_TEMPERATURE; + spargeTemperature = PROFILE_IPA_SPARGE_TEMPERATURE; + boilTemperature = PROFILE_IPA_BOIL_TEMPERATURE; + coolingTemperature = PROFILE_IPA_COOLING_TEMPERATURE; + + backToStatus(); - break; - } + break; + } case eBeerProfileMenu_Belga: { - beerProfile = eBeerProfile_Belga; - - startpointTime = PROFILE_BELGA_STARTPOINT_TIME; - betaGlucanaseTime = PROFILE_BELGA_BETAGLUCANASE_TIME; - debranchingTime = PROFILE_BELGA_DEBRANCHING_TIME; - proteolyticTime = PROFILE_BELGA_PROTEOLYTIC_TIME; - betaAmylaseTime = PROFILE_BELGA_BETAAMYLASE_TIME; - alphaAmylaseTime = PROFILE_BELGA_ALPHAAMYLASE_TIME; - mashoutTime = PROFILE_BELGA_MASHOUT_TIME; - recirculationTime = PROFILE_BELGA_RECIRCULATION_TIME; - spargeTime = PROFILE_BELGA_SPARGE_TIME; - boilTime = PROFILE_BELGA_BOIL_TIME; - coolingTime = PROFILE_BELGA_COOLING_TIME; - - startpointTemperature = PROFILE_BELGA_STARTPOINT_TEMPERATURE; - betaGlucanaseTemperature = PROFILE_BELGA_BETAGLUCANASE_TEMPERATURE; - debranchingTemperature = PROFILE_BELGA_DEBRANCHING_TEMPERATURE; - proteolyticTemperature = PROFILE_BELGA_PROTEOLYTIC_TEMPERATURE; - betaAmylaseTemperature = PROFILE_BELGA_BETAAMYLASE_TEMPERATURE; - alphaAmylaseTemperature = PROFILE_BELGA_ALPHAAMYLASE_TEMPERATURE; - mashoutTemperature = PROFILE_BELGA_MASHOUT_TEMPERATURE; - recirculationTemperature = PROFILE_BELGA_RECIRCULATION_TEMPERATURE; - spargeTemperature = PROFILE_BELGA_SPARGE_TEMPERATURE; - boilTemperature = PROFILE_BELGA_BOIL_TEMPERATURE; - coolingTemperature = PROFILE_BELGA_COOLING_TEMPERATURE; - - backToStatus(); - - break; - } + beerProfile = eBeerProfile_Belga; + + startpointTime = PROFILE_BELGA_STARTPOINT_TIME; + betaGlucanaseTime = PROFILE_BELGA_BETAGLUCANASE_TIME; + debranchingTime = PROFILE_BELGA_DEBRANCHING_TIME; + proteolyticTime = PROFILE_BELGA_PROTEOLYTIC_TIME; + betaAmylaseTime = PROFILE_BELGA_BETAAMYLASE_TIME; + alphaAmylaseTime = PROFILE_BELGA_ALPHAAMYLASE_TIME; + mashoutTime = PROFILE_BELGA_MASHOUT_TIME; + recirculationTime = PROFILE_BELGA_RECIRCULATION_TIME; + spargeTime = PROFILE_BELGA_SPARGE_TIME; + boilTime = PROFILE_BELGA_BOIL_TIME; + coolingTime = PROFILE_BELGA_COOLING_TIME; + + startpointTemperature = PROFILE_BELGA_STARTPOINT_TEMPERATURE; + betaGlucanaseTemperature = PROFILE_BELGA_BETAGLUCANASE_TEMPERATURE; + debranchingTemperature = PROFILE_BELGA_DEBRANCHING_TEMPERATURE; + proteolyticTemperature = PROFILE_BELGA_PROTEOLYTIC_TEMPERATURE; + betaAmylaseTemperature = PROFILE_BELGA_BETAAMYLASE_TEMPERATURE; + alphaAmylaseTemperature = PROFILE_BELGA_ALPHAAMYLASE_TEMPERATURE; + mashoutTemperature = PROFILE_BELGA_MASHOUT_TEMPERATURE; + recirculationTemperature = PROFILE_BELGA_RECIRCULATION_TEMPERATURE; + spargeTemperature = PROFILE_BELGA_SPARGE_TEMPERATURE; + boilTemperature = PROFILE_BELGA_BOIL_TEMPERATURE; + coolingTemperature = PROFILE_BELGA_COOLING_TEMPERATURE; + + backToStatus(); + + break; + } case eBeerProfileMenu_Red: { - beerProfile = eBeerProfile_Red; - - startpointTime = PROFILE_RED_STARTPOINT_TIME; - betaGlucanaseTime = PROFILE_RED_BETAGLUCANASE_TIME; - debranchingTime = PROFILE_RED_DEBRANCHING_TIME; - proteolyticTime = PROFILE_RED_PROTEOLYTIC_TIME; - betaAmylaseTime = PROFILE_RED_BETAAMYLASE_TIME; - alphaAmylaseTime = PROFILE_RED_ALPHAAMYLASE_TIME; - mashoutTime = PROFILE_RED_MASHOUT_TIME; - recirculationTime = PROFILE_RED_RECIRCULATION_TIME; - spargeTime = PROFILE_RED_SPARGE_TIME; - boilTime = PROFILE_RED_BOIL_TIME; - coolingTime = PROFILE_RED_COOLING_TIME; - - startpointTemperature = PROFILE_RED_STARTPOINT_TEMPERATURE; - betaGlucanaseTemperature = PROFILE_RED_BETAGLUCANASE_TEMPERATURE; - debranchingTemperature = PROFILE_RED_DEBRANCHING_TEMPERATURE; - proteolyticTemperature = PROFILE_RED_PROTEOLYTIC_TEMPERATURE; - betaAmylaseTemperature = PROFILE_RED_BETAAMYLASE_TEMPERATURE; - alphaAmylaseTemperature = PROFILE_RED_ALPHAAMYLASE_TEMPERATURE; - mashoutTemperature = PROFILE_RED_MASHOUT_TEMPERATURE; - recirculationTemperature = PROFILE_RED_RECIRCULATION_TEMPERATURE; - spargeTemperature = PROFILE_RED_SPARGE_TEMPERATURE; - boilTemperature = PROFILE_RED_BOIL_TEMPERATURE; - coolingTemperature = PROFILE_RED_COOLING_TEMPERATURE; - - backToStatus(); - - break; - } + beerProfile = eBeerProfile_Red; + + startpointTime = PROFILE_RED_STARTPOINT_TIME; + betaGlucanaseTime = PROFILE_RED_BETAGLUCANASE_TIME; + debranchingTime = PROFILE_RED_DEBRANCHING_TIME; + proteolyticTime = PROFILE_RED_PROTEOLYTIC_TIME; + betaAmylaseTime = PROFILE_RED_BETAAMYLASE_TIME; + alphaAmylaseTime = PROFILE_RED_ALPHAAMYLASE_TIME; + mashoutTime = PROFILE_RED_MASHOUT_TIME; + recirculationTime = PROFILE_RED_RECIRCULATION_TIME; + spargeTime = PROFILE_RED_SPARGE_TIME; + boilTime = PROFILE_RED_BOIL_TIME; + coolingTime = PROFILE_RED_COOLING_TIME; + + startpointTemperature = PROFILE_RED_STARTPOINT_TEMPERATURE; + betaGlucanaseTemperature = PROFILE_RED_BETAGLUCANASE_TEMPERATURE; + debranchingTemperature = PROFILE_RED_DEBRANCHING_TEMPERATURE; + proteolyticTemperature = PROFILE_RED_PROTEOLYTIC_TEMPERATURE; + betaAmylaseTemperature = PROFILE_RED_BETAAMYLASE_TEMPERATURE; + alphaAmylaseTemperature = PROFILE_RED_ALPHAAMYLASE_TEMPERATURE; + mashoutTemperature = PROFILE_RED_MASHOUT_TEMPERATURE; + recirculationTemperature = PROFILE_RED_RECIRCULATION_TEMPERATURE; + spargeTemperature = PROFILE_RED_SPARGE_TEMPERATURE; + boilTemperature = PROFILE_RED_BOIL_TEMPERATURE; + coolingTemperature = PROFILE_RED_COOLING_TEMPERATURE; + + backToStatus(); + + break; + } case eBeerProfileMenu_APA: { - beerProfile = eBeerProfile_APA; - - startpointTime = PROFILE_APA_STARTPOINT_TIME; - betaGlucanaseTime = PROFILE_APA_BETAGLUCANASE_TIME; - debranchingTime = PROFILE_APA_DEBRANCHING_TIME; - proteolyticTime = PROFILE_APA_PROTEOLYTIC_TIME; - betaAmylaseTime = PROFILE_APA_BETAAMYLASE_TIME; - alphaAmylaseTime = PROFILE_APA_ALPHAAMYLASE_TIME; - mashoutTime = PROFILE_APA_MASHOUT_TIME; - recirculationTime = PROFILE_APA_RECIRCULATION_TIME; - spargeTime = PROFILE_APA_SPARGE_TIME; - boilTime = PROFILE_APA_BOIL_TIME; - coolingTime = PROFILE_APA_COOLING_TIME; - - startpointTemperature = PROFILE_APA_STARTPOINT_TEMPERATURE; - betaGlucanaseTemperature = PROFILE_APA_BETAGLUCANASE_TEMPERATURE; - debranchingTemperature = PROFILE_APA_DEBRANCHING_TEMPERATURE; - proteolyticTemperature = PROFILE_APA_PROTEOLYTIC_TEMPERATURE; - betaAmylaseTemperature = PROFILE_APA_BETAAMYLASE_TEMPERATURE; - alphaAmylaseTemperature = PROFILE_APA_ALPHAAMYLASE_TEMPERATURE; - mashoutTemperature = PROFILE_APA_MASHOUT_TEMPERATURE; - recirculationTemperature = PROFILE_APA_RECIRCULATION_TEMPERATURE; - spargeTemperature = PROFILE_APA_SPARGE_TEMPERATURE; - boilTemperature = PROFILE_APA_BOIL_TEMPERATURE; - coolingTemperature = PROFILE_APA_COOLING_TEMPERATURE; - - backToStatus(); - - break; - } + beerProfile = eBeerProfile_APA; + + startpointTime = PROFILE_APA_STARTPOINT_TIME; + betaGlucanaseTime = PROFILE_APA_BETAGLUCANASE_TIME; + debranchingTime = PROFILE_APA_DEBRANCHING_TIME; + proteolyticTime = PROFILE_APA_PROTEOLYTIC_TIME; + betaAmylaseTime = PROFILE_APA_BETAAMYLASE_TIME; + alphaAmylaseTime = PROFILE_APA_ALPHAAMYLASE_TIME; + mashoutTime = PROFILE_APA_MASHOUT_TIME; + recirculationTime = PROFILE_APA_RECIRCULATION_TIME; + spargeTime = PROFILE_APA_SPARGE_TIME; + boilTime = PROFILE_APA_BOIL_TIME; + coolingTime = PROFILE_APA_COOLING_TIME; + + startpointTemperature = PROFILE_APA_STARTPOINT_TEMPERATURE; + betaGlucanaseTemperature = PROFILE_APA_BETAGLUCANASE_TEMPERATURE; + debranchingTemperature = PROFILE_APA_DEBRANCHING_TEMPERATURE; + proteolyticTemperature = PROFILE_APA_PROTEOLYTIC_TEMPERATURE; + betaAmylaseTemperature = PROFILE_APA_BETAAMYLASE_TEMPERATURE; + alphaAmylaseTemperature = PROFILE_APA_ALPHAAMYLASE_TEMPERATURE; + mashoutTemperature = PROFILE_APA_MASHOUT_TEMPERATURE; + recirculationTemperature = PROFILE_APA_RECIRCULATION_TEMPERATURE; + spargeTemperature = PROFILE_APA_SPARGE_TEMPERATURE; + boilTemperature = PROFILE_APA_BOIL_TEMPERATURE; + coolingTemperature = PROFILE_APA_COOLING_TEMPERATURE; + + backToStatus(); + + break; + } case eBeerProfileMenu_Custom: { - beerProfile = eBeerProfile_Custom; - - startpointTime = PROFILE_CUSTOM_STARTPOINT_TIME; - betaGlucanaseTime = PROFILE_CUSTOM_BETAGLUCANASE_TIME; - debranchingTime = PROFILE_CUSTOM_DEBRANCHING_TIME; - proteolyticTime = PROFILE_CUSTOM_PROTEOLYTIC_TIME; - betaAmylaseTime = PROFILE_CUSTOM_BETAAMYLASE_TIME; - alphaAmylaseTime = PROFILE_CUSTOM_ALPHAAMYLASE_TIME; - mashoutTime = PROFILE_CUSTOM_MASHOUT_TIME; - recirculationTime = PROFILE_CUSTOM_RECIRCULATION_TIME; - spargeTime = PROFILE_CUSTOM_SPARGE_TIME; - boilTime = PROFILE_CUSTOM_BOIL_TIME; - coolingTime = PROFILE_CUSTOM_COOLING_TIME; - - startpointTemperature = PROFILE_CUSTOM_STARTPOINT_TEMPERATURE; - betaGlucanaseTemperature = PROFILE_CUSTOM_BETAGLUCANASE_TEMPERATURE; - debranchingTemperature = PROFILE_CUSTOM_DEBRANCHING_TEMPERATURE; - proteolyticTemperature = PROFILE_CUSTOM_PROTEOLYTIC_TEMPERATURE; - betaAmylaseTemperature = PROFILE_CUSTOM_BETAAMYLASE_TEMPERATURE; - alphaAmylaseTemperature = PROFILE_CUSTOM_ALPHAAMYLASE_TEMPERATURE; - mashoutTemperature = PROFILE_CUSTOM_MASHOUT_TEMPERATURE; - recirculationTemperature = PROFILE_CUSTOM_RECIRCULATION_TEMPERATURE; - spargeTemperature = PROFILE_CUSTOM_SPARGE_TEMPERATURE; - boilTemperature = PROFILE_CUSTOM_BOIL_TEMPERATURE; - coolingTemperature = PROFILE_CUSTOM_COOLING_TEMPERATURE; - - backToStatus(); - - break; - } + beerProfile = eBeerProfile_Custom; + + startpointTime = PROFILE_CUSTOM_STARTPOINT_TIME; + betaGlucanaseTime = PROFILE_CUSTOM_BETAGLUCANASE_TIME; + debranchingTime = PROFILE_CUSTOM_DEBRANCHING_TIME; + proteolyticTime = PROFILE_CUSTOM_PROTEOLYTIC_TIME; + betaAmylaseTime = PROFILE_CUSTOM_BETAAMYLASE_TIME; + alphaAmylaseTime = PROFILE_CUSTOM_ALPHAAMYLASE_TIME; + mashoutTime = PROFILE_CUSTOM_MASHOUT_TIME; + recirculationTime = PROFILE_CUSTOM_RECIRCULATION_TIME; + spargeTime = PROFILE_CUSTOM_SPARGE_TIME; + boilTime = PROFILE_CUSTOM_BOIL_TIME; + coolingTime = PROFILE_CUSTOM_COOLING_TIME; + + startpointTemperature = PROFILE_CUSTOM_STARTPOINT_TEMPERATURE; + betaGlucanaseTemperature = PROFILE_CUSTOM_BETAGLUCANASE_TEMPERATURE; + debranchingTemperature = PROFILE_CUSTOM_DEBRANCHING_TEMPERATURE; + proteolyticTemperature = PROFILE_CUSTOM_PROTEOLYTIC_TEMPERATURE; + betaAmylaseTemperature = PROFILE_CUSTOM_BETAAMYLASE_TEMPERATURE; + alphaAmylaseTemperature = PROFILE_CUSTOM_ALPHAAMYLASE_TEMPERATURE; + mashoutTemperature = PROFILE_CUSTOM_MASHOUT_TEMPERATURE; + recirculationTemperature = PROFILE_CUSTOM_RECIRCULATION_TEMPERATURE; + spargeTemperature = PROFILE_CUSTOM_SPARGE_TEMPERATURE; + boilTemperature = PROFILE_CUSTOM_BOIL_TEMPERATURE; + coolingTemperature = PROFILE_CUSTOM_COOLING_TEMPERATURE; + + backToStatus(); + + break; + } case eBeerProfileMenu_Back: { - eMenuType = eMenuType_Main; - repaint = true; - - // reset operation state | INPUT : eRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep - xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenuPosition, MENU_SIZE_MAIN_MENU - 1, 1, 1, 0 ); + eMenuType = eMenuType_Main; + repaint = true; - break; - } + // reset operation state | INPUT : eRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep + //xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenuPosition, MENU_SIZE_MAIN_MENU - 1, 1, 1, 0 ); + xSetupRotaryEncoder( eRotaryEncoderMode_Menu, mdMainMenu._position, MENU_SIZE_MAIN_MENU - 1, 1, 1, 0 ); + + break; + } default: { - } + } } eBeerProfileMenuSelection = eBeerProfileMenu_NULL; @@ -953,12 +939,20 @@ void runBeerProfileSelection() { void xStartStage( unsigned long *stageTime, int *stageTemperature, eCookingStages nextStage, bool bPurgePump, bool bSetFinalYield, bool bSetTime, bool bSetTemperature ) { xSafeHardwarePowerOff(); // Stop anything that might be still going on - - if(bSetFinalYield) { finalYield = xSetFinalYield( finalYield ); } - if(bSetTime) { (*stageTime) = getTimer( clockCounter/1000, (*stageTime) ); } - if(bSetTemperature) { (*stageTemperature) = xSetTemperature( (*stageTemperature) ); } - if(bPurgePump) { xPurgePump(); } - + + if (bSetFinalYield) { + finalYield = xSetFinalYield( finalYield ); + } + if (bSetTime) { + (*stageTime) = getTimer( clockCounter / 1000, (*stageTime) ); + } + if (bSetTemperature) { + (*stageTemperature) = xSetTemperature( (*stageTemperature) ); + } + if (bPurgePump) { + xPurgePump(); + } + startBrewing(); xSetupStage( nextStage ); backToStatus(); @@ -973,127 +967,129 @@ void xStartStageInteractive( unsigned long *stageTime, int *stageTemperature, eC } void runStartFromStageSelection() { - switch(eStartFromStageMenuSelection) { + switch (eStartFromStageMenuSelection) { case eStageMenu_Startpoint: { - xStartStageInteractive( &startpointTime, &startpointTemperature, eCookingStage_Startpoint ); - break; - } + xStartStageInteractive( &startpointTime, &startpointTemperature, eCookingStage_Startpoint ); + break; + } case eStageMenu_BetaGlucanase: { - xStartStageInteractive( &betaGlucanaseTime, &betaGlucanaseTemperature, eCookingStage_BetaGlucanase ); - break; - } + xStartStageInteractive( &betaGlucanaseTime, &betaGlucanaseTemperature, eCookingStage_BetaGlucanase ); + break; + } case eStageMenu_Debranching: { - xStartStageInteractive( &debranchingTime, &debranchingTemperature, eCookingStage_Debranching ); - break; - } + xStartStageInteractive( &debranchingTime, &debranchingTemperature, eCookingStage_Debranching ); + break; + } case eStageMenu_Proteolytic: { - xStartStageInteractive( &proteolyticTime, &proteolyticTemperature, eCookingStage_Proteolytic ); - break; - } + xStartStageInteractive( &proteolyticTime, &proteolyticTemperature, eCookingStage_Proteolytic ); + break; + } case eStageMenu_BetaAmylase: { - xStartStageInteractive( &betaAmylaseTime, &betaAmylaseTemperature, eCookingStage_BetaAmylase ); - break; - } + xStartStageInteractive( &betaAmylaseTime, &betaAmylaseTemperature, eCookingStage_BetaAmylase ); + break; + } case eStageMenu_AlphaAmylase: { - xStartStageInteractive( &alphaAmylaseTime, &alphaAmylaseTemperature, eCookingStage_AlphaAmylase ); - break; - } + xStartStageInteractive( &alphaAmylaseTime, &alphaAmylaseTemperature, eCookingStage_AlphaAmylase ); + break; + } case eStageMenu_Mashout: { - xStartStageInteractive( &mashoutTime, &mashoutTemperature, eCookingStage_Mashout ); - break; - } + xStartStageInteractive( &mashoutTime, &mashoutTemperature, eCookingStage_Mashout ); + break; + } case eStageMenu_Recirculation: { - xStartStageInteractive( &recirculationTime, &recirculationTemperature, eCookingStage_Recirculation ); - break; - } + xStartStageInteractive( &recirculationTime, &recirculationTemperature, eCookingStage_Recirculation ); + break; + } case eStageMenu_Sparge: { - xStartStageInteractive( &spargeTime, &spargeTemperature, eCookingStage_Sparge ); - break; - } + xStartStageInteractive( &spargeTime, &spargeTemperature, eCookingStage_Sparge ); + break; + } case eStageMenu_Boil: { - xStartStageInteractive( &boilTime, &boilTemperature, eCookingStage_Boil ); - break; - } + xStartStageInteractive( &boilTime, &boilTemperature, eCookingStage_Boil ); + break; + } case eStageMenu_Cooling: { - xStartStageInteractive( &coolingTime, &coolingTemperature, eCookingStage_Cooling ); - break; - } + xStartStageInteractive( &coolingTime, &coolingTemperature, eCookingStage_Cooling ); + break; + } case eStageMenu_Back: { - resetMenu( true ); - break; - } + resetMenu( true ); + break; + } default: { - } + } } eStartFromStageMenuSelection = eStageMenu_NULL; } void runMainMenuSelection() { - switch(eMainMenuSelection) { + switch (mdMainMenu._selection) { + //switch (eMainMenuSelection) { case eMainMenu_GO: { - xStartStage( NULL, NULL, eCookingStage_Startpoint, true, true, false, false ); - break; - } + xStartStage( NULL, NULL, eCookingStage_Startpoint, true, true, false, false ); + break; + } case eMainMenu_GO_FROM_STAGE: { - eMenuType = eMenuType_StartFromStage; - repaint = true; - xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eBeerProfileMenuPosition, MENU_SIZE_PROFILES_MENU - 1, 1, 1, 0 ); - break; - } + eMenuType = eMenuType_StartFromStage; + repaint = true; + xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eBeerProfileMenuPosition, MENU_SIZE_PROFILES_MENU - 1, 1, 1, 0 ); + break; + } case eMainMenu_STOP: { - stopBrewing(); - backToStatus(); - break; - } + stopBrewing(); + backToStatus(); + break; + } case eMainMenu_SKIP: { - cookTime = 0; - backToStatus(); - break; - } + cookTime = 0; + backToStatus(); + break; + } case eMainMenu_BeerProfile: { - eMenuType = eMenuType_BeerProfile; - repaint = true; - xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eBeerProfileMenuPosition, MENU_SIZE_PROFILES_MENU - 1, 1, 1, 0 ); - break; - } - case eMainMenu_Stage: { - eMenuType = eMenuType_Stage; - repaint = true; - xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eStageMenuPosition, MENU_SIZE_STAGE_MENU - 1, 1, 1, 0 ); - break; - } + eMenuType = eMenuType_BeerProfile; + repaint = true; + xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eBeerProfileMenuPosition, MENU_SIZE_PROFILES_MENU - 1, 1, 1, 0 ); + break; + } + case eMainMenu_Stage: { + eMenuType = eMenuType_Stage; + repaint = true; + xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eStageMenuPosition, MENU_SIZE_STAGE_MENU - 1, 1, 1, 0 ); + break; + } case eMainMenu_Malt: { - eMenuType = eMenuType_Malt; - repaint = true; - xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMaltMenuPosition, MENU_SIZE_MALT_MENU - 1, 1, 1, 0 ); - break; - } + eMenuType = eMenuType_Malt; + repaint = true; + xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMaltMenuPosition, MENU_SIZE_MALT_MENU - 1, 1, 1, 0 ); + break; + } case eMainMenu_Hops: { - backToStatus(); - break; - } + backToStatus(); + break; + } case eMainMenu_Clean: { - xStartStageHeadless( eCookingStage_Clean, true ); - break; - } + xStartStageHeadless( eCookingStage_Clean, true ); + break; + } case eMainMenu_Purge: { - xStartStageHeadless( eCookingStage_Purge, true ); - break; - } + xStartStageHeadless( eCookingStage_Purge, true ); + break; + } case eMainMenu_Settings: { - eMenuType = eMenuType_Settings; - repaint = true; - xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eSettingsMenuPosition, MENU_SIZE_SETTINGS_MENU - 1, 1, 1, 0 ); - break; - } + eMenuType = eMenuType_Settings; + repaint = true; + xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eSettingsMenuPosition, MENU_SIZE_SETTINGS_MENU - 1, 1, 1, 0 ); + break; + } case eMainMenu_Back: { - backToStatus(); - break; - } + backToStatus(); + break; + } default: { - } + } } - eMainMenuSelection = eMainMenu_NULL; + mdMainMenu._selection = eMainMenu_NULL; + //eMainMenuSelection = eMainMenu_NULL; } void xCountTheTime( int temperatureMarginRange, boolean bMaximumOfUpDown ) { @@ -1101,10 +1097,10 @@ void xCountTheTime( int temperatureMarginRange, boolean bMaximumOfUpDown ) { // Get current maximum sensed temperaure double temperatureCount = 0; - if( bMaximumOfUpDown ) { + if ( bMaximumOfUpDown ) { float tup = upPT100.getCurrentTemperature(); float tdown = downPT100.getCurrentTemperature(); - if(tup > tdown) { + if (tup > tdown) { temperatureCount = tdown; } else { @@ -1116,10 +1112,10 @@ void xCountTheTime( int temperatureMarginRange, boolean bMaximumOfUpDown ) { // Ignote time ticks if temperature is not within the acceptable margin for this stage unsigned long elapsedTime = now - clockLastUpdate; - if( temperatureCount < (cookTemperature - temperatureMarginRange) ) { + if ( temperatureCount < (cookTemperature - temperatureMarginRange) ) { clockIgnore += elapsedTime; } - + // Calculate the remaining time on the clock clockCounter = cookTime * 1000 - (elapsedTime - clockIgnore); @@ -1130,18 +1126,18 @@ void xCountTheTime( int temperatureMarginRange, boolean bMaximumOfUpDown ) { clockLastUpdate = now; - #ifdef DEBUG_OFF +#ifdef DEBUG_OFF debugPrintFunction("xCountTheTime"); debugPrintVar("millis()", now); debugPrintVar("cookTime", cookTime); debugPrintVar("clockStartTime", clockStartTime); debugPrintVar("clockIgnore", clockIgnore); - debugPrintVar("clockCounter", clockCounter); - #endif + debugPrintVar("clockCounter", clockCounter); +#endif } bool isTimeLeft() { - if( clockCounter > 0 ) { + if ( clockCounter > 0 ) { return true; } return false; @@ -1157,24 +1153,24 @@ bool xRegulateTemperature( boolean bMaximumOfUpDown ) { double difference = 0; bool overTemperature = false; double wattage = 0.0; - + float tup = upPT100.getCurrentTemperature(); float tdown = downPT100.getCurrentTemperature(); float tbase = basePT100.getCurrentTemperature(); - if( bMaximumOfUpDown ) { - if(tup > tdown) { + if ( bMaximumOfUpDown ) { + if (tup > tdown) { difference = cookTemperature - tup; } else { difference = cookTemperature - tdown; } - if(tbase > cookTemperature && (tbase >= (PUMP_TEMPERATURE_MAX_OPERATION - 2.0) || difference >= 5.0)) { + if (tbase > cookTemperature && (tbase >= (PUMP_TEMPERATURE_MAX_OPERATION - 2.0) || difference >= 5.0)) { difference = cookTemperature - tbase; } - if( (tbase < cookTemperature) && (difference < (cookTemperature - tbase)) ) { + if ( (tbase < cookTemperature) && (difference < (cookTemperature - tbase)) ) { difference = cookTemperature - tbase; } } else { @@ -1182,71 +1178,71 @@ bool xRegulateTemperature( boolean bMaximumOfUpDown ) { } // Deviation between the cook temperature set and the cook temperature measured - if( difference < 0.0 ) { + if ( difference < 0.0 ) { difference = difference * (-1.0); overTemperature = true; } - + // Calculate applied wattage, based on the distance from the target temperature - if( overTemperature ) { + if ( overTemperature ) { // turn it off wattage = 0.0; } else { //if(difference <= 0.1) { - // turn it off + // turn it off // wattage = 0.0; //} else { - if(difference <= 0.5) { - // pulse lightly at 500 watt - if(cookTemperature > 99.0) { + if (difference <= 0.5) { + // pulse lightly at 500 watt + if (cookTemperature > 99.0) { + wattage = 2000.0; + } + else { + if (cookTemperature > 70.0) { + wattage = 1000.0; + } + else { + wattage = 500.0; + } + } + } else { + if (difference <= 1.0) { + // pulse moderately at 1000 watt + if (cookTemperature > 99.0) { wattage = 2000.0; } else { - if(cookTemperature > 70.0) { - wattage = 1000.0; - } - else { - wattage = 500.0; - } + wattage = 1000.0; } + } else { - if(difference <= 1.0) { - // pulse moderately at 1000 watt - if(cookTemperature > 99.0) { - wattage = 2000.0; - } - else { - wattage = 1000.0; - } - + if (difference <= 3.0) { + // pulse hardly at 2000 watt + wattage = 2000.0; } else { - if(difference <= 3.0) { - // pulse hardly at 2000 watt - wattage = 2000.0; - } else { - //pulse constantly at HEATING_ELEMENT_MAX_WATTAGE watt - wattage = HEATING_ELEMENT_MAX_WATTAGE; - } + //pulse constantly at HEATING_ELEMENT_MAX_WATTAGE watt + wattage = HEATING_ELEMENT_MAX_WATTAGE; } } + } //} } - + // Update the recorded time for the begining of the window, if the previous window has passed - while((millis() - windowStartTime) > iWindowSize) { // Check if it's time to vary the pulse width modulation and if so do it by shifting the "Relay in ON" Window + while ((millis() - windowStartTime) > iWindowSize) { // Check if it's time to vary the pulse width modulation and if so do it by shifting the "Relay in ON" Window windowStartTime += iWindowSize; } - + // Apply wattage to the element at the right time - if( ulWattToWindowTime( wattage ) > (millis() - windowStartTime) ) { - digitalWrite(HEATING_ELEMENT_OUTPUT_PIN,HIGH); + if ( ulWattToWindowTime( wattage ) > (millis() - windowStartTime) ) { + digitalWrite(HEATING_ELEMENT_OUTPUT_PIN, HIGH); bStatusElement = true; } else { - digitalWrite(HEATING_ELEMENT_OUTPUT_PIN,LOW); + digitalWrite(HEATING_ELEMENT_OUTPUT_PIN, LOW); bStatusElement = false; } - #ifdef DEBUG_OFF +#ifdef DEBUG_OFF //debugPrintFunction("xRegulateTemperature"); debugPrintVar("difference", difference); //debugPrintVar("overTemperature", overTemperature); @@ -1254,12 +1250,12 @@ bool xRegulateTemperature( boolean bMaximumOfUpDown ) { //debugPrintVar("ulWattToWindowTime( wattage )", ulWattToWindowTime( wattage ) ); //debugPrintVar("millis()", millis()); //debugPrintVar("windowStartTime", windowStartTime); - //debugPrintVar("test", ulWattToWindowTime( wattage ) > (millis() - windowStartTime) ); - #endif + //debugPrintVar("test", ulWattToWindowTime( wattage ) > (millis() - windowStartTime) ); +#endif } void xPurgePump() { - for(int i = 0; i < 2; i++) { + for (int i = 0; i < 2; i++) { analogWrite(PUMP_PIN, PUMP_SPEED_MAX_MOSFET); // analogWrite values from 0 to 255 delay(1000); analogWrite(PUMP_PIN, PUMP_SPEED_STOP_MOSFET); // analogWrite values from 0 to 255 @@ -1270,7 +1266,7 @@ void xPurgePump() { bool xRegulatePumpSpeed() { // analogWrite(PUMP_PIN, iPumpSpeed); // analogWrite values from 0 to 255 - if(basePT100.getCurrentTemperature() > PUMP_TEMPERATURE_MAX_OPERATION) { + if (basePT100.getCurrentTemperature() > PUMP_TEMPERATURE_MAX_OPERATION) { analogWrite(PUMP_PIN, PUMP_SPEED_STOP_MOSFET); // analogWrite values from 0 to 255 basePT100.setPumpStatus( false ); @@ -1295,10 +1291,10 @@ void xWarnCookEnded() { } void xPrepareForStage( int stageTime, int stageTemperature, int stagePumpSpeed, eCookingStages stage ) { - #ifdef DEBUG_OFF +#ifdef DEBUG_OFF debugPrintFunction("xPrepareForStage"); debugPrintVar("cookingStage", stage); - #endif +#endif // Reset the clock unsigned long now = millis(); @@ -1313,218 +1309,218 @@ void xPrepareForStage( int stageTime, int stageTemperature, int stagePumpSpeed, } void xSetupStage(eCookingStages nextStage) { - #ifdef DEBUG_OFF +#ifdef DEBUG_OFF debugPrintFunction("xSetupStage"); debugPrintVar("cookingStage", nextStage); - #endif +#endif // Operate the machine according to the current mode - switch(nextStage) { + switch (nextStage) { case eCookingStage_Startpoint: { - switch(beerProfile) { - case eBeerProfile_Trigo: { - float wheatAmount = 0.05 * ((float) finalYield); - float pilsnerAmount = 0.2 * ((float) finalYield); - String say = "Cruch "; - say += String(wheatAmount); - say += String("Kg of Wheat and "); - say += String(pilsnerAmount); - say += String("Kg of Pilsner Malt into a pot."); - - xWaitForAction("Malt", say); - repaint = true; - break; - } - case eBeerProfile_IPA: { - float caramelAmount = 0.013157895 * ((float) finalYield); - float wheatAmount = 0.060526316 * ((float) finalYield); - float pilsnerAmount = 0.115789474 * ((float) finalYield); - float munichAmount = 0.028947368 * ((float) finalYield); - String say = "Cruch "; - say += String(caramelAmount); - say += String("Kg of Caramel 120, "); - say += String(wheatAmount); - say += String("Kg of Wheat, "); - say += String(pilsnerAmount); - say += String("Kg of Pilsner, "); - say += String(munichAmount); - say += String("Kg of Munich into a pot."); - - xWaitForAction("Malt", say); - repaint = true; - break; - } - default: { + switch (beerProfile) { + case eBeerProfile_Trigo: { + float wheatAmount = 0.05 * ((float) finalYield); + float pilsnerAmount = 0.2 * ((float) finalYield); + String say = "Cruch "; + say += String(wheatAmount); + say += String("Kg of Wheat and "); + say += String(pilsnerAmount); + say += String("Kg of Pilsner Malt into a pot."); + + xWaitForAction("Malt", say); + repaint = true; + break; + } + case eBeerProfile_IPA: { + float caramelAmount = 0.013157895 * ((float) finalYield); + float wheatAmount = 0.060526316 * ((float) finalYield); + float pilsnerAmount = 0.115789474 * ((float) finalYield); + float munichAmount = 0.028947368 * ((float) finalYield); + String say = "Cruch "; + say += String(caramelAmount); + say += String("Kg of Caramel 120, "); + say += String(wheatAmount); + say += String("Kg of Wheat, "); + say += String(pilsnerAmount); + say += String("Kg of Pilsner, "); + say += String(munichAmount); + say += String("Kg of Munich into a pot."); + + xWaitForAction("Malt", say); + repaint = true; + break; + } + default: { + } } - } - // Make sure there is water - xWaitForAction("Water", "Make sure there is water in the machine before start cooking."); + // Make sure there is water + xWaitForAction("Water", "Make sure there is water in the machine before start cooking."); - repaint = true; - xPrepareForStage( startpointTime, startpointTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_Startpoint ); - break; - } + repaint = true; + xPrepareForStage( startpointTime, startpointTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_Startpoint ); + break; + } case eCookingStage_BetaGlucanase: { - switch(beerProfile) { - case eBeerProfile_Trigo: { - float wheatAmount = 0.05 * ((float) finalYield); - float pilsnerAmount = 0.2 * ((float) finalYield); - String say = "Put "; - say += String(wheatAmount); - say += String("Kg of Wheat and "); - say += String(pilsnerAmount); - say += String("Kg of Pilsner Malt in."); - - xWaitForAction("Malt", say); - repaint = true; - break; - } - case eBeerProfile_IPA: { - float caramelAmount = 0.013157895 * ((float) finalYield); - float wheatAmount = 0.060526316 * ((float) finalYield); - float pilsnerAmount = 0.115789474 * ((float) finalYield); - float munichAmount = 0.028947368 * ((float) finalYield); - String say = "Cruch "; - say += String(caramelAmount); - say += String("Kg of Caramel 120, "); - say += String(wheatAmount); - say += String("Kg of Wheat, "); - say += String(pilsnerAmount); - say += String("Kg of Pilsner, "); - say += String(munichAmount); - say += String("Kg of Munich into a pot."); - - xWaitForAction("Malt", say); - repaint = true; - break; + switch (beerProfile) { + case eBeerProfile_Trigo: { + float wheatAmount = 0.05 * ((float) finalYield); + float pilsnerAmount = 0.2 * ((float) finalYield); + String say = "Put "; + say += String(wheatAmount); + say += String("Kg of Wheat and "); + say += String(pilsnerAmount); + say += String("Kg of Pilsner Malt in."); + + xWaitForAction("Malt", say); + repaint = true; + break; + } + case eBeerProfile_IPA: { + float caramelAmount = 0.013157895 * ((float) finalYield); + float wheatAmount = 0.060526316 * ((float) finalYield); + float pilsnerAmount = 0.115789474 * ((float) finalYield); + float munichAmount = 0.028947368 * ((float) finalYield); + String say = "Cruch "; + say += String(caramelAmount); + say += String("Kg of Caramel 120, "); + say += String(wheatAmount); + say += String("Kg of Wheat, "); + say += String(pilsnerAmount); + say += String("Kg of Pilsner, "); + say += String(munichAmount); + say += String("Kg of Munich into a pot."); + + xWaitForAction("Malt", say); + repaint = true; + break; + } + default: {} } - default: {} + xPrepareForStage( betaGlucanaseTime, betaGlucanaseTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_BetaGlucanase ); + break; } - xPrepareForStage( betaGlucanaseTime, betaGlucanaseTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_BetaGlucanase ); - break; - } case eCookingStage_Debranching: { - xPrepareForStage( debranchingTime, debranchingTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_Debranching ); - break; - } + xPrepareForStage( debranchingTime, debranchingTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_Debranching ); + break; + } case eCookingStage_Proteolytic: { - xPrepareForStage( proteolyticTime, proteolyticTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_Proteolytic ); - break; - } + xPrepareForStage( proteolyticTime, proteolyticTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_Proteolytic ); + break; + } case eCookingStage_BetaAmylase: { - xPrepareForStage( betaAmylaseTime, betaAmylaseTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_BetaAmylase ); - break; - } + xPrepareForStage( betaAmylaseTime, betaAmylaseTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_BetaAmylase ); + break; + } case eCookingStage_AlphaAmylase: { - xPrepareForStage( alphaAmylaseTime, alphaAmylaseTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_AlphaAmylase ); - break; - } + xPrepareForStage( alphaAmylaseTime, alphaAmylaseTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_AlphaAmylase ); + break; + } case eCookingStage_Mashout: { - xPrepareForStage( mashoutTime, mashoutTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_Mashout ); - break; - } + xPrepareForStage( mashoutTime, mashoutTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_Mashout ); + break; + } case eCookingStage_Recirculation: { - xWaitForAction("Sparge Water", "Start heating your sparge water."); - repaint = true; - xPrepareForStage( recirculationTime, recirculationTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_Recirculation ); - break; - } + xWaitForAction("Sparge Water", "Start heating your sparge water."); + repaint = true; + xPrepareForStage( recirculationTime, recirculationTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_Recirculation ); + break; + } case eCookingStage_Sparge: { - xWaitForAction("Sparge Water", "Start pouring the sparge water."); - repaint = true; - xPrepareForStage( spargeTime, spargeTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_Sparge ); - break; - } + xWaitForAction("Sparge Water", "Start pouring the sparge water."); + repaint = true; + xPrepareForStage( spargeTime, spargeTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_Sparge ); + break; + } case eCookingStage_Boil: { - switch(beerProfile) { - case eBeerProfile_Trigo: { - String say = "Get "; + switch (beerProfile) { + case eBeerProfile_Trigo: { + String say = "Get "; - float hopAmount = 0.8 * ((float) finalYield); - say += String(hopAmount); + float hopAmount = 0.8 * ((float) finalYield); + say += String(hopAmount); - say += String("g of Magnum 9.4\% and Styrian Golding 5\% ready."); + say += String("g of Magnum 9.4\% and Styrian Golding 5\% ready."); - xWaitForAction("Hops", say); + xWaitForAction("Hops", say); - break; - } - case eBeerProfile_IPA: { - String say = "Get "; + break; + } + case eBeerProfile_IPA: { + String say = "Get "; - float hopAmount = 0.8 * ((float) finalYield); - say += String(hopAmount); + float hopAmount = 0.8 * ((float) finalYield); + say += String(hopAmount); - say += String("g of Chinook, Cascade and Styrian Golding ready."); + say += String("g of Chinook, Cascade and Styrian Golding ready."); - xWaitForAction("Hops", say); + xWaitForAction("Hops", say); - break; - } - default: { - xWaitForAction("Hops", "Add the hops in the right order, at the right time."); + break; + } + default: { + xWaitForAction("Hops", "Add the hops in the right order, at the right time."); + } } - } - repaint = true; + repaint = true; - // A basic operation for a basic stage - xPrepareForStage( boilTime, boilTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_Boil ); - - break; - } + // A basic operation for a basic stage + xPrepareForStage( boilTime, boilTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_Boil ); + + break; + } case eCookingStage_Cooling: { - // Make sure there is water - xWaitForAction("Coil", "Add the coil and connect it to the main water supply."); + // Make sure there is water + xWaitForAction("Coil", "Add the coil and connect it to the main water supply."); - repaint = true; + repaint = true; - // A basic operation for a basic stage - xPrepareForStage( coolingTime, coolingTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_Cooling ); + // A basic operation for a basic stage + xPrepareForStage( coolingTime, coolingTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_Cooling ); - break; - } + break; + } case eCookingStage_Clean: { - // Make sure there is water - xWaitForAction("Water", "Add 13 liters."); + // Make sure there is water + xWaitForAction("Water", "Add 13 liters."); - // Make sure there is water - xWaitForAction("Star San HB", "Add 0.89oz/26ml."); + // Make sure there is water + xWaitForAction("Star San HB", "Add 0.89oz/26ml."); - repaint = true; + repaint = true; - // A basic operation for a basic stage - xPrepareForStage( cleaningTime, cleaningTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_Clean ); + // A basic operation for a basic stage + xPrepareForStage( cleaningTime, cleaningTemperature, PUMP_SPEED_MAX_MOSFET, eCookingStage_Clean ); - break; - } + break; + } case eCookingStage_Purge: { - // A basic operation for a basic stage - xPrepareForStage( 0, 0, PUMP_SPEED_MAX_MOSFET, eCookingStage_Purge ); + // A basic operation for a basic stage + xPrepareForStage( 0, 0, PUMP_SPEED_MAX_MOSFET, eCookingStage_Purge ); - xRegulatePumpSpeed(); + xRegulatePumpSpeed(); - break; - } + break; + } case eCookingStage_Done: { - // A basic operation for a basic stage - xPrepareForStage( 0, 0, PUMP_SPEED_STOP_MOSFET, eCookingStage_Done ); + // A basic operation for a basic stage + xPrepareForStage( 0, 0, PUMP_SPEED_STOP_MOSFET, eCookingStage_Done ); - break; - } + break; + } } } void xTransitionIntoStage(eCookingStages nextStage) { // Turn off all hardware that can damage itself if the machine is not cooking - xSafeHardwarePowerOff(); - + xSafeHardwarePowerOff(); + // Warn the user a stage has ended xWarnClockEnded(); - + // Reset global stage variables xSetupStage( nextStage ); } @@ -1532,39 +1528,39 @@ void xTransitionIntoStage(eCookingStages nextStage) { void xBasicStageOperation( int iStageTime, int iStageTemperature, int iStageTemperatureRange, eCookingStages nextStage, boolean bMaximumOfUpDown ) { // Account for time spent at the target temperature | Input 1: range in ºC within which the target temperature is considered to be reached - #ifdef DEBUG_OFF +#ifdef DEBUG_OFF xCountTheTime( iStageTemperatureRange, false ); - #else +#else xCountTheTime( iStageTemperatureRange, bMaximumOfUpDown ); - #endif - - if( isTimeLeft() ) { +#endif + + if ( isTimeLeft() ) { // Do temperature control xRegulateTemperature( bMaximumOfUpDown ); // Do flow control xRegulatePumpSpeed(); - + } else { - #ifdef DEBUG_OFF +#ifdef DEBUG_OFF debugPrintFunction("xBasicStageOperation"); debugPrintVar("clockCounter", clockCounter); - #endif - +#endif + // Continue to the next stage, there is nothing to do, in this stage xTransitionIntoStage( nextStage ); return; } - + return; } void xManageMachineSystems() { - #ifdef DEBUG +#ifdef DEBUG Serial.print(millis()); Serial.print(","); - if(cooking) { + if (cooking) { Serial.print("1"); } else { @@ -1573,14 +1569,14 @@ void xManageMachineSystems() { Serial.print(","); Serial.print(cookTemperature); Serial.print(","); - if(bStatusElement) { + if (bStatusElement) { Serial.print("1"); } else { Serial.print("0"); } Serial.print(","); - #endif +#endif // Measure temperature, for effect basePT100.measure(false); @@ -1588,107 +1584,107 @@ void xManageMachineSystems() { downPT100.measure(true); // If cooking is done, return (this is a nice place to double check safety and ensure the cooking parts aren't on. - if(!cooking) { + if (!cooking) { xSafeHardwarePowerOff(); return; } - + // Operate the machine according to the current mode - switch(cookingStage) { + switch (cookingStage) { case eCookingStage_Startpoint: { - // A basic operation for a basic stage - xBasicStageOperation( startpointTime, startpointTemperature, 0, eCookingStage_BetaGlucanase, false); - - break; - } + // A basic operation for a basic stage + xBasicStageOperation( startpointTime, startpointTemperature, 0, eCookingStage_BetaGlucanase, false); + + break; + } case eCookingStage_BetaGlucanase: { - // A basic operation for a basic stage - xBasicStageOperation( betaGlucanaseTime, betaGlucanaseTemperature, 3, eCookingStage_Debranching, true ); - - break; - } + // A basic operation for a basic stage + xBasicStageOperation( betaGlucanaseTime, betaGlucanaseTemperature, 3, eCookingStage_Debranching, true ); + + break; + } case eCookingStage_Debranching: { - // A basic operation for a basic stage - xBasicStageOperation( debranchingTime, debranchingTemperature, 3, eCookingStage_Proteolytic, true ); - - break; - } + // A basic operation for a basic stage + xBasicStageOperation( debranchingTime, debranchingTemperature, 3, eCookingStage_Proteolytic, true ); + + break; + } case eCookingStage_Proteolytic: { - // A basic operation for a basic stage - xBasicStageOperation( proteolyticTime, proteolyticTemperature, 3, eCookingStage_BetaAmylase, true ); - - break; - } + // A basic operation for a basic stage + xBasicStageOperation( proteolyticTime, proteolyticTemperature, 3, eCookingStage_BetaAmylase, true ); + + break; + } case eCookingStage_BetaAmylase: { - // A basic operation for a basic stage - xBasicStageOperation( betaAmylaseTime, betaAmylaseTemperature, 4, eCookingStage_AlphaAmylase, true ); - - break; - } + // A basic operation for a basic stage + xBasicStageOperation( betaAmylaseTime, betaAmylaseTemperature, 4, eCookingStage_AlphaAmylase, true ); + + break; + } case eCookingStage_AlphaAmylase: { - // A basic operation for a basic stage - xBasicStageOperation( alphaAmylaseTime, alphaAmylaseTemperature, 2, eCookingStage_Mashout, true ); - - break; - } + // A basic operation for a basic stage + xBasicStageOperation( alphaAmylaseTime, alphaAmylaseTemperature, 2, eCookingStage_Mashout, true ); + + break; + } case eCookingStage_Mashout: { - // A basic operation for a basic stage - xBasicStageOperation( mashoutTime, mashoutTemperature, 1, eCookingStage_Recirculation, true ); - - break; - } + // A basic operation for a basic stage + xBasicStageOperation( mashoutTime, mashoutTemperature, 1, eCookingStage_Recirculation, true ); + + break; + } case eCookingStage_Recirculation: { - // A basic operation for a basic stage - xBasicStageOperation( recirculationTime, recirculationTemperature, 1, eCookingStage_Sparge, true ); - - break; - } + // A basic operation for a basic stage + xBasicStageOperation( recirculationTime, recirculationTemperature, 1, eCookingStage_Sparge, true ); + + break; + } case eCookingStage_Sparge: { - // A basic operation for a basic stage - xBasicStageOperation( spargeTime, spargeTemperature, 3, eCookingStage_Boil, false ); - - break; - } + // A basic operation for a basic stage + xBasicStageOperation( spargeTime, spargeTemperature, 3, eCookingStage_Boil, false ); + + break; + } case eCookingStage_Boil: { - // A basic operation for a basic stage - xBasicStageOperation( boilTime, boilTemperature, 2, eCookingStage_Cooling, false ); - - break; - } + // A basic operation for a basic stage + xBasicStageOperation( boilTime, boilTemperature, 2, eCookingStage_Cooling, false ); + + break; + } case eCookingStage_Cooling: { - // A basic operation for a basic stage - xBasicStageOperation( coolingTime, coolingTemperature, 0, eCookingStage_Done, false ); + // A basic operation for a basic stage + xBasicStageOperation( coolingTime, coolingTemperature, 0, eCookingStage_Done, false ); - break; - } + break; + } case eCookingStage_Clean: { - // A basic operation for a basic stage - xBasicStageOperation( cleaningTime, cleaningTemperature, 0, eCookingStage_Done, false ); + // A basic operation for a basic stage + xBasicStageOperation( cleaningTime, cleaningTemperature, 0, eCookingStage_Done, false ); - break; - } + break; + } case eCookingStage_Purge: { - // A basic operation for a basic stage - //xBasicStageOperation( coolingTime, coolingTemperature, 1, eCookingStage_Done ); - iPumpSpeed = PUMP_SPEED_MAX_MOSFET; + // A basic operation for a basic stage + //xBasicStageOperation( coolingTime, coolingTemperature, 1, eCookingStage_Done ); + iPumpSpeed = PUMP_SPEED_MAX_MOSFET; - xRegulatePumpSpeed(); + xRegulatePumpSpeed(); - break; - } + break; + } case eCookingStage_Done: { - // Update cooking state - stopBrewing(); + // Update cooking state + stopBrewing(); - // Ask for screen refresh - repaint = true; - - // Warn the user that the cooking is done - xWarnCookEnded(); + // Ask for screen refresh + repaint = true; - break; - } + // Warn the user that the cooking is done + xWarnCookEnded(); + + break; + } } } @@ -1707,12 +1703,13 @@ void stopBrewing() { void resetMenu( boolean requestRepaintPaint ) { eMenuType = eMenuType_Main; - if( requestRepaintPaint ) { + if ( requestRepaintPaint ) { repaint = true; } - + // reset operation state | INPUT : eRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep - xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenuPosition, MENU_SIZE_MAIN_MENU - 1, 1, 1, 0 ); + //xSetupRotaryEncoder( eRotaryEncoderMode_Menu, eMainMenuPosition, MENU_SIZE_MAIN_MENU - 1, 1, 1, 0 ); + xSetupRotaryEncoder( eRotaryEncoderMode_Menu, mdMainMenu._position, MENU_SIZE_MAIN_MENU - 1, 1, 1, 0 ); } void backToStatus() { @@ -1730,29 +1727,29 @@ int getTimer( int initialValue, int defaultValue ) { int rotaryEncoderPreviousPosition = 0; int minutes = 0; int seconds = 0; - + // Setup Screen lcd.clear(); - lcd.home(); + lcd.home(); lcd.print("Set Time ("); - minutes = defaultValue/60; + minutes = defaultValue / 60; lcd.print(minutes); - seconds = defaultValue-minutes*60; + seconds = defaultValue - minutes * 60; lcd.print(":"); - if(seconds<10) { + if (seconds < 10) { lcd.print("0"); } lcd.print(seconds); lcd.print(")"); - lcd.setCursor (0,LCD_VERTICAL_RESOLUTION-1); + lcd.setCursor (0, LCD_VERTICAL_RESOLUTION - 1); lcd.print(" 0:00"); - - while(true) { + + while (true) { // Check if pushbutton is pressed - if ((digitalRead(ROTARY_ENCODER_SW_PIN))) { + if ((digitalRead(ROTARY_ENCODER_SW_PIN))) { // Wait until switch is released - while (digitalRead(ROTARY_ENCODER_SW_PIN)) {} - + while (digitalRead(ROTARY_ENCODER_SW_PIN)) {} + // debounce delay(10); @@ -1762,32 +1759,32 @@ int getTimer( int initialValue, int defaultValue ) { // Don't forget to keep an eye on the cooking xManageMachineSystems(); } - + // display current timer if (rotaryEncoderVirtualPosition != rotaryEncoderPreviousPosition) { rotaryEncoderPreviousPosition = rotaryEncoderVirtualPosition; - minutes = rotaryEncoderVirtualPosition/60; - seconds = rotaryEncoderVirtualPosition-minutes*60; - - lcd.setCursor (0,LCD_VERTICAL_RESOLUTION-1); - - if(minutes<100) { + minutes = rotaryEncoderVirtualPosition / 60; + seconds = rotaryEncoderVirtualPosition - minutes * 60; + + lcd.setCursor (0, LCD_VERTICAL_RESOLUTION - 1); + + if (minutes < 100) { lcd.print(" "); } - if(minutes<10) { + if (minutes < 10) { lcd.print(" "); } lcd.print(" "); lcd.print(minutes); lcd.print(":"); - if(seconds<10) { + if (seconds < 10) { lcd.print("0"); } lcd.print(seconds); lcd.println(" "); } } - + return rotaryEncoderVirtualPosition; } @@ -1796,29 +1793,29 @@ int getTimer( int initialValue ) { } int getTemperature(int initialValue) { - + // set operation state rotaryEncoderMode = eRotaryEncoderMode_Generic; - rotaryEncoderVirtualPosition = initialValue; + rotaryEncoderVirtualPosition = initialValue; // initialize variables int rotaryEncoderPreviousPosition = 0; - + // Setup Screen lcd.clear(); - lcd.home(); + lcd.home(); lcd.print("Set Temperature"); - lcd.setCursor (0,LCD_VERTICAL_RESOLUTION-1); + lcd.setCursor (0, LCD_VERTICAL_RESOLUTION - 1); lcd.print(" 0 *C"); - + rotaryEncoderMaxPosition = TEMPERATURE_SETTING_MAX_VALUE; - - while(true) { + + while (true) { // Check if pushbutton is pressed - if ((digitalRead(ROTARY_ENCODER_SW_PIN))) { + if ((digitalRead(ROTARY_ENCODER_SW_PIN))) { // Wait until switch is released - while (digitalRead(ROTARY_ENCODER_SW_PIN)) {} - + while (digitalRead(ROTARY_ENCODER_SW_PIN)) {} + // debounce delay(10); @@ -1828,18 +1825,18 @@ int getTemperature(int initialValue) { // Don't forget to keep an eye on the cooking xManageMachineSystems(); } - + // display current timer if (rotaryEncoderVirtualPosition != rotaryEncoderPreviousPosition) { rotaryEncoderPreviousPosition = rotaryEncoderVirtualPosition; - - lcd.setCursor (0,LCD_VERTICAL_RESOLUTION-1); + + lcd.setCursor (0, LCD_VERTICAL_RESOLUTION - 1); lcd.print(" "); - if(rotaryEncoderVirtualPosition<10) { + if (rotaryEncoderVirtualPosition < 10) { lcd.print(" "); } else { - if(rotaryEncoderVirtualPosition<100) { + if (rotaryEncoderVirtualPosition < 100) { lcd.print(" "); } } @@ -1848,17 +1845,17 @@ int getTemperature(int initialValue) { lcd.println(" "); } } - + return rotaryEncoderVirtualPosition; } -int xSetGenericValue(int initialValue, int minimumValue, int maximumValue, const char *valueName, const char *unit) { +int xSetGenericValue(int initialValue, int minimumValue, int maximumValue, const char *valueName, const char *unit) { // set operation state | INPUT : eRotaryEncoderMode newMode, int newPosition, int newMaxPosition, int newMinPosition, int newSingleStep, int newMultiStep xSetupRotaryEncoder( eRotaryEncoderMode_Generic, initialValue, maximumValue, minimumValue, 1, 5 ); // initialize variables int rotaryEncoderPreviousPosition = 0; - + // Setup Screen lcd.clear(); lcd.home(); @@ -1867,13 +1864,13 @@ int xSetGenericValue(int initialValue, int minimumValue, int maximumValue, const lcd.setCursor ( 0 , LCD_VERTICAL_RESOLUTION - 1 ); lcd.print( " 0 " ); lcd.print( unit ); - - while(true) { + + while (true) { // Check if pushbutton is pressed if ( digitalRead(ROTARY_ENCODER_SW_PIN) ) { // Wait until switch is released - while ( digitalRead(ROTARY_ENCODER_SW_PIN) ) {} - + while ( digitalRead(ROTARY_ENCODER_SW_PIN) ) {} + // debounce delay( 10 ); @@ -1883,18 +1880,18 @@ int xSetGenericValue(int initialValue, int minimumValue, int maximumValue, const // Don't forget to keep an eye on the cooking xManageMachineSystems(); } - + // Check if there was an update by the rotary encoder - if( rotaryEncoderVirtualPosition != rotaryEncoderPreviousPosition ) { + if ( rotaryEncoderVirtualPosition != rotaryEncoderPreviousPosition ) { rotaryEncoderPreviousPosition = rotaryEncoderVirtualPosition; - + lcd.setCursor( 0, LCD_VERTICAL_RESOLUTION - 1 ); lcd.print( " " ); - if( rotaryEncoderVirtualPosition < 10 ) { + if ( rotaryEncoderVirtualPosition < 10 ) { lcd.print( " " ); } else { - if( rotaryEncoderVirtualPosition < 100 ) { + if ( rotaryEncoderVirtualPosition < 100 ) { lcd.print( " " ); } } @@ -1904,15 +1901,15 @@ int xSetGenericValue(int initialValue, int minimumValue, int maximumValue, const lcd.println( " " ); } } - + return rotaryEncoderVirtualPosition; } -int xSetTemperature( int initialValue ) { +int xSetTemperature( int initialValue ) { return xSetGenericValue( initialValue, TEMPERATURE_MIN_VALUE, TEMPERATURE_MAX_VALUE, "temperature", "*C" ); } -int xSetFinalYield( int initialValue ) { +int xSetFinalYield( int initialValue ) { return xSetGenericValue( initialValue, SETTING_MACHINE_YIELD_CAPACITY_MIN, SETTING_MACHINE_YIELD_CAPACITY_MAX, "Final Yield", "l" ); } @@ -1920,21 +1917,21 @@ unsigned long getInactivityTime() { unsigned long now = millis(); unsigned long rotaryEncoderInactivityTime = now - lastInterruptTime; - if(rotaryEncoderInactivityTime > SETTING_MAX_INACTIVITY_TIME) { + if (rotaryEncoderInactivityTime > SETTING_MAX_INACTIVITY_TIME) { if (digitalRead(ROTARY_ENCODER_SW_PIN)) { - while(digitalRead(ROTARY_ENCODER_SW_PIN)) { - delay(ROTARY_ENCODER_SW_DEBOUNCE_TIME); - } - - now = millis(); - rotaryEncoderInactivityTime = now - lastInterruptTime; - rotarySwDetectTime = now; - - repaint = true; - refresh = true; + while (digitalRead(ROTARY_ENCODER_SW_PIN)) { + delay(ROTARY_ENCODER_SW_DEBOUNCE_TIME); + } + + now = millis(); + rotaryEncoderInactivityTime = now - lastInterruptTime; + rotarySwDetectTime = now; + + repaint = true; + refresh = true; } } - + unsigned long switchInactivityTime = now - rotarySwDetectTime; return rotaryEncoderInactivityTime > switchInactivityTime ? switchInactivityTime : rotaryEncoderInactivityTime ; } @@ -1942,12 +1939,12 @@ unsigned long getInactivityTime() { // ###################### Set Variables ################################################## void xWaitForAction(String title, String message) { - while(true) { + while (true) { // Check if pushbutton is pressed if ( digitalRead(ROTARY_ENCODER_SW_PIN) ) { // Wait until switch is released - while ( digitalRead(ROTARY_ENCODER_SW_PIN) ) {} - + while ( digitalRead(ROTARY_ENCODER_SW_PIN) ) {} + // debounce delay( 10 ); @@ -1957,7 +1954,7 @@ void xWaitForAction(String title, String message) { sing(BUZZ_1, PIEZO_PIN); // Print the message - if(! lcdPrint(&lcd, title, message)) { + if (! lcdPrint(&lcd, title, message)) { break; } } @@ -1971,7 +1968,7 @@ boolean gotButtonPress(int iPin) { ret = true; while (digitalRead(iPin)) {} // wait til switch is released delay(10); // debounce - } + } return ret; } diff --git a/config.h b/config.h index 0ea0188..44e2957 100644 --- a/config.h +++ b/config.h @@ -89,6 +89,43 @@ #define MENU_SIZE_MALT_MENU 4 #define MENU_SIZE_SETTINGS_MENU 6 +// ++++++++++++++++++++++++ Menus ++++++++++++++++++++++++ +#define MENU_MAIN_TITLE "Brewery Menu" +#define MENU_MAIN_DIALOG { "", "-> GO ", "-> GO from stage", "-> STOP ", "-> SKIP ", "-> BeerProfile ", "-> Stages ", "-> Malt ", "-> Hops ", "-> Clean ", "-> Purge ", "-> Settings ", "-> Back " } +#define MENU_MAIN_INIT_POSITION eMainMenu_GO +#define MENU_MAIN_INIT_SELECTION eMainMenu_NULL +#define MENU_MAIN_INIT_REPAINT false + +#define MENU_PROFILE_TITLE "Profile Menu" +#define MENU_PROFILE_DIALOG {"", "-> Basic ", "-> Trigo ", "-> IPA ", "-> Belga ", "-> Red ", "-> APA ", "-> Custom ", "-> Back " } +#define MENU_PROFILE_INIT_POSITION eBeerProfileMenu_Basic +#define MENU_PROFILE_INIT_SELECTION eBeerProfileMenu_NULL +#define MENU_PROFILE_INIT_REPAINT false + +#define MENU_STAGE_TITLE "Stage Menu" +#define MENU_STAGE_DIALOG {"", "-> Startpoint ", "-> BetaGlucanase", "-> Debranching ", "-> Proteolytic ", "-> Beta Amylase ", "-> Alpha Amylase", "-> Mashout ", "-> Recirculation", "-> Sparge ", "-> Boil ", "-> Cooling ", "-> Back " } +#define MENU_STAGE_INIT_POSITION eStageMenu_Startpoint +#define MENU_STAGE_INIT_SELECTION eStageMenu_NULL +#define MENU_STAGE_INIT_REPAINT false + +#define MENU_MALT_TITLE "Malt Menu" +#define MENU_MALT_DIALOG {"", "-> CM Ch. Pilsen", "-> CM Wheat Blan", "-> Back " } +#define MENU_MALT_INIT_POSITION eMaltMenu_CastleMalting_Chteau_Pilsen_2RS +#define MENU_MALT_INIT_SELECTION eMaltMenu_NULL +#define MENU_MALT_INIT_REPAINT false + +#define MENU_SETTINGS_TITLE "Settings Menu" +#define MENU_SETTINGS_DIALOG {"", "-> PT100 Element", "-> PT100 Up ", "-> PT100 Down ", "-> Back " } +#define MENU_SETTINGS_INIT_POSITION eSettingsMenu_PT100_Element +#define MENU_SETTINGS_INIT_SELECTION eSettingsMenu_NULL +#define MENU_SETTINGS_INIT_REPAINT false + +#define MENU_START_TITLE MENU_STAGE_TITLE +#define MENU_START_DIALOG MENU_STAGE_DIALOG +#define MENU_START_INIT_POSITION MENU_STAGE_INIT_POSITION +#define MENU_START_INIT_SELECTION MENU_STAGE_INIT_SELECTION +#define MENU_START_INIT_REPAINT MENU_STAGE_INIT_REPAINT + // ++++++++++++++++++++++++ Serial Monotor ++++++++++++++++++++++++ #define SETTING_SERIAL_MONITOR_BAUD_RATE 9600 #define SETTING_SERIAL_MONITOR_WELCOME_MESSAGE "Let's start Brewing!" -- 2.24.1