#include <U8g2lib.h>
#include <Wire.h>
#include "ErriezRotaryFullStep.h"

#include "Menu.h"
#include "Item.h"

U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE);

const byte ROTARY_PIN1 = 2;
const byte ROTARY_PIN2 = 3;
const byte SWITCH = 4;

RotaryFullStep rotary(ROTARY_PIN1, ROTARY_PIN2, false, 150);

const byte NUMBER_OF_ITEMS = 0;
const byte NUMBER_OF_SUBMENUS = 5;

Menu menu(&u8g2, "main", 5);

Menu submenus[NUMBER_OF_SUBMENUS]{
  Menu(&u8g2, "[1] 1.1 10", 0, 3),
  Menu(&u8g2, "[2] LFO 19.1", 0),
  Menu(&u8g2, "[3] Start =", 0),
  Menu(&u8g2, "[4] End 23.1", 0),
  Menu(&u8g2, "SETTINGS", 0),
};

Item T1Items[3]{
  Item("item 1"),
  Item("item 2"),
  Item("item 3"),
};

byte previousSelectedItem = -1;

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

  u8g2.begin();
  u8g2.setFont(u8g2_font_pressstart2p_8r);
  u8g2.setFontMode(1);

  pinMode(SWITCH, INPUT_PULLUP);

  attachInterrupt(digitalPinToInterrupt(ROTARY_PIN1), rotaryInterrupt, CHANGE);
  attachInterrupt(digitalPinToInterrupt(ROTARY_PIN2), rotaryInterrupt, CHANGE);

  for (byte i = 0; i < 3; i++) {
    submenus[0].addItem(i, &T1Items[i]);
  }

  for (byte i = 0; i < NUMBER_OF_SUBMENUS; i++) {
    menu.addSubmenu(i, &submenus[i]);
  }

  menu.display();
}

void checkSwitch()
{
  if (digitalRead(SWITCH) == 0) {
    menu.select();
  }
}

void rotaryInterrupt()
{
  int rotaryState = rotary.read();
  
  if (rotaryState > 0) {
    menu.down();
  } else if (rotaryState < 0) {
    menu.up();
  }
}

void loop() {
  checkSwitch();

  Menu *currentMenu = menu.getCurrentMenu();

  if (menu.hasChanged()) {
    menu.display();
    menu._hasChanged = false;
  }
  /* byte selectedItem = menu.getSelectedItem();

  if (previousSelectedItem != selectedItem) {
    menu.display();
    previousSelectedItem = selectedItem;
  } */
}

sketch.ino

diagram.json

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

U8g2

libraries.txt

#ifndef Menu_H
#define Menu_H

#include <Arduino.h>
#include <U8g2lib.h>
#include "Item.h"

class Menu {
  
  private:
    U8G2_SSD1306_128X64_NONAME_1_HW_I2C *_u8g2;
    char * _name;
    Item *_items[10];
    Menu *_submenus[10];
    byte _selectedItem;
    byte _submenu;
    byte _numberOfSubmenus;
    byte _numberOfItems;
    
    
  public:
    Menu(U8G2_SSD1306_128X64_NONAME_1_HW_I2C *_u8g2, char * name, byte numberOfSubmenus, byte numberOfItems = 0);
    char * getName();
    void addItem(byte index, Item *item);
    Item* getItem(byte index);
    void addSubmenu(byte index, Menu *submenu);
    Menu* getSubmenu(byte index);
    void select();
    void up();
    void down();
    void display();
    byte getSelectedItem();
    bool hasChanged();
    bool _hasChanged;
};

#endif

Menu.h

#include <U8g2lib.h>
#include "Menu.h"

Menu::Menu(U8G2_SSD1306_128X64_NONAME_1_HW_I2C *u8g2, char * name, byte numberOfSubmenus, byte numberOfItems) {
  this->_u8g2 = u8g2;
  this->_name = name;
  this->_numberOfSubmenus = numberOfSubmenus;
  this->_numberOfItems = numberOfItems;
  this->_selectedItem = 0;
  this->_submenu = 255;
  this->_hasChanged = true;
}

