InputSpecification.hpp

Go to the documentation of this file.

 
#pragma once
 
//-------------------------------------------------------------------
// Imports
//-------------------------------------------------------------------
 
#include "SimWheelTypes.hpp"
#include <cstdint>
#include <stdexcept>
#include <vector>
#include <map>
#include <array>
 
//-------------------------------------------------------------------
// Input specification: Button matrix
//-------------------------------------------------------------------
 
typedef std::map<OutputGPIO, std::map<InputGPIO, InputNumber>> ButtonMatrix;
 
inline void populateButtonMatrix(
    ButtonMatrix &matrix,
    const OutputGPIOCollection selectors,
    const InputGPIOCollection inputs,
    const InputNumber first)
{
    uint8_t in = (uint8_t)first;
    for (auto row : selectors)
        for (auto col : inputs)
            matrix[row][col] = in++;
}
 
//-------------------------------------------------------------------
// Input specification: analog multiplexers
//-------------------------------------------------------------------
 
enum class Mux8Pin
{
    A0 = 0,
    A1,
    A2,
    A3,
    A4,
    A5,
    A6,
    A7
};
 
enum class Mux16Pin
{
    I0 = 0,
    I1,
    I2,
    I3,
    I4,
    I5,
    I6,
    I7,
    I8,
    I9,
    I10,
    I11,
    I12,
    I13,
    I14,
    I15,
};
 
enum class Mux32Pin
{
    S1 = 0,
    S2,
    S3,
    S4,
    S5,
    S6,
    S7,
    S8,
    S9,
    S10,
    S11,
    S12,
    S13,
    S14,
    S15,
    S16,
    S17,
    S18,
    S19,
    S20,
    S21,
    S22,
    S23,
    S24,
    S25,
    S26,
    S27,
    S28,
    S29,
    S30,
    S31,
    S32
};
 
template <typename PinTags>
struct AnalogMultiplexerChip : public std::map<PinTags, InputNumber>
{
public:
    AnalogMultiplexerChip(InputGPIO inputPin)
        : std::map<PinTags, InputNumber>(), inputGPIO{inputPin} {}
 
    AnalogMultiplexerChip(const AnalogMultiplexerChip &) = default;
 
    AnalogMultiplexerChip(AnalogMultiplexerChip &&) = default;
 
    AnalogMultiplexerChip &operator=(const AnalogMultiplexerChip &) = default;
 
    AnalogMultiplexerChip &operator=(AnalogMultiplexerChip &&) = default;
 
    void reserve_and_book()
    {
        inputGPIO.reserve();
        for (auto i = this->begin(); i != this->end(); i++)
            i->second.book();
    }
 
    inline InputGPIO getInputGPIO() { return inputGPIO; }
 
private:
    InputGPIO inputGPIO;
};
 
typedef AnalogMultiplexerChip<Mux8Pin> AnalogMultiplexerChip8;
 
typedef AnalogMultiplexerChip<Mux16Pin> AnalogMultiplexerChip16;
 
typedef AnalogMultiplexerChip<Mux32Pin> AnalogMultiplexerChip32;
 
template <typename PinTags>
using AnalogMultiplexerGroup = std::vector<AnalogMultiplexerChip<PinTags>>;
 
//-------------------------------------------------------------------
// Input specification: GPIO Expanders
//-------------------------------------------------------------------
 
enum class MCP23017Pin
{
    GPA0 = 0,
    GPA1,
    GPA2,
    GPA3,
    GPA4,
    GPA5,
    GPA6,
    GPA7,
    GPB0,
    GPB1,
    GPB2,
    GPB3,
    GPB4,
    GPB5,
    GPB6,
    GPB7
};
 
enum class PCF8574Pin
{
    P0 = 0,
    P1,
    P2,
    P3,
    P4,
    P5,
    P6,
    P7
};
 
template <typename PinTags>
using GPIOExpanderChip = std::map<PinTags, InputNumber>;
 
typedef GPIOExpanderChip<MCP23017Pin> MCP23017Expander;
 
typedef GPIOExpanderChip<PCF8574Pin> PCF8574Expander;
 
//-------------------------------------------------------------------
// Input specification: PISO Shift registers
//-------------------------------------------------------------------
 
enum class SR8Pin
{
    H = 0,
    G,
    F,
    E,
    D,
    C,
    B,
    A
};
 
typedef std::map<SR8Pin, InputNumber> ShiftRegisterChip;
 
typedef std::vector<ShiftRegisterChip> ShiftRegisterChain;
 
//-------------------------------------------------------------------
// Input specification: binary-coded switches
//-------------------------------------------------------------------
 
typedef std::array<InputNumber, 8> CodedSwitch8;
 
typedef std::array<InputNumber, 16> CodedSwitch16;
 
typedef std::array<InputNumber, 32> CodedSwitch32;