cPin.hpp

Go to the documentation of this file.

#pragma once
 
#include "cAwaitable.hpp"
 
#include <concepts>
#include <bitset>
#include <tuple>
 
namespace fiber
{
 
    // ------------------ single pin ------------------

    template<class Pin>
    concept cOutPin = requires(Pin pin, bool level){
        { pin.high() } -> std::same_as<void>;
        { pin.low() } -> std::same_as<void>;
        { pin.write(level) } -> std::same_as<void>;
    };

    template<class Pin>
    concept cInPin = requires( Pin pin){
        { /*nodiscard*/ pin.is_high() } -> std::same_as<bool>;
        { /*nodiscard*/ pin.is_low() } -> std::same_as<bool>;
        { /*nodiscard*/ pin.read() } -> std::same_as<bool>;
    };

    template<class Pin>
    concept cPin = requires(Pin pin, bool boolean){
        { pin.high() } -> std::same_as<void>;
        { pin.low() } -> std::same_as<void>;
        { pin.write(boolean) } -> std::same_as<void>;
 
        { pin.input() } -> std::same_as<void>;
        { pin.output() } -> std::same_as<void>;
        { pin.dir(boolean) } -> std::same_as<void>;
 
        { /*nodiscard*/ pin.is_high() } -> std::same_as<bool>;
        { /*nodiscard*/ pin.is_low() } -> std::same_as<bool>;
        { /*nodiscard*/ pin.read() } -> std::same_as<bool>;
    };
 
    // ------------------ multiple pins ------------------

    template<class Pins, std::size_t N>
    concept cOutPins = requires(Pins pins, std::bitset<N> values, std::size_t n){
        { pins.write(values) } -> std::same_as<void>;
        { pins.template view<0>() } -> cOutPin;
    };

    template<class Pins, std::size_t N>
    concept cInPins = requires(Pins pins){
        { pins.read() } -> std::same_as<std::bitset<N>>;
        { pins.template view<0>() } -> cInPin;
    };

    template<class Pins, std::size_t N>
    concept cPins = requires(Pins pins, std::bitset<N> values){
        { pins.write(values) } -> std::same_as<void>;
        { pins.dir(values) } -> std::same_as<void>;
        { pins.read() } -> std::same_as<std::bitset<N>>;
        { pins.template view<0>() } -> cPin;
    };
 
// ---------------------------------------------------------------------------------------------
//                                  Helpers
// ---------------------------------------------------------------------------------------------

    class VoidPin{
        public:

        constexpr void write([[maybe_unused]]bool b){}

        constexpr void high(){}

        constexpr void low(){}

        constexpr void dir([[maybe_unused]] bool b){}

        constexpr void input(){}

        constexpr void output(){}

        [[nodiscard]] constexpr bool read()  {return false;}

        [[nodiscard]] constexpr bool is_high()  {return false;}

        [[nodiscard]] constexpr bool is_low()  {return true;}
    }; static_assert(cPin<VoidPin>, "VoidPin needs to implement cPin");
 
    template<cPin Pin>
    class InvertedPin{
    private:
        Pin _pin;
 
    public: 
        constexpr InvertedPin(const Pin& pin) : _pin(pin){}
 
        constexpr void high(){_pin.low();}
        constexpr void low(){_pin.high();}
        constexpr void write(bool level){_pin.write(!level);}
 
        constexpr void input(){_pin.input();}
        constexpr void output(){_pin.output();}
        constexpr void dir(bool direction){_pin.dir(direction);}
        
        [[nodiscard]] constexpr bool is_high()  {return _pin.is_low();}
        [[nodiscard]] constexpr bool is_low()  {return _pin.is_high();}
        [[nodiscard]] constexpr bool read()  {return !_pin.read();}
    }; static_assert(cPin<InvertedPin<VoidPin>>, "InvertedPin needs to implement cPin");
 
    template<size_t N>
    class VoidPins{
    public:
        constexpr void write([[maybe_unused]]std::bitset<N> values){}

        constexpr void dir([[maybe_unused]]std::bitset<N> values){}
        
        [[nodiscard]] constexpr std::bitset<N> read(){return std::bitset<N>(0);}
        
        template<size_t pin>
        requires(pin < N)
        [[nodiscard]] constexpr VoidPin view(){return VoidPin();}
        
    }; static_assert(cPins<VoidPins<8>, 8>, "cPinArray needs to implement cPins");

    template<typename... Pins>
    requires (cPin<Pins> && ...)
    class PinTuple{
        std::tuple<Pins...> pins;
 
    public:
        
        constexpr PinTuple(Pins... pins) : pins(std::forward<Pins>(pins)...){}

        constexpr void write(std::bitset<sizeof...(Pins)> values){
            write_impl(values, std::make_index_sequence<sizeof...(Pins)>{});
        }

        constexpr void dir(std::bitset<sizeof...(Pins)> values){
            dir_impl(values, std::make_index_sequence<sizeof...(Pins)>{});
        }

        [[nodiscard]] constexpr std::bitset<sizeof...(Pins)> read()  {
            return read_impl(std::make_index_sequence<sizeof...(Pins)>{});
        }

        template<size_t pin>
        requires(pin < sizeof...(Pins))
        [[nodiscard]] constexpr auto view(){return std::get<pin>(pins);}
 
    private:
        template<std::size_t... I>
        constexpr void write_impl(const std::bitset<sizeof...(Pins)>& values, std::index_sequence<I...>) {
            (..., std::get<I>(pins).write(values[I]));
        }
 
        template<std::size_t... I>
        constexpr void dir_impl(const std::bitset<sizeof...(Pins)>& values, std::index_sequence<I...>) {
            (..., std::get<I>(pins).dir(values[I]));
        }
 
        template<std::size_t... I>
        constexpr std::bitset<sizeof...(Pins)> read_impl(std::index_sequence<I...>)  {
            std::bitset<sizeof...(Pins)> result = ((std::bitset<sizeof...(Pins)>(std::get<I>(pins).read() ? 1 : 0) << I) | ...);
            return result;
        }
 
    }; static_assert(cPins<PinTuple<VoidPin, VoidPin>, 2>, "PinTuple needs to implement cPins");
 
} // namespace fiber