open62541.hpp

Go to the documentation of this file.

 
#ifndef CORE_PROTOCOL_OPEN62541_OPEN62541_HPP_
#define CORE_PROTOCOL_OPEN62541_OPEN62541_HPP_
 
// System header files
#include <chrono>
#include <string>
#include <thread>
#include <mutex>
#include <atomic>
 
// Third party headers
#include <log4cplus/logger.h>
#include <open62541.h>
 
// Local header files
#include "ifw/core/protocol/base/dispatcher.hpp"
#include "ifw/core/protocol/base/iComm.hpp"
#include "ifw/core/protocol/open62541/iDataChangeHandler.hpp"
#include "ifw/core/protocol/open62541/monitoredItem.hpp"
#include "ifw/core/protocol/open62541/subscription.hpp"
 
 
using namespace std::literals::chrono_literals;
 
namespace protocol::opcua {
class IDataChangeHandler;
 
struct OpcuaConnection {
    UA_Client *m_client;
    std::atomic<bool> m_connected {false};
    std::atomic<bool> m_lost_connection {false};
 
    UA_StatusCode m_last_error{0};
    UA_SecureChannelState m_last_channel_state{UA_SECURECHANNELSTATE_CLOSED};
    UA_SecureChannelState m_channel_state{UA_SECURECHANNELSTATE_CLOSED};
    UA_SessionState m_last_session_state{UA_SESSIONSTATE_CLOSED};
    UA_SessionState m_session_state{UA_SESSIONSTATE_CLOSED};
    UA_StatusCode m_last_connect_status{UA_STATUSCODE_BADCONNECTIONCLOSED};
    UA_StatusCode m_connect_status{UA_STATUSCODE_GOOD};
    std::mutex m_mutex;
};
 
class Open62541 : public protocol::base::IComm, public IDataChangeHandler {
 
    static constexpr std::chrono::milliseconds NETWORK_TIMEOUT = 2000ms;
 
 
public:
    Open62541();
    virtual ~Open62541();
 
    virtual void Connect(const std::string& device, const std::string& address);
 
    virtual void Read(protocol::base::VectorVariant &params) override;
 
    virtual void Write(const protocol::base::VectorVariant& params) override;
 
    virtual void Rpc(const std::string& obj,
                     const std::string& proc,
                     const protocol::base::VectorVariant& params,
                     protocol::base::Variant& result) override;
 
    UA_StatusCode ResumeSubscriptions();
 
    virtual void StartMonitorItem(const std::string& item) override;
 
    virtual void StartMonitorItems(const std::vector<std::string>& item_vector) override;
 
    virtual void StopMonitorItem(const std::string& item) override;
 
    virtual void Disconnect();
 
    virtual void
    RegisterCB(protocol::base::Dispatcher<protocol::base::VectorVariant &> &dispatcher,
               protocol::base::Dispatcher<> &failure,
               protocol::base::Dispatcher<> &normal);
 
 
    void SetEndpoint(const std::string &endpoint);
 
    std::string GetEndpoint() const;
 
    virtual void HandleDataChange(const std::shared_ptr<MonitoredItem> monitor_item,
                                  UA_DataValue* value);
    virtual void HandleSessionChanges(bool status);
 
    void UpdateState(UA_SecureChannelState channel_state,
                     UA_SessionState session_state,
                     UA_StatusCode recovery_status);
 
    inline static std::map<std::string, std::shared_ptr<OpcuaConnection>>
                                                       m_connection_map;
 
private:
 
    bool IsConnected(const std::string &address);
 
    void InactivityAcions();
 
    UA_StatusCode CreateSubscription(bool renew_monitor_items = false);
 
    void RemoveSubscription();
 
    void GetNodeId(std::string value, int &ns, std::string &name);
 
    static void InactivityCallback(UA_Client *client);
 
    static void StateCallback(UA_Client *client,
                              UA_SecureChannelState channelState,
                              UA_SessionState sessionState,
                              UA_StatusCode recoveryStatus);
 
 
 
    SubscriptionPtr m_subscription;
 
    std::string m_endpoint;
 
    bool m_monitoring;
 
    inline static std::map<std::string, std::pair<std::string, Open62541*>> m_registration_map;
 
    std::string m_device;
 
    std::map<std::string, MonitoredItemPtr> m_map_monitor_items;
 
    protocol::base::Dispatcher<protocol::base::VectorVariant &> m_dispatcher;
 
    protocol::base::Dispatcher<> m_failure;
 
    protocol::base::Dispatcher<> m_normal;
 
    log4cplus::Logger m_logger;
 
 
};
 
} // namespace protocol::opcua
 
#endif // CORE_PROTOCOL_OPEN62541_OPEN62541_HPP_