InputHardware.hpp

Go to the documentation of this file.

 
#pragma once
 
//-------------------------------------------------------------------
// Imports
//-------------------------------------------------------------------
 
#include "InternalTypes.hpp" // For BitQueue
#include "InputSpecification.hpp"
 
//-------------------------------------------------------------------
// (Abstract) DigitalInput
//-------------------------------------------------------------------
 
class DigitalInput
{
public:
    uint64_t mask = ~0ULL;
 
public:
    virtual ~DigitalInput() noexcept {}
 
    virtual uint64_t read(uint64_t lastState) = 0;
 
protected:
    void addToMask(uint64_t bitmap) { mask &= ~bitmap; }
};
 
//-------------------------------------------------------------------
// Single button
//-------------------------------------------------------------------
 
class DigitalButton : public DigitalInput
{
protected:
    InputGPIO pinNumber;
    uint64_t bitmap;
 
public:
    DigitalButton(InputGPIO pinNumber, InputNumber buttonNumber);
 
    virtual uint64_t read(uint64_t lastState) 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
    uint64_t cwButtonBitmap;
    uint64_t ccwButtonBitmap;
    BitQueue queue;
 
    // 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 uint64_t read(uint64_t lastState) 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 uint64_t read(uint64_t lastState) override;
};
 
//-------------------------------------------------------------------
// Analog Multiplexers
//-------------------------------------------------------------------
 
class AnalogMultiplexerInput : public DigitalInput
{
private:
    OutputGPIOCollection selectorPins;
    InputGPIOCollection inputPins;
    const uint64_t *bitmap;
    size_t switchCount;
 
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 uint64_t read(uint64_t lastState) override;
 
private:
    void initializeMux();
};
 
//-------------------------------------------------------------------
// Coded rotary switch
//-------------------------------------------------------------------
 
class RotaryCodedSwitchInput : public DigitalInput
{
private:
    InputGPIOCollection inputPins;
    uint64_t *bitmap = nullptr;
    bool complementaryCode;
 
public:
    RotaryCodedSwitchInput(
        const RotaryCodedSwitch &spec,
        const InputGPIOCollection &pins,
        bool complementaryCode);
    ~RotaryCodedSwitchInput();
 
    virtual uint64_t read(uint64_t lastState) override;
};
 
//-------------------------------------------------------------------
// 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(uint64_t &state);
 
public:
    PCF8574ButtonsInput(
        const PCF8574Expander &inputNumbers,
        uint8_t address7Bits,
        I2CBus bus = I2CBus::PRIMARY);
 
    virtual uint64_t read(uint64_t lastState) override;
};
 
class MCP23017ButtonsInput : public I2CInput
{
private:
    MCP23017Expander inputNumbers;
    bool getGPIOstate(uint64_t &state);
    void configure();
 
public:
    MCP23017ButtonsInput(
        const MCP23017Expander &inputNumbers,
        uint8_t address7Bits,
        I2CBus bus = I2CBus::PRIMARY);
 
    virtual uint64_t read(uint64_t lastState) override;
};
 
//-------------------------------------------------------------------
// Shift registers
//-------------------------------------------------------------------
 
class ShiftRegistersInput : public DigitalInput
{
private:
    size_t switchCount;
    InputGPIO serialPin;
    OutputGPIO loadPin;
    OutputGPIO nextPin;
    const uint64_t *bitmap;
    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 uint64_t read(uint64_t lastState) 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;
};
 
//-------------------------------------------------------------------
// Fake input hardware for testing
//-------------------------------------------------------------------
 
class FakeDigitalInput : public DigitalInput
{
private:
    FakeInput *_instance;
 
public:
    FakeDigitalInput(FakeInput *instance) { _instance = instance; }
 
    virtual uint64_t read(uint64_t lastState) override
    {
        return _instance->state;
    }
};
 
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;
    };
};