diagram.json

#include <arduino-timer.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

/**
   Timers
*/
Timer<1, millis> appTimer;

const int ENCODER_TIMER = 10;
const int MENU_TIMEOUT = 60000;
const int MENU_REFRESH_TIMEOUT = 1000;

/**
   Encoder
*/
#define ENCODER_S1_PIN 32
#define ENCODER_S2_PIN 33
#define ENCODER_BTN_PIN 25

int lastEncoderValue = -1;
unsigned long lastEncoderInput = millis();
bool encoderConfirmValue = false;

/**
   LCD
*/
LiquidCrystal_I2C lcd(0x27, 20, 4);

void setup() {
  Serial.begin(115200);
  while (!Serial);

  initEncoder();
  initLCD();

  printFrame();
}

void printFrame() {
  byte verticalLine[8] = {
    B00100,
    B00100,
    B00100,
    B00100,
    B00100,
    B00100,
    B00100,
    B00100
  };

  byte char2[8] = {
    B00000,
    B00000,
    B00000,
    B11100,
    B00100,
    B00100,
    B00100,
    B00100
  };

  byte char1[8] = {
    0b00000,
    0b00000,
    0b00000,
    0b00111,
    0b00100,
    0b00100,
    0b00100,
    0b00100
  };

  byte char3[8] = {
    0b00100,
    0b00100,
    0b00100,
    0b00111,
    0b00000,
    0b00000,
    0b00000,
    0b00000
  };

  byte char4[8] = {
    0b00100,
    0b00100,
    0b00100,
    0b11100,
    0b00000,
    0b00000,
    0b00000,
    0b00000
  };

  lcd.createChar(0, verticalLine);
  lcd.createChar(1, char1);
  lcd.createChar(2, char2);
  lcd.createChar(3, char3);
  lcd.createChar(4, char4);

  lcd.setCursor(1,0);
  lcd.print("------------------");
  lcd.setCursor(1,3);
  lcd.print("------------------");
  lcd.setCursor(0,1);
  lcd.write(byte(0));
  lcd.setCursor(0,2);
  lcd.write(byte(0));
  lcd.setCursor(19,1);
  lcd.write(byte(0));
  lcd.setCursor(19,2);
  lcd.write(byte(0));
  lcd.setCursor(0,0);
  lcd.write(byte(1));
  lcd.setCursor(19,0);
  lcd.write(byte(2));
  lcd.setCursor(0,3);
  lcd.write(byte(3));
  lcd.setCursor(19,3);
  lcd.write(byte(4));
}

void loop() {

}

void initEncoder() {
  pinMode(ENCODER_S1_PIN, INPUT);
  pinMode(ENCODER_S2_PIN, INPUT);
  pinMode(ENCODER_BTN_PIN, INPUT_PULLUP);
}

void initLCD() {
  lcd.init();
  lcd.backlight();
}


esp32-dht22.ino

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries
arduino-timer-master@wokwi:a490b6206689b34761bd8b033c95071d32b327e0
LiquidCrystal I2C

libraries.txt

#include <Arduino.h>
#include <WString.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

#include "MenuController.h"

void MenuController::init() {
  this->_lcd.begin(20, 4, LCD_8BITMODE);

  Serial.println("Building menu ...");
  this->buildMenu();
}

void MenuController::render() {
  if (!this->isEnable()) {
    this->_lcd.clear();

    return;
  } else {
    if (!this->isChanged()) {
      return;
    }

    this->renderMenu();
    this->clearChange();
  }
}

void MenuController::buildMenu() {
  this->buildMenuList();
}

void MenuController::buildMenuList() {
  this->_menu = MenuList();

  // ---

  MenuList subMenu = MenuList();
  subMenu.addItem("Test 1.1", NULL, []() {
    Serial.println("Confirm Test 1.1");
  });
  subMenu.addItem("Test 1.2", NULL, []() {
    Serial.println("Confirm Test 1.2");
  });
  subMenu.addItem("Test 1.3", NULL, []() {
    Serial.println("Confirm Test 1.3");
  });

  this->_menu.addItem("Test 1", &subMenu);

  // ---

  subMenu = MenuList();
  subMenu.addItem("Test 2.1", NULL, []() {
    Serial.println("Confirm Test 2.1");
  });
  subMenu.addItem("Test 2.2", NULL, []() {
    Serial.println("Confirm Test 2.2");
  });

  this->_menu.addItem("Test 2", &subMenu);

  // ---

  this->_menu.addItem("Test 3", NULL, []() {
    Serial.println("Confirm Test 3");
  });
}

void MenuController::renderMenu() {
  Serial.println("Render menu ...");

  this->LCDClear();
  this->LCDPrint(0, "[ DMX LightControl ]");

  MenuList subMenu;
  MenuItem* selectedItem = this->_menu.getSelectedItem();

  if (this->submenu == true && selectedItem->getSubMenu() != NULL) {
    subMenu = *selectedItem->getSubMenu();

    Serial.println("Submenu size: ");
    Serial.println(subMenu.size());
  } else {
    if (this->_menu.size() > 0) {
      size_t currentIndex = this->_menu.getSelectedIndex();
      String prefix;

      for (size_t i = 0; i < this->_menu.size(); i++) {
        if (i == currentIndex) {
          prefix = "> ";
        } else {
          prefix = "  ";
        }

        this->LCDPrint(i + 1, prefix + String(this->_menu.getItem(i)->getName()));
      }
    }
  }
}

void MenuController::LCDClear() {
  this->_lcd.clear();
}

void MenuController::LCDPrint(int row, String text) {
  this->_lcd.setCursor(0, row);
  this->_lcd.print(text);
}

