cia402_drive.h

Go to the documentation of this file.

#pragma once
 
#include <chrono>
#include <expected>
#include <nlohmann/json_fwd.hpp>
#include <optional>
#include <string>
#include <string_view>
 
#include "node/cia402.h"
#include "node/profile_device.h"
 
namespace mm::node {
 
struct Cia402Status {
  cia402::State state{};                           
  uint16_t statusword = 0;                         
  uint16_t controlword = 0;                        
  cia402::OperationMode modeOfOperationDisplay{};  
  std::optional<int32_t> targetPosition;
  std::optional<int32_t> targetVelocity;
  std::optional<int32_t> targetTorque;
  std::optional<int32_t> actualPosition;
  std::optional<int32_t> actualVelocity;
  std::optional<int32_t> actualTorque;
  std::optional<std::string> errorDescription;
};
 
void to_json(nlohmann::json& j, const Cia402Status& s);
 
struct PositionRangeLimit {
  int32_t min{};  
  int32_t max{};  
};
 
struct SoftwarePositionLimit {
  int32_t min{};  
  int32_t max{};  
};
 
struct GearRatio {
  uint32_t motorRevolutions{};  
  uint32_t shaftRevolutions{};  
};
 
struct FeedConstant {
  uint32_t feed{};              
  uint32_t shaftRevolutions{};  
};
 
struct HomingSpeeds {
  uint32_t switchSearch{};  
  uint32_t zeroSearch{};    
};
 
struct DigitalOutputs {
  uint32_t physicalOutputs{};  
  uint32_t bitMask{};          
};
 
enum class Cia402Command { kEnable, kDisable, kQuickStop, kFaultReset };
 
std::optional<Cia402Command> parseCia402Command(std::string_view token);
 
enum class Cia402TargetKind { kPosition, kVelocity, kTorque };
 
std::optional<Cia402TargetKind> parseCia402TargetKind(std::string_view token);
 
std::string_view toString(Cia402TargetKind kind);
 
std::optional<Cia402TargetKind> targetKindForMode(cia402::OperationMode mode);
 
struct TargetFromActual {
  Cia402TargetKind kind{};
  int32_t value = 0;
};
 
void to_json(nlohmann::json& j, const TargetFromActual& t);
 
class Cia402Drive : public ProfileDevice {
 public:
  explicit Cia402Drive(Device& device) : ProfileDevice(device) {}
 
  std::expected<cia402::State, std::string> state() const;
 
  std::expected<uint16_t, std::string> statusword() const;
 
  std::expected<uint16_t, std::string> controlword() const;
 
  std::expected<void, std::string> setControlword(uint16_t value);
 
  std::expected<cia402::OperationMode, std::string> operationMode() const;
 
  std::expected<void, std::string> setOperationMode(cia402::OperationMode mode);
 
  std::expected<int8_t, std::string> operationModeValue() const;
 
  std::expected<int8_t, std::string> operationModeValueDisplay() const;
 
  std::expected<void, std::string> setOperationModeValue(int8_t mode);
 
  std::expected<void, std::string> applyOperationMode(
      int8_t mode, std::chrono::milliseconds timeout = std::chrono::milliseconds(200));
 
  std::expected<Cia402Status, std::string> readStatus() const;
 
  // --- State-machine transitions ------------------------------------------------------------
  // Each issues exactly one controlword edge via a read-modify-write that touches only the
  // command bits (cia402::kCommandMask), preserving mode-specific / halt / manufacturer bits.
  // They command a transition; they do not wait for the drive to reach the target state.
 
  std::expected<void, std::string> shutdown();
 
  std::expected<void, std::string> switchOn();
 
  std::expected<void, std::string> enableOperation();
 
  std::expected<void, std::string> disableVoltage();
 
  std::expected<void, std::string> quickStop();
 
  std::expected<void, std::string> faultReset();
 
  // --- Convenience walks ---------------------------------------------------------------------
 
  std::expected<void, std::string> transitionToState(
      cia402::State target, std::chrono::milliseconds timeout = std::chrono::milliseconds(2000),
      bool allowQuickStopOverride = false);
 
