os_command.h

Go to the documentation of this file.

#pragma once
 
#include <chrono>
 
#include "motion_master_error.h"
#include "util.h"
 
class Cia402Drive;
 
class OsCommand {
 public:
  enum class Command {
    kEncoderRegisterCommunication = 0,
    kIcmuCalibration = 1,
    kOpenLoopFieldMode = 2,
    kHrdStreaming = 3,
    kMotorPhaseOrderDetection = 4,
    kCommutationOffsetMeasurement = 5,
    kOpenPhaseDetection = 6,
    kPolePairDetection = 7,
    kPhaseResistanceMeasurement = 8,
    kPhaseInductanceMeasurement = 9,
    kTorqueConstantMeasurement = 10,
    // DEPRECATED: kInternalEncoder1Singleturn = 12,
    kIgnoreBissStatusBits = 14,
    kSystemIdentification = 15,
    kReserved = 255
  };

  OsCommand(Cia402Drive& cia402_drive, uint8_t* command_bytes,
            uint32_t timeout_in_ms = 1000, bool auto_abort = false,
            bool wait = true,
            const std::function<void()>& started_callback = {},
            const std::function<void(uint8_t)>& progress_callback = {});

  explicit OsCommand(
      Cia402Drive& cia402_drive, uint32_t timeout_in_ms = 1000,
      bool auto_abort = false, bool wait = true,
      const std::function<void()>& started_callback = {},
      const std::function<void(uint8_t)>& progress_callback = {});

  OsCommand(Cia402Drive& cia402_drive, Command command,
            uint8_t command_byte_1 = 0, uint8_t command_byte_2 = 0,
            uint8_t command_byte_3 = 0, uint8_t command_byte_4 = 0,
            uint8_t command_byte_5 = 0, uint8_t command_byte_6 = 0,
            uint8_t command_byte_7 = 0, uint32_t timeout_in_ms = 1000,
            bool auto_abort = false, bool wait = true,
            const std::function<void()>& started_callback = {},
            const std::function<void(uint8_t)>& progress_callback = {});

  MotionMasterError run();

  void set_command(const std::string& command);

  void set_command(uint8_t* command_bytes);

  void set_command(Command command, uint8_t command_byte_1 = 0,
                   uint8_t command_byte_2 = 0, uint8_t command_byte_3 = 0,
                   uint8_t command_byte_4 = 0, uint8_t command_byte_5 = 0,
                   uint8_t command_byte_6 = 0, uint8_t command_byte_7 = 0);

  void set_command_uint32_value(uint32_t value);

  void set_timeout(uint32_t timeout_in_ms);

  void set_auto_abort(bool auto_abort);

  void set_wait(bool wait);

  uint8_t* response_data();

  uint8_t get_uint8_response_data();

  uint16_t get_uint16_response_data();

  uint32_t get_uint32_response_data();

  uint8_t get_error_code();
 
 private:
  enum class Status : uint8_t {
    kCompletedNoErrorNoReply = 0,
    kCompletedNoErrorWithReply = 1,
    kCompletedWithErrorNoReply = 2,
    kCompletedWithErrorWithReply = 3,
    kInProgress0 = 100,
    kInProgress100 = 200,
    kCmdInProgress = 255
  };
 
  enum class GeneralError {
    kNotAllowed = 251,
    kAborted = 252,
    kTimeout = 253,
    kUnsupported = 254,
    kReserved = 255
  };
 
  enum class HrdStreamingError : uint8_t {
    kInitialization = 0,
    kStreaming = 1,
    kDurationValue = 2,
    kDataIndexValue = 3,
    kActionValue = 4
  };
 
  enum class OpenPhaseDetectionError : uint8_t {
    kOpenTerminalA = 0,
    kOpenTerminalB = 1,
    kOpenTerminalC = 2,
    kOpenFetAHigh = 3,
    kOpenFetALow = 4,
    kOpenFetBHigh = 5,
    kOpenFetBLow = 6,
    kOpenFetCHigh = 7,
    kOpenFetCLow = 8,
  };
 
