Menu.h

Go to the documentation of this file.

/*******************************************************************************
 * @file Menu.h
 * @brief Defines the menu classes used by the SoloController app
 ******************************************************************************/
 
#ifndef MENU_INCLUDED
#define MENU_INCLUDED
 
#include "Canvas.h"
#include "Button.h"
#include "Sensor.h"
#include "TextBox.h"
 
using sensorVal_t = Sensor::sensorVal_t;
using namespace std;
 
/******************************************************************************/
/***                                                                        ***/
/***                    Class Definition: SoloMenu                          ***/
/***                                                                        ***/
/******************************************************************************
 * @brief Base class used by all menus.
 *
 * @details
 * This menu provides the core functionality for the menu system. Each menu
 * displayed on the TFT will derive from this class. The primary responsibility
 * for this class is to manage all Button, Labels, and Submenus, ensuring
 * that requests to update graphics or handle presses to the TFT touch screen
 * are handled properly. All menus are intended to be Singleton objects.
 * Each object uses significant DRAM resources.
 ******************************************************************************/
class SoloMenu
{
 
  const uint16_t _x0;     // Upper left x-coordinate for the menu in the TFT display
  const uint16_t _y0;     // Upper left y-coordinate for the menu in the TFT display
  const uint16_t _width;  // Width of the menu
  const uint16_t _height; // Height of the menu
 
  // Tracks the ID of the button currently pressed
  int8_t _buttonID = -1;
 
  /* Pointers to various arrays managed by this class
   */
  uint8_t _numButtons = 0;
  Button **_buttonArr;
 
protected:

  SoloMenu(void)
      : _x0{0}, _y0{0}, _width{LCD_XSIZE_TFT}, _height{LCD_YSIZE_TFT} {};

  SoloMenu(uint16_t x0, uint16_t y0, uint16_t width, uint16_t height)
      : _x0{x0}, _y0{y0}, _width{width}, _height{height} {};

  ~SoloMenu(void) = default;

 
public:
  SoloMenu(const SoloMenu &) = delete;

  SoloMenu &operator=(const SoloMenu &) = delete;


  virtual void begin(void);

  virtual void update(void);

  virtual void show(void) = 0;

  void loadConfig(void)
  {
    Serial.println("SoloMenu->loadConfig() called");
  }

  virtual void checkButtons(void);

  virtual void releaseButton(void);

  static bool hasScreenBeenTouched(void);



  inline uint16_t x(void) const
  {
    return _x0;
  };

  inline uint16_t y(void) const
  {
    return _y0;
  };

  inline uint16_t width(void) const
  {
    return _width;
  };

  inline uint16_t height(void) const
  {
    return _height;
  };

 
protected:

  int8_t _pressButtonIfTouched(void);

  void _register(Button **buttonPtrArray, uint8_t nButtons);

};
 
extern SoloMenu *menu; 
 
/******************************************************************************/
/***                                                                        ***/
/***                    Class Definition: MainMenu                          ***/
/***                                                                        ***/
/******************************************************************************/
#define NUM_MAINMENU_BUTTONS 0 
class MainMenu : public SoloMenu
{
 
  Canvas _PrimaryCanvas;          // Primary Canvas is the one displayed in the TFT
/*  ROM_Canvas _SecondaryNormalCvs; // Canvas that holds a 2nd image of the Main Menu
  ROM_Canvas _SecondaryAlarmCvs;  // Canvas that holds an image of an alarmed Main Menu
  ROM_Canvas _ButtonCanvas;       // Canvas containing button images used by the menu
 
  // The various buttons used by the menu
  ToggleButton _KettleTempAlarmButton;
  ToggleButton _KettleVolAlamButton;
  ToggleButton _ChillerTempAlarmButton;
  ToggleButton _ModeButton;
  ToggleButton _PumpButton;
  ToggleButton _AuxButton;
  MomentaryButton _SetupButton; */
 
  // Button array contains pointers to (above) buttons
  Button *_buttonArr[NUM_MAINMENU_BUTTONS];
 
  // Instance of the singleton
  static MainMenu *_instance;

  MainMenu(void);

  ~MainMenu(void) = default;
 
public:
  static MainMenu &getInstance(void)
  {
    if (!_instance)
      _instance = new MainMenu();
    return *_instance;
  };

  MainMenu(const MainMenu &) = delete;

  MainMenu &operator=(const MainMenu &) = delete;

  void begin(void) override;

  void update(void) override;

  inline void show(void) override
  {
    menu = this;
    _PrimaryCanvas.setMainWindow();
  }
};
 
extern SoloMenu *setupMenu; 
 
/******************************************************************************/
/***                                                                        ***/
/***                 Class Definition: SetupVolMenu                         ***/
/***                                                                        ***/
/******************************************************************************/
#define NUM_SETUPVOLMENU_BUTTONS 0
class SetupVolMenu : public SoloMenu
{
 
  ROM_Canvas _PrimaryCanvas; // Primary Canvas displayed on the TFT
 
  // The various buttons used by the menu
/*  ImmediateButton _TempSetup;
  ImmediateButton _PID_Setup;
  MomentaryButton _DoneButton;
  ToggleButton _CalPoint1;
  ToggleButton _CalPoint2; */
 
