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>
            void reserve(const std::vector<GPIOtype> &collection)
            {
                for (auto item : collection)
                    item.reserve();
            }
 
            void buttonMatrix(const ButtonMatrix &matrix)
            {
                OutputGPIOCollection selectors;
                InputGPIOCollection inputs;
                uint64_t previousInputNumbers = InputNumber::booked();
                for (ButtonMatrix::const_iterator row = matrix.begin(); row != matrix.end(); row++)
                {
                    OutputGPIO selectorPin = row->first;
                    addIfNotExists<OutputGPIO>(selectorPin, selectors);
                    for (std::map<InputGPIO, InputNumber>::const_iterator col = row->second.begin(); col != row->second.end(); col++)
                    {
                        InputGPIO inputPin = col->first;
                        addIfNotExists<InputGPIO>(inputPin, inputs);
                        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>
            void analogMultiplexer(const OutputGPIOCollection &selectors, const AnalogMultiplexerGroup<PinTags> chips)
            {
                uint64_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");
            }
 
            void shiftRegisterChain(
                OutputGPIO loadPin,
                OutputGPIO nextPin,
                InputGPIO inputPin,
                const ShiftRegisterChain &chain)
            {
                uint64_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>
            void GPIOExpander(const GPIOExpanderChip<PinTags> &chip)
            {
                uint64_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");
            }
 
            void rotaryEncoder(InputGPIO dtPin, InputGPIO clkPin, InputNumber cw, InputNumber ccw)
            {
                uint64_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");
            }
 
            void button(InputGPIO pin, InputNumber inputNumber)
            {
                pin.reserve();
                if (inputNumber == UNSPECIFIED::VALUE)
                    throw empty_input_number_set("single button");
                inputNumber.book();
            }
 
            void codedRotarySwitch(const RotaryCodedSwitch &spec, const InputGPIOCollection &inputs)
            {
                uint8_t pinCount = inputs.size();
                if ((pinCount < 2) || (pinCount > 8))
                    throw std::runtime_error("Wrong count of input pins in a coded rotary switch");
                reserve<InputGPIO>(inputs);
                uint8_t maxIndex = (1 << pinCount); // = 2^pinCount
                for (RotaryCodedSwitch::const_iterator i = spec.begin(); i != spec.end(); i++)
                {
                    if (i->first >= maxIndex)
                        throw std::runtime_error(
                            "Invalid position ()" +
                            std::to_string(i->first) +
                            ") in a coded rotary switch. Valid range is [0," +
                            std::to_string(maxIndex) +
                            ")");
                    (i->second).book();
                }
            }
        } // namespace validate
    } // namespace inputs
} // namespace internals