spoe.h

Go to the documentation of this file.

#pragma once
 
#include <atomic>
#include <boost/asio.hpp>
#include <chrono>
#include <nlohmann/json.hpp>
#include <string>
 
#include "base.h"
#include "core/util.h"
 
namespace mm::comm::spoe {
 
enum class SpoeMessageType : uint8_t {
  SDO_READ = 0x01,   
  SDO_WRITE = 0x02,  
  PDO_RXTX_FRAME =
      0x03,  
  PDO_CONTROL = 0x04,      
  SDO_BATCH_READ = 0x06,   
  FIRMWARE_UPDATE = 0x0B,  
  FILE_READ = 0x0C,        
  FILE_WRITE = 0x0D,       
  STATE_CONTROL =
      0x0E,           
  STATE_READ = 0x0F,  
  //   PARAM_INDEXES_LIST = 0x10,  ///< Request a list of parameter indexes.
  PARAM_LIST = 0x13,  
  SERVER_INFO = 0x20  
};
 
enum class SpoeMessageRequestStatus : uint8_t {
  OK = 0x00,      
  FIRST = 0x80,   
  MIDDLE = 0xC0,  
  LAST = 0x40,    
};
 
enum class SpoeMessageParamListErrorStatus : uint8_t {
  SUCCESS_ACK = 0x58,  
 
  ERR = 0x63,
  BUSY_INDICATION = 0x28,
};
 
enum class SpoeMessageSdoStatus : uint16_t {
  NO_ERR = 0x0000,  
  GENERIC = 0x0001,
  NOT_FOUND = 0x0002,
  READ_ONLY = 0x0003,
  WRITE_ONLY = 0x0004,
  WRONG_TYPE = 0x0005,
  INVALID_LIST = 0x0006,
  INSUFFICIENT_BUFFER = 0x0007,
  VALUEINFO_UNAVAILABLE = 0x0008,
  UNKNOWN_OR_UNSUPPORTED = 0x0009,
  LOCAL_TRANSFER = 0x000A,
  UNSUPPORTED_ACCESS = 0x000B,
  SI0_NOT_ZERO = 0x000C,
  SUB_NOT_FOUND = 0x000D,
};
 
// enum class SpoeMessageSdoStatus : uint16_t {
//   NO_ERROR = 0x0000,
// };
 
enum class SpoeMessageFileErrorStatus : uint8_t {
  SUCCESS_ACK = 0x58,  
 
  UNDEFINED = 0x00,
  NOT_FOUND = 0x01,
  ACCESS_DENIED = 0x02,
  STORAGE_FULL = 0x03,
  ILLEGAL_REQ = 0x04,
  PACKET_NUMBER = 0x05,
  ALREADY_EXISTS = 0x06,
  NO_USER = 0x07,
  BOOTSTRAP_ONLY = 0x08,
  NOT_BOOTSTRAP = 0x09,
  NO_RIGHTS = 0x0A,
  PROGRAM_ERROR = 0x0B,
  BUSY = 0x0C,
  FILENAME_LEN = 0x0D,
  TIMEOUT = 0x0E,
  FLASH_BUSY = 0x28,
  COMMUNICATION_BRIDGE_ERROR = 0x63
};
 
enum class SpoeMessagePacketStatus : uint8_t {
  OK = 0x00,      
  FIRST = 0x80,   
  MIDDLE = 0xC0,  
  LAST = 0x40,    
};
 
enum class PdoMode : uint8_t {
  NONE = 0,  
  MONITOR =
      1,  
  CONTROL = 2  
};
 
struct Message {
  static constexpr size_t kHeaderSize = 7;
 
  static constexpr size_t kBufferSize = 1500 - kHeaderSize;
 
  SpoeMessageType type;
 
  uint16_t id;
 
  uint16_t status;
 
  uint16_t size;
 
  std::vector<uint8_t> data;
};
 
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Message, type, id, status, size, data);
 
Message parseMessage(const std::vector<uint8_t>& buffer);
 
