SimpleStack.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_SIMPLESTACK_HXX_
#define _OPENLCB_SIMPLESTACK_HXX_
 
#include <fcntl.h>
 
#include "executor/Executor.hxx"
#include "nmranet_config.h"
#include "openmrn_features.h"
#include "openlcb/AliasAllocator.hxx"
#include "openlcb/ConfigRepresentation.hxx"
#include "openlcb/ConfigUpdateFlow.hxx"
#include "openlcb/DatagramCan.hxx"
#include "openlcb/DatagramTcp.hxx"
#include "openlcb/DefaultNode.hxx"
#include "openlcb/EventHandlerTemplates.hxx"
#include "openlcb/EventService.hxx"
#include "openlcb/IfCan.hxx"
#include "openlcb/MemoryConfig.hxx"
#include "openlcb/NodeInitializeFlow.hxx"
#include "openlcb/ProtocolIdentification.hxx"
#include "openlcb/SimpleNodeInfo.hxx"
#include "openlcb/TractionTrain.hxx"
#include "openlcb/TrainInterface.hxx"
#include "utils/ActivityLed.hxx"
#include "utils/GcTcpHub.hxx"
#include "utils/GridConnectHub.hxx"
#include "utils/HubDevice.hxx"
#include "utils/HubDeviceNonBlock.hxx"
#ifdef OPENMRN_FEATURE_FD_CAN_DEVICE
#include "utils/HubDeviceSelect.hxx"
#endif
 
namespace openmrn_arduino
{
class OpenMRN;
}
 
namespace openlcb
{
 
extern const char CDI_DATA[];
 
extern const char *const CONFIG_FILENAME;
extern const size_t CONFIG_FILE_SIZE;
 
class SimpleStackBase
{
protected:
    class PhysicalIf
    {
    public:
        virtual ~PhysicalIf()
        {
        }
 
        virtual If *iface() = 0;
        virtual DatagramService *datagram_service() = 0;
    };
 
public:
    static const unsigned EXECUTOR_PRIORITIES = 5;
 
    SimpleStackBase(
        std::function<std::unique_ptr<PhysicalIf>()> create_if_helper);
 
    Executor<EXECUTOR_PRIORITIES> *executor()
    {
        return &executor_;
    }
 
    Service *service()
    {
        return &service_;
    }
 
    If *iface()
    {
        return iface_;
    }
 
    DatagramService *dg_service()
    {
        return datagramService_;
    }
 
    SimpleInfoFlow *info_flow()
    {
        return &infoFlow_;
    }
 
    virtual Node *node() = 0;
 
    MemoryConfigHandler *memory_config_handler()
    {
        return &memoryConfigHandler_;
    }
 
    ConfigUpdateService *config_service()
    {
        return &configUpdateFlow_;
    }
 
    void set_tx_activity_led(
        const Gpio *led, long long period = MSEC_TO_NSEC(33))
    {
        auto *al = new ActivityLed(iface(), led, period);
        iface()->set_tx_hook(std::bind(&ActivityLed::activity, al));
    }
 
    void restart_stack();
 
    friend class ::openmrn_arduino::OpenMRN;
 
    void loop_executor(bool delay_start = false)
    {
        start_stack(delay_start);
        executor_.thread_body();
    }
 
    void start_after_delay();
 
    void start_executor_thread(const char *name, int priority,
        size_t stack_size, bool delay_start = false)
    {
        start_stack(delay_start);
        executor_.start_thread(name, priority, stack_size);
    }
 
    int create_config_file_if_needed(const InternalConfigData &ofs,
        uint16_t expected_version, unsigned file_size);
 
    int check_version_and_factory_reset(const InternalConfigData &ofs,
        uint16_t expected_version, bool force = false);
 
    static void factory_reset_all_events(
        const InternalConfigData &ofs, uint64_t node_id, int fd);
 
    static void set_event_offsets(const vector<uint16_t> *offsets);
 
    void send_event(uint64_t event_id)
    {
        auto *b = node()->iface()->global_message_write_flow()->alloc();
        b->data()->reset(Defs::MTI_EVENT_REPORT, node()->node_id(),
            eventid_to_buffer(event_id));
        node()->iface()->global_message_write_flow()->send(b);
    }
 
    void send_message_to(
        Defs::MTI mti, NodeHandle dst, const string &payload = EMPTY_PAYLOAD)
    {
        auto *b = node()->iface()->addressed_message_write_flow()->alloc();
        b->data()->reset(mti, node()->node_id(), dst, payload);
        node()->iface()->addressed_message_write_flow()->send(b);
    }
 
    virtual uint64_t get_pip()
    {
        return 0;
    }
 
protected:
    void start_stack(bool delay_start);
 
    virtual void start_iface(bool restart) = 0;
 
    virtual void start_node() = 0;
 
    void default_start_node();
 