  std::expected<void, std::string> enable(
      std::chrono::milliseconds timeout = std::chrono::milliseconds(2000));
 
  std::expected<void, std::string> disable();
 
  // --- Cyclic setpoints (typed convenience over the standard objects) ------------------------
 
  std::expected<int32_t, std::string> targetPosition() const;
 
  std::expected<void, std::string> setTargetPosition(int32_t counts);
 
  std::expected<int32_t, std::string> targetVelocity() const;
 
  std::expected<void, std::string> setTargetVelocity(int32_t value);
 
  std::expected<int16_t, std::string> targetTorque() const;
 
  std::expected<void, std::string> setTargetTorque(int16_t perMille);
 
  std::expected<int32_t, std::string> setTargetToActual(Cia402TargetKind kind);
 
  std::expected<int32_t, std::string> positionActualValue() const;
 
  std::expected<int32_t, std::string> velocityActualValue() const;
 
  std::expected<int16_t, std::string> torqueActualValue() const;
 
  // --- Profile objects (0x603F..0x6502) --------------------------------------------------------
  // Flag-aware accessors over the remaining standard drive-profile objects, ordered by
  // index/subindex. Every getter re-reads the device on each call (these objects are writable or
  // volatile) except supportedDriveModes(), a constant capability field cached after the first
  // read.
 
  std::expected<uint16_t, std::string> errorCode() const;
 
  std::expected<int16_t, std::string> quickStopOptionCode() const;
 
  std::expected<void, std::string> setQuickStopOptionCode(int16_t value);
 
  std::expected<int32_t, std::string> positionDemandValue() const;
 
  std::expected<uint32_t, std::string> followingErrorWindow() const;
 
  std::expected<void, std::string> setFollowingErrorWindow(uint32_t value);
 
  std::expected<uint16_t, std::string> followingErrorTimeout() const;
 
  std::expected<void, std::string> setFollowingErrorTimeout(uint16_t value);
 
  std::expected<uint32_t, std::string> positionWindow() const;
 
  std::expected<void, std::string> setPositionWindow(uint32_t value);
 
  std::expected<uint16_t, std::string> positionWindowTime() const;
 
  std::expected<void, std::string> setPositionWindowTime(uint16_t value);
 
  std::expected<int32_t, std::string> velocityDemandValue() const;
 
  std::expected<uint16_t, std::string> velocityWindow() const;
 
  std::expected<void, std::string> setVelocityWindow(uint16_t value);
 
  std::expected<uint16_t, std::string> velocityWindowTime() const;
 
  std::expected<void, std::string> setVelocityWindowTime(uint16_t value);
 
  std::expected<uint16_t, std::string> velocityThreshold() const;
 
  std::expected<void, std::string> setVelocityThreshold(uint16_t value);
 
  std::expected<uint16_t, std::string> velocityThresholdTime() const;
 
  std::expected<void, std::string> setVelocityThresholdTime(uint16_t value);
 
  std::expected<uint16_t, std::string> maxTorque() const;
 
  std::expected<void, std::string> setMaxTorque(uint16_t perMille);
 
  std::expected<uint16_t, std::string> maxCurrent() const;
 
  std::expected<void, std::string> setMaxCurrent(uint16_t perMille);
 
  std::expected<int16_t, std::string> torqueDemand() const;
 
  std::expected<uint32_t, std::string> motorRatedCurrent() const;
 
  std::expected<void, std::string> setMotorRatedCurrent(uint32_t milliamps);
 
  std::expected<uint32_t, std::string> motorRatedTorque() const;
 
  std::expected<void, std::string> setMotorRatedTorque(uint32_t millinewtonMetres);
 
  std::expected<uint32_t, std::string> dcLinkCircuitVoltage() const;
 
  std::expected<PositionRangeLimit, std::string> positionRangeLimit() const;
 
  std::expected<void, std::string> setPositionRangeLimit(const PositionRangeLimit& limit);
 
  std::expected<int32_t, std::string> homeOffset() const;
 
  std::expected<void, std::string> setHomeOffset(int32_t value);
 
  std::expected<SoftwarePositionLimit, std::string> softwarePositionLimit() const;
 
