// 27 July 2024.
//
// There is a problem with the dependencies, see:
//   https://wokwi.com/projects/404566441698707457
// That problem is solved by uploading all the source files
// and fixing the includes.
// The files are taken from the library at 27 July 2024.
//
// Sketch taken from: 
//   https://github.com/forntoh/LcdMenu/tree/master/examples/Basic
//



/*
 Basic Menu

 https://lcdmenu.forntoh.dev/examples/basic

*/

#include <LiquidCrystal_I2C.h>
#include "LcdMenu.h"
#include "commandProccesors.h"

#define LCD_ROWS 2
#define LCD_COLS 16

// Configure keyboard keys (ASCII)
#define UP 56     // NUMPAD 8
#define DOWN 50   // NUMPAD 2
#define ENTER 53  // NUMPAD 5
#define BACK 55   // NUMPAD 7

// Initialize the main menu items
MAIN_MENU(
    ITEM_BASIC("Start service"),
    ITEM_BASIC("Connect to WiFi"),
    ITEM_BASIC("Settings"),
    ITEM_BASIC("Blink SOS"),
    ITEM_BASIC("Blink random")
);
// Construct the LcdMenu
LcdMenu menu(LCD_ROWS, LCD_COLS);

void setup() {
    Serial.begin(9600);
    // Initialize LcdMenu with the menu items
    menu.setupLcdWithMenu(0x27, mainMenu);
}

void loop() {
    if (!Serial.available()) return;
    char command = Serial.read();

    processMenuCommand(menu, command, UP, DOWN, ENTER, BACK);
}

sketch.ino

diagram.json

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

LiquidCrystal I2C


libraries.txt

/**
 * ---
 *
 * # ItemCommand
 *
 * This item type indicates that the current item is a **command**.
 * When `enter()` is invoked, the command *(callback)* bound to this item is
 * invoked.
 */

#ifndef ItemCommand_H
#define ItemCommand_H

// Include the header file for the base class.
#include "MenuItem.h"

// Declare a class for menu items that represent commands.
class ItemCommand : public MenuItem {
   private:
    // Declare a function pointer for the command callback.
    fptr callback;

   public:
    /**
     * Construct a new ItemCommand object.
     *
     * @param key The key of the item.
     * @param callback A reference to the callback function to be invoked when
     * the item is entered.
     */
    ItemCommand(const char* key, fptr callback)
        : MenuItem(key, MENU_ITEM_COMMAND) {
        this->callback = callback;
    }

    /**
     * Get the callback function for this item.
     *
     * @return The function pointer to the callback function.
     */
    fptr getCallback() override { return callback; }

    /**
     * Set the callback function for this item.
     *
     * @param callback A reference to the new callback function to be invoked
     * when the item is entered.
     */
    void setCallBack(fptr callback) override { this->callback = callback; };
};

#define ITEM_COMMAND(...) (new ItemCommand(__VA_ARGS__))

#endif  // ITEM_COMMAND_H


ItemCommand.h

/**
 * ---
 *
 * # ItemInput
 *
 * This is an item type where a user can type in information,
 * the information is persisted in the item and can be gotten later by
 * using `item->value`
 */

#ifndef ItemInput_H
#define ItemInput_H

// Include the header file for the base class.
#include "MenuItem.h"

// Declare a class for menu items that allow the user to input information.
class ItemInput : public MenuItem {
   private:
    // Declare a string to hold the input value.
    char* value;

    // Declare a function pointer for the input callback.
    fptrStr callback;

   public:
    /**
     * Construct a new ItemInput object with an initial value.
     *
     * @param text The text to display for the item.
     * @param value The initial value for the input.
     * @param callback A reference to the callback function to be invoked when
     * the input is submitted.
     */
    ItemInput(const char* text, char* value, fptrStr callback)
        : MenuItem(text, MENU_ITEM_INPUT), value(value), callback(callback) {}

    /**
     * Construct a new ItemInput object with no initial value.
     *
     * @param text The text to display for the item.
     * @param callback A reference to the callback function to be invoked when
     * the input is submitted.
     */
    ItemInput(const char* text, fptrStr callback)
        : ItemInput(text, (char*)"", callback) {}

