#include "Display.h"
#include "Classes.h"

Setting DisplayBrightness("Display", 250, 100, 10);
Setting ButtonBrightness("Button", 250, 100, 10);
Setting HapticStrength("Haptic", 100, 40, 5);
Setting Coolness("Coolness", 250, 200, 5);
MenuHandler Menu("Settings", 2, 3, 4);

void setup() {
  Serial.begin(9600);

  tft.begin();

  Menu.init();
  Menu.add(&DisplayBrightness);
  Menu.add(&ButtonBrightness);
  Menu.add(&HapticStrength);
  Menu.add(&Coolness);
}

void loop() {
  Menu.update();
}

MenuManager_UNO.ino

diagram.json

libraries.txt

#ifndef CLASSES_H
#define CLASSES_H

#include "Display.h"

#define DISPLAY_PADDING         15
#define TEXT_SPACING            30
#define MENU_SETTINGS_COUNT     10
#define BAR_WIDTH              100
#define BAR_SPACING              2
#define BAR_HEIGHT              16
#define BAR_RADIUS               1
#define CURSOR_PADDING           8

class Setting {
  private:
    String _name;
    int16_t _value;
    uint8_t _maxValue;
    uint8_t _stepSize;
    uint8_t _barCount;
    bool _changed = true;
    bool _added = false;

  public:
    Setting(String name, uint8_t maxValue, int16_t value, uint8_t barCount) {
      setName(name);
      setMaxValue(maxValue);
      setValue(value);
      setBarCount(barCount);
      setStepSize(maxValue / barCount);
    }

    // Setter
    void setName(String name) {
      _name = name;
    }
    void setMaxValue(uint8_t maxValue) {
      _maxValue = maxValue;
    }
    void setValue(int16_t value) {
      if (value > _maxValue) {
        _value = _maxValue;
      } else if (value < 0) {
        _value = 0;
      } else {
        _value = value;
        changed(true);
      }
    }
    void setStepSize(uint8_t stepSize) {
      _stepSize = stepSize;
    }
    void setBarCount(uint8_t barCount) {
      _barCount = barCount;
    }
    void changed(bool changed) {
      _changed = changed;
    }
    void added(bool added) {
      _added = added;
    }

    // Getter
    String getName() {
      return _name;
    }
    uint8_t getMaxValue() {
      return _maxValue;
    }
    int16_t getValue() {
      return _value;
    }
    uint8_t getStepSize() {
      return _stepSize;
    }
    uint8_t getBarCount() {
      return _barCount;
    }
    bool hasChanged() {
      return _changed;
    }
    bool isAdded() {
      return _added;
    }
};

class MenuHandler {
  private:
    String _name;
    uint8_t _selectButtonPin;
    uint8_t _incButtonPin;
    uint8_t _decButtonPin;
    uint8_t _buttonStates;
    uint8_t _buttonStatesOld;
    uint8_t _idx;
    Setting * _settingsList[MENU_SETTINGS_COUNT];
    uint8_t _selectedSetting;
    uint8_t _oldSetting = MENU_SETTINGS_COUNT;
    uint8_t _addedSettingsCount;

  public:
    MenuHandler(String name, uint8_t selectButtonPin, uint8_t incButtonPin, uint8_t decButtonPin) {
      setName(name);
      setSelectButtonPin(selectButtonPin);
      setIncButtonPin(incButtonPin);
      setDecButtonPin(decButtonPin);
    }

    // Setter
    void setName(String name) {
      _name = name;
    }
    void setSelectButtonPin(uint8_t selectButtonPin) {
      _selectButtonPin = selectButtonPin;
    }
    void setIncButtonPin(uint8_t incButtonPin) {
      _incButtonPin = incButtonPin;
    }
    void setDecButtonPin(uint8_t decButtonPin) {
      _decButtonPin = decButtonPin;
    }
    void setButtonStates(uint8_t buttonStates) {
      _buttonStates = buttonStates;
    }
    void setButtonStatesOld(uint8_t buttonStatesOld) {
      _buttonStatesOld = buttonStatesOld;
    }
    void setIdx(uint8_t idx) {
      if (idx < MENU_SETTINGS_COUNT) {
        _idx = idx;
      } else {
        _idx = 0;
        //Serial.println("[!] Resetting menu idx count to 0");
      }
    }
    void setSelectedSetting(uint8_t currentSettingIdx) {
      _selectedSetting = currentSettingIdx;
    }
    void setOldSetting(uint8_t oldSettingIdx) {
      _oldSetting = oldSettingIdx;
    }
    void setAddedSettingsCount(uint8_t addedSettingsCount) {
      _addedSettingsCount = addedSettingsCount;
    }

    // Getter
    String getName() {
      return _name;
    }
    uint8_t getSelectButtonPin() {
      return _selectButtonPin;
    }
    uint8_t getIncButtonPin() {
      return _incButtonPin;
    }
    uint8_t getDecButtonPin() {
      return _decButtonPin;
    }
    uint8_t getButtonStates() {
      return _buttonStates;
    }
    uint8_t getButtonStatesOld() {
      return _buttonStatesOld;
    }
    uint8_t getIdx() {
      return _idx;
    }
    uint8_t getSelectedSetting() {
      return _selectedSetting;
    }
    uint8_t getOldSetting() {
      return _oldSetting;
    }
    uint8_t getAddedSettingsCount() {
      return _addedSettingsCount;
    }

    // Main methods
    void init() {
      //Serial.println("Initializing " + getName());
      pinMode(getSelectButtonPin(), INPUT_PULLUP);
      pinMode(getIncButtonPin(), INPUT_PULLUP);
      pinMode(getDecButtonPin(), INPUT_PULLUP);

      tft.setCursor(DISPLAY_PADDING, DISPLAY_PADDING);
      tft.setTextColor(ILI9341_RED);
      tft.setTextSize(2);
      tft.println(getName());
    }

