#include <Wire.h>
#include <SPI.h>
#include <Arduino.h>
#include "OutputPin.h"
#include "Display.h"
#include "Power.h"
#include "Storage.h"
#include "KeyFrame.h"
#include "Animation.h"

// #define EB_FAST 30     // таймаут быстрого поворота, мс
// #define EB_DEB 30      // дебаунс кнопки, мс
// #define EB_HOLD 1000   // таймаут удержания кнопки, мс
// #define EB_STEP 200    // период срабатывания степ, мс
// #define EB_CLICK 400   // таймаут накликивания, мс

#include "EncButton.h"

#define CALIBRATION false
#define DEFAULT_VOLTAGE_READ_DELAY 10000

Display display{};

Power power;

Storage storage;

unsigned long lastVoltageRead = 0;
unsigned long lastFPSUpdate = 0;
unsigned long lastFPSDisplay = 0;
unsigned int readVoltageDelay = DEFAULT_VOLTAGE_READ_DELAY;

struct {
    EncButton<EB_TICK, 2> vape;
    EncButton<EB_TICK, 3> set;
    EncButton<EB_TICK, 4> down;
    EncButton<EB_TICK, 5> up;
} buttons;

struct {
    OutputPin led{LED_BUILTIN};
    OutputPin vibro{PIN_A1};
} pins;

KeyFrame keyFrames[]{
    {"VAPE!!", 666},
    {"vape!!", 666}
};

struct {
    Animation vaping = Animation(keyFrames, (sizeof(keyFrames) / sizeof(keyFrames[0])), true);
} animations;

void setup() {
    Serial.begin(9600);
    display.init();
    storage.readData();
    power.setVoltageConst(storage.data.voltsConst);
}

bool menuMode = false;
bool vapeMode = false;
unsigned long vapeStartTime;
int maxVapeTime = 10000;
bool isActionChanged = true;

void loop() {
    buttons.vape.tick();
    // if (millis() - lastFPSUpdate > 1000 || lastFPSUpdate == 0) {
        // display.frames = 0;
        // lastFPSUpdate = millis();
    // }
    if (millis() - lastVoltageRead > readVoltageDelay || lastVoltageRead == 0) {
        int voltage = power.readBatteryVoltage();
        Serial.println(voltage);
        lastVoltageRead = millis();
        display.printHeader(power.percentage);
//        display.printFooter("Volts:" + power.readableVoltage);
    }
    if (vapeMode) {
        vapeAction();
    } else if (menuMode) {
        menuAction();
    } else {
        defaultAction();
    }
    display.update();

    // if (millis() - lastFPSDisplay > 250 || lastFPSDisplay == 0) {
    //    display.printFps();
        // lastFPSDisplay = millis();
    // }
}

void defaultAction() {
    if (isActionChanged) {
        Serial.println("Default mode enabled");
    }
    pins.led.disable();
    pins.vibro.disable();
    display.println("DEFAULT");
    readVoltageDelay = DEFAULT_VOLTAGE_READ_DELAY;
    isActionChanged = false;
    if (buttons.vape.isHolded()) {
        vapeMode = true;
        isActionChanged = true;
    } else if (buttons.vape.hasClicks(2)) {
        menuMode = true;
        isActionChanged = true;
    }
}

void vapeAction() {
    if (isActionChanged) {
        Serial.println("Vape mode enabled");
        vapeStartTime = millis();
    }
    pins.led.enable();
    pins.vibro.enable();
    display.playAnimation(animations.vaping);
    readVoltageDelay = 1000;
    isActionChanged = false;
    bool expired = millis() - vapeStartTime >= maxVapeTime;
    Serial.println(millis() - vapeStartTime);
    if (expired || buttons.vape.isRelease()) {
        vapeMode = false;
        isActionChanged = true;
    }
}

void menuAction() {
    if (isActionChanged) {
        Serial.println("Menu mode enabled");
    }
    pins.led.disable();
    pins.vibro.disable();
    display.println("MENU");
    readVoltageDelay = DEFAULT_VOLTAGE_READ_DELAY;
    isActionChanged = false;
    if (buttons.vape.hasClicks(3)) {
        menuMode = false;
        isActionChanged = true;
    }
}

sketch.ino

diagram.json

#ifndef INFINITUM_PIN_H
#define INFINITUM_PIN_H