std::vector<uint8_t> serializeSpoeMessage(const Message& message);
 
struct ServerInfo {
  uint16_t protocolVersion;
 
  uint8_t monitoringMode;
};
 
class DeviceParameterRefresher
    : public mm::comm::base::DeviceParameterRefresher {
 public:
  // Forward constructor to base class constructor
  DeviceParameterRefresher(mm::comm::base::Device& device,
                           std::chrono::milliseconds interval);
 
 protected:
  void refresh(const std::vector<mm::comm::base::Parameter::Address>& addresses)
      override;
};
 
class Device : public mm::comm::base::Device {
 public:
  Device(const std::string& ip, uint16_t port, uint16_t position = 0,
         std::chrono::milliseconds refresherInterval =
             std::chrono::milliseconds(3000));
 
  ~Device();
 
  std::string getSocketAddress() const;
 
  uint16_t incrementSeqId();
 
  bool connect(std::chrono::seconds expiryTime = std::chrono::seconds(3));
 
  bool isConnected();
 
  bool disconnect();
 
  Message exchangeWithTimeout(
      const Message& request,
      const std::chrono::steady_clock::duration expiryTime);
 
  uint16_t getPosition() const override;
 
  uint8_t getState(bool refresh = false,
                   const std::chrono::steady_clock::duration expiryTime =
                       std::chrono::milliseconds(5000)) override;
 
  bool setState(uint8_t state,
                const std::chrono::steady_clock::duration expiryTime =
                    std::chrono::milliseconds(5000)) override;
 
  std::vector<uint8_t> readFile(
      const std::string& filename,
      const std::chrono::steady_clock::duration expiryTime =
          std::chrono::milliseconds(5000)) override;
 
  std::vector<std::string> readFileList(
      const bool stripSizeSuffix = true,
      const std::chrono::steady_clock::duration expiryTime =
          std::chrono::milliseconds(5000)) override;
 
  void removeFile(const std::string& filename,
                  const std::chrono::steady_clock::duration expiryTime =
                      std::chrono::milliseconds(5000)) override;
 
  void updateFirmware(
      const std::vector<std::uint8_t>& data,
      const std::vector<std::string>& skipFiles = {"SOMANET_CiA_402.xml.zip",
                                                   "stack_image.svg.zip"},
      std::function<void(uint8_t, std::string)> progressCallback = nullptr,
      const std::chrono::steady_clock::duration expiryTime =
          std::chrono::milliseconds(60000)) override;
 
  void writeFile(const std::string& filename, const std::vector<uint8_t>& data,
                 const std::chrono::steady_clock::duration expiryTime =
                     std::chrono::milliseconds(5000)) override;
 
  bool triggerFirmwareUpdate(const std::chrono::steady_clock::duration
                                 expiryTime = std::chrono::milliseconds(2000));
 
  std::vector<mm::comm::base::Parameter> getParametersFromDevice(
      bool readValues = false,
      const std::chrono::steady_clock::duration expiryTime =
          std::chrono::milliseconds(1000));
 
  std::vector<uint8_t> readSdo(
      uint16_t index, uint8_t subindex,
      const std::chrono::steady_clock::duration expiryTime =
          std::chrono::milliseconds(1000));
 
  std::vector<std::vector<uint8_t>> readSdoBatch(
      const std::vector<mm::comm::base::Parameter::Address>& addresses,
      const std::chrono::steady_clock::duration expiryTime =
          std::chrono::milliseconds(1000));
 
  std::vector<std::vector<uint8_t>> readSdoBatch(
      const std::vector<mm::comm::base::Parameter>& parameters,
      const std::chrono::steady_clock::duration expiryTime =
          std::chrono::milliseconds(1000));
 
  void readSdoBatchAndUpdateParameters(
      std::vector<mm::comm::base::Parameter>& parameters,
      std::size_t batchSize = 50,
      std::chrono::steady_clock::duration expiryTime =
          std::chrono::milliseconds(1000));
 