bool Menu::hasChanged() {
  return this->_hasChanged;
}

char * Menu::getName() {
  return this->_name;
}

void Menu::addItem(byte index, Item *item) {
  this->_items[index] = item;
}

Item* Menu::getItem(byte index) {
  return this->_items[index];
}

void Menu::addSubmenu(byte index, Menu *submenu) {
  this->_submenus[index] = submenu;
}

Menu* Menu::getSubmenu(byte index) {
  return this->_submenus[index];
}

void Menu::up() {
  if (this->_selectedItem == 0) {
    return;
  }

  --this->_selectedItem;
  this->_hasChanged = true;
}

void Menu::down() {
  if (this->_selectedItem == this->_numberOfItems - 1) {
    return;
  }

  ++this->_selectedItem;
  this->_hasChanged = true;
}

void Menu::select() {
  this->_submenu = this->_selectedItem;
  this->_selectedItem = 0;
  this->_hasChanged = true;

  Serial.print("Select: ");
  Serial.println(this->_submenu);
}

void Menu::display() {
  this->_u8g2->clearBuffer();	
  this->_u8g2->firstPage();

  /* Menu *currentMenu;

  if (this->_submenu > -1) {
    *currentMenu = &this->getSubmenu(this->_submenu);
  } else {
    *currentMenu = &this;
  } */

  Serial.print("Display: ");
  Serial.println(this->_submenu);

  do {
    //this->_u8g2->drawTriangle(124, 0, 120, 5, 128, 5);
    //this->_u8g2->drawTriangle(124, 64, 121, 60, 128, 60);

    if (this->_submenu < 255) {
      Serial.println(this->getSubmenu(this->_submenu)->getName());
      Serial.println(this->getSubmenu(this->_submenu)->_numberOfSubmenus);

      for (byte i = 0; i < this->getSubmenu(this->_submenu)->_numberOfSubmenus; i++) {
        if (this->getSubmenu(this->_submenu)->_selectedItem == i) {
          this->_u8g2->setDrawColor(1);
          this->_u8g2->drawBox(0, ((i + 1) * 10) -9, 118, 9);

          this->_u8g2->setDrawColor(2);
          this->_u8g2->drawStr(0, (i + 1) * 10, this->getSubmenu(this->_submenu)->getSubmenu(i)->getName());
          this->_u8g2->setDrawColor(1);
        } else {
          this->_u8g2->drawStr(0, (i + 1) * 10, this->getSubmenu(this->_submenu)->getSubmenu(i)->getName());
        }
      }

      for (byte i = 0; i < this->getSubmenu(this->_submenu)->_numberOfItems; i++) {
        if (this->getSubmenu(this->_submenu)->_selectedItem == i) {
          this->_u8g2->setDrawColor(1);
          this->_u8g2->drawBox(0, ((i + 1) * 10) -9, 118, 9);

          this->_u8g2->setDrawColor(2);
          this->_u8g2->drawStr(0, (i + 1) * 10, this->getSubmenu(this->_submenu)->getItem(i)->getName());
          this->_u8g2->setDrawColor(1);
        } else {
          this->_u8g2->drawStr(0, (i + 1) * 10, this->getSubmenu(this->_submenu)->getItem(i)->getName());
        }
      }
    } else {
      for (byte i = 0; i < this->_numberOfSubmenus; i++) {
        if (this->_selectedItem == i) {
          this->_u8g2->setDrawColor(1);
          this->_u8g2->drawBox(0, ((i + 1) * 10) -9, 118, 9);

          this->_u8g2->setDrawColor(2);
          this->_u8g2->drawStr(0, (i + 1) * 10, this->getSubmenu(i)->getName());
          this->_u8g2->setDrawColor(1);
        } else {
          this->_u8g2->drawStr(0, (i + 1) * 10, this->getSubmenu(i)->getName());
        }
      }

      for (byte i = 0; i < this->_numberOfItems; i++) {
        if (this->_selectedItem == i) {
          this->_u8g2->setDrawColor(1);
          this->_u8g2->drawBox(0, ((i + 1) * 10) -9, 118, 9);

          this->_u8g2->setDrawColor(2);
          this->_u8g2->drawStr(0, (i + 1) * 10, this->getItem(i)->getName());
          this->_u8g2->setDrawColor(1);
        } else {
          this->_u8g2->drawStr(0, (i + 1) * 10, this->getItem(i)->getName());
        }
      }
    }

    this->_u8g2->sendBuffer();
  } while (this->_u8g2->nextPage());
}

