OpcUa/ServerClientInteraction

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
 
 
#include <iostream>
#include <memory>
#include <locale>
#include <codecvt>
#include <thread>
 
#include <cvb/opcua/server.hpp>
#include <cvb/opcua/client.hpp>
 
#if defined _WIN32 && defined(UNICODE)
#define STDOUT std::wcout
#else
#define STDOUT std::cout
#endif
 
int main(int, char*[])
{
  try
  {
    // shared between server and client
    bool started = false;
    bool stopped = false;
    auto nodeName = CVB_LIT("TestFloatNode");
    std::thread th; // server thread
 
    // setup a server
    auto server = [&]()
    {
      try
      {
        // create actual server object
        auto server = Cvb::OpcUa::Server::Create(4840);
 
        // add a custom namespace (these are used for filtering/sorting data, but are optional, Namespace "0" always exists).
        auto nsIndex = server->AddNameSpace("My Custom Namespace");
 
        // create a nodeId to the "objects" folder, this folder exists/should exist in all server implementations.
        auto root = Cvb::OpcUa::NodeID::Create(Cvb::OpcUa::Namespace0NodeID::OBJECTSFOLDER);
        // create a nodeId of a "folder" type. This is needed to create a folder.
        auto type = Cvb::OpcUa::NodeID::Create(Cvb::OpcUa::Namespace0NodeID::FOLDERTYPE);
        // create a folder node with the previous namespace and nodeId.
        auto folder = Cvb::OpcUa::ObjectNode::CreateFromType(nsIndex, "My Custom Folder", *root, *type);
        // add the node
        server->AddNode(*folder);
 
        // create a "float" node.
        auto node = Cvb::OpcUa::FloatNode::Create(nsIndex, nodeName, *folder->NodeID(), 5.5);
 
        // add the float node.
        server->AddNode(*node);
 
        // register a callback to the float node.
        auto callbackCookieWrite = node->RegisterWriteCallback([&node]()
        {
          STDOUT << CVB_LIT("write to ") << node->DisplayName() << std::endl;
        });
 
        // start the server
        server->Start();
 
        // this simply tells the client thread that the server is ready and can be connected on.
        started = true;
 
        // wait until end of the test.
        while (!stopped)
          std::this_thread::sleep_for(std::chrono::milliseconds(100));
 
        // stop the server.
        server->Stop();
 
        // unregister the callback.
        node->UnregisterCallback(callbackCookieWrite);
      }
      catch (Cvb::OpcUa::OpcUaException e1)
      {
        started = true; // to ignore waiting
        stopped = true;
        std::cout << e1.what() << std::endl;
      }
      catch (const std::exception & ex)
      {
        started = true; // to ignore waiting
        stopped = true;
        std::cout << ex.what() << std::endl;
      }
 
    };
    // start server
    th = std::thread(server);
 
    // wait until server is ready
    while (!started)
      std::this_thread::sleep_for(std::chrono::milliseconds(3));
 
    if (stopped)
      throw std::runtime_error("server creation failed");
 
    try
    {
      // create and connect client (client stops/disconnects at the end of its livetime, hence the extra scope)
      auto client = Cvb::OpcUa::Client::Create(CVB_LIT("opc.tcp://127.0.0.1:4840"));
 
      // get server objectsfolder nodeid
      auto obj = client->Node(*Cvb::OpcUa::NodeID::Create(Cvb::OpcUa::Namespace0NodeID::OBJECTSFOLDER));
 
      // defining our browsefilter
      auto bf = Cvb::OpcUa::BrowseFilter::Create();
      // apply the browsefilter. the result is a vector of nodeIds.
      auto result = obj->Browse(*bf);
 
      // iterate results
      for (const auto & element : result)
      {
        // get generic node (and node properties)
        auto node = client->Node<Cvb::OpcUa::BaseNode>(*element);
 
        // print node displayname and expandedtext (nodeid/namespace)
        auto name = node->DisplayName();
        auto ns = node->NodeID()->ExpandedText();
        std::cout << ns << " " << name << std::endl;
 
        // read and write the value of all FloatNodes
        if (node->NodeClass() == Cvb::OpcUa::NodeClass::Variable)
        {
          // get the node again as a variable node (this way we can get a specific type extracted)
          auto vnode = client->Node<Cvb::OpcUa::VariableNode>(*element);
          if (vnode->DataType() == Cvb::OpcUa::DataType::Double || vnode->DataType() == Cvb::OpcUa::DataType::Float)
          {
            // now get the node a float
            auto fnode = client->Node<Cvb::OpcUa::FloatNode>(*element);
 
            // read -> write -> read
            auto tmp = fnode->Value();
            std::cout << "node value before change " << tmp << std::endl;
            fnode->SetValue(tmp + 1.1);
            std::cout << "node value after change" << fnode->Value() << std::endl;
          }
        }
      }
      // the end of the scope will disconnect the client from the server
 
      // stop the server
      stopped = true;
    }
    catch (Cvb::OpcUa::OpcUaException e1)
    {
      std::cout << "client: " << e1.what() << std::endl;
      stopped = true;
    }
    catch (const std::exception & ex)
    {
      std::cout << "client: " << ex.what() << std::endl;
      stopped = true;
    }
    th.join();
  }
  catch (Cvb::OpcUa::OpcUaException e1)
  {
    std::cout << e1.what() << std::endl;
    return e1.ErrorCode();
  }
  catch (const std::exception & ex)
  {
    std::cout << ex.what() << std::endl;
    return -1;
  }
  return 0;
}