  bool writeSdo(uint16_t index, uint8_t subindex,
                const std::vector<uint8_t>& data,
                const std::chrono::steady_clock::duration expiryTime =
                    std::chrono::milliseconds(1000));
 
  size_t loadParameters(bool readValues = false,
                        const std::chrono::steady_clock::duration expiryTime =
                            std::chrono::milliseconds(9000)) override;
 
  void clearParameters() override;
 
  std::vector<std::reference_wrapper<mm::comm::base::Parameter>> parameters()
      override;
 
  mm::comm::base::Parameter& findParameter(uint16_t index,
                                           uint8_t subindex) override;
 
  mm::comm::base::Parameter& upload(
      const uint16_t index, const uint8_t subindex,
      const std::chrono::steady_clock::duration expiryTime =
          std::chrono::milliseconds(3000)) override;
 
  template <typename T>
  T upload(uint16_t index, uint8_t subindex,
           const std::chrono::steady_clock::duration expiryTime =
               std::chrono::milliseconds(5000)) {
    mm::comm::base::Parameter& parameter = upload(index, subindex, expiryTime);
    return parameter.getValue<T>();
  }
 
  void download(uint16_t index, uint8_t subindex,
                const std::chrono::steady_clock::duration expiryTime =
                    std::chrono::milliseconds(5000)) override;
 
  void download(uint16_t index, uint8_t subindex,
                const mm::comm::base::ParameterValue& value,
                const std::chrono::steady_clock::duration expiryTime =
                    std::chrono::milliseconds(5000)) override;
 
  template <typename T>
  void download(uint16_t index, uint8_t subindex, const T& value,
                const std::chrono::steady_clock::duration expiryTime =
                    std::chrono::milliseconds(5000)) {
    download(index, subindex, mm::comm::base::ParameterValue(value));
  }
 
  ServerInfo getServerInfo(const std::chrono::steady_clock::duration
                               expiryTime = std::chrono::milliseconds(3000));
 
  bool setPdoMode(PdoMode mode,
                  const std::chrono::steady_clock::duration expiryTime =
                      std::chrono::milliseconds(3000));
 
  std::vector<uint8_t> exchangeProcessData(
      const std::vector<uint8_t>& data,
      const std::chrono::steady_clock::duration expiryTime =
          std::chrono::milliseconds(1000));
 
  void performProcessDataExchangeAsync();
 
  void exchangeProcessDataAndUpdateParameters(
      uint64_t missedCycles = 0) override;
 
  mm::comm::base::PdoMappingStatus getPdoMappingStatus(
      uint16_t index, uint8_t subindex) const override;
 
  mm::comm::base::MappedParameterValues getMappedParameterValues();
 
  bool isOnline() override;
 
  DeviceParameterRefresher& refresher() { return refresher_; }
 
 private:
  boost::asio::io_context ioContext_;  
  boost::asio::ip::tcp::endpoint
      endpoint_;  
  boost::asio::ip::tcp::socket
      socket_;  
 
  std::recursive_mutex
      mutex_;  
 
  std::mutex disconnectMutex_;  
 
  std::atomic<uint16_t> seqId_{0};  
 
  uint16_t position_;  
 
  uint8_t state_;  
 
  std::unordered_map<mm::comm::base::Parameter::Address,
                     mm::comm::base::Parameter>
      parametersMap_;  
  mm::comm::base::PdoMappings
      pdoMappings_;  
 
  std::atomic_flag isSendingAndReceivingProcessData_ =
      ATOMIC_FLAG_INIT;  
 
  mm::core::util::ThreadSafeQueue<std::vector<uint8_t>>
      txPdoQueue_;  
 
  std::mutex
      sendAndReceiveProcessDataExceptionPtrMutex_;  
 
  std::exception_ptr sendAndReceiveProcessDataExceptionPtr_ =
      nullptr;  
 
  DeviceParameterRefresher refresher_;  
};
 
}  // namespace mm::comm::spoe