#include <Arduino.h>

class Pin {
private:
    uint8_t pin;
public:
    bool isDigital;

    explicit Pin(uint8_t pin, uint8_t mode = INPUT, bool isDigital = true);

    void setMode(uint8_t mode);

    void setPin(uint8_t newPin);

    uint8_t getPin();
};


#endif //INFINITUM_PIN_H


Pin.h

#ifndef INFINITUM_INPUTPIN_H
#define INFINITUM_INPUTPIN_H

#include "Pin.h"

class InputPin : Pin {
public:
    explicit InputPin(uint8_t pin, uint8_t mode = INPUT, bool isDigital = true);

    bool read();

    int readValue();
};


#endif //INFINITUM_INPUTPIN_H


InputPin.h

#ifndef INFINITUM_OUTPUTPIN_H
#define INFINITUM_OUTPUTPIN_H

#include "Pin.h"

class OutputPin : public Pin {
public:
    bool isEnabled = false;

    explicit OutputPin(uint8_t pin, bool isDigital = true);

    virtual void enable();

    virtual void disable();
};

#endif //INFINITUM_OUTPUTPIN_H


OutputPin.h

#ifndef INFINITUM_POWER_H
#define INFINITUM_POWER_H

#include <Arduino.h>

#define MIN_BATTERY_VOLTAGE 3.0

class Power {
private:
    int oldBatteryVoltage = 0;
    int batteryVoltage = 0;
    int filteredBatteryVoltage = 0;
    float filterK = 0.04;
    float voltageConstant = 1.068421052;
public:
    String readableVoltage;

    int percentage;

    int maxVoltage = 5200;

    int getBatteryVoltage();

    int getFilteredBatteryVoltage();

    int readBatteryVoltage();

    bool isBatteryCharged();

    int filterVolts(int volts);

    int filterWatts(int watts, float ohms);

    int getPWM(int volts);

    void setVoltageConst(float voltageConst);
};


#endif //INFINITUM_POWER_H


Power.h

#ifndef INFINITUM_STORAGE_H
#define INFINITUM_STORAGE_H
// #include "EEPROMex.h"

class Storage {
public:
    struct {
        int volts;
        int watts;
        float ohms;
        float voltsConst = 1.1;
    } data;

    void readData();

    void writeData();
};


#endif //INFINITUM_STORAGE_H


Storage.h

#include "Pin.h"

Pin::Pin(uint8_t pin, uint8_t mode, bool isDigital) {
    this->pin = pin;
    pinMode(pin, mode);
}

void Pin::setMode(uint8_t mode) {
    pinMode(this->pin, mode);
}

void Pin::setPin(uint8_t newPin) {
    this->pin = newPin;
}

uint8_t Pin::getPin() {
    return this->pin;
}


Pin.cpp

#include "InputPin.h"

InputPin::InputPin(uint8_t pin, uint8_t mode, bool isDigital) : Pin(pin, mode, isDigital) {}

bool InputPin::read() {
    return digitalRead(this->getPin());
}

int InputPin::readValue() {
    return analogRead(this->getPin());
}


InputPin.cpp

#include "OutputPin.h"

OutputPin::OutputPin(uint8_t pin, bool isDigital) : Pin(pin, OUTPUT, isDigital) {}

void OutputPin::enable() {
    if (!this->isEnabled) {
        if (this->isDigital) {
            digitalWrite(this->getPin(), HIGH);
        } else {
            analogWrite(this->getPin(), 255);
        }
        this->isEnabled = true;
    }
}

void OutputPin::disable() {
    if (this->isEnabled) {
        if (this->isDigital) {
            digitalWrite(this->getPin(), LOW);
        } else {
            analogWrite(this->getPin(), 0);
        }
        this->isEnabled = false;
    }
}


OutputPin.cpp

#include "Storage.h"

void Storage::readData() {
    // EEPROM.readBlock(0, this->data);
}

void Storage::writeData() {
    // EEPROM.writeBlock(0, this->data);
}

Storage.cpp

#include "Power.h"

int Power::getBatteryVoltage() {
    return this->batteryVoltage;
}

int Power::getFilteredBatteryVoltage() {
    return this->filteredBatteryVoltage;
}

