DigitalPinSetAccess.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
 */
#ifndef DIGITALPINSETACCESS_HPP
#define DIGITALPINSETACCESS_HPP

#include <duds/hardware/interface/DigitalPort.hpp>
#include <duds/hardware/interface/DigitalPinAccessBase.hpp>

namespace duds { namespace hardware { namespace interface {

class DigitalPinSetAccess : public DigitalPinAccessBase {
    std::vector<unsigned int> pinvec;
    DigitalPinSetAccess(DigitalPort *port, std::vector<unsigned int> &&pids) :
        DigitalPinAccessBase(port), pinvec(std::move(pids)) { }
    void reserveAdditional(unsigned int len);
    friend DigitalPort;
public:
    DigitalPinSetAccess() = default;
    ~DigitalPinSetAccess() {
        retire();
    }
    /*
     * A move constructor. Causes troubles internal to DigitalPort.
     */
    //DigitalPinSetAccess(DigitalPinAccess &&old) noexcept;
    void retire() noexcept;
    void retire(unsigned int pos);
    DigitalPinSetAccess &operator=(DigitalPinSetAccess &&old) noexcept;
    const std::vector<unsigned int> &localIds() const {
        return pinvec;
    }
    std::vector<unsigned int> globalIds() const {
        return port()->globalIds(pinvec);
    }
    bool havePins() const {
        return (port() != nullptr) && !pinvec.empty();
    }
    bool exists(unsigned int pos) const {
        return (pos < pinvec.size()) && (pinvec[pos] != -1);
    }
    unsigned int size() const {
        return (unsigned int)pinvec.size();
    }
    unsigned int localId(unsigned int pos) const {
        // check range using at()
        return pinvec.at(pos);
    }
    unsigned int globalId(unsigned int pos) const {
        // check range using at()
        return port()->globalId(pinvec.at(pos));
    }
    DigitalPinCap capabilities(unsigned int pos) const {
        return port()->capabilities(globalId(pos));
    }
    std::vector<DigitalPinCap> capabilities() const {
        return port()->capabilitiesLocalIds(pinvec);
    }
    DigitalPinConfig configuration(unsigned int pos) const {
        return port()->configuration(globalId(pos));
    }
    std::vector<DigitalPinConfig> configuration() const {
        return port()->configurationLocalIds(pinvec);
    }
    std::vector<unsigned int> subset(const std::vector<unsigned int> &pos) const;
    DigitalPinRejectedConfiguration::Reason proposeConfig(
        unsigned int pos,
        DigitalPinConfig &conf
    ) const {
        return port()->proposeConfig(globalId(pos), conf);
    }
    DigitalPinRejectedConfiguration::Reason proposeConfig(
        unsigned int pos,
        DigitalPinConfig &proposed,
        DigitalPinConfig &initial
    ) const {
        return port()->proposeConfig(globalId(pos), proposed, initial);
    }
    bool proposeConfig(
        std::vector<DigitalPinConfig> &propConf,
        std::vector<DigitalPinConfig> &initConf,
        std::function<void(DigitalPinRejectedConfiguration::Reason)> insertReason
            = std::function<void(DigitalPinRejectedConfiguration::Reason)>()
    ) {
        return port()->proposeConfigLocalIds(
            pinvec,
            propConf,
            initConf,
            insertReason
        );
    }
    /*
    template <class FwdConfIter>
    std::vector<DigitalPinConfig> proposeConfig(
        const FwdConfIter &begin,
        const FwdConfIter &end,
    ) const {
        // need to have a copy of the configs for changes
        std::vector<DigitalPinConfig> proposed(begin, end);
        port()->proposeConfig(proposed, pinvec);
        return proposed;
        // provide DigitalPinRejectedConfiguration ???
    }
    template <class FwdConfIter>
    void modifyConfig(const FwdConfIter &begin, const FwdConfIter &end) const;
    */
    DigitalPinConfig modifyConfig(
        unsigned int pos,
        const DigitalPinConfig &conf
    ) const {
        return port()->modifyConfig(globalId(pos), conf, &portdata);
    }
    void modifyConfig(const DigitalPinConfig &conf) const;
    void modifyConfig(std::vector<DigitalPinConfig> &conf) const {
        port()->modifyConfig(pinvec, conf, &portdata);
    }
    void modifyConfig(
        const std::vector<unsigned int> &pos,
        std::vector<DigitalPinConfig> &conf
    ) const {
        port()->modifyConfig(subset(pos), conf, &portdata);
    }
    bool input(unsigned int pos) const {
        return port()->input(globalId(pos), &portdata);
    }
    std::vector<bool> input() const {
        return port()->input(pinvec, &portdata);
    }
    std::vector<bool> input(const std::vector<unsigned int> &pos) const {
        return port()->input(subset(pos), &portdata);
    }
    void output(unsigned int pos, bool state) const {
        port()->output(globalId(pos), state, &portdata);
    }
    void output(const std::vector<bool> &state) const {
        port()->output(pinvec, state, &portdata);
    }
    void output(bool state) const;
    void output(
        const std::vector<unsigned int> &pos,
        const std::vector<bool> &state
    ) const {
        port()->output(subset(pos), state, &portdata);
    }

    // convenience functions -- may expand later

    bool simultaneousOperations() const {
        return port()->simultaneousOperations();
    }
    bool independentConfig() const {
        return port()->independentConfig();
    }
    bool isInput(unsigned int pos) const {
        return configuration(pos) & DigitalPinConfig::DirInput;
    }
    bool isOutput(unsigned int pos) const {
        return configuration(pos) & DigitalPinConfig::DirOutput;
    }
    bool canBeInput(unsigned int pos) const {
        return capabilities(pos) & DigitalPinCap::Input;
    }
    bool canBeOutput(unsigned int pos) const {
        return capabilities(pos) &  (
            DigitalPinCap::OutputPushPull |
            DigitalPinCap::OutputDriveLow |
            DigitalPinCap::OutputDriveHigh
        );
    }
    bool canFloat(unsigned int pos) const {
        return capabilities(pos) & DigitalPinCap::OutputHighImpedance;
    }
    template <typename Int>
    void write(Int val, int bits) const {
        // range check; must have enough pins
        if ((bits < 1) || (bits > pinvec.size())) {
            DUDS_THROW_EXCEPTION(PinRangeError());
        }
        // range check; value must fit
        if (val >= (1 << bits)) {
            DUDS_THROW_EXCEPTION(DigitalPinNumericRangeError() <<
                DigitalPinNumericOutput(val) << DigitalPinNumericBits(bits)
            );
        }
        // prepare a place to store the output.
        std::vector<bool> out;
        out.reserve(bits);
        // produce the output
        for (; bits; --bits) {
            out.push_back(val & 1);
            val >>= 1;
        }
        // whole set?
        if (out.size() == pinvec.size()) {
            // write the value using all pins
            port()->output(pinvec, out, &portdata);
        } else {
            // produce a subset of the pins
            std::vector<unsigned int> pins(
                pinvec.begin(),
                pinvec.begin() + out.size()
            );
            // write out the number
            port()->output(pins, out, &portdata);
        }
    }
    template <typename Int>
    void write(Int val) const {
        write(val, pinvec.size());
    }
};

// maybe a full-port access object?

} } }

#endif        //  #ifndef DIGITALPINSETACCESS_HPP