void MenuController::LCDCenterPrint(int row, String text) {
  int textLength = text.length();

  this->_lcd.setCursor((this->_lcdCols - textLength) / 2, row);
  this->_lcd.print(text);
}

void MenuController::prev() {
  if (!this->isEnable()) {
    this->enable();
    return;
  }

  this->_menu.prevItem();

  this->change();
}

void MenuController::next() {
  if (!this->isEnable()) {
    this->enable();
    return;
  }

  this->_menu.nextItem();

  this->change();
}

void MenuController::confirm() {
  if (!this->isEnable()) {
    this->enable();
    return;
  }

  this->_menu.confirmItem();

  MenuItem* confirmedItem = this->_menu.getConfirmedItem();

  if (confirmedItem == NULL) {
    return;
  } else if (confirmedItem->getSubMenu() == NULL) {
    Serial.println("Excecute action ...");
    confirmedItem->executeAction();
    this->submenu = false;
  } else {
    Serial.println("Load submenu ...");
    this->submenu = true;
  }

  this->_menu.clearConfirmedItem();

  this->change();
}

bool MenuController::isEnable() {
  return this->status;
}

void MenuController::enable() {
  if (!this->isEnable()) {
    this->status = true;
  }

  this->backlight();
}

void MenuController::disable() {
  if (this->isEnable()) {
    this->status = false;
    this->backlight();
  }
}

void MenuController::change() {
  this->changed = true;
}

void MenuController::clearChange() {
  this->changed = false;
}

bool MenuController::isChanged() {
  return this->changed;
}

void MenuController::backlight() {
  if (this->isEnable()) {
    this->_lcd.backlight();
  } else {
    this->_lcd.noBacklight();
  }
}

void handleTest() {
  Serial.println("HANDLE TEST!");
}

MenuController.cpp

#include <LiquidCrystal_I2C.h>

#ifndef MenuController_h
#define MenuController_h

#include "MenuClasses.h"

class MenuController
{
  private:
    LiquidCrystal_I2C _lcd;
    MenuList _menu;

    int _lcdRows = 4;
    int _lcdCols = 20;

    int selectedIndex = 0;
    int confirmIndex = -1;

    bool status = true;
    bool changed = true;
    bool submenu = false;

  public:
    MenuController(LiquidCrystal_I2C lcd) : _lcd(lcd) {}

    void init();

    void buildMenu();
    void buildMenuList();

    void render();
    void renderMenu();

    void prev();
    void next();
    void confirm();
    void enable();
    bool isEnable();
    void disable();
    void change();
    void clearChange();
    bool isChanged();
    void backlight();

    void LCDClear();
    void LCDPrint(int row, String text);
    void LCDCenterPrint(int row, String text);
};

#endif // MenuController.h


MenuController.h

class MenuItem;

class MenuList {
  public:
    MenuList();
    void addItem(const char* name, MenuList* subMenu = NULL, void (*action)() = NULL);
    size_t size();
    size_t getSelectedIndex();
    size_t getConfirmedIndex();
    MenuItem** getItems();
    MenuItem* getSelectedItem();
    MenuItem* getConfirmedItem();
    MenuItem* getItem(size_t index);
    void selectItem(size_t index);
    void nextItem();
    void prevItem();
    void confirmItem();
    void clearConfirmedItem();

  private:
    MenuItem* _items;
    size_t _size;
    size_t _selectedIndex;
    size_t _confirmedIndex;
};

class MenuItem {
  public:
    MenuItem();
    MenuItem(const char* name, MenuList* subMenu = NULL, void (*action)() = NULL);
    const char* getName();
    MenuList* getSubMenu();
    void executeAction();

  private:
    const char* _name;
    MenuList* _subMenu;
    void (*_action)();
};


MenuClasses.h

#include <WString.h>

#include "MenuClasses.h"

MenuList::MenuList() {
  _items = new MenuItem[10];
  _size = 0;
  _selectedIndex = 0;
  _confirmedIndex = -1;
}

void MenuList::addItem(const char* name, MenuList* subMenu, void (*action)()) {
  MenuItem item(name, subMenu, action);
  _items[_size] = item;
  _size++;
}

size_t MenuList::size() {
  return _size;
}

size_t MenuList::getSelectedIndex() {
  return _selectedIndex;
}

size_t MenuList::getConfirmedIndex() {
  if (_confirmedIndex == -1) {
    return NULL;
  }

  return _confirmedIndex;
}

MenuItem** MenuList::getItems() {
  return &_items;
}

MenuItem* MenuList::getSelectedItem() {
  return &_items[_selectedIndex];
}

MenuItem* MenuList::getConfirmedItem() {
  if (_confirmedIndex == -1) {
    return NULL;
  }

  return &_items[_confirmedIndex];
}

MenuItem* MenuList::getItem(size_t index) {
  return &_items[index];
}

void MenuList::selectItem(size_t index) {
  _selectedIndex = index;
}

void MenuList::nextItem() {
  _selectedIndex++;
  if (_selectedIndex >= _size) {
    _selectedIndex = 0;
  }
}

void MenuList::prevItem() {
  if (_selectedIndex == 0) {
    _selectedIndex = _size - 1;
  } else {
    _selectedIndex--;
  }
}

void MenuList::confirmItem() {
  _confirmedIndex = _selectedIndex;
}

void MenuList::clearConfirmedItem() {
  _confirmedIndex == -1;
}

MenuItem::MenuItem() {

}

MenuItem::MenuItem(const char* name, MenuList* subMenu, void (*action)()) {
  _name = name;
  _subMenu = subMenu;
  _action = action;
}

const char* MenuItem::getName() {
  return _name;
}

MenuList* MenuItem::getSubMenu() {
  return _subMenu;
}

void MenuItem::executeAction() {
  if (_action != NULL) {
    _action();
  }
}
