StateMachineEncoder.h

Go to the documentation of this file.

/*
* Copyright (c) 2018 https://www.thecoderscorner.com (Dave Cherry).
 * This product is licensed under an Apache license, see the LICENSE file in the top-level directory.
 */

#ifndef IOA_STATEMACHINE_ENCODER_H
#define IOA_STATEMACHINE_ENCODER_H
 
#include <TaskPlatformDeps.h>
#include "PlatformDetermination.h"
#include "SwitchInput.h"
 
//
// DO NOT REMOVE THE ISR_ATTR and DRAM_ATTR ANNOTATIONS
//
 

enum class EncoderInterruptMode {
    SINGLE_PIN,
    ALL_PINS,
    TIMER,
    NONE
};

ISR_ATTR void encoderInterruptHandler();

class StateRotaryEncoderBuilder {
private:
    pinid_t pinA = 2;
    pinid_t pinB = 3;
    pinid_t interruptPin = -1;
    EncoderCallbackFn callback = nullptr;
    EncoderListener* listener = nullptr;
    EncoderInterruptMode interruptMode = EncoderInterruptMode::NONE;
    HWAccelerationMode accelerationMode = HWACCEL_REGULAR;
    EncoderType encoderType = FULL_CYCLE;
    bool needPullup = true;
    uint8_t encoderNum = 0;
public:
    StateRotaryEncoderBuilder& withEncoderPins(const pinid_t l_pinA, const pinid_t l_pinB) {
        pinA = l_pinA;
        pinB = l_pinB;
        return *this;
    }

    StateRotaryEncoderBuilder& withEncoderNum(const uint8_t l_encoderNum) {
        this->encoderNum = l_encoderNum;
        return *this;
    }

    StateRotaryEncoderBuilder& withPullUpInput(const bool l_needPullup) {
        this->needPullup = l_needPullup;
        return *this;
    }

    StateRotaryEncoderBuilder& withCallback(const EncoderCallbackFn l_callback) {
        callback = l_callback;
        return *this;
    }

    StateRotaryEncoderBuilder& withListener(EncoderListener* l_listener) {
        listener = l_listener;
        return *this;
    }

    StateRotaryEncoderBuilder& interruptOnSinglePin(const pinid_t l_interruptPin) {
        interruptMode = EncoderInterruptMode::SINGLE_PIN;
        interruptPin = l_interruptPin;
        return *this;
    }

    StateRotaryEncoderBuilder& interruptOnBothPins() {
        interruptMode = EncoderInterruptMode::ALL_PINS;
        return *this;
    }

    StateRotaryEncoderBuilder& interruptOnTimer() {
        interruptMode = EncoderInterruptMode::TIMER;
        return *this;
    }

    StateRotaryEncoderBuilder& withAccelerationMode(const HWAccelerationMode l_accelerationMode) {
        accelerationMode = l_accelerationMode;
        return *this;
    }

    StateRotaryEncoderBuilder& withEncoderType(const EncoderType l_encoderType) {
        encoderType = l_encoderType;
        return *this;
    }

    [[nodiscard]] bool configurationValid() const {
        if (listener == nullptr && callback == nullptr) {
            return false; // no notification has been configured
        }
 
        if (interruptMode == EncoderInterruptMode::SINGLE_PIN && (interruptPin == pinA || interruptPin == pinB || interruptPin < 0)) {
            return false; // The single pin must not be A or B, it should be in hardware as A or B.
        }
 
        // A and B must not be the same.
        return (pinA != pinB) && interruptMode != EncoderInterruptMode::NONE;
    }

    bool build() const; // NOLINT(*-use-nodiscard) because it is not a getter it is optional error handling.
};

inline bool setupStateMachineRotaryEncoder(const StateRotaryEncoderBuilder& builder) {
    return builder.build();
}
 
#endif