byte Menu::getSelectedItem() {
  return this->_selectedItem;
}

Menu.cpp

#ifndef Item_H
#define Item_H

#include <Arduino.h>

class Item {
  
  private:
    char * _name;
    
  public:
    Item(char * name);
    char * getName();
};

#endif

Item.h

#include "Item.h"

Item::Item(char * name) {
  this->_name = name;
}

char * Item::getName() {
  return this->_name;
}

Item.cpp

/*
 * MIT License
 *
 * Copyright (c) 2018-2021 Erriez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/*!
 * \file ErriezRotaryFullStep.h
 * \brief Three speed full step Rotary Encoder library for Arduino
 * \details
 *      Source:         https://github.com/Erriez/ErriezRotaryEncoderFullStep
 *      Documentation:  https://erriez.github.io/ErriezRotaryEncoderFullStep
 */

#ifndef ERRIEZ_ROTARY_FULL_STEP_H_
#define ERRIEZ_ROTARY_FULL_STEP_H_

#include <Arduino.h>

/*!
 * \brief Full step Rotary Encoder class
 */
class RotaryFullStep
{
public:
    RotaryFullStep(uint8_t pin1, uint8_t pin2, bool pullUp=true, uint8_t sensitivity=100);
    int read();
    void setSensitivity(uint8_t sensitivity);
    uint8_t getSensitivity();

private:
    unsigned long  _lastChange;
    uint8_t _pin1;
    uint8_t _pin2;
    uint8_t _state;
    uint8_t _sensitivity;
};

#endif // ERRIEZ_ROTARY_FULL_STEP_H_

ErriezRotaryFullStep.h

/*
 * MIT License
 *
 * Copyright (c) 2018-2021 Erriez
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/*!
 * \file ErriezRotaryFullStep.cpp
 * \brief Three speed full step Rotary Encoder library for Arduino.
 * \details
 *      Source:         https://github.com/Erriez/ErriezRotaryEncoderFullStep
 *      Documentation:  https://erriez.github.io/ErriezRotaryEncoderFullStep
 */

#if (defined(__AVR__) || defined(ARDUINO_ARCH_SAM) || defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_ARCH_STM32F1))
#include <avr/pgmspace.h>
#else
#include <pgmspace.h>
#endif

#include "ErriezRotaryFullStep.h"

#define DIR_NONE  0x00      //!< No complete step yet
#define DIR_CW    0x10      //!< Clockwise step
#define DIR_CCW   0x20      //!< Counter-clockwise step

// Use the full-step state table, clockwise and counter clockwise
// Emits a code at '00' only
#define RFS_START          0x00     //!< Rotary full step start
#define RFS_CW_FINAL       0x01     //!< Rotary full step clock wise final
#define RFS_CW_BEGIN       0x02     //!< Rotary full step clock begin
#define RFS_CW_NEXT        0x03     //!< Rotary full step clock next
#define RFS_CCW_BEGIN      0x04     //!< Rotary full step counter clockwise begin
#define RFS_CCW_FINAL      0x05     //!< Rotary full step counter clockwise final
#define RFS_CCW_NEXT       0x06     //!< Rotary full step counter clockwise next

