device.h

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <expected>
#include <format>
#include <memory>
#include <mutex>
#include <nlohmann/json_fwd.hpp>
#include <optional>
#include <span>
#include <string>
#include <unordered_map>
#include <variant>
#include <vector>
 
#include "comm/fieldbus_driver.h"
#include "node/device_parameter.h"
#include "node/pdo_mapping.h"
 
namespace mm::node {
 
struct ProcessData;
 
class ParameterCache;
 
class Device {
 public:
  Device(uint16_t slavePosition, mm::comm::FieldbusDriver& driver,
         ProcessData* processData = nullptr, const ParameterCache* parameterCache = nullptr);
 
  uint16_t slavePosition() const;
 
  const std::string& name() const;
 
  uint32_t vendorId() const;
 
  uint32_t productCode() const;
 
  uint32_t revisionNumber() const;
 
  uint32_t serialNumber() const;
 
  bool mailboxActive() const;
 
  bool exchangesProcessData() const;
 
  std::expected<std::vector<uint8_t>, std::string> readSdo(uint16_t index, uint8_t subindex) const;
 
  std::expected<void, std::string> writeSdo(uint16_t index, uint8_t subindex,
                                            std::span<const uint8_t> data) const;
 
  std::expected<std::vector<uint8_t>, std::string> readFile(const std::string& filename) const;
 
  std::expected<void, std::string> writeFile(const std::string& filename,
                                             std::span<const uint8_t> data) const;
 
  std::expected<void, std::string> readRegister(uint16_t address, std::span<uint8_t> data) const;
 
  std::expected<void, std::string> writeRegister(uint16_t address,
                                                 std::span<const uint8_t> data) const;
 
  std::expected<std::vector<uint8_t>, std::string> readSii() const;
 
  std::expected<void, std::string> writeSii(std::span<const uint8_t> data) const;
 
  std::expected<void, std::string> initializeParameters(bool readValues = false,
                                                        bool useCompleteAccess = true);
 
  std::expected<void, std::string> readFlatPdoMapping();
 
  const FlatPdoMapping& flatPdoMapping() const;
 
  std::expected<PdoMapping, std::string> readPdoMapping();
 
  std::expected<void, std::string> writePdoMapping(const PdoMapping& mapping);
 
  std::expected<void, std::string> setValue(uint16_t index, uint8_t subindex,
                                            DeviceParameterValue newValue);
 
  std::expected<DeviceParameterValue, std::string> setValueFromBytes(
      uint16_t index, uint8_t subindex, std::span<const uint8_t> bytes);
 
  std::expected<std::vector<uint8_t>, std::string> valueAsBytes(uint16_t index,
                                                                uint8_t subindex) const;
 
  const std::unordered_map<uint32_t, DeviceParameter>& parameters() const;
 
  std::vector<DeviceParameter> parametersOrdered() const;
 
  const DeviceParameter* parameter(uint16_t index, uint8_t subindex) const;
 
  std::optional<DeviceParameterValue> value(uint16_t index, uint8_t subindex) const;
 
  std::optional<DeviceParameter> parameterCopy(uint16_t index, uint8_t subindex) const;
 
  std::optional<uint16_t> dataType(uint16_t index, uint8_t subindex) const;
 
  std::expected<DeviceParameterValue, std::string> readParameter(uint16_t index, uint8_t subindex);
 
  std::expected<void, std::string> readAllParameters(bool useCompleteAccess = true);
 
  std::expected<void, std::string> writeParameter(uint16_t index, uint8_t subindex,
                                                  DeviceParameterValue newValue);
 
  template <typename T>
  std::expected<void, std::string> writeValue(uint16_t index, uint8_t subindex, T newValue) {
    return writeParameter(index, subindex, DeviceParameterValue{newValue});
  }
 
  template <typename T>
  std::expected<T, std::string> readValue(uint16_t index, uint8_t subindex) {
    auto v = readParameter(index, subindex);
    if (!v) {
      return std::unexpected(v.error());
    }
    if (const auto* p = std::get_if<T>(&*v)) {
      return *p;
    }
    return std::unexpected(
        std::format("parameter 0x{:04X}:{:02X} holds a different type", index, subindex));
  }
 
 private:
  DeviceParameter* findParameter(uint16_t index, uint8_t subindex);
 
  void readParameterValues(std::vector<DeviceParameter>& defs, bool useCompleteAccess);
 
  std::expected<std::vector<PdoMappingObject>, std::string> readPdoAssignment(
      uint16_t assignmentIndex);
 
  uint16_t slavePosition_;
  mm::comm::FieldbusDriver& driver_;
  // Live process-data runtime, or nullptr for SDO-only operation. Injected by DeviceManager so
  // read/writeParameter can prefer PDO over SDO while exchanging. Non-owning; the owner
  // (DeviceManager) outlives every Device it created. A raw pointer keeps Device
  // move-constructible.
  ProcessData* processData_ = nullptr;
  // On-disk parameter-definition cache, or nullptr to always enumerate live. Non-owning; owned by
  // DeviceManager, which outlives every Device. Consulted only by initializeParameters.
  const ParameterCache* parameterCache_ = nullptr;
  std::string name_;
  uint32_t vendorId_;
  uint32_t productCode_;
  uint32_t revisionNumber_;
  uint32_t serialNumber_;
  // Guards parameters_ against the off-RT monitoring threads (the refresher refreshes cached
  // values, the sampler reads them) racing the control-plane thread. Held only briefly — across
  // a cache read/write, or a single mailbox transaction in read/writeParameter; never across the
  // multi-entry object-dictionary enumeration, which builds a local map and swaps it in under
  // the lock. Lock order, where both are taken: DeviceManager::busMutex_ before this.
  //
  // Held by unique_ptr because std::mutex is neither movable nor copyable, and Device is moved
  // into DeviceManager's std::vector<Device> (which relocates on growth). The indirection keeps
  // Device move-constructible (the pointer moves); a Device is never copied, only moved.
  std::unique_ptr<std::mutex> parametersMutex_;
  std::unordered_map<uint32_t, DeviceParameter> parameters_;
  FlatPdoMapping flatPdoMapping_;
};
 
void to_json(nlohmann::json& j, const Device& d);
 
std::expected<int, std::string> reconcileDetectedModules(const Device& device);
 
}  // namespace mm::node