ipbrw.cpp

Go to the documentation of this file.

#include "ipbrw.h"
#include <bits/stdc++.h>
#include <cstdlib> // for rand() function
#include <iostream>

IpBusImpl::IpBusImpl(const std::string &connectionFilePath,
                     const std::string &connectionId) {
  uhal::ConnectionManager connectionMgr(connectionFilePath);
  hardwareInterface =
      new uhal::HwInterface(connectionMgr.getDevice(connectionId));
}

IpBusImpl::~IpBusImpl() {
  delete hardwareInterface;
  hardwareInterface = nullptr;
}

uint32_t IpBusImpl::getSize(const std::string &nodeId) const {
  return this->hardwareInterface->getNode(nodeId).getSize();
}

bool IpBusImpl::read(const std::string &nodeId, uint32_t &result) {
  const uhal::Node &lNode = this->hardwareInterface->getNode(nodeId);
  uhal::ValWord<uint32_t> lReg = lNode.read();
  this->hardwareInterface->dispatch();
  if (!lReg.valid()) {
    std::cerr << "Error: Register read failed." << std::endl;
    return false;
  } else {
    result = lReg.value();
    return true;
  }
}

bool IpBusImpl::write(const std::string &nodeId, const uint32_t value) {
  const uhal::Node &lNode = this->hardwareInterface->getNode(nodeId);
  lNode.write(value);
  this->hardwareInterface->dispatch();
  return true;
}

bool IpBusImpl::readBlock(const std::string &nodeId,
                          std::vector<uint32_t> &results,
                          const uint32_t &aSize) {
  const uhal::Node &lNode = this->hardwareInterface->getNode(nodeId);
  uhal::ValVector<uint32_t> lReg = lNode.readBlock(aSize);
  this->hardwareInterface->dispatch();
  if (!lReg.valid()) {
    std::cerr << "Error: Register read failed." << std::endl;
    return false;
  } else {
    results.clear();
    copy(lReg.begin(), lReg.end(), back_inserter(results));
    return true;
  }
}

bool IpBusImpl::writeBlock(const std::string &nodeId,
                           const std::vector<uint32_t> values) {
  const uhal::Node &lNode = this->hardwareInterface->getNode(nodeId);
  lNode.writeBlock(values);
  this->hardwareInterface->dispatch();
  return true;
}

IpBusImpl *IpBusImpl::pipbus_createSocket(const std::string &connectionFilePath,
                                          const std::string &connectionId) {
  static IpBusImpl _self(connectionFilePath, connectionId);
  return &_self;
}

void IpBusImpl::setLogLevelTo(const std::string level) {
  if (level == "Debug") {
    uhal::setLogLevelTo(uhal::Debug());
  } else if (level == "Info") {
    uhal::setLogLevelTo(uhal::Info());
  } else if (level == "Notice") {
    uhal::setLogLevelTo(uhal::Notice());
  } else if (level == "Warning") {
    uhal::setLogLevelTo(uhal::Warning());
  } else if (level == "Error") {
    uhal::setLogLevelTo(uhal::Error());
  } else if (level == "Fatal") {
    uhal::setLogLevelTo(uhal::Fatal());
  } else {
    std::cerr << "Invalid log level. Use Debug, Info, Notice, Warning, "
              << "Error, or Fatal." << std::endl;
    uhal::setLogLevelTo(uhal::Info());
  }
}

void IpBusImpl::close() {
        if (hardwareInterface != nullptr) {
        try {
                // uHAL does not provide a close method,
                // But we can delete the HwInterface to close the connection.
                delete hardwareInterface;
                hardwareInterface = nullptr;
        } catch (const std::exception& e) {
                std::cerr << "Error closing connection: " << e.what() << std::endl;
        }
        }
}