firmware/src/input/RotaryEncoderInterruptBase.cpp

#include "RotaryEncoderInterruptBase.h"
#include "configuration.h"

RotaryEncoderInterruptBase::RotaryEncoderInterruptBase(const char *name) : concurrency::OSThread(name)
{
    this->_originName = name;
}

void RotaryEncoderInterruptBase::init(
    uint8_t pinA, uint8_t pinB, uint8_t pinPress, input_broker_event eventCw, input_broker_event eventCcw,
    input_broker_event eventPressed, input_broker_event eventPressedLong,
    //    std::function<void(void)> onIntA, std::function<void(void)> onIntB, std::function<void(void)> onIntPress) :
    void (*onIntA)(), void (*onIntB)(), void (*onIntPress)())
{
    this->_pinA = pinA;
    this->_pinB = pinB;
    this->_pinPress = pinPress;
    this->_eventCw = eventCw;
    this->_eventCcw = eventCcw;
    this->_eventPressed = eventPressed;
    this->_eventPressedLong = eventPressedLong;

    bool isRAK = false;
#ifdef RAK_4631
    isRAK = true;
#endif

    if (!isRAK || pinPress != 0) {
        pinMode(pinPress, INPUT_PULLUP);
        attachInterrupt(pinPress, onIntPress, CHANGE);
    }
    if (!isRAK || this->_pinA != 0) {
        pinMode(this->_pinA, INPUT_PULLUP);
        attachInterrupt(this->_pinA, onIntA, CHANGE);
    }
    if (!isRAK || this->_pinA != 0) {
        pinMode(this->_pinB, INPUT_PULLUP);
        attachInterrupt(this->_pinB, onIntB, CHANGE);
    }

    this->rotaryLevelA = digitalRead(this->_pinA);
    this->rotaryLevelB = digitalRead(this->_pinB);
    LOG_INFO("Rotary initialized (%d, %d, %d)", this->_pinA, this->_pinB, pinPress);
}

int32_t RotaryEncoderInterruptBase::runOnce()
{
    InputEvent e = {};
    e.inputEvent = INPUT_BROKER_NONE;
    e.source = this->_originName;
    unsigned long now = millis();

    // Handle press long/short detection
    if (this->action == ROTARY_ACTION_PRESSED) {
        bool buttonPressed = !digitalRead(_pinPress);
        if (!pressDetected && buttonPressed) {
            pressDetected = true;
            pressStartTime = now;
        }

        if (pressDetected) {
            uint32_t duration = now - pressStartTime;
            if (!buttonPressed) {
                // released -> if short press, send short, else already sent long
                if (duration < LONG_PRESS_DURATION && now - lastPressKeyTime >= pressDebounceMs) {
                    lastPressKeyTime = now;
                    LOG_DEBUG("Rotary event Press short");
                    e.inputEvent = this->_eventPressed;
                }
                pressDetected = false;
                pressStartTime = 0;
                lastPressLongEventTime = 0;
                this->action = ROTARY_ACTION_NONE;
            } else if (duration >= LONG_PRESS_DURATION && this->_eventPressedLong != INPUT_BROKER_NONE &&
                       lastPressLongEventTime == 0) {
                // fire single-shot long press
                lastPressLongEventTime = now;
                LOG_DEBUG("Rotary event Press long");
                e.inputEvent = this->_eventPressedLong;
            }
        }
    } else if (this->action == ROTARY_ACTION_CW) {
        LOG_DEBUG("Rotary event CW");
        e.inputEvent = this->_eventCw;
    } else if (this->action == ROTARY_ACTION_CCW) {
        LOG_DEBUG("Rotary event CCW");
        e.inputEvent = this->_eventCcw;
    }

    if (e.inputEvent != INPUT_BROKER_NONE) {
        this->notifyObservers(&e);
    }

    if (!pressDetected) {
        this->action = ROTARY_ACTION_NONE;
    }

    return INT32_MAX;
}

void RotaryEncoderInterruptBase::intPressHandler()
{
    this->action = ROTARY_ACTION_PRESSED;
    setIntervalFromNow(20); // start checking for long/short
}

void RotaryEncoderInterruptBase::intAHandler()
{
    // CW rotation (at least on most common rotary encoders)
    int currentLevelA = digitalRead(this->_pinA);
    if (this->rotaryLevelA == currentLevelA) {
        return;
    }
    this->rotaryLevelA = currentLevelA;
    this->rotaryStateCCW = intHandler(currentLevelA == HIGH, this->rotaryLevelB, ROTARY_ACTION_CCW, this->rotaryStateCCW);
}

void RotaryEncoderInterruptBase::intBHandler()
{
    // CW rotation (at least on most common rotary encoders)
    int currentLevelB = digitalRead(this->_pinB);
    if (this->rotaryLevelB == currentLevelB) {
        return;
    }
    this->rotaryLevelB = currentLevelB;
    this->rotaryStateCW = intHandler(currentLevelB == HIGH, this->rotaryLevelA, ROTARY_ACTION_CW, this->rotaryStateCW);
}

/**
 * @brief Rotary action implementation.
 *   We assume, the following pin setup:
 *    A   --||
 *    GND --||]========
 *    B   --||
 *
 * @return The new state for rotary pin.
 */
RotaryEncoderInterruptBaseStateType RotaryEncoderInterruptBase::intHandler(bool actualPinRaising, int otherPinLevel,
                                                                           RotaryEncoderInterruptBaseActionType action,
                                                                           RotaryEncoderInterruptBaseStateType state)
{
    RotaryEncoderInterruptBaseStateType newState = state;
    if (actualPinRaising && (otherPinLevel == LOW)) {
        if (state == ROTARY_EVENT_CLEARED) {
            newState = ROTARY_EVENT_OCCURRED;
            if ((this->action != ROTARY_ACTION_PRESSED) && (this->action != action)) {
                this->action = action;
            }
        }
    } else if (!actualPinRaising && (otherPinLevel == HIGH)) {
        // Logic to prevent bouncing.
        newState = ROTARY_EVENT_CLEARED;
    }
    setIntervalFromNow(ROTARY_DELAY); // TODO: this modifies a non-volatile variable!

    return newState;
}