InputValidation.hpp

Go to the documentation of this file.

 
#pragma once
 
//-------------------------------------------------------------------
// Imports
//-------------------------------------------------------------------
 
#include "InputSpecification.hpp"
 
//-------------------------------------------------------------------
// API
//-------------------------------------------------------------------
 
namespace internals
{
    namespace inputs
    {
        namespace validate
        {
            template <typename GPIOtype>
            inline void reserve(const std::set<GPIOtype> &collection)
            {
                for (auto item : collection)
                    item.reserve();
            }
 
            inline void buttonMatrix(const ButtonMatrix &matrix)
            {
                OutputGPIOCollection selectors;
                InputGPIOCollection inputs;
                uint128_t previousInputNumbers = InputNumber::booked();
                for (ButtonMatrix::const_iterator row = matrix.cbegin();
                     row != matrix.cend();
                     row++)
                {
                    OutputGPIO selectorPin = row->first;
                    selectors.insert(selectorPin);
                    for (std::map<InputGPIO, InputNumber>::const_iterator col = row->second.begin(); col != row->second.end(); col++)
                    {
                        InputGPIO inputPin = col->first;
                        inputs.insert(inputPin);
                        InputNumber inputNumber = col->second;
                        inputNumber.book();
                    }
                }
                reserve<OutputGPIO>(selectors);
                reserve<InputGPIO>(inputs);
                if (previousInputNumbers == InputNumber::booked())
                    throw empty_input_number_set("button matrix");
            }
 
            template <typename PinTags>
            inline void analogMultiplexer(const OutputGPIOCollection &selectors, const AnalogMultiplexerGroup<PinTags> chips)
            {
                uint128_t previousInputNumbers = InputNumber::booked();
                reserve<OutputGPIO>(selectors);
                for (auto chip : chips)
                    chip.reserve_and_book();
                if (previousInputNumbers == InputNumber::booked())
                    throw empty_input_number_set("analog multiplexers");
            }
 
            inline void shiftRegisterChain(
                OutputGPIO loadPin,
                OutputGPIO nextPin,
                InputGPIO inputPin,
                const ShiftRegisterChain &chain)
            {
                uint128_t previousInputNumbers = InputNumber::booked();
                loadPin.reserve();
                nextPin.reserve();
                inputPin.reserve();
                for (auto chip : chain)
                {
                    for (ShiftRegisterChip::const_iterator i = chip.begin(); i != chip.end(); i++)
                        (i->second).book();
                }
                if (previousInputNumbers == InputNumber::booked())
                    throw empty_input_number_set("PISO shift registers");
            }
 
            template <typename PinTags>
            inline void GPIOExpander(const GPIOExpanderChip<PinTags> &chip)
            {
                uint128_t previousInputNumbers = InputNumber::booked();
                for (auto i = chip.begin(); i != chip.end(); i++)
                    (i->second).book();
                if (previousInputNumbers == InputNumber::booked())
                    throw empty_input_number_set("GPIO expander");
            }
 
            inline void rotaryEncoder(
                InputGPIO dtPin,
                InputGPIO clkPin,
                InputNumber cw,
                InputNumber ccw)
            {
                uint128_t previousInputNumbers = InputNumber::booked();
                dtPin.reserve();
                clkPin.reserve();
                cw.book();
                ccw.book();
                if (previousInputNumbers == InputNumber::booked())
                    throw empty_input_number_set("rotary encoder");
                if (cw == UNSPECIFIED::VALUE)
                    throw std::runtime_error("Useless rotary encoder: no input number for clockwise rotation");
                if (ccw == UNSPECIFIED::VALUE)
                    throw std::runtime_error("Useless rotary encoder: no input number for counter-clockwise rotation");
                if (cw == ccw)
                    throw std::runtime_error("Useless rotary encoder: same input numbers for clockwise and counter-clockwise");
            }
 
            inline void button(InputGPIO pin, InputNumber inputNumber)
            {
                pin.reserve();
                if (inputNumber == UNSPECIFIED::VALUE)
                    throw empty_input_number_set("single button");
                inputNumber.book();
            }
 
            inline void joystick(
                ADC_GPIO xAxisPin,
                ADC_GPIO yAxisPin,
                InputNumber up,
                InputNumber down,
                InputNumber left,
                InputNumber right)
            {
                if (xAxisPin == yAxisPin)
                    throw std::runtime_error(
                        "inputs::addJoystick() is using the same pin for both axes");
                xAxisPin.reserve();
                yAxisPin.reserve();
                up.book();
                down.book();
                left.book();
                right.book();
            }
 
        } // namespace validate
    } // namespace inputs
} // namespace internals