int Power::readBatteryVoltage() {
    int voltage = random(5040, 5080);

    this->batteryVoltage = voltage;
    this->readableVoltage = String(voltage / 1000.0);
    this->percentage = min((int) ((voltage / (float) this->maxVoltage) * 100), 100);
    return voltage;
}

bool Power::isBatteryCharged() {
    this->batteryVoltage = readBatteryVoltage();
    this->filteredBatteryVoltage =
            this->filterK * this->batteryVoltage + (1 - this->filterK) * this->oldBatteryVoltage;  // фильтруем
    this->oldBatteryVoltage = this->filteredBatteryVoltage;                                // фильтруем
    return this->filteredBatteryVoltage < MIN_BATTERY_VOLTAGE * 1000;
}

int Power::filterVolts(int volts) {
    return min(volts, this->filteredBatteryVoltage);
}

int Power::filterWatts(int watts, float ohms) {
    byte maxW = sq((float) this->filteredBatteryVoltage / 1000) / ohms;
    return min(watts, maxW);
}

int Power::getPWM(int volts) {
    return (float) volts / this->filteredBatteryVoltage * 1024;
}

void Power::setVoltageConst(float voltageConst) {
    this->voltageConstant = voltageConst;
}


Power.cpp

#ifndef INFINITUM_DISPLAY_H
#define INFINITUM_DISPLAY_H

#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include "KeyFrame.h"
#include "Animation.h"

#define OLED_RESET 4
#define SCREEN_ADDRESS 0x3C
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32

class Display {
private:
    Adafruit_SSD1306 display{OLED_RESET};
    String oldBody;
    String oldFooter;
    int oldPercentage;
public:
    bool hasChanges = false;

    unsigned int frames = 0;

    bool init();

    void enable();

    void disable();

    void println(const String& text);

    void printHeader(int percentage, bool printPercentage = false);

    void printFooter(const String& text);

    void playAnimation(Animation &animation);

    void printFps();

    uint8_t centerStartPos(const String& text, int textSize = 1);

    void clear();

    void update();
};


#endif //INFINITUM_DISPLAY_H


Display.h

#include "Display.h"

void Display::enable() {
    this->display.ssd1306_command(SSD1306_DISPLAYON);
}

void Display::disable() {
    this->display.ssd1306_command(SSD1306_DISPLAYOFF);
}

uint8_t Display::centerStartPos(const String &text, int textSize) {
    return (SCREEN_WIDTH - 6 * text.length() * textSize) / 2;
}

void Display::printHeader(int percentage, bool printPercentage) {
    if (percentage == this->oldPercentage) {
        return;
    } else {
        this->hasChanges = true;
    }
    this->display.fillRect(49, 0, SCREEN_WIDTH, 8, BLACK);
    this->display.fillRect(SCREEN_WIDTH - 13, 0, 12, 1, WHITE);
    this->display.fillRect(SCREEN_WIDTH - 13, 7, 12, 1, WHITE);
    this->display.fillRect(SCREEN_WIDTH - 2, 1, 1, 6, WHITE);
    this->display.fillRect(SCREEN_WIDTH - 14, 1, 1, 6, WHITE);
    for (int i = 0; percentage > 0 && i <= percentage / 20; i++) {
        this->display.fillRect(SCREEN_WIDTH - 12 + (i * 2), 2, 1, 4, WHITE);
    }
    if (printPercentage) {
        String text = String(percentage) + "%";
        uint8_t startPos = SCREEN_WIDTH - (text.length() * 6) - 15;
        this->display.setCursor(startPos, 0);
        this->display.setTextSize(1);
        this->display.setTextColor(WHITE);
        this->display.println(text);
    }   
}

void Display::printFooter(const String &text) {
    if (text == this->oldFooter) {
        return;
    } else {
        this->hasChanges = true;
    }
    this->display.fillRect(0, 24, SCREEN_WIDTH, 8, BLACK);
    uint8_t startPos = this->centerStartPos(text, 1);
    this->display.setCursor(startPos, 24);
    this->display.setTextSize(1);
    this->display.setTextColor(WHITE);
    this->display.println(text);
}

void Display::println(const String &text) {
    if (text == this->oldBody) {
        return;
    } else {
        this->hasChanges = true;
    }
    oldBody = text;
    this->display.fillRect(0, 8, SCREEN_WIDTH, 16, BLACK);
    int textSize = text.length() > 10 ? 1 : 2;
    uint8_t startPos = this->centerStartPos(text, textSize);
    this->display.setTextSize(textSize);
    this->display.setTextColor(WHITE);
    this->display.setCursor(startPos, 8);
    this->display.println(text);

}