    /**
     * Get the current input value for this item.
     *
     * @return The current input value as a string.
     */
    char* getValue() override { return value; }

    /**
     * Set the input value for this item.
     *
     * @param value The new input value.
     */
    void setValue(char* value) override { this->value = value; }

    /**
     * Get the callback function for this item.
     *
     * @return The function pointer to the callback function.
     */
    fptrStr getCallbackStr() override { return callback; }
};

#define ITEM_INPUT(...) (new ItemInput(__VA_ARGS__))

#endif  // ITEM_INPUT_H


ItemInput.h

/**
 * ---
 *
 * # ItemList
 *
 * This item type indicates that the current item is a **list**.
 *
 * ### Functionality
 * - `left()`: cycles down the list
 * - `right()`: cycles up the list. This function can be used alone with a
 * single button. Once the menu reaches the end of the list, it automatically
 * starts back from the beginning.
 * - `enter()`: invokes the command *(callback)* bound to this item.
 *
 * ### Usage
 * This item can be used for other primitive data types; you just need to pass
 * it as a string, then parse the result to the desired datatype.
 *
 * ### Parameters
 * @param key: key of the items
 * @param items: array of items to display
 * @param itemCount: number of items in `items`
 * @param callback: reference to a callback function that will be invoked
 * when the user selects an item from the list.
 */
#ifndef ItemList_H
#define ItemList_H
#include "MenuItem.h"

class ItemList : public MenuItem {
   private:
    fptrInt callback = NULL;  ///< Pointer to a callback function
    String* items = NULL;     ///< Pointer to an array of items
    const uint8_t itemCount;  ///< The total number of items in the list
    uint16_t itemIndex = 0;   ///< The current selected item index

   public:
    /**
     * @brief Constructs a new ItemList object.
     *
     * @param key The key of the menu item.
     * @param items The array of items to display.
     * @param itemCount The number of items in the array.
     * @param callback A pointer to the callback function to execute when
     * this menu item is selected.
     */
    ItemList(const char* key, String* items, const uint8_t itemCount,
             fptrInt callback)
        : MenuItem(key, MENU_ITEM_LIST), itemCount(itemCount) {
        this->callback = callback;
        this->items = items;
    }

    /**
     * @brief Returns the index of the currently selected item.
     *
     * @return The index of the currently selected item.
     */
    uint16_t getItemIndex() override { return itemIndex; }

    /**
     * @brief Changes the index of the current item.
     *
     * @return The index of the item to be selected.
     */
    void setItemIndex(uint16_t itemIndex) override {
        this->itemIndex = constrain(itemIndex, 0, (uint16_t)(itemCount)-1);
    }

    /**
     * @brief Get the callback bound to the current item.
     *
     * @return The the callback bound to the current item.
     */
    fptrInt getCallbackInt() override { return callback; }

    /**
     * @brief Returns the total number of items in the list.
     *
     * @return The total number of items in the list.
     */
    uint8_t getItemCount() override { return itemCount; };

    /**
     * @brief Returns a pointer to the array of items.
     *
     * @return A pointer to the array of items.
     */
    String* getItems() override { return items; }
};

#define ITEM_STRING_LIST(...) (new ItemList(__VA_ARGS__))

#endif

ItemList.h

/**
 * @file ItemProgress.h
 * @brief This file contains the declaration of the ItemProgress class.
 */

#ifndef ItemProgress_H
#define ItemProgress_H

#include "MenuItem.h"

/**
 * @class ItemProgress
 * @brief ItemProgress indicates that the current item is a list.
 */
class ItemProgress : public MenuItem {
   private:
    fptrMapping mapping = NULL;  ///< Pointer to a mapping function
    fptrInt callback = NULL;     ///< Pointer to a callback function
    uint16_t progress = 0;       ///< The progress
    uint8_t stepLength = 1;

   public:
    /**
     * @brief Constructs a new ItemProgress object.
     *
     * @param key The key of the menu item.
     * @param start The starting position of the list.
     * @param mapping A pointer to the mapping function.
     * @param callback A pointer to the callback function to execute when this
     * menu item is selected.
     */
    ItemProgress(const char* key, uint16_t start, uint8_t stepLength,
                 fptrMapping mapping, fptrInt callback)
        : MenuItem(key, MENU_ITEM_PROGRESS),
          mapping(mapping),
          callback(callback),
          progress(start),
          stepLength(stepLength) {}

