InputHardware.hpp

Go to the documentation of this file.

 
#pragma once
 
//-------------------------------------------------------------------
// Imports
//-------------------------------------------------------------------
 
#include "InternalTypes.hpp" // For BitQueue
#include "InputSpecification.hpp"
#include <initializer_list>
 
//-------------------------------------------------------------------
// (Abstract) DigitalInput
//-------------------------------------------------------------------
 
class DigitalInput
{
public:
    virtual ~DigitalInput() noexcept {}
 
    virtual void read(uint128_t &state) = 0;
};
 
//-------------------------------------------------------------------
// Single button
//-------------------------------------------------------------------
 
class DigitalButton : public DigitalInput
{
protected:
    InputGPIO pinNumber;
    uint8_t inputNumber;
 
public:
    DigitalButton(InputGPIO pinNumber, InputNumber buttonNumber);
 
    virtual void read(uint128_t &state) override;
};
 
//-------------------------------------------------------------------
// Rotary encoder
//-------------------------------------------------------------------
 
class RotaryEncoderInput : public DigitalInput
{
private:
    InputGPIO clkPin, dtPin; // pins
    uint8_t code;            // State of the decoding algorithm
    uint16_t sequence;       // Last sequence of states
    uint8_t cwButton;
    uint8_t ccwButton;
    BitQueue queue;
    bool cwOrCcw;
 
    // duration of the current "pulse" event in polling cycles
    uint8_t currentPulseWidth;
 
    // a "virtual button" press event was notified at read(),
    // so a release event must be notified next
    bool pressEventNotified;
 
    static void isrh(void *instance);
    static void isrhAlternateEncoding(void *instance);
 
public:
    inline static uint8_t pulseMultiplier = 1;
 
    RotaryEncoderInput(
        InputGPIO clkPin,
        InputGPIO dtPin,
        InputNumber cwButtonNumber,
        InputNumber ccwButtonNumber,
        bool useAlternateEncoding = false);
 
    static bool setPulseMultiplier(uint8_t multiplier)
    {
        if ((multiplier > 0) && (multiplier < 7) &&
            (pulseMultiplier != multiplier))
        {
            pulseMultiplier = multiplier;
            return true;
        }
        return false;
    };
 
    virtual void read(uint128_t &state) override;
};
 
//-------------------------------------------------------------------
// Button matrix
//-------------------------------------------------------------------
 
class ButtonMatrixInput : public DigitalInput
{
private:
    // InputGPIOCollection inputPins = {};
    // OutputGPIOCollection outputPins = {};
    ButtonMatrix matrix;
    bool negativeLogic;
 
public:
    ButtonMatrixInput(
        const ButtonMatrix &matrix,
        bool negativeLogic = false);
 
    virtual void read(uint128_t &state) override;
};
 
//-------------------------------------------------------------------
// Analog Multiplexers
//-------------------------------------------------------------------
 
class AnalogMultiplexerInput : public DigitalInput
{
private:
    ::std::vector<OutputGPIO> selectorPins{};
    ::std::vector<InputGPIO> inputPins{};
    ::std::vector<uint8_t> inputNumber{};
 
public:
    AnalogMultiplexerInput(
        OutputGPIO selectorPin1,
        OutputGPIO selectorPin2,
        OutputGPIO selectorPin3,
        const AnalogMultiplexerGroup<Mux8Pin> &chips);
 
    AnalogMultiplexerInput(
        OutputGPIO selectorPin1,
        OutputGPIO selectorPin2,
        OutputGPIO selectorPin3,
        OutputGPIO selectorPin4,
        const AnalogMultiplexerGroup<Mux16Pin> &chips);
 
    AnalogMultiplexerInput(
        OutputGPIO selectorPin1,
        OutputGPIO selectorPin2,
        OutputGPIO selectorPin3,
        OutputGPIO selectorPin4,
        OutputGPIO selectorPin5,
        const AnalogMultiplexerGroup<Mux32Pin> &chips);
 
    virtual void read(uint128_t &state) override;
 
private:
    void initializeMux(
        ::std::initializer_list<OutputGPIO> selectorPins,
        const ::std::vector<InputGPIO> &inputPins);
};
 
//-------------------------------------------------------------------
// I2C input hardware
//-------------------------------------------------------------------
 
class I2CInput : public DigitalInput // : public I2CInput
{
protected:
    void *device = nullptr;
 
public:
    I2CInput(
        uint8_t address7Bits,
        I2CBus bus = I2CBus::PRIMARY,
        uint8_t max_speed_mult = 1);
 
    virtual ~I2CInput();
};
 
class PCF8574ButtonsInput : public I2CInput
{
private:
    PCF8574Expander inputNumbers;
    bool getGPIOstate(uint8_t &state);
 
public:
    PCF8574ButtonsInput(
        const PCF8574Expander &inputNumbers,
        uint8_t address7Bits,
        I2CBus bus = I2CBus::PRIMARY);
 