    Executor<EXECUTOR_PRIORITIES> executor_ {NO_THREAD()};
    Service service_ {&executor_};
    std::unique_ptr<PhysicalIf> ifaceHolder_;
    If *iface_ {ifaceHolder_->iface()};
    DatagramService *datagramService_ {ifaceHolder_->datagram_service()};
    ConfigUpdateFlow configUpdateFlow_ {iface()};
    InitializeFlow initFlow_ {&service_};
    EventService eventService_ {iface()};
    SimpleInfoFlow infoFlow_ {iface()};
 
    MemoryConfigHandler memoryConfigHandler_ {
        datagramService_, nullptr, config_num_memory_spaces()};
 
    std::unique_ptr<HubFlow> gcHub_;
    std::unique_ptr<GCAdapterBase> gcAdapter_;
    std::vector<std::unique_ptr<Destructable>> additionalComponents_;
};
 
class SimpleCanStackBase : public SimpleStackBase
{
public:
    SimpleCanStackBase(const openlcb::NodeID node_id);
 
    CanHubFlow *can_hub()
    {
        return &static_cast<CanPhysicalIf *>(ifaceHolder_.get())->canHub0_;
    }
 
    void add_can_port_blocking(const char *device)
    {
        int can_fd = ::open(device, O_RDWR);
        HASSERT(can_fd >= 0);
        auto *port = new FdHubPort<CanHubFlow>(
            can_hub(), can_fd, EmptyNotifiable::DefaultInstance());
        additionalComponents_.emplace_back(port);
    }
 
#ifdef OPENMRN_FEATURE_FD_CAN_DEVICE
    void add_can_port_async(const char *device)
    {
        auto *port = new HubDeviceNonBlock<CanHubFlow>(can_hub(), device);
        additionalComponents_.emplace_back(port);
    }
 
    void add_can_port_select(const char *device)
    {
        auto *port = new HubDeviceSelect<CanHubFlow>(can_hub(), device);
        additionalComponents_.emplace_back(port);
    }
 
    void add_can_port_select(int fd, Notifiable *on_error = nullptr)
    {
        auto *port = new HubDeviceSelect<CanHubFlow>(can_hub(), fd, on_error);
        additionalComponents_.emplace_back(port);
    }
#endif // OPENMRN_FEATURE_FD_CAN_DEVICE
 
    void add_gridconnect_port(const char *path, Notifiable *on_exit = nullptr);
 
#if defined(__linux__) || defined(__MACH__)
    void add_gridconnect_tty(const char *device, Notifiable *on_exit = nullptr);
#endif
#if defined(__linux__)
    void add_socketcan_port_select(const char *device, int loopback = 1);
#endif
 
    void start_tcp_hub_server(int port = 12021)
    {
        gcHubServer_.reset(new GcTcpHub(can_hub(), port));
    }
 
    GcTcpHub *get_tcp_hub_server()
    {
        return gcHubServer_.get();
    }
 
    void shutdown_tcp_hub_server()
    {
        gcHubServer_.reset(nullptr);
    }
 
    void connect_tcp_gridconnect_hub(const char *host, int port)
    {
        int fd = ConnectSocket(host, port);
        HASSERT(fd >= 0);
        create_gc_port_for_can_hub(can_hub(), fd);
    }
 
    void print_all_packets(bool timestamped = false)
    {
        auto *port = new DisplayPort(&service_, timestamped);
        gridconnect_hub()->register_port(port);
        additionalComponents_.emplace_back(port);
    }
 
    HubFlow *gridconnect_hub()
    {
        if (!gcHub_)
        {
            gcHub_.reset(new HubFlow(&service_));
            gcAdapter_.reset(GCAdapterBase::CreateGridConnectAdapter(
                gcHub_.get(), can_hub(), false));
        }
        return gcHub_.get();
    }
 
    IfCan *if_can()
    {
        return &static_cast<CanPhysicalIf *>(ifaceHolder_.get())->ifCan_;
    }
 
    void add_stream_support();
 
    class WithStreamSupport
    {
    public:
        WithStreamSupport(SimpleCanStackBase *p)
        {
            p->add_stream_support();
        }
    };
 
protected:
    void start_iface(bool restart) override;
    
private:
    class CanPhysicalIf : public PhysicalIf
    {
    public:
        CanPhysicalIf(const openlcb::NodeID node_id, Service *service)
            : canHub0_(service)
            , ifCan_(service->executor(), &canHub0_,
                  config_local_alias_cache_size(),
                  config_remote_alias_cache_size(), config_local_nodes_count())
            , datagramService_(&ifCan_, config_num_datagram_registry_entries(),
                  config_num_datagram_clients())
        {
            AddAliasAllocator(node_id, &ifCan_);
        }
 
        ~CanPhysicalIf()
        {
        }
 
        If *iface() override
        {
            return &ifCan_;
        }
        DatagramService *datagram_service() override
        {
            return &datagramService_;
        }
        CanHubFlow canHub0_;
        IfCan ifCan_;
        CanDatagramService datagramService_;
    };
 