    ItemProgress(const char* key, uint16_t start, fptrInt callback)
        : ItemProgress(key, start, 1, NULL, callback) {}

    ItemProgress(const char* key, fptrInt callback)
        : ItemProgress(key, 0, 1, NULL, callback) {}

    ItemProgress(const char* key, uint8_t stepLength, fptrMapping mapping,
                 fptrInt callback)
        : ItemProgress(key, 0, stepLength, mapping, callback) {}

    /**
     * @brief Increments the progress of the list.
     */
    void increment() override {
        if (progress >= MAX_PROGRESS) return;
        progress += stepLength;
    }

    /**
     * @brief Decrements the progress of the list.
     */
    void decrement() override {
        if (progress <= MIN_PROGRESS) return;
        progress -= stepLength;
    }

    /**
     * Set the progress on the item
     * @param uint16_t progress for the item
     */
    void setProgress(uint16_t value) override {
        if (progress < MIN_PROGRESS || progress > MAX_PROGRESS) return;
        progress = value;
    }

    /**
     * Return the progress
     */
    uint16_t getItemIndex() override { return progress; }

    /**
     * Return the callback
     */
    fptrInt getCallbackInt() override { return callback; }

    /**
     * @brief Returns the value to be displayed.
     *        If there's no mapping, it returns the progress
     *        else it returns the mapped progress
     *
     * @return A pointer to the value of the current list item.
     */
    char* getValue() override {
        if (mapping == NULL) {
            static char buf[6];
            itoa(progress, buf, 10);
            return buf;
        } else {
            return mapping(progress);
        }
    }
};

#define ITEM_PROGRESS(...) (new ItemProgress(__VA_ARGS__))

#endif  // ItemProgress_H

ItemProgress.h

/**
 * ---
 *
 * # ItemSubMenu
 *
 * This item type indicates that the current item contains a sub menu.
 * The sub menu is opened when `enter()` is invoked.
 */

#ifndef ItemSubMenu_H
#define ItemSubMenu_H
#include "MenuItem.h"

class ItemSubMenu : public ItemHeader {
   public:
    /**
     * @param text text to display for the item
     * @param parent the parent of the sub menu item
     */
    ItemSubMenu(const char* text, MenuItem** parent)
        : ItemHeader(text, parent, MENU_ITEM_SUB_MENU) {}
};

#define ITEM_SUBMENU(...) (new ItemSubMenu(__VA_ARGS__))

#endif


ItemSubMenu.h

/**
 * ---
 *
 * # ItemToggle
 *
 * This item type indicates that the current item is **toggleable**.
 * When `enter()` is invoked, the state of `isOn` is toggled.
 */

#ifndef ItemToggle_H
#define ItemToggle_H
#include "MenuItem.h"

class ItemToggle : public MenuItem {
   private:
    bool enabled = false;
    const char* textOn = NULL;
    const char* textOff = NULL;
    fptrInt callback = NULL;

   public:
    /**
     * @param key key of the item
     * @param callback reference to callback function
     */
    ItemToggle(const char* key, fptrInt callback)
        : ItemToggle(key, "ON", "OFF", callback) {}

    /**
     * @brief Create an ItemToggle object.
     * @param key key of the item
     * @param textOn display text when ON
     * @param textOff display text when OFF
     * @param callback reference to callback function
     */
    ItemToggle(const char* key, const char* textOn, const char* textOff,
               fptrInt callback)
        : MenuItem(key, MENU_ITEM_TOGGLE),
          textOn(textOn),
          textOff(textOff),
          callback(callback) {}

    /**
     * @brief Get the integer callback function of this item.
     * @return the integer callback function
     */
    fptrInt getCallbackInt() override { return callback; }

    /**
     * @brief Get the current state of this toggle item.
     * @return the current state
     */
    boolean isOn() override { return enabled; }

    /**
     * @brief Set the current state of this toggle item.
     * @param isOn the new state
     */
    void setIsOn(boolean isOn) override { this->enabled = isOn; }