void Display::clear() {
    this->display.clearDisplay();
}

void Display::update() {
    if (this->hasChanges) {
        this->frames++;
        this->display.display();
        this->hasChanges = false;
    }
}

bool Display::init() {
    bool result = this->display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS); 
    if (result) {
        this->display.clearDisplay();
    }   
    return result;
}

void Display::printFps() {
    this->display.fillRect(0, 0, 48, 8, BLACK);
    this->display.setCursor(0, 0);
    this->display.setTextSize(1);
    this->display.setTextColor(WHITE);
    this->display.println("FPS:" + String(this->frames));
    this->display.display();
}

void Display::playAnimation(Animation &animation) {
    if (animation.isReady()) {
        KeyFrame frame = animation.getFrame();
        this->println(frame.text);
    } 
}


Display.cpp

#ifndef EncButton_h
#define EncButton_h

// =========== НАСТРОЙКИ (можно передефайнить из скетча) ============
#define _EB_FAST 30     // таймаут быстрого поворота
#define _EB_DEB 80      // дебаунс кнопки
#define _EB_HOLD 1000   // таймаут удержания кнопки
#define _EB_STEP 500    // период срабатывания степ
#define _EB_CLICK 400	// таймаут накликивания

// =========== НЕ ТРОГАЙ ============
#include <Arduino.h>

// флаг макро
#define _setFlag(x) (flags |= 1 << x)
#define _clrFlag(x) (flags &= ~(1 << x))
#define _readFlag(x) ((flags >> x) & 1)

#ifndef EB_FAST
#define EB_FAST _EB_FAST
#endif
#ifndef EB_DEB
#define EB_DEB _EB_DEB
#endif
#ifndef EB_HOLD
#define EB_HOLD _EB_HOLD
#endif
#ifndef EB_STEP
#define EB_STEP _EB_STEP
#endif
#ifndef EB_CLICK
#define EB_CLICK _EB_CLICK
#endif

enum eb_callback {
    TURN_HANDLER,
    RIGHT_HANDLER,
    LEFT_HANDLER,
    RIGHT_H_HANDLER,
    LEFT_H_HANDLER,
    CLICK_HANDLER,
    HOLDED_HANDLER,
    STEP_HANDLER,
    HOLD_HANDLER,
    CLICKS_HANDLER,
    PRESS_HANDLER,
    RELEASE_HANDLER,
};

// константы
#define EB_TICK 0
#define EB_CALLBACK 1

#define EB_NO_PIN 255

#define VIRT_ENC 254
#define VIRT_ENCBTN 253
#define VIRT_BTN 252

// класс
template < uint8_t _EB_MODE, uint8_t _S1 = EB_NO_PIN, uint8_t _S2 = EB_NO_PIN, uint8_t _KEY = EB_NO_PIN >
class EncButton {
public:
    // можно указать режим работы пина
    EncButton(const uint8_t mode = INPUT_PULLUP) {
        if (_S1 < 252 && mode == INPUT_PULLUP) pullUp();
    }
    
    // подтянуть пины внутренней подтяжкой
    void pullUp() {
        if (_S1 < 252) {                    // реальное устройство
            if (_S2 == EB_NO_PIN) {         // обычная кнопка
                pinMode(_S1, INPUT_PULLUP);
            } else if (_KEY == EB_NO_PIN) { // энк без кнопки
                pinMode(_S1, INPUT_PULLUP);
                pinMode(_S2, INPUT_PULLUP);
            } else {                        // энк с кнопкой
                pinMode(_S1, INPUT_PULLUP);
                pinMode(_S2, INPUT_PULLUP);
                pinMode(_KEY, INPUT_PULLUP);
            }
        }
    }
    
    // установить таймаут удержания кнопки для isHold(), мс (до 30 000)
    void setHoldTimeout(int tout) {
        _holdT = tout >> 7;
    }
    
    // виртуально зажать кнопку энкодера
    void holdEncButton(bool state) {
        if (state) _setFlag(7);
        else _clrFlag(7);
    }
    
