ethernet_client.h

Go to the documentation of this file.

#pragma once
 
#include <boost/asio.hpp>
#include <chrono>
#include <string>
 
#include "common.h"
 
enum class EthernetMessageType : uint8_t {
  SDO_READ = 0x01,   
  SDO_WRITE = 0x02,  
  PDO_RXTX_FRAME =
      0x03,  
  PDO_CONTROL = 0x04,      
  PDO_MAP = 0x05,          
  FIRMWARE_UPDATE = 0x0B,  
  FILE_READ = 0x0C,        
  FILE_WRITE = 0x0D,       
  STATE_CONTROL =
      0x0E,           
  STATE_READ = 0x0F,  
  // PARAM_LIST = 0x10,  ///< Request a list of parameters.
  // PARAM_DESC = 0x11,  ///< Request a description of a parameter.
  // PARAM_SUB_DESC =
  //     0x12,  ///< Request a description of a parameter's sub-entries.
  PARAM_FULL_LIST = 0x13,  
  SERVER_INFO = 0x20       
};
 
enum class EthernetMessageStatus : uint8_t {
  OK = 0x00,      
  FIRST = 0x80,   
  MIDDLE = 0xC0,  
  LAST = 0x40,    
  ERR = 0x28      
};
 
enum class EthernetSqiReplyStatus : uint8_t {
  BSY = 0x28,  
  ACK = 0x58,  
  ERR = 0x63   
};
 
struct EthernetMessage {
  static constexpr size_t kHeaderSize = 7;
 
  static constexpr size_t kBufferSize = 1500 - kHeaderSize;
 
  EthernetMessageType type;
 
  uint16_t id;
 
  EthernetMessageStatus status;
 
  EthernetSqiReplyStatus sqiStatus;
 
  uint16_t size;
 
  std::vector<uint8_t> data;
};
 
EthernetMessage parseEthernetMessage(const std::vector<uint8_t>& buffer);
 
std::vector<uint8_t> serializeEthernetMessage(const EthernetMessage& message);
 
class EthernetDevice : common::Device {
 public:
  EthernetDevice(const std::string& ip, unsigned short port);
 
  ~EthernetDevice();
 
  uint16_t incrementSeqId();
 
  bool connect();
 
  bool isConnected();
 
  bool disconnect();
 
  EthernetMessage exchangeWithTimeout(
      const EthernetMessage& request,
      const std::chrono::steady_clock::duration expiryTime);
 
  uint8_t getState(const std::chrono::steady_clock::duration expiryTime =
                       std::chrono::milliseconds(3000)) override;
 
  bool setState(uint8_t state,
                const std::chrono::steady_clock::duration expiryTime =
                    std::chrono::milliseconds(3000)) 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(3000));
 
  bool removeFile(const std::string& filename,
                  const std::chrono::steady_clock::duration expiryTime =
                      std::chrono::milliseconds(3000));
 
  bool 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<common::Parameter> getParameters(
      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));
 
  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));
 
  void loadParameters(bool readValues = false,
                      const std::chrono::steady_clock::duration expiryTime =
                          std::chrono::milliseconds(9000)) override;
 
  void clearParameters() override;
 
  common::Parameter& findParameter(uint16_t index, uint8_t subindex) override;
 
  common::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)) {
    common::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 common::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, common::ParameterValue(value));
  }
 
  std::vector<uint8_t> sendAndReceiveProcessData(
      const std::vector<uint8_t>& data,
      const std::chrono::steady_clock::duration expiryTime =
          std::chrono::milliseconds(1000));
 
  void exchangeProcessDataAndUpdateParameters() override;
 
 private:
  boost::asio::io_context ioContext_;  
  boost::asio::ip::tcp::endpoint
      endpoint_;  
  boost::asio::ip::tcp::socket
      socket_;  
 
  std::mutex mutex_;  
 
  std::atomic<uint16_t> seqId_{0};  
 
  std::unordered_map<common::ParameterKey, common::Parameter>
      parametersMap_;  
  common::PdoMappings pdoMappings_;  
};