    const char* getTextOn() override { return this->textOn; }

    const char* getTextOff() override { return this->textOff; }
};

#define ITEM_TOGGLE(...) (new ItemToggle(__VA_ARGS__))

#endif

ItemToggle.h

LcdMenu.h

/*
  MenuItem.h - MenuItem declaration and definition

  MIT License

  Copyright (c) 2020-2023 Forntoh Thomas

  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.
*/

#ifndef MenuItem_H
#define MenuItem_H

#include "constants.h"

/**
 * The MenuItem class
 */
class MenuItem {
   protected:
    const char* text = NULL;
    byte type = MENU_ITEM_NONE;

   public:
    MenuItem(const char* text) : text(text) {}
    MenuItem(const char* text, byte type) : text(text), type(type) {}
    /**
     * ## Getters
     */

    /**
     * `Boolean` state of the item *(either ON or OFF)*
     */
    virtual boolean isOn() { return false; }
    /**
     * String value of an `ItemInput`
     */
    virtual char* getValue() { return NULL; }
    /**
     * Get the text of the item
     * @return `String` - Item's text
     */
    virtual const char* getText() { return text; }
    /**
     * Get the callback of the item
     * @return `ftpr` - Item's callback
     */
    virtual fptr getCallback() { return NULL; }
    /**
     * Get the callback of the item
     * @return `fptrInt` - Item's callback
     */
    virtual fptrInt getCallbackInt() { return NULL; }
    /**
     * Get the callback of the item
     * @return `fptrStr` - Item's callback
     */
    virtual fptrStr getCallbackStr() { return NULL; }
    /**
     * Get the sub menu at item
     * @return `MenuItem*` - Submenu at item
     */
    virtual MenuItem** getSubMenu() { return NULL; }
    /**
     * Get the type of the item
     * @return `byte` - type of menu item
     */
    byte getType() { return type; }
    /**
     * Get the text when toggle is ON
     * @return `String` - ON text
     */
    virtual const char* getTextOn() { return NULL; }
    /**
     * Get the text when toggle is OFF
     * @return `String` - OFF text
     */
    virtual const char* getTextOff() { return NULL; }
    /**
     * Current index of list for `ItemList`
     */
    virtual uint16_t getItemIndex() { return 0; }
    /**
     * Number of items in the list for `ItemList`
     */
    virtual uint8_t getItemCount() { return 0; };
    /**
     * Get the list of items
     * @return `String*` - List of items
     */
    virtual String* getItems() { return NULL; }
    /**
     * @brief Increments the progress of the list.
     */
    virtual void increment(){};
    /**
     * @brief Decrements the progress of the list.
     */
    virtual void decrement(){};
    /**
     * ## Setters
     */

    /**
     * `Boolean` state of the item *(either ON or OFF)*
     */
    virtual void setIsOn(boolean isOn){};
    /**
     * String value of an `ItemInput`
     */
    virtual void setValue(char* value){};
    /**
     * Set the text of the item
     * @param text text to display for the item
     */
    void setText(const char* text) { this->text = text; };
    /**
     * Set the callback on the item
     * @param callback reference to callback function
     */
    virtual void setCallBack(fptr callback){};
    /**
     * Current index of list for `ItemList`
     */
    virtual void setItemIndex(uint16_t itemIndex){};
    /**
     * Set the progress on the item
     * @param uint16_t progress for the item
     */
    virtual void setProgress(uint16_t value){};

    /**
     * Operators
     */

    /**
     * Get item at index from the submenu
     * @param index for the item
     */
    virtual MenuItem* operator[](const uint8_t index) { return NULL; };
};
#define ITEM_BASIC(...) (new MenuItem(__VA_ARGS__))

/**
 *
 * # ItemHeader
 *
 * This item must be present at the all menus collections *(the first item in
 * the array)*.
 *
 * **Example**
 *
 * ```cpp
 * MenuItem mainMenu[] = {ItemHeader(),
 *                        MenuItem("Item 1"),
 *                        MenuItem("Item 2"),
 *                        ...
 * ```
 */

class ItemHeader : public MenuItem {
   protected:
    MenuItem** parent = NULL;