    virtual void read(uint128_t &state) override;
};
 
class MCP23017ButtonsInput : public I2CInput
{
private:
    MCP23017Expander inputNumbers;
    bool getGPIOstate(uint16_t &state);
    void configure();
 
public:
    MCP23017ButtonsInput(
        const MCP23017Expander &inputNumbers,
        uint8_t address7Bits,
        I2CBus bus = I2CBus::PRIMARY);
 
    virtual void read(uint128_t &state) override;
};
 
//-------------------------------------------------------------------
// Shift registers
//-------------------------------------------------------------------
 
class ShiftRegistersInput : public DigitalInput
{
private:
    size_t switchCount;
    InputGPIO serialPin;
    OutputGPIO loadPin;
    OutputGPIO nextPin;
    ::std::vector<uint8_t> inputNumber{};
    bool loadHighOrLow;
    bool nextHighToLowOrLowToHigh;
    bool negativeLogic;
 
public:
    ShiftRegistersInput(
        OutputGPIO loadPin,
        OutputGPIO nextPin,
        InputGPIO inputPin,
        const ShiftRegisterChain &chain,
        InputNumber SER_inputNumber = UNSPECIFIED::VALUE,
        const bool loadHighOrLow = false,
        const bool nextHighToLowOrLowToHigh = false,
        const bool negativeLogic = true);
 
    virtual void read(uint128_t &state) override;
};
 
//-------------------------------------------------------------------
// Potentiometers
//-------------------------------------------------------------------
 
class AnalogInput
{
public:
    virtual void getCalibrationData(int &minReading, int &maxReading) = 0;
 
    virtual void setCalibrationData(int minReading, int maxReading) = 0;
 
    virtual void resetCalibrationData() = 0;
 
    virtual void read(uint8_t &value, bool &autoCalibrated) = 0;
 
    virtual ~AnalogInput() noexcept {}
};
 
class AnalogClutchInput : public AnalogInput
{
protected:
    ADC_GPIO pinNumber;
    int minADCReading;
    int maxADCReading;
    int lastADCReading;
    uint8_t lastValue;
 
public:
    AnalogClutchInput(ADC_GPIO pinNumber);
 
    void resetCalibrationData() override;
 
    void getCalibrationData(int &minReading, int &maxReading) override;
 
    void setCalibrationData(int minReading, int maxReading) override;
 
    void read(uint8_t &value, bool &autoCalibrated) override;
};
 
class AnalogJoystickInput : public DigitalInput
{
protected:
    ADC_GPIO xAxisPin;
    ADC_GPIO yAxisPin;
    uint8_t up;
    uint8_t down;
    uint8_t left;
    uint8_t right;
    int upAdcReading;
    int downAdcReading;
    int leftAdcReading;
    int rightAdcReading;
    bool xAxisReverse;
    bool AxisReverse;
 
public:
    AnalogJoystickInput(
        ADC_GPIO xAxisPin,
        ADC_GPIO yAxisPin,
        InputNumber up,
        InputNumber down,
        InputNumber left,
        InputNumber right,
        uint8_t xCenter = 127,
        uint8_t yCenter = 127,
        uint8_t xDeadZone = 63,
        uint8_t yDeadZone = 63,
        bool xAxisReverse = false,
        bool yAxisReverse = false);
 
    virtual void read(uint128_t &state) override;
};
 
//-------------------------------------------------------------------
// Fake input hardware for testing
//-------------------------------------------------------------------
 
class FakeDigitalInput : public DigitalInput
{
private:
    FakeInput *_instance;
 
public:
    FakeDigitalInput(FakeInput *instance) { _instance = instance; }
 
    virtual void read(uint128_t &state) override
    {
        // for (uint8_t i = 0; i < 128; i++)
        //     if (!_instance.mask.bit(i))
        //         state.set_bit(i, _instance.bit(i));
        state = (state & (_instance->mask)) |
                (_instance->state & ~(_instance->mask));
    }
};
 
class FakeAxis : public AnalogInput
{
private:
    FakeInput *_instance;
    bool _leftOrRight;
 
public:
    FakeAxis(FakeInput *instance, bool leftOrRight)
    {
        _leftOrRight = leftOrRight;
        _instance = instance;
    }
 
    void resetCalibrationData() override
    {
        _instance->recalibrationRequestCount++;
    };
 
    void getCalibrationData(int &minReading, int &maxReading) override
    {
        minReading = 0;
        maxReading = 254;
    }
 
    void setCalibrationData(int minReading, int maxReading) override {};
 
    void read(uint8_t &value, bool &autoCalibrated)
    {
        autoCalibrated = false;
        if (_leftOrRight)
            value = _instance->leftAxis;
        else
            value = _instance->rightAxis;
    };
};