Equipment communication for SECS/GEM, Modbus and OPC UA

memset(&options, 0, sizeof(options));
options.struct_size = (uint32_t)sizeof(options);
options.version = 1;
status = pdcomm_opcua_client_options_init(&options);
if (status != PDCOMM_OPCUA_OK) { print_error("options", status); goto done; }
options.timeout_ms = timeout;
options.policy = policy;
options.mode = mode;
options.flags = policy == PDCOMM_OPCUA_POLICY_NONE ? PDCOMM_OPCUA_ALLOW_NONE : 0;
options.certificate_der.data = certificate;
options.certificate_der.size = certificate_size;
options.private_key_pem.data = key;
options.private_key_pem.size = key_size;
options.trusted_server_der.data = trust;
options.trusted_server_der.size = trust_size;
status = pdcomm_opcua_client_connect((const uint8_t *)argv[1], strlen(argv[1]), &options, &client);
/* The SDK copied the identity; wipe the private key now. */
example_wipe(key, key_size);
key = NULL;
if (status != PDCOMM_OPCUA_OK) { print_error("connect", status); goto done; }
status = pdcomm_opcua_client_activate_anonymous(client);
if (status != PDCOMM_OPCUA_OK) { print_error("activate", status); goto done; }
printf("Session activated (anonymous)\n");

const auto limits = tutorial::itemLimits();
pdcomm::TcpEndpoint transport(argv[3], tutorial::tcpOptions(active ? PDCOMM_TCP_ACTIVE : PDCOMM_TCP_PASSIVE));
std::unique_ptr<pdcomm::GemHost> host;
std::unique_ptr<pdcomm::GemEquipment> equipment;
if (hostRole) host.reset(new pdcomm::GemHost(std::move(transport), pdcomm::gemHostOptions(limits, 64)));
else {
    equipment.reset(new pdcomm::GemEquipment(std::move(transport), limits,
        pdcomm::GemControl::HostOffline, pdcomm::GemOnlineMode::Remote, "PDComm", "0.1.0", 8, 1024, 4096));
    const std::vector<uint8_t> temperature = {0x41, 0xac, 0, 0};
    auto value = pdcomm::SecsItem::primitive(PDCOMM_SECS_F4, temperature, limits);
    equipment->registerStatus(1, "Temperature", "C", value);
    auto lot = pdcomm::SecsItem::primitive(PDCOMM_SECS_ASCII, std::vector<uint8_t>{'L','O','T','-','0','0','1'}, limits);
    equipment->registerStatus(2, "Lot", "", lot);
}
pdcomm::GemEndpoint *endpoint = hostRole ? static_cast<pdcomm::GemEndpoint*>(host.get()) : equipment.get();
endpoint->start();
if (!active) std::cout << "LISTEN " << endpoint->tcp().localAddress() << std::endl;

static async Task<GemEquipmentWorker> StartEquipmentAsync(
    string address,
    HsmsOptions transport,
    SecsLimits limits,
    HsmsWorkerOptions worker,
    CancellationToken cancellationToken)
{
    using SecsItem temperature = SecsItem.FromF4([21.5f], limits);
    using SecsItem lot = SecsItem.FromAscii("LOT-001", limits);
    GemStatusVariable[] variables =
    [
        new(1, "Temperature", "C", temperature),
        new(2, "Lot", "", lot),
    ];
    return await GemEquipmentWorker.StartAsync(
        address,
        transport,
        DemoOptions.Equipment(limits),
        worker,
        variables,
        cancellationToken);
}

using Endpoint = pdcomm::modbus::QtEndpoint;
using Done = std::function<void(const QJsonObject &result, const QString &error)>;

// A worker thread that owns one endpoint.
class Worker {
public:
  Worker() {
    context_->moveToThread(&thread_);
    // The context and its poll timer are deleted on the worker thread.
    QObject::connect(&thread_, &QThread::finished, context_, &QObject::deleteLater);
    thread_.start();
  }
  ~Worker() {
    thread_.quit();
    thread_.wait();
  }

  // Runs one command on the worker thread and hands the result to `done` on
  // the main thread.
  void call(const QJsonObject &command, Done done) {
    QMetaObject::invokeMethod(context_, [this, command, done] {
      QJsonObject result;
      QString error;
      try {
        result = endpoint_.call(command);
      } catch (const std::exception &failure) {
        error = QString::fromUtf8(failure.what());
      }
      QMetaObject::invokeMethod(qApp, [done, result, error] { done(result, error); },
                                Qt::QueuedConnection);
    }, Qt::QueuedConnection);
  }