    ItemHeader(const char* text, MenuItem** parent, byte type)
        : MenuItem(text, type), parent(parent) {}

   public:
    /**
     */
    ItemHeader() : ItemHeader("", NULL, MENU_ITEM_MAIN_MENU_HEADER) {}
    /**
     * @param parent the parent menu item
     */
    ItemHeader(MenuItem** parent)
        : ItemHeader("", parent, MENU_ITEM_SUB_MENU_HEADER) {}

    MenuItem** getSubMenu() override { return this->parent; };

    MenuItem* operator[](const uint8_t index) override {
        return getSubMenu()[index];
    }
};

/**
 * ---
 *
 * # ItemFooter
 *
 * This item must be present at the all menus *(the last item in the array)*
 *
 * **Example**
 *
 * ```cpp
 * MenuItem mainMenu[] = {ItemHeader(),
 *                        MenuItem("Item 1"),
 *                        MenuItem("Item 2"),
 *                        ...
 *                        ItemFooter()};
 * ```
 */

class ItemFooter : public MenuItem {
   public:
    /**
     */
    ItemFooter() : MenuItem(NULL, MENU_ITEM_END_OF_MENU) {}
};

#define MAIN_MENU(...)           \
    extern MenuItem* mainMenu[]; \
    MenuItem* mainMenu[] = {new ItemHeader(), __VA_ARGS__, new ItemFooter()}

#define SUB_MENU(subMenu, parent, ...)                          \
    MenuItem* subMenu[] = {new ItemHeader(parent), __VA_ARGS__, \
                           new ItemFooter()}

#endif

MenuItem.h

#pragma once
//#include <Arduino.h>

#ifdef MenuItem_H
/**
 * Processes the given command on the LcdMenu object.
 *
 * @param menu The LcdMenu object on which the command is to be processed.
 * @param cmd The command to be processed.
 * @param upCmd The command for moving up in the menu.
 * @param downCmd The command for moving down in the menu.
 * @param enterCmd The command for entering/editing a value.
 * @param backCmd The command for going back in the menu.
 * @param leftCmd The command for moving left in the menu.
 * @param rightCmd The command for moving right in the menu.
 *
 * @return true if the command is consumed, false otherwise.
 *
 * @throws None
 */
bool processCommand(LcdMenu& menu, byte cmd, byte upCmd, byte downCmd,
                    byte enterCmd, byte backCmd, byte leftCmd, byte rightCmd) {
    if (cmd == upCmd) {
        menu.up();
    } else if (cmd == downCmd) {
        menu.down();
    } else if (cmd == leftCmd) {
        menu.left();
    } else if (cmd == rightCmd) {
        menu.right();
    } else if (cmd == enterCmd) {
        menu.enter();
    } else if (cmd == backCmd) {
        menu.back();
    } else {
        return false;
    }
    return true;
}
#endif

#if defined(MenuItem_H) && !defined(ItemInput_H)
/**
 * @brief Process general menu navigation commands for the LCD menu.
 *
 * This function interprets the provided command and performs corresponding
 * actions on the given LCD menu for general navigation purposes.
 *
 * @param menu      The LcdMenu instance representing the LCD menu.
 * @param cmd       The byte value representing the input command to be
 *                  processed.
 * @param upCmd     The byte value representing the command for moving up in the
 *                  menu.
 * @param downCmd   The byte value representing the command for moving down in
 *                  the menu.
 * @param enterCmd  The byte value representing the command for entering a menu
 *                  item or mode.
 * @param backCmd   The byte value representing the command for going back in
 *                  the menu.
 * @param leftCmd   The optional byte value representing the command for moving
 *                  left in the menu.
 * @param rightCmd  The optional byte value representing the command for moving
 *                  right in the menu.
 * @return          `true` if the command is consumed, `false` otherwise.
 */
bool processMenuCommand(LcdMenu& menu, byte cmd, byte upCmd, byte downCmd,
                        byte enterCmd, byte backCmd, byte leftCmd = 255,
                        byte rightCmd = 255) {
    return processCommand(menu, cmd, upCmd, downCmd, enterCmd, backCmd, leftCmd,
                          rightCmd);
}
#endif