  std::expected<void, std::string> setSoftwarePositionLimit(const SoftwarePositionLimit& limit);
 
  std::expected<uint8_t, std::string> polarity() const;
 
  std::expected<void, std::string> setPolarity(uint8_t value);
 
  std::expected<uint32_t, std::string> maxMotorSpeed() const;
 
  std::expected<void, std::string> setMaxMotorSpeed(uint32_t value);
 
  std::expected<uint32_t, std::string> profileVelocity() const;
 
  std::expected<void, std::string> setProfileVelocity(uint32_t value);
 
  std::expected<uint32_t, std::string> profileAcceleration() const;
 
  std::expected<void, std::string> setProfileAcceleration(uint32_t value);
 
  std::expected<uint32_t, std::string> profileDeceleration() const;
 
  std::expected<void, std::string> setProfileDeceleration(uint32_t value);
 
  std::expected<uint32_t, std::string> quickStopDeceleration() const;
 
  std::expected<void, std::string> setQuickStopDeceleration(uint32_t value);
 
  std::expected<int16_t, std::string> motionProfileType() const;
 
  std::expected<void, std::string> setMotionProfileType(int16_t value);
 
  std::expected<uint32_t, std::string> torqueSlope() const;
 
  std::expected<void, std::string> setTorqueSlope(uint32_t value);
 
  std::expected<int16_t, std::string> torqueProfileType() const;
 
  std::expected<void, std::string> setTorqueProfileType(int16_t value);
 
  std::expected<GearRatio, std::string> gearRatio() const;
 
  std::expected<void, std::string> setGearRatio(const GearRatio& ratio);
 
  std::expected<FeedConstant, std::string> feedConstant() const;
 
  std::expected<void, std::string> setFeedConstant(const FeedConstant& constant);
 
  std::expected<int8_t, std::string> homingMethod() const;
 
  std::expected<void, std::string> setHomingMethod(int8_t method);
 
  std::expected<HomingSpeeds, std::string> homingSpeeds() const;
 
  std::expected<void, std::string> setHomingSpeeds(const HomingSpeeds& speeds);
 
  std::expected<uint32_t, std::string> homingAcceleration() const;
 
  std::expected<void, std::string> setHomingAcceleration(uint32_t value);
 
  std::expected<uint32_t, std::string> siUnitVelocity() const;
 
  std::expected<void, std::string> setSiUnitVelocity(uint32_t value);
 
  std::expected<int32_t, std::string> velocityOffset() const;
 
  std::expected<void, std::string> setVelocityOffset(int32_t value);
 
  std::expected<int16_t, std::string> torqueOffset() const;
 
  std::expected<void, std::string> setTorqueOffset(int16_t value);
 
  std::expected<uint16_t, std::string> touchProbeFunction() const;
 
  std::expected<void, std::string> setTouchProbeFunction(uint16_t value);
 
  std::expected<uint16_t, std::string> touchProbeStatus() const;
 
  std::expected<int32_t, std::string> touchProbe1PositiveEdge() const;
 
  std::expected<int32_t, std::string> touchProbe1NegativeEdge() const;
 
  std::expected<uint32_t, std::string> touchProbeTimeStamp1PositiveValue() const;
 
  std::expected<uint32_t, std::string> touchProbeTimeStamp1NegativeValue() const;
 
  std::expected<uint16_t, std::string> positioningOptionCode() const;
 
  std::expected<void, std::string> setPositioningOptionCode(uint16_t value);
 
  std::expected<int32_t, std::string> followingErrorActualValue() const;
 
  std::expected<int32_t, std::string> controlEffort() const;
 
  std::expected<int32_t, std::string> positionDemandInternalValue() const;
 
  std::expected<uint32_t, std::string> digitalInputs() const;
 
  std::expected<DigitalOutputs, std::string> digitalOutputs() const;
 
  std::expected<void, std::string> setDigitalOutputs(const DigitalOutputs& outputs);
 
  std::expected<uint32_t, std::string> supportedDriveModes() const;
 
 private:
  std::expected<void, std::string> applyCommand(uint16_t command);
};
 
std::expected<Cia402Drive, std::string> createCia402Drive(Device& device);
 
}  // namespace mm::node