static const PROGMEM uint8_t fullStepTable[7][4] = {
    // RFS_START
    {RFS_START,      RFS_CW_BEGIN,  RFS_CCW_BEGIN, RFS_START},
    // RFS_CW_FINAL
    {RFS_CW_NEXT,    RFS_START,     RFS_CW_FINAL,  RFS_START | DIR_CW},
    // RFS_CW_BEGIN
    {RFS_CW_NEXT,    RFS_CW_BEGIN,  RFS_START,     RFS_START},
    // RFS_CW_NEXT
    {RFS_CW_NEXT,    RFS_CW_BEGIN,  RFS_CW_FINAL,  RFS_START},
    // RFS_CCW_BEGIN
    {RFS_CCW_NEXT,   RFS_START,     RFS_CCW_BEGIN, RFS_START},
    // RFS_CCW_FINAL
    {RFS_CCW_NEXT,   RFS_CCW_FINAL, RFS_START,     RFS_START | DIR_CCW},
    // RFS_CCW_NEXT
    {RFS_CCW_NEXT,   RFS_CCW_FINAL, RFS_CCW_BEGIN, RFS_START},
};

/*!
 * \brief
 *     Constructor full step Rotary Encoder
 * \param pin1
 *     Rotary Encoder pin 1
 * \param pin2
 *     Rotary Encoder pin 2
 * \param pullUp
 *     true:  Enable internal pull-up on Rotary Encoder pins [default argument].
 *     false: Disable internal pull-up on Rotary Encoder pins.
 * \param sensitivity
 *     Set sensitivity rotation speed value 0..255.
 *     A higher is more sensitive for rotation speed, a smaller value is less
 *     sensitive or will disable speed detection.
 *     Default is 100.
 */
RotaryFullStep::RotaryFullStep(uint8_t pin1, uint8_t pin2, bool pullUp, uint8_t sensitivity) :
    _pin1(pin1), _pin2(pin2), _state(0), _sensitivity(sensitivity)
{
    if (pullUp) {
        // Enable internal pull-up
        pinMode(_pin1, INPUT_PULLUP);
        pinMode(_pin2, INPUT_PULLUP);
    }
}

/*!
 * \brief
 *     Read Rotary Encoder state
 * \details
 *     Call this function as fast as possible to prevent missing pin changes.
 *     This seems to work for most rotary encoders when calling this function
 *     within 10ms in an endless loop.
 *
 *     The sensitivity value is used to calculate three rotation speeds by
 *     measuring the speed of the Rotary Encoder pin changes. The rotation speed
 *     depends on the number of Rotary notches and knob size. The value should
 *     experimentally determined.
 * \return Rotary speed and direction
 *     -3: Counter clockwise turn, multiple notches fast
 *     -2: Counter clockwise turn, multiple notches
 *     -1: Counter clockwise turn, single notch
 *      0:  No change
 *      1:  Clockwise turn, single notch
 *      2:  Clockwise turn, multiple notches
 *      3:  Clockwise turn, multiple notches fast
 */
int RotaryFullStep::read()
{
    int pinState;
    int rotaryState;
    unsigned long timeStamp;
    unsigned long changeTime;

    // Sample rotary digital pins
    pinState = (digitalRead(_pin1) << 1) | digitalRead(_pin2);

    // Determine new state from the pins and state table.
    _state = pgm_read_byte(&fullStepTable[_state & 0x0f][pinState]);

    // Check rotary state
    switch (_state & 0x30) {
        case DIR_CW:
            rotaryState = 1;
            break;
        case DIR_CCW:
            rotaryState = -1;
            break;
        case DIR_NONE:
        default:
            rotaryState = 0;
    }

    // Check if rotary changed
    if (rotaryState != 0) {
        timeStamp = millis();
        changeTime = timeStamp - _lastChange;
        _lastChange = timeStamp;

        // Check speed change
        if (changeTime < (_sensitivity / 2)) {
            rotaryState *= 3;
        } else if (changeTime < _sensitivity) {
            rotaryState *= 2;
        }
    }

    return rotaryState;
}

/*!
 * \brief
 *     Set sensitivity value.
 * \param sensitivity
 *     Sensitivity value 0..255
 */
void RotaryFullStep::setSensitivity(uint8_t sensitivity)
{
    _sensitivity = sensitivity;
}

/*!
 * \brief
 *     Get sensitivity value.
 * \return
 *     Sensitivity value 0..255.
 */
uint8_t RotaryFullStep::getSensitivity()
{
    return _sensitivity;
}