#ifdef ItemInput_H
/**
 * @brief Process input commands for menu with ItemInput using a charset.
 *
 * This function interprets the provided command and performs corresponding
 * actions on the given LCD menu in the context of an ItemInput type.
 *
 * @param menu         The LcdMenu instance representing the LCD menu.
 * @param cmd          The byte value representing the input command to be
 *                     processed.
 * @param pos          The reference to an int8_t variable storing the current
 *                     position in the charset when in edit mode.
 * @param charset      The pointer to a constant character array representing
 *                     the charset.
 * @param size         The size of the charset.
 * @param upCmd        The byte value representing the command for moving up in
 *                     the menu.
 * @param downCmd      The byte value representing the command for
 *                     moving down in the menu.
 * @param enterCmd     The byte value representing the command for
 *                     entering/editing a value.
 * @param backCmd      The byte value representing the command for going back in
 *                     the menu.
 * @param clearCmd     The optional byte value representing the command for
 *                     clearing the value.
 * @param backspaceCmd The optional byte value representing the command for
 *                     backspacing.
 * @param leftCmd      The optional byte value representing the command for
 *                     moving left in the menu.
 * @param rightCmd     The optional byte value representing the command for
 *                     moving right in the menu.
 * @return             `true` if the command is consumed, `false` otherwise.
 */
bool processMenuCommand(LcdMenu& menu, byte cmd, int8_t& pos,
                        const char* charset, uint8_t size, byte upCmd,
                        byte downCmd, byte enterCmd, byte backCmd,
                        byte clearCmd = 255, byte backspaceCmd = 255,
                        byte leftCmd = 255, byte rightCmd = 255) {
    if (cmd == upCmd) {
        if (menu.isInEditMode()) pos = (pos + 1) % size;
        // Works only in edit mode
        menu.drawChar(charset[pos]);
        menu.up();
    } else if (cmd == downCmd) {
        if (menu.isInEditMode()) pos = constrain(pos - 1, 0, size);
        menu.drawChar(charset[pos]);
        menu.down();
    } else if (cmd == leftCmd) {
        menu.left();
    } else if (cmd == rightCmd) {
        menu.right();
    } else if (cmd == enterCmd) {
        if (pos != -1) menu.type(charset[pos]);
        pos = -1;
        menu.enter();
    } else if (cmd == backCmd) {
        pos = -1;
        menu.back();
    } else if (cmd == clearCmd) {
        pos = -1;
        menu.clear();
    } else if (cmd == backspaceCmd) {
        pos = -1;
        menu.backspace();
    } else {
        return false;
    }
    return true;
}

/**
 * @brief Process input commands for a menu with ItemInput.
 *
 * This function interprets the provided command and performs corresponding
 * actions on the given LCD menu in the context of an ItemInput type.
 *
 * @param menu         The LcdMenu instance representing the LCD menu.
 * @param cmd          The byte value representing the input command to be
 *                     processed.
 * @param upCmd        The byte value representing the command for moving up in
 *                     the menu.
 * @param downCmd      The byte value representing the command for
 *                     moving down in the menu.
 * @param leftCmd      The byte value representing the command for
 *                     moving left in the menu.
 * @param rightCmd     The byte value representing the command for
 *                     moving right in the menu.
 * @param enterCmd     The byte value representing the command for
 *                     entering/editing a value.
 * @param backCmd      The byte value representing the command for going back in
 *                     the menu.
 * @param clearCmd     The optional byte value representing the command for
 *                     clearing the value.
 * @param backspaceCmd The optional byte value representing the command for
 *                     backspacing.
 * @return             `true` if the command is consumed, `false` otherwise.
 */
bool processMenuCommand(LcdMenu& menu, byte cmd, byte upCmd, byte downCmd,
                        byte leftCmd, byte rightCmd, byte enterCmd,
                        byte backCmd, byte clearCmd = 255,
                        byte backspaceCmd = 255) {
    if (!processCommand(menu, cmd, upCmd, downCmd, enterCmd, backCmd, leftCmd,
                        rightCmd)) {
        if (cmd == clearCmd)
            menu.clear();
        else if (cmd == backspaceCmd)  // Remove one character from the tail
            menu.backspace();
        else if (cmd != '\n')  // Type the character you want
            menu.type(cmd);
        else
            return false;
    }
    return true;
}
#endif

