DccAccyConsumer.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_DCCACCYCONSUMER_HXX_
#define _OPENLCB_DCCACCYCONSUMER_HXX_
 
#include "dcc/TrackIf.hxx"
#include "openlcb/EventHandlerTemplates.hxx"
#include "openlcb/TractionDefs.hxx"
 
namespace openlcb
{
 
class DccAccyConsumerBase : public SimpleEventHandler
{
protected:
    DccAccyConsumerBase(Node *node)
        : node_(node)
    {
        EventRegistry::instance()->register_handler(
            EventRegistryEntry(
                this, TractionDefs::ACTIVATE_BASIC_DCC_ACCESSORY_EVENT_BASE),
            12);
        EventRegistry::instance()->register_handler(
            EventRegistryEntry(
                this, TractionDefs::INACTIVATE_BASIC_DCC_ACCESSORY_EVENT_BASE),
            12);
        memset(lastSetState_, 0, sizeof(lastSetState_));
        memset(isStateKnown_, 0, sizeof(isStateKnown_));
    }
 
    ~DccAccyConsumerBase()
    {
        EventRegistry::instance()->unregister_handler(this);
    }
 
    void handle_identify_global(const EventRegistryEntry &registry_entry,
        EventReport *event, BarrierNotifiable *done) OVERRIDE
    {
        AutoNotify an(done);
        if (event->dst_node && event->dst_node != node_)
        {
            return;
        }
        if (registry_entry.event ==
            TractionDefs::ACTIVATE_BASIC_DCC_ACCESSORY_EVENT_BASE)
        {
            event->event_write_helper<1>()->WriteAsync(node_,
                Defs::MTI_CONSUMER_IDENTIFIED_RANGE, WriteHelper::global(),
                eventid_to_buffer(EncodeRange(
                    TractionDefs::ACTIVATE_BASIC_DCC_ACCESSORY_EVENT_BASE,
                    4095)),
                done->new_child());
        }
        if (registry_entry.event ==
            TractionDefs::INACTIVATE_BASIC_DCC_ACCESSORY_EVENT_BASE)
        {
            event->event_write_helper<2>()->WriteAsync(node_,
                Defs::MTI_CONSUMER_IDENTIFIED_RANGE, WriteHelper::global(),
                eventid_to_buffer(EncodeRange(
                    TractionDefs::INACTIVATE_BASIC_DCC_ACCESSORY_EVENT_BASE,
                    4095)),
                done->new_child());
        }
    }
 
    void handle_event_report(const EventRegistryEntry &registry_entry,
        EventReport *event, BarrierNotifiable *done) override
    {
        AutoNotify an(done);
        if (!parse_event(event->event))
        {
            return;
        }
        uint32_t m = (1U) << eventMask_;
        isStateKnown_[eventOfs_] |= m;
        if (normalReverse_)
        {
            lastSetState_[eventOfs_] |= m;
        }
        else
        {
            lastSetState_[eventOfs_] &= ~m;
        }
 
        send_accy_command();
    }
 
    void handle_identify_consumer(const EventRegistryEntry &entry,
        EventReport *event, BarrierNotifiable *done) override
    {
        AutoNotify an(done);
        if (!parse_event(event->event))
        {
            return;
        }
        uint32_t m = (1U) << eventMask_;
        EventState s;
        if (isStateKnown_[eventOfs_] & m)
        {
            if (lastSetState_[eventOfs_] & m)
            {
                // normal
                s = EventState::VALID;
            }
            else
            {
                // reversed
                s = EventState::INVALID;
            }
            if (normalReverse_ != 1)
            {
                // query was reversed. invert the event state
                s = invert_event_state(s);
            }
        }
        else
        {
            s = EventState::UNKNOWN;
        }
        Defs::MTI mti = Defs::MTI_CONSUMER_IDENTIFIED_VALID + s;
        event->event_write_helper<1>()->WriteAsync(node_, mti,
            WriteHelper::global(), eventid_to_buffer(event->event),
            done->new_child());
    }
 
    virtual void send_accy_command() = 0;
 
    bool parse_event(EventId event)
    {
        if (event >= TractionDefs::ACTIVATE_BASIC_DCC_ACCESSORY_EVENT_BASE &&
            event <
                TractionDefs::ACTIVATE_BASIC_DCC_ACCESSORY_EVENT_BASE + 4096)
        {
            onOff_ = 1;
            dccAddress_ =
                event - TractionDefs::ACTIVATE_BASIC_DCC_ACCESSORY_EVENT_BASE;
        }
        else if (event >=
                TractionDefs::INACTIVATE_BASIC_DCC_ACCESSORY_EVENT_BASE &&
            event <
                TractionDefs::INACTIVATE_BASIC_DCC_ACCESSORY_EVENT_BASE + 4096)
        {
            onOff_ = 0;
            dccAddress_ =
                event - TractionDefs::INACTIVATE_BASIC_DCC_ACCESSORY_EVENT_BASE;
        }
        else
        {
            return false;
        }
        normalReverse_ = dccAddress_ & 1;
        eventOfs_ = dccAddress_ >> 6;
        eventMask_ = (dccAddress_ >> 1) & 31;
        return true;
    }
 
