PinConfiguration.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) 2018  Jeff Jackowski
 */
#include <boost/property_tree/ptree_fwd.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/member.hpp>
#include <duds/hardware/interface/DigitalPinSet.hpp>
#include <duds/hardware/interface/DigitalPin.hpp>
#include <duds/hardware/interface/ChipSelect.hpp>
#include <unordered_map>
#include <set>

namespace duds { namespace hardware { namespace interface {

class ChipSelectManager;
class DigitalPort;

struct PinConfigurationError : virtual std::exception, virtual boost::exception { };
struct PortDoesNotExistError : PinConfigurationError { };
struct PortBadPinIdError : PinConfigurationError { };
struct PortDuplicateError : PinConfigurationError { };
struct PortDuplicatePinIdError : PinConfigurationError { };
struct PinBadIdError : PinConfigurationError { };
struct SelectManagerDuplicateError : PinConfigurationError { };
struct SelectManagerUnknownTypeError : PinConfigurationError { };
struct SelectManagerDoesNotExistError : PinConfigurationError { };
struct SelectManagerNotCreated : PinConfigurationError { };
struct SelectDuplicateError : PinConfigurationError { };
struct SelectBadStateError : PinConfigurationError { };
struct SelectNoPinsError : PinConfigurationError { };
struct SelectMultiplePortsError : PinConfigurationError { };
struct SelectDoesNotExistError : PinConfigurationError { };
struct SetMultiplePortsError : PinConfigurationError { };
struct SetDuplicateError : PinConfigurationError { };
struct SetDoesNotExistError : PinConfigurationError { };
struct SetNotCreatedError : PinConfigurationError { };

typedef boost::error_info<struct Info_PortName, std::string>
    PortName;
typedef boost::error_info<struct Info_PortId, std::string>
    PinBadId;
typedef boost::error_info<struct Info_PortPinId, unsigned int>
    PortPinId;
typedef boost::error_info<struct Info_SelectManagerName, std::string>
    SelectManagerName;
typedef boost::error_info<struct Info_SelectName, std::string>
    SelectName;
typedef boost::error_info<struct Info_SelectBadState, std::string>
    SelectBadState;
typedef boost::error_info<struct Info_SelectBadType, std::string>
    SelectBadType;
typedef boost::error_info<struct Info_SetName, std::string>
    SetName;

class PinConfiguration {
public:
    struct Port;
    struct Pin {
        Port *parent;
        std::string name;
        unsigned int gid;
        unsigned int pid;
        static constexpr unsigned int NoPin = -1;
        static constexpr unsigned int NoIdSpecified = -2;
        void parse(
            const std::pair<const std::string, boost::property_tree::ptree> &item,
            Port *owner
        );
        Pin();
        Pin(
            const std::pair<const std::string, boost::property_tree::ptree> &item,
            Port *owner
        );
    };
    struct index_gid { };
    struct index_pid { };
    struct index_name { };
    struct index_seq { };
    typedef boost::multi_index::multi_index_container<
        Pin,
        boost::multi_index::indexed_by<
            boost::multi_index::ordered_non_unique<
                boost::multi_index::tag<index_gid>,
                boost::multi_index::member<Pin, unsigned int, &Pin::gid>
            >,
            boost::multi_index::ordered_non_unique<
                boost::multi_index::tag<index_pid>,
                boost::multi_index::member<Pin, unsigned int, &Pin::pid>
            >,
            boost::multi_index::hashed_non_unique<
                boost::multi_index::tag<index_name>,
                boost::multi_index::member<Pin, std::string, &Pin::name>
            >,
            boost::multi_index::sequenced<
                boost::multi_index::tag<index_seq>
            >
        >
    > Pins;
    struct Port {
        std::shared_ptr<DigitalPort> dport;
        Pins pins;
        std::string typeval;
        unsigned int idOffset;
        Port();
        void parse(
            const std::pair<const std::string, boost::property_tree::ptree> &item
        );
        const PinConfiguration::Pins::index<index_gid>::type &gidIndex() const {
            return pins.get<index_gid>();
        }
        const PinConfiguration::Pins::index<index_pid>::type &pidIndex() const {
            return pins.get<index_pid>();
        }
        const PinConfiguration::Pins::index<index_seq>::type &seqIndex() const {
            return pins.get<index_seq>();
        }
    };
    typedef std::unordered_map<std::string, Port>  PortMap;
    struct SelMgr {
        std::shared_ptr<ChipSelectManager> csm;
        std::vector<unsigned int> pins;
        std::unordered_map<std::string, unsigned int> selNames;
        Port *usePort;
        enum MgrType {
            Unknown,
            Binary,
            Multiplexer,
            Pin,
            PinSet
        };
        MgrType type;
        union {
            std::uint32_t selStates;
            bool initSelHigh;
        };
        SelMgr();
        SelMgr(
            const std::pair<const std::string, boost::property_tree::ptree> &item,
            const PinConfiguration *pinconf
        );
    };
    typedef std::unordered_map<std::string, SelMgr>  SelMgrMap;
    struct ChipSel {
        ChipSelect sel;
        SelMgr *mgr;
        int chipId;
        ChipSel() = default;
        ChipSel(SelMgr *m, int id);
    };
    typedef std::unordered_map<std::string, ChipSel>  ChipSelMap;
    struct PinSet {
        DigitalPinSet dpSet;
        Pins pins;
        std::string selName;
        Port *usePort;
        PinSet() = default;
        PinSet(
            const std::pair<const std::string, boost::property_tree::ptree> &item,
            const PinConfiguration *pinconf
        );
        const PinConfiguration::Pins::index<index_seq>::type &seqIndex() const {
            return pins.get<index_seq>();
        }
        PinConfiguration::Pins::index<index_seq>::type::iterator begin() {
            return pins.get<index_seq>().begin();
        }
        PinConfiguration::Pins::index<index_seq>::type::iterator end() {
            return pins.get<index_seq>().end();
        }
    };
    typedef std::unordered_map<std::string, PinSet>  PinSetMap;
private:
    Pins allpins;
    PortMap ports;
    SelMgrMap selMgrs;
    ChipSelMap chipSels;
    PinSetMap pinSets;
public:
    PinConfiguration() = default;
    PinConfiguration(const boost::property_tree::ptree &pt);
    void parse(const boost::property_tree::ptree &pt);
    void attachPort(
        const std::shared_ptr<DigitalPort> &dp,
        const std::string &name = "default"
    );
    const Pin &pin(const std::string &str) const;
    unsigned int pinGlobalId(const std::string &str) const {
        return pin(str).gid;
    }
    const Port &port(const std::string &name = "default") const;
    const PinSet &pinSet(const std::string &name) const;
    const ChipSel &chipSelect(const std::string &name) const;
    const SelMgr &selectManager(const std::string &name) const;
    void getPinSetAndSelect(
        DigitalPinSet &dpset,
        ChipSelect &sel,
        const std::string &setName
    ) const;
    const DigitalPinSet &getPinSet(const std::string &setName) const;
    const ChipSelect &getSelect(const std::string &selName) const;
    DigitalPin getPin(const std::string &pinName) const;
    bool getPin(DigitalPin &dest, const std::string &pinName) const;
    bool havePin(const std::string &pinName) const;
    bool haveChipSelect(const std::string &name) const {
        return chipSels.count(name) > 0;
    }
    PortMap::const_iterator portsBegin() const {
        return ports.cbegin();
    }
    PortMap::const_iterator portsEnd() const {
        return ports.cend();
    }
    SelMgrMap::const_iterator selectManagersBegin() const {
        return selMgrs.cbegin();
    }
    SelMgrMap::const_iterator selectManagersEnd() const {
        return selMgrs.cend();
    }
    ChipSelMap::const_iterator selectsBegin() const {
        return chipSels.cbegin();
    }
    ChipSelMap::const_iterator selectsEnd() const {
        return chipSels.cend();
    }
    PinSetMap::const_iterator pinSetsBegin() const {
        return pinSets.cbegin();
    }
    PinSetMap::const_iterator pinSetsEnd() const {
        return pinSets.cend();
    }
};

} } }