commandProccesors.h

#pragma once
//#include <Arduino.h>

typedef void (*fptr)();
typedef void (*fptrInt)(uint16_t);
typedef void (*fptrStr)(char*);
typedef char* (*fptrMapping)(uint16_t);
//
// menu item types
//
const byte MENU_ITEM_MAIN_MENU_HEADER = 1;
const byte MENU_ITEM_SUB_MENU_HEADER = 2;
const byte MENU_ITEM_SUB_MENU = 3;
const byte MENU_ITEM_COMMAND = 4;
const byte MENU_ITEM_INPUT = 5;
const byte MENU_ITEM_NONE = 6;
const byte MENU_ITEM_TOGGLE = 7;
const byte MENU_ITEM_END_OF_MENU = 8;
const byte MENU_ITEM_LIST = 9;
const byte MENU_ITEM_PROGRESS = 10;
//
#define MIN_PROGRESS 0
#define MAX_PROGRESS 1000

constants.h

#include "utils.h"
#include "constants.h"

void substring(char* str, uint8_t start, uint8_t size, char* substr) {
    strncpy(substr, str + start, size);
    substr[size] = '\0';
}

void concat(const char* first, char second, const char* third, char* result) {
    size_t len1 = strlen(first);
    size_t len3 = strlen(third);

    memcpy(result, first, len1);
    result[len1] = second;
    memcpy(result + len1 + 1, third, len3);
    result[len1 + 1 + len3] = '\0';
}

void concat(const char* first, char second, char* result) {
    size_t len1 = strlen(first);
    memcpy(result, first, len1);
    result[len1] = second;
    result[len1 + 1] = '\0';
}

void concat(const char* first, const char* second, char* result) {
    strcpy(result, first);
    strcat(result, second);
}

void remove(char* str, uint8_t index, uint8_t count) {
    uint8_t len = strlen(str);
    if (index + count > len) {
        count = len - index;
    }
    memmove(str + index, str + index + count, len - count - index + 1);
}

long mapProgress(uint16_t progress, long minValue, long maxValue) {
    // Map the progress value to a new range (minValue to maxValue)
    return map(progress, MIN_PROGRESS, MAX_PROGRESS, minValue, maxValue);
}

float mapProgress(uint16_t progress, float minValue, float maxValue) {
    // Normalize the progress value and map it to the specified floating-point
    // range
    return static_cast<float>(progress) / MAX_PROGRESS * (maxValue - minValue) +
           minValue;
}

void printCmd(const __FlashStringHelper* command) {
    Serial.print(F("#CMD# "));
    Serial.println(command);
}

void printCmd(const __FlashStringHelper* command, const char value) {
    Serial.print(F("#CMD# "));
    Serial.print(command);
    Serial.print(F("="));
    Serial.println(value);
}

void printCmd(const __FlashStringHelper* command, const uint8_t value) {
    Serial.print(F("#CMD# "));
    Serial.print(command);
    Serial.print(F("="));
    Serial.println(value, DEC);
}

void printCmd(const __FlashStringHelper* command, const char* value) {
    Serial.print(F("#CMD# "));
    Serial.print(command);
    Serial.print(F("="));
    Serial.println(value);
}


utils.cpp

#ifndef MenuUtils_H
#define MenuUtils_H

#include <Arduino.h>

void substring(char* str, uint8_t start, uint8_t size, char* substr);

void concat(const char* first, char second, const char* third, char* result);

void concat(const char* first, char second, char* result);

void concat(const char* first, const char* second, char* result);

void remove(char* str, uint8_t index, uint8_t count);

long mapProgress(uint16_t progress, long minValue, long maxValue);

float mapProgress(uint16_t progress, float minValue, float maxValue);

void printCmd(const __FlashStringHelper* command);

void printCmd(const __FlashStringHelper* command, const char value);

void printCmd(const __FlashStringHelper* command, const uint8_t value);

void printCmd(const __FlashStringHelper* command, const char* value);

#endif