profile_device.h

Go to the documentation of this file.

#pragma once
 
#include <chrono>
#include <cstdint>
#include <expected>
#include <optional>
#include <stop_token>
#include <string>
#include <string_view>
#include <vector>
 
#include "node/device.h"
 
namespace mm::node {
 
enum GenericObject : uint16_t {
  kDeviceType = 0x1000,     
  kErrorRegister = 0x1001,  
  kCobIdSync = 0x1005,      
  kCommunicationCyclePeriod = 0x1006,     
  kManufacturerDeviceName = 0x1008,       
  kManufacturerSoftwareVersion = 0x100A,  
  kGuardTime = 0x100C,                    
  kLifeTimeFactor = 0x100D,               
  kStoreParameters = 0x1010,              
  kRestoreDefaultParameters = 0x1011,     
  kConsumerHeartbeatTime = 0x1016,        
  kProducerHeartbeatTime = 0x1017,        
  kIdentity = 0x1018,                     
  kSynchronousCounterOverflowValue = 0x1019,  
  kOsCommand = 0x1023,      
  kOsCommandMode = 0x1024,  
};
 
struct Identity {
  uint32_t vendorId{};        
  uint32_t productCode{};     
  uint32_t revisionNumber{};  
  uint32_t serialNumber{};    
};
 
struct RestoreDefaultParameters {
  uint32_t all{};            
  uint32_t communication{};  
  uint32_t application{};    
  uint32_t manufacturer{};   
};
 
enum class RestoreGroup : uint8_t {
  kAll = 1,            
  kCommunication = 2,  
  kApplication = 3,    
  kManufacturer = 4,   
};
 
std::optional<RestoreGroup> parseRestoreGroup(std::string_view token);
 
constexpr std::string_view toString(RestoreGroup group) {
  switch (group) {
    case RestoreGroup::kAll:
      return "all";
    case RestoreGroup::kCommunication:
      return "communication";
    case RestoreGroup::kApplication:
      return "application";
    case RestoreGroup::kManufacturer:
      return "manufacturer";
  }
  return "unknown";
}
 
struct StoreParametersConfig {
  uint32_t retries = 10;                    
  std::chrono::milliseconds interval{500};  
  std::chrono::milliseconds settle{1000};   
 
  std::stop_token stop{};
};
 
struct RestoreDefaultParametersConfig {
  uint32_t retries = 10;                    
  std::chrono::milliseconds interval{500};  
  std::chrono::milliseconds settle{1000};   
  std::stop_token stop{};                   
};
 
class ProfileDevice {
 public:
  explicit ProfileDevice(Device& device) : device_(device) {}
 
  Device& device() { return device_; }
  const Device& device() const { return device_; }
 
  std::expected<uint32_t, std::string> deviceType() const;
 
  std::expected<uint8_t, std::string> errorRegister() const;
 
  std::expected<int32_t, std::string> cobIdSync() const;
 
  std::expected<void, std::string> setCobIdSync(int32_t value);
 
  std::expected<int32_t, std::string> communicationCyclePeriod() const;
 
  std::expected<void, std::string> setCommunicationCyclePeriod(int32_t value);
 
  std::expected<std::string, std::string> manufacturerDeviceName() const;
 
  std::expected<std::string, std::string> manufacturerSoftwareVersion() const;
 
  std::expected<uint16_t, std::string> guardTime() const;
 
  std::expected<void, std::string> setGuardTime(uint16_t value);
 
  std::expected<uint8_t, std::string> lifeTimeFactor() const;
 
  std::expected<void, std::string> setLifeTimeFactor(uint8_t value);
 
  std::expected<uint32_t, std::string> storeParameters() const;
 
  std::expected<void, std::string> setStoreParameters(uint32_t signature);
 
  std::expected<void, std::string> runStoreParameters(const StoreParametersConfig& config = {});
 
  std::expected<RestoreDefaultParameters, std::string> restoreDefaultParameters() const;
 
  std::expected<void, std::string> setRestoreAllDefaultParameters(uint32_t signature);
 
  std::expected<void, std::string> setRestoreCommunicationDefaultParameters(uint32_t signature);
 
  std::expected<void, std::string> setRestoreApplicationDefaultParameters(uint32_t signature);
 
  std::expected<void, std::string> setRestoreManufacturerDefaultParameters(uint32_t signature);
 
  std::expected<void, std::string> runRestoreDefaultParameters(
      RestoreGroup group, const RestoreDefaultParametersConfig& config = {});
 
  std::expected<uint32_t, std::string> consumerHeartbeatTime() const;
 
  std::expected<void, std::string> setConsumerHeartbeatTime(uint32_t value);
 
  std::expected<uint16_t, std::string> producerHeartbeatTime() const;
 
  std::expected<void, std::string> setProducerHeartbeatTime(uint16_t value);
 
  std::expected<Identity, std::string> identity() const;
 
  std::expected<uint8_t, std::string> synchronousCounterOverflowValue() const;
 
  std::expected<void, std::string> setSynchronousCounterOverflowValue(uint8_t value);
 
  std::expected<std::vector<uint8_t>, std::string> osCommand() const;
 
  std::expected<void, std::string> setOsCommand(const std::vector<uint8_t>& command);
 
  std::expected<uint8_t, std::string> osCommandStatus() const;
 
  std::expected<std::vector<uint8_t>, std::string> osCommandResponse() const;
 
  std::expected<void, std::string> setOsCommandMode(uint8_t mode);
 
 protected:
  Device& device_;
};
 
std::expected<ProfileDevice, std::string> createProfileDevice(Device& device);
 
}  // namespace mm::node