    std::unique_ptr<PhysicalIf> create_if(const openlcb::NodeID node_id);
 
    std::unique_ptr<GcTcpHub> gcHubServer_;
};
 
class SimpleTcpStackBase : public SimpleStackBase
{
public:
    SimpleTcpStackBase(const openlcb::NodeID node_id);
 
    void add_tcp_port_select(int fd, Notifiable* on_error = nullptr)
    {
        if_tcp()->add_network_fd(fd, on_error);
    }
 
protected:
    void start_iface(bool restart) override;
 
private:
    HubFlow *tcp_hub()
    {
        return &static_cast<TcpPhysicalIf *>(ifaceHolder_.get())->tcpHub_;
    }
 
    IfTcp* if_tcp()
    {
        return &static_cast<TcpPhysicalIf *>(ifaceHolder_.get())->ifTcp_;
    }
 
    class TcpPhysicalIf : public PhysicalIf
    {
    public:
        TcpPhysicalIf(const openlcb::NodeID node_id, Service *service)
            : tcpHub_(service)
            , ifTcp_(node_id, &tcpHub_, config_local_nodes_count())
            , datagramService_(&ifTcp_, config_num_datagram_registry_entries(),
                  config_num_datagram_clients())
        {
        }
 
        ~TcpPhysicalIf()
        {
        }
 
        If *iface() override
        {
            return &ifTcp_;
        }
        DatagramService *datagram_service() override
        {
            return &datagramService_;
        }
        HubFlow tcpHub_;
        IfTcp ifTcp_;
        TcpDatagramService datagramService_;
    };
 
    std::unique_ptr<PhysicalIf> create_if(const openlcb::NodeID node_id);
};
 
class SimpleCanStack : public SimpleCanStackBase
{
public:
    SimpleCanStack(const openlcb::NodeID node_id);
 
    Node *node() override
    {
        return &node_;
    }
 
private:
    static const auto PIP_RESPONSE = Defs::EVENT_EXCHANGE | Defs::DATAGRAM |
        Defs::MEMORY_CONFIGURATION | Defs::ABBREVIATED_DEFAULT_CDI |
        Defs::SIMPLE_NODE_INFORMATION | Defs::CDI;
 
    void start_node() override
    {
        default_start_node();
    }
 
    uint64_t get_pip() override
    {
        return PIP_RESPONSE;
    }
 
    DefaultNode node_;
    ProtocolIdentificationHandler pipHandler_ {&node_, PIP_RESPONSE};
    SNIPHandler snipHandler_ {iface(), &node_, &infoFlow_};
};
 
class SimpleTcpStack : public SimpleTcpStackBase
{
public:
    SimpleTcpStack(const openlcb::NodeID node_id);
 
    Node *node() override
    {
        return &node_;
    }
 
private:
    static const auto PIP_RESPONSE = Defs::EVENT_EXCHANGE | Defs::DATAGRAM |
        Defs::MEMORY_CONFIGURATION | Defs::ABBREVIATED_DEFAULT_CDI |
        Defs::SIMPLE_NODE_INFORMATION | Defs::CDI;
 
    void start_node() override
    {
        default_start_node();
    }
 
    uint64_t get_pip() override
    {
        return PIP_RESPONSE;
    }
 
    DefaultNode node_;
    ProtocolIdentificationHandler pipHandler_ {&node_, PIP_RESPONSE};
    SNIPHandler snipHandler_ {iface(), &node_, &infoFlow_};
};
 
class SimpleTrainCanStack : public SimpleCanStackBase
{
public:
    SimpleTrainCanStack(
        openlcb::TrainImpl *train, const char *fdi_xml, NodeID node_id);
 
    Node *node() override
    {
        return &trainNode_;
    }
 
private:
    static const auto PIP_RESPONSE = openlcb::Defs::SIMPLE_PROTOCOL_SUBSET |
        openlcb::Defs::DATAGRAM | openlcb::Defs::MEMORY_CONFIGURATION |
        openlcb::Defs::EVENT_EXCHANGE | openlcb::Defs::SIMPLE_NODE_INFORMATION |
        openlcb::Defs::TRACTION_CONTROL | openlcb::Defs::TRACTION_FDI |
        Defs::ABBREVIATED_DEFAULT_CDI | Defs::CDI;
 
    void start_node() override;
 
    uint64_t get_pip() override
    {
        return PIP_RESPONSE;
    }
 
    TrainService tractionService_ {iface()};
    TrainNodeWithId trainNode_;
    FixedEventProducer<openlcb::TractionDefs::IS_TRAIN_EVENT>
        isTrainEventHandler {&trainNode_};
    ReadOnlyMemoryBlock fdiBlock_;
    ProtocolIdentificationHandler pipHandler_ {&trainNode_, PIP_RESPONSE};
    SNIPHandler snipHandler_ {iface(), &trainNode_, &infoFlow_};
};
 
} // namespace openlcb
 
#endif //  _OPENLCB_SIMPLESTACK_HXX_