HwInterface.cpp

Go to the documentation of this file.

#include "HwInterface.h"
#include <filesystem>
#include <iostream>
 
using namespace PIpBusInterface;
 
// Static member initialization
SocketManager HwInterface::manager = SocketManager();

HwInterface::HwInterface(std::string connectionFilePath,
                         std::string connectionId,
                         PSocketMode::PSocketMode mock_mode,
                         std::string mock_directory)
    : connectionFilePath(connectionFilePath), connectionId(connectionId),
      mock_mode(mock_mode), mock_directory(mock_directory) {
  if (mock_directory.empty()) {
    mock_directory = connectionId + "_mock_dir"; // Default directory
  }
  std::filesystem::create_directory(mock_directory);
  manager.setMode(mock_mode);
 
  log(uhal::Debug(),
      "Creating HwInterface. Adding server socket for device: ", connectionId,
      " from ", connectionFilePath);
  data_stream_assert(manager.addServerSocket(connectionId, PSocketParam{"localhost", 3390}, Backend::server(connectionFilePath, connectionId), "./", Mock::server()));
}

HwInterface::~HwInterface() {
  nodes.clear();
  log(uhal::Debug(), "Deleting HwInterface:", connectionFilePath, ", ",
      connectionId);
}

Node &HwInterface::getNode(const std::string nodeId) {
  if (nodes.count(nodeId)) {
    return *nodes[nodeId];
  }
  nodes[nodeId] = std::unique_ptr<Node>(new Node(this, nodeId));
  return *nodes[nodeId];
}

bool HwInterface::write(const std::string &nodeId, const uint32_t &aValue) {
  std::vector<uint32_t> data = {aValue};
  UaMessage msgOut{connectionId, nodeId, &data};
  return manager.sendMsg(connectionId, msgOut);
}

uint32_t HwInterface::read(const std::string nodeId) const {
  UaMessage UaMessage(connectionId, nodeId);
  manager.recvMsg(connectionId, UaMessage);
  std::vector<uint32_t> *valuePtr = UaMessage.value.get();
  return valuePtr->at(0);
}

bool HwInterface::writeBlock(const std::string &nodeId,
                             const std::vector<uint32_t> &aValues) const {
  UaMessage msgOut{connectionId, nodeId, &aValues};
  return manager.sendMsg(connectionId, msgOut);
}

std::vector<uint32_t> HwInterface::readBlock(const std::string &nodeId,
                                             const uint32_t &aSize) const {
  UaMessage msg{connectionId, nodeId, aSize};
  manager.recvMsg(connectionId, msg);
  return *msg.value.get();
}

Node::Node(HwInterface *_hwInterface, const std::string _nodeId)
    : hwInterface(_hwInterface), nodeId(_nodeId) {
  log(uhal::Debug(), "Creating node: ", nodeId);
}

Node::~Node() { log(uhal::Debug(), "Deleting node: ", nodeId); }

bool Node::write(const uint32_t &aValue) const {
  hwInterface->write(nodeId, aValue);
  return true;
}

uint32_t Node::read() const { return hwInterface->read(nodeId); }

std::vector<uint32_t> Node::readBlock(const uint32_t &aSize) const {
  return hwInterface->readBlock(nodeId, aSize);
}

bool Node::writeBlock(const std::vector<uint32_t> &aValues) const {
  return hwInterface->writeBlock(nodeId, aValues);
}