DigitalPinConfig.hpp

Go to the documentation of this file.

/*
 * This file is part of the DUDS project. It is subject to the BSD-style
 * license terms in the LICENSE file found in the top-level directory of this
 * distribution and at https://github.com/jjackowski/duds/blob/master/LICENSE.
 * No part of DUDS, including this file, may be copied, modified, propagated,
 * or distributed except according to the terms contained in the LICENSE file.
 *
 * Copyright (C) 2017  Jeff Jackowski
 */
#include <cstdint>
#include <duds/hardware/interface/DigitalPinErrors.hpp>
#include <iostream>

namespace duds { namespace hardware { namespace interface {

struct DigitalPinCap;

struct DigitalPinConfig {
    typedef duds::general::BitFlags<struct DigitalPinConfigFlags, std::uint32_t>
        Flags;
    // direction
    static constexpr Flags DirInput = Flags::Bit(0);
    static constexpr Flags DirOutput = Flags::Bit(1); // normally implies bit 7
    static constexpr Flags DirImmaterial = Flags::Bit(2);
    static constexpr Flags DirNoChange = Flags::Zero();
    static constexpr Flags DirMask =
        DirInput | DirOutput;
    // input options - pull up/down
    static constexpr Flags InputNoPull = Flags::Bit(3);
    static constexpr Flags InputPulldown = Flags::Bit(4);
    static constexpr Flags InputPullup = Flags::Bit(5);
    static constexpr Flags InputPullImmaterial = Flags::Bit(6);
    static constexpr Flags InputPullNoChange = Flags::Zero();
    static constexpr Flags InputPullMask =
        InputNoPull | InputPullup | InputPulldown;
    // input options - event
    static constexpr Flags EventNone = Flags::Bit(7);
    static constexpr Flags EventEdgeFalling = Flags::Bit(8);
    static constexpr Flags EventEdgeRising = Flags::Bit(9);
    static constexpr Flags EventEdge = EventEdgeFalling | EventEdgeRising;
    static constexpr Flags EventLevelLow = Flags::Bit(10);
    static constexpr Flags EventLevelHigh = Flags::Bit(11);
    static constexpr Flags EventImmaterial = Flags::Bit(12);
    static constexpr Flags EventNoChange = Flags::Zero();
    static constexpr Flags EventMask =
        EventNone | EventEdgeRising | EventEdgeFalling |
        EventLevelLow | EventLevelHigh;
    // input options - interrupt
    static constexpr Flags InterruptNone = Flags::Bit(13);
    static constexpr Flags InterruptOnEvent = Flags::Bit(14);
    static constexpr Flags InterruptImmaterial = Flags::Bit(15);
    static constexpr Flags InterruptNoChange = Flags::Zero();
    static constexpr Flags InterruptMask = InterruptNone | InterruptOnEvent;
    // output options
    static constexpr Flags OutputDriveLow = Flags::Bit(16);
    static constexpr Flags OutputDriveHigh = Flags::Bit(17);
    static constexpr Flags OutputPushPull = OutputDriveLow | OutputDriveHigh;
    static constexpr Flags OutputHighImpedance = Flags::Bit(18);
    static constexpr Flags OutputImmaterial = Flags::Bit(19);
    static constexpr Flags OutputNoChange = Flags::Zero();
    static constexpr Flags OutputMask =
        OutputDriveLow | OutputDriveHigh | OutputPushPull |
        OutputHighImpedance;
    static constexpr Flags OperationNoChange = Flags::Zero();
    static constexpr Flags InputState = Flags::Bit(20);
    static constexpr Flags OutputState = Flags::Bit(21);
    Flags options;
    std::uint16_t minOutputCurrent;
    std::uint16_t maxOutputCurrent;
    DigitalPinConfig() = default;
    constexpr DigitalPinConfig(
        const Flags opt,
        const std::uint16_t minOut = 0,
        const std::uint16_t maxOut = 0
    ) :
        options(opt),
        minOutputCurrent(minOut),
        maxOutputCurrent(maxOut)
    { }
    struct ClearAll { };
    constexpr DigitalPinConfig(const ClearAll) :
        options(Flags::Zero()),
        minOutputCurrent(0),
        maxOutputCurrent(0)
    { }
    void checkValidity() const;
    void combine(const DigitalPinConfig &newCfg);
    static DigitalPinConfig combine(
        const DigitalPinConfig &oldCfg,
        const DigitalPinConfig &newCfg
    );
    void reverseCombine(const DigitalPinConfig &oldCfg) {
        DigitalPinConfig oc(oldCfg);
        oc.combine(*this);
        *this = oc;
    }
    DigitalPinRejectedConfiguration::Reason compatible(
        const DigitalPinCap &cap
    ) const;
};

typedef boost::error_info<
    struct Info_DigitalPinConfig, DigitalPinConfig
> DigitalPinConfigInfo;

inline std::ostream &operator<<(std::ostream &os, const DigitalPinConfig &c) {
    return os << '(' << c.options.flags() << ',' << c.minOutputCurrent << ',' <<
    c.maxOutputCurrent << ')';
}

constexpr DigitalPinConfig::Flags operator & (
    const DigitalPinConfig &cap,
    const DigitalPinConfig::Flags &flg
) {
    return cap.options & flg;
}

constexpr DigitalPinConfig::Flags operator & (
    const DigitalPinConfig::Flags &flg,
    const DigitalPinConfig &cap
) {
    return flg & cap.options;
}

constexpr DigitalPinConfig::Flags operator | (
    const DigitalPinConfig &cap,
    const DigitalPinConfig::Flags &flg
) {
    return cap.options | flg;
}

constexpr DigitalPinConfig::Flags operator | (
    const DigitalPinConfig::Flags &flg,
    const DigitalPinConfig &cap
) {
    return flg | cap.options;
}

constexpr DigitalPinConfig::Flags operator ^ (
    const DigitalPinConfig &cap,
    const DigitalPinConfig::Flags &flg
) {
    return cap.options ^ flg;
}

constexpr DigitalPinConfig::Flags operator ^ (
    const DigitalPinConfig::Flags &flg,
    const DigitalPinConfig &cap
) {
    return flg ^ cap.options;
}

constexpr bool operator == (
    const DigitalPinConfig &cap,
    const DigitalPinConfig::Flags &flg
) {
    return cap.options == flg;
}

constexpr bool operator == (
    const DigitalPinConfig::Flags &flg,
    const DigitalPinConfig &cap
) {
    return flg == cap.options;
}

constexpr bool operator != (
    const DigitalPinConfig &cap,
    const DigitalPinConfig::Flags &flg
) {
    return cap.options != flg;
}

constexpr bool operator != (
    const DigitalPinConfig::Flags &flg,
    const DigitalPinConfig &cap
) {
    return flg != cap.options;
}

} } }