    // тикер, вызывать как можно чаще или в прерывании
    // вернёт отличное от нуля значение, если произошло какое то событие
    uint8_t tick(uint8_t s1 = 0, uint8_t s2 = 0, uint8_t key = 0) {
        if (!_isrFlag) {
            _isrFlag = 1;
            
            // обработка энка (компилятор вырежет блок если не используется)
            // если объявлены два пина или выбран вирт. энкодер или энкодер с кнопкой
            if ((_S1 < 252 && _S2 < 252) || _S1 == VIRT_ENC || _S1 == VIRT_ENCBTN) {
                uint8_t state;
                if (_S1 >= 252) state = s1 | (s2 << 1);                 // получаем код
                else state = fastRead(_S1) | (fastRead(_S2) << 1);  // получаем код                
                poolEnc(state);
            }

            // обработка кнопки (компилятор вырежет блок если не используется)
            // если S2 не указан (кнопка) или указан KEY или выбран вирт. энкодер с кнопкой или кнопка
            if ((_S1 < 252 && _S2 == EB_NO_PIN) || _KEY != EB_NO_PIN || _S1 == VIRT_BTN || _S1 == VIRT_ENCBTN) {
                if (_S1 < 252 && _S2 == EB_NO_PIN) _btnState = !fastRead(_S1);    // обычная кнопка
                if (_KEY != EB_NO_PIN) _btnState = !fastRead(_KEY);               // энк с кнопкой
                if (_S1 == VIRT_BTN) _btnState = s1;                                // вирт кнопка
                if (_S1 == VIRT_ENCBTN) _btnState = key;                            // вирт энк с кнопкой
                poolBtn();           
            }
            
            if (_EB_MODE) {
                if (*_callback[0] && isTurn()) _callback[0]();
                switch (EBState) {
                case 1: if (*_callback[1]) _callback[1](); break;	// isRight			
                case 2: if (*_callback[2]) _callback[2](); break;	// isLeft			
                case 3: if (*_callback[3]) _callback[3](); break;	// isRightH			
                case 4: if (*_callback[4]) _callback[4](); break;	// isLeftH			
                case 5: if (*_callback[5]) _callback[5](); break;	// isClick			
                case 6: if (*_callback[6]) _callback[6](); break;	// isHolded			
                case 7: if (*_callback[7]) _callback[7](); break;	// isStep
                case 8: if (*_callback[11]) _callback[11](); break;	// isPress			
                case 9: if (*_callback[12]) _callback[12](); break;	// isRelease
                }
                EBState = 0;
                if (*_callback[8] && _readFlag(4)) _callback[8](); 	// isHold
                if (_readFlag(6)) {			
                    if (*_callback[9]) _callback[9]();				// clicks
                    if (*_callback[10] && clicks == _amount) _callback[10]();
                    _clrFlag(6);
                }		
            }
        }
        _isrFlag = 0;
        return EBState;
    }
    
    // подключить обработчик
    void attach(eb_callback type, void (*handler)()) {
        _callback[type] = *handler;
    }
    
    // отключить обработчик
    void detach(eb_callback type) {
        _callback[type] = NULL;
    }
    
    // подключить обработчик на количество кликов (может быть только один!)
    void attachClicks(uint8_t amount, void (*handler)()) {
        _amount = amount;
        _callback[10] = *handler;
    }
    
    // отключить обработчик на количество кликов
    void detachClicks() {
        _callback[10] = NULL;
    }
    
    // получить статус
    uint8_t getState() { return EBState; }
    
    // сбросить статус
    void resetState() { EBState = 0; }
    
    // поворот вправо
    bool isRight() { return _EB_MODE ? (_dir == 1 ? 1 : 0) : checkState(1); }
    bool right() { return isRight(); }
    
    // поворот влево
    bool isLeft() { return _EB_MODE ? (_dir == 2 ? 1 : 0) : checkState(2); }
    bool left() { return isLeft(); }
    
    // поворот вправо нажатый
    bool isRightH() { return _EB_MODE ? (_dir == 3 ? 1 : 0) : checkState(3); }
    bool rightH() { return isRightH(); }
    
    // поворот влево нажатый
    bool isLeftH() { return _EB_MODE ? (_dir == 4 ? 1 : 0) : checkState(4); }
    bool leftH() { return isLeftH(); }
    
    // быстрый поворот
    bool isFast() { return _readFlag(1); }
    bool fast() { return isFast(); }
    
