TractionThrottleInterface.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_TRACTIONTHROTTLEINTERFACE_HXX_
#define _OPENLCB_TRACTIONTHROTTLEINTERFACE_HXX_
 
#include "executor/CallableFlow.hxx"
#include "openlcb/Defs.hxx"
#include "openlcb/TrainInterface.hxx"
 
namespace openlcb
{
 
class Node;
struct TractionThrottleInput;
 
struct TractionThrottleCommands
{
    enum SetDst
    {
        SET_DST,
    };
 
    enum AssignTrain
    {
        ASSIGN_TRAIN,
    };
 
    enum ReleaseTrain
    {
        RELEASE_TRAIN,
    };
 
    enum LoadState
    {
        LOAD_STATE,
    };
 
    enum ConsistAdd
    {
        CONSIST_ADD,
    };
 
    enum ConsistDel
    {
        CONSIST_DEL,
    };
 
    enum ConsistQry
    {
        CONSIST_QRY,
    };
};
 
struct TractionThrottleInput : public CallableFlowRequestBase
{
    enum Command
    {
        CMD_SET_DST,
        CMD_ASSIGN_TRAIN,
        CMD_RELEASE_TRAIN,
        CMD_LOAD_STATE,
        CMD_CONSIST_ADD,
        CMD_CONSIST_DEL,
        CMD_CONSIST_QRY,
    };
 
    void reset(const TractionThrottleCommands::SetDst &, const NodeID &dst)
    {
        cmd = CMD_SET_DST;
        this->dst = dst;
    }
 
    void reset(const TractionThrottleCommands::AssignTrain &, const NodeID &dst,
        bool listen)
    {
        cmd = CMD_ASSIGN_TRAIN;
        this->dst = dst;
        this->flags = listen ? 1 : 0;
    }
 
    void reset(const TractionThrottleCommands::ReleaseTrain &)
    {
        cmd = CMD_RELEASE_TRAIN;
    }
 
    void reset(const TractionThrottleCommands::LoadState &)
    {
        cmd = CMD_LOAD_STATE;
    }
 
    void reset(const TractionThrottleCommands::ConsistAdd &, NodeID slave,
        uint8_t flags)
    {
        cmd = CMD_CONSIST_ADD;
        dst = slave;
        this->flags = flags;
    }
 
    void reset(const TractionThrottleCommands::ConsistDel &, NodeID slave)
    {
        cmd = CMD_CONSIST_DEL;
        dst = slave;
    }
 
    void reset(const TractionThrottleCommands::ConsistQry &)
    {
        cmd = CMD_CONSIST_QRY;
        replyCause = 0xff;
    }
 
    void reset(const TractionThrottleCommands::ConsistQry &, uint8_t ofs)
    {
        cmd = CMD_CONSIST_QRY;
        consistIndex = ofs;
        replyCause = 0;
    }
 
    Command cmd;
    NodeID dst;
    uint8_t flags;
 
    uint8_t replyCause;
    uint8_t consistCount;
    uint8_t consistIndex;
};
 
class TractionThrottleInterface : public openlcb::TrainImpl
{
public:
    virtual void toggle_fn(uint32_t fn) = 0;
 
    virtual void query_fn(uint32_t fn)
    {
    }
 
    virtual bool is_train_assigned() = 0;
 
    virtual openlcb::Node *throttle_node() = 0;
 
    virtual void set_throttle_listener(
        std::function<void(int fn)> update_callback) = 0;
 
    virtual openlcb::NodeID target_node() = 0;
};
 
class TractionThrottleBase : public CallableFlow<TractionThrottleInput>,
                             public TractionThrottleInterface
{
public:
    TractionThrottleBase(Service *s)
        : CallableFlow<TractionThrottleInput>(s)
    {
    }
 
    enum
    {
        FN_NOT_KNOWN = 0xffff,
    };
};
 
} // namespace openlcb
 
#endif // _OPENLCB_TRACTIONTHROTTLEINTERFACE_HXX_