  enum class PolePairDetectionError : uint8_t { kCurrentAmplitude = 0 };
 
  enum class PhaseResistanceMeasurementError : uint8_t {
    kCurrentAmplitude = 0
  };
 
  enum class PhaseInductanceMeasurementError : uint8_t {
    kCurrentAmplitude = 0
  };
 
  const std::map<Command, std::map<uint8_t, MotionMasterError::Error>>
      command_error_map_ = {
          {Command::kHrdStreaming,
           {{to_integral(HrdStreamingError::kInitialization),
             MotionMasterError::Error::kHrdStreamInitFailed},
            {to_integral(HrdStreamingError::kStreaming),
             MotionMasterError::Error::kHrdStreamStreamingFailed},
            {to_integral(HrdStreamingError::kDurationValue),
             MotionMasterError::Error::kHrdStreamDurationValue},
            {to_integral(HrdStreamingError::kDataIndexValue),
             MotionMasterError::Error::kHrdStreamDataIndexValue},
            {to_integral(HrdStreamingError::kActionValue),
             MotionMasterError::Error::kHrdStreamActionValue}}},
          {Command::kOpenPhaseDetection,
           {{to_integral(OpenPhaseDetectionError::kOpenTerminalA),
             MotionMasterError::Error::kOpenPhaseDetectionOpenTerminalA},
            {to_integral(OpenPhaseDetectionError::kOpenTerminalB),
             MotionMasterError::Error::kOpenPhaseDetectionOpenTerminalB},
            {to_integral(OpenPhaseDetectionError::kOpenTerminalC),
             MotionMasterError::Error::kOpenPhaseDetectionOpenTerminalC},
            {to_integral(OpenPhaseDetectionError::kOpenFetAHigh),
             MotionMasterError::Error::kOpenPhaseDetectionOpenFetAHigh},
            {to_integral(OpenPhaseDetectionError::kOpenFetALow),
             MotionMasterError::Error::kOpenPhaseDetectionOpenFetALow},
            {to_integral(OpenPhaseDetectionError::kOpenFetBHigh),
             MotionMasterError::Error::kOpenPhaseDetectionOpenFetBHigh},
            {to_integral(OpenPhaseDetectionError::kOpenFetBLow),
             MotionMasterError::Error::kOpenPhaseDetectionOpenFetBLow},
            {to_integral(OpenPhaseDetectionError::kOpenFetCHigh),
             MotionMasterError::Error::kOpenPhaseDetectionOpenFetCHigh},
            {to_integral(OpenPhaseDetectionError::kOpenFetCLow),
             MotionMasterError::Error::kOpenPhaseDetectionOpenFetCLow}}},
          {Command::kPolePairDetection,
           {{to_integral(PolePairDetectionError::kCurrentAmplitude),
             MotionMasterError::Error::kPolePairDetectionCurrentAmplitude}}},
          {Command::kPhaseResistanceMeasurement,
           {{to_integral(PhaseResistanceMeasurementError::kCurrentAmplitude),
             MotionMasterError::Error::
                 kPhaseResistanceMeasurementCurrentAmplitude}}},
          {Command::kPhaseInductanceMeasurement,
           {{to_integral(PhaseInductanceMeasurementError::kCurrentAmplitude),
             MotionMasterError::Error::
                 kPhaseInductanceMeasurementCurrentAmplitude}}}};
 
  Cia402Drive& cia402_drive_;
 
  // OS command mutexes mapped by their CiA402 device IDs
  static inline std::unordered_map<int32_t, std::mutex>
      cia402_drive_id_to_mutex_map_;
 
  std::string command_;
  std::string response_;
  Status status_;
 
  uint32_t timeout_in_ms_;
  bool auto_abort_;
  bool wait_;
 
  const std::function<void()>& started_callback_;
  const std::function<void(uint8_t)>& progress_callback_;
};