    unsigned onOff_ : 1;
    unsigned normalReverse_ : 1;
    unsigned dccAddress_ : 12;
    unsigned eventOfs_ : 6;
    unsigned eventMask_ : 5;
 
    uint32_t lastSetState_[64];
    uint32_t isStateKnown_[64];
 
    Node *node_;
};
 
class DccAccyConsumer : public DccAccyConsumerBase
{
public:
    DccAccyConsumer(Node *node, dcc::TrackIf *track)
        : DccAccyConsumerBase(node)
        , track_(track)
    {
    }
 
    ~DccAccyConsumer()
    {
    }
 
private:
    void send_accy_command() override
    {
        dcc::TrackIf::message_type *pkt;
        mainBufferPool->alloc(&pkt);
        pkt->data()->add_dcc_basic_accessory(dccAddress_, onOff_);
        pkt->data()->packet_header.rept_count = 3;
        track_->send(pkt);
    }
 
    dcc::TrackIf *track_;
};
 
class DccExtAccyConsumerBase : public SimpleEventHandler
{
protected:
    static constexpr unsigned NUM_ADDRESS = 2048;
    static constexpr unsigned NUM_ASPECT = 256;
    static constexpr unsigned NUM_EVENT = NUM_ASPECT * NUM_ADDRESS;
    
    DccExtAccyConsumerBase(Node *node)
        : node_(node)
    {
        EventRegistry::instance()->register_handler(
            EventRegistryEntry(
                this, TractionDefs::EXT_DCC_ACCESSORY_EVENT_BASE),
            11+8 /*number of bits*/);
    }
 
    ~DccExtAccyConsumerBase()
    {
        EventRegistry::instance()->unregister_handler(this);
    }
 
    void handle_identify_global(const EventRegistryEntry &registry_entry,
        EventReport *event, BarrierNotifiable *done) OVERRIDE
    {
        AutoNotify an(done);
        if (event->dst_node && event->dst_node != node_)
        {
            return;
        }
        event->event_write_helper<1>()->WriteAsync(node_,
            Defs::MTI_CONSUMER_IDENTIFIED_RANGE, WriteHelper::global(),
            eventid_to_buffer(EncodeRange(
                TractionDefs::EXT_DCC_ACCESSORY_EVENT_BASE, NUM_EVENT - 1)),
            done->new_child());
    }
 
    void handle_event_report(const EventRegistryEntry &registry_entry,
        EventReport *event, BarrierNotifiable *done) override
    {
        AutoNotify an(done);
        if (!parse_event(event->event))
        {
            return;
        }
        send_accy_command();
    }
 
    void handle_identify_consumer(const EventRegistryEntry &entry,
        EventReport *event, BarrierNotifiable *done) override
    {
        AutoNotify an(done);
        if (!parse_event(event->event))
        {
            return;
        }
        event->event_write_helper<1>()->WriteAsync(node_,
            Defs::MTI_CONSUMER_IDENTIFIED_UNKNOWN, WriteHelper::global(),
            eventid_to_buffer(event->event), done->new_child());
    }
 
    virtual void send_accy_command() = 0;
 
    bool parse_event(EventId event)
    {
        if (event >= TractionDefs::EXT_DCC_ACCESSORY_EVENT_BASE &&
            event <
                TractionDefs::EXT_DCC_ACCESSORY_EVENT_BASE + NUM_EVENT)
        {
            aspect_ = event & 0xff;
            dccAddress_ = (event >> 8) & (NUM_ADDRESS - 1);
            return true;
        }
        else
        {
            return false;
        }
    }
 
 
    unsigned dccAddress_ : 11;
    unsigned aspect_ : 8;
 
    Node *node_;
};
 
class DccExtAccyConsumer : public DccExtAccyConsumerBase
{
public:
    DccExtAccyConsumer(Node *node, dcc::TrackIf *track)
        : DccExtAccyConsumerBase(node)
        , track_(track)
    {
    }
 
    ~DccExtAccyConsumer()
    {
    }
 
private:
    void send_accy_command() override
    {
        dcc::TrackIf::message_type *pkt;
        mainBufferPool->alloc(&pkt);
        pkt->data()->add_dcc_ext_accessory(dccAddress_, aspect_);
        pkt->data()->packet_header.rept_count = 3;
        track_->send(pkt);
    }
 
    dcc::TrackIf *track_;
};
 
 
} // namespace openlcb
 
#endif  // _OPENLCB_DCCACCYCONSUMER_HXX_