    // энкодер повёрнут
    bool isTurn() {
        if (_readFlag(0)) {
            _clrFlag(0);
            return true;
        } return false;		
    }
    bool turn() { return isTurn(); }
    
    // кнопка нажата
    bool isPress() { return checkState(8); }
    bool press() { return isPress(); }
    
    // кнопка отпущена
    bool isRelease() { return checkState(9); }
    bool release() { return isRelease(); }
    
    // клик по кнопке
    bool isClick() { return checkState(5); }
    bool click() { return isClick(); }
    
    // кнопка удержана
    bool isHolded() { return checkState(6); }    
    
    // кнопка удержана (грамотный аналог holded =)
    bool isHeld() { return isHolded(); }
    bool held() { return isHolded(); }
    
    // кнопка удерживается
    bool isHold() { return _readFlag(4); }
    bool hold() { return isHold(); }
    
    // режим импульсного удержания
    bool isStep() { return checkState(7); }
    bool step() { return isStep(); }
    
    // статус кнопки
    bool state() { return !fastRead(_S1); }
    
    // имеются клики
    bool hasClicks(uint8_t numClicks) {
        if (clicks == numClicks && _readFlag(6)) {
            _clrFlag(6);
            return 1;
        }
        return 0;
    }
    
    // имеются клики
    uint8_t hasClicks() {
        if (_readFlag(6)) {
            _clrFlag(6);
            return clicks;
        } return 0;	
    }
    
    // счётчик энкодера
    int counter = 0;
    
    // счётчик кликов
    uint8_t clicks = 0;

private:
    bool fastRead(const uint8_t pin) {
#if defined(__AVR_ATmega328P__) || defined(__AVR_ATmega168__)
        if (pin < 8) return bitRead(PIND, pin);
        else if (pin < 14) return bitRead(PINB, pin - 8);
        else if (pin < 20) return bitRead(PINC, pin - 14);
#elif defined(__AVR_ATtiny85__) || defined(__AVR_ATtiny13__)
        return bitRead(PINB, pin);
#else
        return digitalRead(pin);
#endif
        return 0;
    }
    
    void poolEnc(uint8_t state) {
        if (_encRST && state == 0b11) {                             		// ресет и энк защёлкнул позицию
            if (_S2 == EB_NO_PIN || _KEY != EB_NO_PIN) {                    // энкодер с кнопкой
                if (!_readFlag(4)) {                                        // если кнопка не "удерживается"
                    if (_lastState == 0b10) EBState = (_btnState || _readFlag(7)) ? 3 : 1, counter++;
                    else if (_lastState == 0b01) EBState = (_btnState || _readFlag(7)) ? 4 : 2, counter--;
                }
            } else {                                                        // просто энкодер
                if (_lastState == 0b10) EBState = 1, counter++;
                else if (_lastState == 0b01) EBState = 2, counter--;
            }
            if (EBState > 0) {
                if (_EB_MODE) _dir = EBState;					
                if (millis() - _debTimer < EB_FAST) _setFlag(1);	// быстрый поворот
                else _clrFlag(1);						        // обычный поворот		
                if (EBState < 5) _setFlag(0);			        // флаг поворота для юзера
            }

            _encRST = 0;
            _debTimer = millis();
        }
        if (state == 0b00) _encRST = 1;
        _lastState = state;
    }
    