    void readButtons() {
      for (int i = 2; i < 5; i++) {
        if (!digitalRead(i)) {
          bitSet(_buttonStates, i - 2);
        } else {
          bitClear(_buttonStates, i - 2);
        }
      }
    }

    void checkButtons() {
      if (getButtonStates() != getButtonStatesOld()) {
        for (int i = 0; i < 4; i++) {
          if (bitRead(getButtonStates(), i)) {
            uint8_t idx = getSelectedSetting();
            
            if (i == 0) {
              uint8_t nextIdx = (idx + 1) % getAddedSettingsCount();
              setSelectedSetting(nextIdx);
              //Serial.println("nextIdx: " + String(nextIdx) + " ➔ Currently selected setting \"" + _settingsList[getSelectedSetting()]->getName() + "\"");
            } else if (i == 1) {
              _settingsList[idx]->setValue(_settingsList[idx]->getValue() - _settingsList[idx]->getStepSize());
              //Serial.println("Setting \"" + _settingsList[idx]->getName() + "\" - Value: " + String(_settingsList[idx]->getValue()));
            } else {
              _settingsList[idx]->setValue(_settingsList[idx]->getValue() + _settingsList[idx]->getStepSize());
              //Serial.println("Setting \"" + _settingsList[idx]->getName() + "\" - Value: " + String(_settingsList[idx]->getValue()));
            }
          }
        }
        setButtonStatesOld(getButtonStates());
      }
    }

    void add(Setting * setting) {
      if (!setting->isAdded()) {

        // Replacing
        if (_settingsList[getIdx()] != nullptr) {
          //Serial.println("[!] Replacing setting \"" + _settingsList[getIdx()]->getName() + "\" with \"" + setting->getName() + "\"");
          _settingsList[getIdx()]->added(false);
          setAddedSettingsCount(getAddedSettingsCount() - 1);
        }

        // Adding
        //Serial.println("[✔] Adding setting \"" + setting->getName() + "\"");
        _settingsList[getIdx()] = setting;
        setting->added(true);
        setIdx(getIdx() + 1);
        setAddedSettingsCount(getAddedSettingsCount() + 1);
      } else {
        //Serial.println("[x] Setting \"" + setting->getName() + "\" already added");
      }
    }

    void update() {
      readButtons();
      checkButtons();

      tft.setTextColor(ILI9341_WHITE);
      tft.setTextSize(1);

      // Cursor
      if (getSelectedSetting() != getOldSetting()) {
        uint8_t idx = getSelectedSetting();
        uint8_t x = DISPLAY_PADDING - CURSOR_PADDING;
        uint8_t y = 60 - CURSOR_PADDING + idx * TEXT_SPACING;
        uint8_t yOld = 60 - CURSOR_PADDING + getOldSetting() * TEXT_SPACING;
        uint8_t w = tft.width() - 2 * DISPLAY_PADDING - BAR_SPACING + 2 * CURSOR_PADDING;
        uint8_t h = BAR_HEIGHT + 2 * CURSOR_PADDING;

        tft.drawRoundRect(x, yOld, w, h, 3, tft.color565(0, 0, 0));
        tft.drawRoundRect(x, y, w, h, 3, tft.color565(200, 200, 200));
        //tft.fillCircle(DISPLAY_PADDING + 3, 66 + getOldSetting()*TEXT_SPACING, 3, ILI9341_BLACK);
        //tft.fillCircle(DISPLAY_PADDING + 3, 66 + idx*TEXT_SPACING, 3, ILI9341_RED);
        setOldSetting(idx);
        //Serial.println("[*] Updating cursor");
      }

      // Settings list
      for (int i = 0; i < MENU_SETTINGS_COUNT; i++) {
        if (_settingsList[i] != nullptr && _settingsList[i]->hasChanged()) {
          int16_t value = _settingsList[i]->getValue();
          uint8_t stepSize = _settingsList[i]->getStepSize();
          uint8_t barCount = _settingsList[i]->getBarCount();
          uint8_t barsToDraw = value / stepSize;
          //Serial.println("Bars to draw: " + String(barsToDraw));

          tft.setCursor(DISPLAY_PADDING, 60 + i * TEXT_SPACING);
          tft.println(_settingsList[i]->getName());

          // Reset bars
          for (int j = 0; j < barCount; j++) {
            tft.fillRoundRect(tft.width() - DISPLAY_PADDING - BAR_WIDTH + j * BAR_WIDTH/barCount, 60 + i * TEXT_SPACING, (BAR_WIDTH/barCount) - BAR_SPACING, BAR_HEIGHT, BAR_RADIUS, tft.color565(50, 100, 0));
          }
          // Draw new bars
          for (int j = 0; j < barsToDraw; j++) {
            tft.fillRoundRect(tft.width() - DISPLAY_PADDING - BAR_WIDTH + j * BAR_WIDTH/barCount, 60 + i * TEXT_SPACING, (BAR_WIDTH/barCount) - BAR_SPACING, BAR_HEIGHT, BAR_RADIUS, tft.color565(100, 255, 0));
          }

          _settingsList[i]->changed(false);

          //Serial.println("[!] Updating display because \"" + _settingsList[i]->getName() + "\" changed recently...");
        }
      }
    }
};

#endif

Classes.h

#ifndef DISPLAY_H
#define DISPLAY_H

#include <Adafruit_ILI9341.h>

#define TFT_CS   9
#define TFT_DC   10
Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC);

#endif