  // Button array contains pointers to (above) buttons
  Button *_buttonArr[NUM_SETUPVOLMENU_BUTTONS];
 
  // Singleton instance of the SetupVolMenu menu
  static SetupVolMenu *_instance;

  SetupVolMenu(void);

  ~SetupVolMenu(void) = default;
 
public:
  static SetupVolMenu &getInstance(void)
  {
    if (!_instance)
      _instance = new SetupVolMenu();
    return *_instance;
  };

  SetupVolMenu(const SetupVolMenu &) = delete;

  SetupVolMenu &operator=(const SetupVolMenu &) = delete;

  void begin(void) override;

  void update(void) override;

  inline void show(void) override
  {
    menu = this;
    setupMenu = this;
    _PrimaryCanvas.setMainWindow();
  }
};
 
/******************************************************************************/
/***                                                                        ***/
/***                 Class Definition: SetupTempMenu                        ***/
/***                                                                        ***/
/******************************************************************************/
#define NUM_SETUPTEMPMENU_BUTTONS 0
class SetupTempMenu : public SoloMenu
{
 
  ROM_Canvas _PrimaryCanvas; // Primary Canvas displayed on the TFT
 
  // The various buttons used by the menu
/*  ImmediateButton _VolSetup;
  ImmediateButton _PID_Setup;
  MomentaryButton _DoneButton;
  ToggleButton _KettleProbe;
  ToggleButton _ChillerProbe;
 
  // Button array contains pointers to (above) buttons
  Button *_buttonArr[NUM_SETUPTEMPMENU_BUTTONS]; */
 
  // Singleton instance of SetupTempMenu
  static SetupTempMenu *_instance;

  SetupTempMenu(void);

  ~SetupTempMenu(void) = default;
 
public:
  static SetupTempMenu &getInstance(void)
  {
    if (!_instance)
      _instance = new SetupTempMenu();
    return *_instance;
  };

  SetupTempMenu(const SetupTempMenu &) = delete;

  SetupTempMenu &operator=(const SetupTempMenu &) = delete;

  void begin(void) override;

  void update(void) override;

  inline void show(void) override
  {
    menu = this;
    setupMenu = this;
    _PrimaryCanvas.setMainWindow();
  }
};
 
/******************************************************************************/
/***                                                                        ***/
/***                 Class Definition: SetupPID_Menu                        ***/
/***                                                                        ***/
/******************************************************************************/
#define NUM_SETUPPIDMENU_BUTTONS 0
class SetupPID_Menu : public SoloMenu
{
 
  ROM_Canvas _PrimaryCanvas; // Primary Canvas displayed on the TFT
 
/*  // The various buttons used by the menu
  ImmediateButton _VolSetup;
  ImmediateButton _TempSetup;
  MomentaryButton _DoneButton;
  ToggleButton _AutoTune; */
 
  // Button array contains pointers to (above) buttons
  Button *_buttonArr[NUM_SETUPPIDMENU_BUTTONS];
 
  // Singleton instance of SetupPID_Menu
  static SetupPID_Menu *_instance;

  SetupPID_Menu(void);

  ~SetupPID_Menu(void) = default;
 
public:
  static SetupPID_Menu &getInstance(void)
  {
    if (!_instance)
      _instance = new SetupPID_Menu();
    return *_instance;
  };

  SetupPID_Menu(const SetupPID_Menu &) = delete;

  SetupPID_Menu &operator=(const SetupPID_Menu &) = delete;

  void begin(void) override;

  void update(void) override;

  inline void show(void) override
  {
    menu = this;
    setupMenu = this;
    _PrimaryCanvas.setMainWindow();
  }
};
 
/******************************************************************************/
/***                                                                        ***/
/***                         Callback Functions                             ***/
/***                                                                        ***/
/******************************************************************************/

namespace CB
{

  namespace MAIN
  {

    void kettleTempAlarmOn(void);
    void kettleTempAlarmOff(void);
    void kettleVolAlarmOn(void);
    void kettleVolAlarmOff(void);
    void chillerTempAlarmOn(void);
    void chillerTempAlarmOff(void);
    void elementOn(void);
    void elementOff(void);
    void boilModeOn(void);
    void mashModeOn(void);
    void pumpOn(void);
    void pumpOff(void);
    void auxOn(void);
    void auxOff(void);
    void setupButtonPressed(void);

    void setBoilRate(sensorVal_t boilRate);           
    void setMashTemp(sensorVal_t mashTemp);           
    void setKettleTempSV(sensorVal_t kettleTempSV);   
    void setKettleVolSV(sensorVal_t kettleVolSV);     
    void setChillerTempSV(sensorVal_t chillerTempSV); 

  }

  namespace SETUP
  {
    void volSetup(void);         
    void tempSetup(void);        
    void PID_Setup(void);        
    void returnToMainMenu(void); 

    namespace VOL
    {
      void calPoint1(void); 
      void calPoint2(void); 
    }

    namespace TEMP
    {
      void kettleProbe(void);  
      void chillerProbe(void); 
    }

    namespace PID
    {
      void autoTune(void);
    }
  }
}
 
#endif