    void poolBtn() {
        uint32_t thisMls = millis();
        uint32_t debounce = thisMls - _debTimer;
        if (_btnState) {                                                	// кнопка нажата
            if (!_readFlag(3)) {                                          	// и не была нажата ранее
                if (debounce > EB_DEB) {                                   	// и прошел дебаунс
                    _setFlag(3);                                            // флаг кнопка была нажата
                    _debTimer = thisMls;                                    // сброс таймаутов
                    EBState = 8;                                           	// кнопка нажата
                }
                if (debounce > EB_CLICK) {									// кнопка нажата после EB_CLICK
                    clicks = 0;												// сбросить счётчик и флаг кликов
                    flags &= ~0b01100000;
                }
            } else {                                                      	// кнопка уже была нажата
                if (!_readFlag(4)) {                                        // и удержание ещё не зафиксировано
                    if (debounce < (_holdT << 7)) {                         // прошло меньше удержания
                        if (EBState != 0 && EBState != 8) _setFlag(2);      // но энкодер повёрнут! Запомнили
                    } else {                                                // прошло больше времени удержания
                        if (!_readFlag(2)) {                                // и энкодер не повёрнут
                            EBState = 6;                                   	// значит это удержание (сигнал)
                            _setFlag(4);                                    // запомнили что удерживается
                            _debTimer = thisMls;                            // сброс таймаута
                        }
                    }
                } else {                                                    // удержание зафиксировано
                    if (debounce > EB_STEP) {                              	// таймер степа
                        EBState = 7;                                       	// сигналим
                        _debTimer = thisMls;                                // сброс таймаута
                    }
                }
            }
        } else {                                                        	// кнопка не нажата
            if (_readFlag(3)) {                                           	// но была нажата
                if (debounce > EB_DEB && !_readFlag(4) && !_readFlag(2)) {	// энкодер не трогали и не удерживали - это клик
                    EBState = 5;
                    clicks++;
                } else EBState = 9;                                         // кнопка отпущена
                flags &= ~0b00011100;                                       // clear 2 3 4                    
                _debTimer = thisMls;                                        // сброс таймаута
            } else if (clicks > 0 && debounce > EB_CLICK && !_readFlag(5)) flags |= 0b01100000;	 // флаг на клики
        }
    }
    
    bool checkState(uint8_t val) {
        if (EBState == val) {
            EBState = 0;
            return 1;
        } return 0;
    }
    uint32_t _debTimer = 0;
    uint8_t _lastState = 0, EBState = 0;
    bool _btnState = 0, _encRST = 0, _isrFlag = 0;
    uint8_t flags = 0;
    uint8_t _holdT = EB_HOLD >> 7;

    uint8_t _dir = 0;
    void (*_callback[_EB_MODE ? 13 : 0])() = {};
    uint8_t _amount = 0;


    // flags
    // 0 - enc turn
    // 1 - enc fast
    // 2 - enc был поворот
    // 3 - флаг кнопки
    // 4 - hold
    // 5 - clicks flag
    // 6 - clicks get
    // 7 - enc button hold    

    // EBState
    // 0 - idle
    // 1 - right
    // 2 - left
    // 3 - rightH
    // 4 - leftH
    // 5 - click
    // 6 - holded
    // 7 - step
    // 8 - press
    // 9 - release
};

#endif

EncButton.h

#ifndef INFINITUM_ANIMATION_H
#define INFINITUM_ANIMATION_H

#include "KeyFrame.h";

class Animation {
private:
  byte position = 0;
  unsigned long nextTimeToPlay = 0;
public:
  KeyFrame *keyFrames;
  byte framesCount;
  bool isLoop;
  bool isAutoReverse;
  bool isEnded = false;

  Animation(KeyFrame keyFrames[], byte framesCount, bool isLoop = false, bool isAutoReverse = false);

  KeyFrame getFrame();

  bool isReady();
};


#endif //INFINITUM_ANIMATION_H


Animation.h

#include "Animation.h"

Animation::Animation(KeyFrame keyFrames[], byte framesCount, bool isLoop, bool isAutoReverse) {
  this->keyFrames = keyFrames;
  this->framesCount = framesCount;
  this->isLoop = isLoop;
  this->isAutoReverse = isAutoReverse;
}

KeyFrame Animation::getFrame() {
  byte oldPosition = this->position;
  if (!this->isEnded) {
    this->position++;
    if(this->position >= framesCount) {
      if (this->isLoop) {
        this->position = 0;
      } else {
        this->isEnded = true;
      }
    }
  }
  if (this->isEnded) {
    this->nextTimeToPlay = -1; 
  } else {
    this->nextTimeToPlay = millis() + this->keyFrames[position].delay; 
  }
  return this->keyFrames[oldPosition];
}

bool Animation::isReady() {
  return this->nextTimeToPlay < millis();
}



Animation.cpp

#ifndef INFINITUM_KEY_FRAME_H
#define INFINITUM_KEY_FRAME_H

#include <Arduino.h>

class KeyFrame {
private:
public:
String text;
  int delay;
  KeyFrame(String text, int delay = 0) {
    this->text = text;
    this->delay = delay;
  };
};


#endif //INFINITUM_KEY_FRAME_H


KeyFrame.h

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

# Automatically added based on includes:
Adafruit GFX Library
# ---
