device_parameter.h

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <expected>
#include <format>
#include <nlohmann/json_fwd.hpp>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <variant>
#include <vector>
 
namespace mm::node {
 
using DeviceParameterValue =
    std::variant<int8_t, int16_t, int32_t, int64_t,      // NOLINT(whitespace/indent_namespace)
                 uint8_t, uint16_t, uint32_t, uint64_t,  // NOLINT(whitespace/indent_namespace)
                 float, double,                          // NOLINT(whitespace/indent_namespace)
                 std::string, std::vector<uint8_t>>;     // NOLINT(whitespace/indent_namespace)
 
constexpr uint32_t makeParameterKey(uint16_t index, uint8_t subindex) {
  return (static_cast<uint32_t>(index) << 8) | static_cast<uint32_t>(subindex);
}
 
DeviceParameterValue defaultValueForDataType(uint16_t dataType);
 
std::optional<double> numericValue(const DeviceParameterValue& value);
 
enum class SyncState : uint8_t {
  Unknown,  
  Synced,   
  Pending,  
};
 
std::string_view syncStateName(SyncState state);
 
struct DeviceParameter {
  uint16_t index{};            
  uint8_t subindex{};          
  std::string name;            
  uint16_t objectCode{};       
  uint16_t dataType{};         
  uint16_t bitLength{};        
  uint16_t access{};           
  DeviceParameterValue value;  
  SyncState syncState{SyncState::Unknown};  
  std::optional<uint32_t> unit;             
  std::optional<DeviceParameterValue> defaultValue;  
  std::optional<DeviceParameterValue> minValue;      
  std::optional<DeviceParameterValue> maxValue;      
 
  uint32_t key() const { return makeParameterKey(index, subindex); }
 
  template <typename T>
  std::expected<T, std::string> getValue() const {
    if (const auto* p = std::get_if<T>(&value)) {
      return *p;
    }
    return std::unexpected(
        std::format("parameter 0x{:04X}:{:02X} holds a different type", index, subindex));
  }
 
  std::expected<double, std::string> numeric() const;
 
  std::expected<void, std::string> setValue(const DeviceParameterValue& v);
 
  template <typename T>
  std::expected<void, std::string> setValue(const T& v) {
    return setValue(DeviceParameterValue{v});
  }
 
  bool isReadable() const { return (access & 0x07) != 0; }
 
  bool inRange(const DeviceParameterValue& v) const;
 
  DeviceParameterValue clampToRange(const DeviceParameterValue& v) const;
};
 
std::expected<DeviceParameterValue, std::string> decodeSdoBytes(uint16_t dataType,
                                                                std::span<const uint8_t> bytes);
 
std::expected<std::vector<uint8_t>, std::string> encodeSdoBytes(uint16_t dataType,
                                                                const DeviceParameterValue& value);
 
void to_json(nlohmann::json& j, const DeviceParameter& p);
 
}  // namespace mm::node