mm::node::somanet Namespace Reference

Pure SOMANET (Synapticon manufacturer-specific) vocabulary — object indices, sub-entry numbers and enumerations, with no dependency on Device. More...

Namespaces
namespace	objects

Classes
struct	IcHausField
	One field of a register — a named piece of it, with what the datasheet calls it. More...
struct	IcHausRegister
	One row of a register map — usually one address, sometimes a printed range. More...
struct	IcHausRegisterSpace
	One addressable register space of one chip. More...
struct	KueblerRegister
	One register of the Kübler encoder. More...

Enumerations
enum class	IcHausChip : uint8_t { kIcMu , kIcPvl }
	Which chip a register space belongs to. More...
enum class	KueblerFormat : uint8_t { kUnsigned , kSigned , kBitField , kSignedHalves }
	How a register's value should be read once assembled. More...
enum class	KueblerAccess : uint8_t { kReadOnly , kWriteOnly , kReadWrite }
	Whether the encoder allows reading a register, writing it, or both. More...
enum	Object : uint16_t {   kCommutationAngleOffset = 0x2001 , kMotorSpecificSettings = 0x2003 , kBrakeOptions = 0x2004 , kCommutationOffsetDetection = 0x2009 ,   kErrorReport = 0x203F }
	Manufacturer-specific object indices (the 0x2000-0x5FFF vendor range). More...
enum	ErrorReportEntry : uint8_t { kErrorReportDescription = 1 }
	Sub-entries of 0x203F (error report). The enum value is the subindex. More...
enum	MotorSetting : uint8_t {   kMotorPolePairs = 1 , kMotorTorqueConstant = 2 , kMotorPhaseResistance = 3 , kMotorPhaseInductance = 4 ,   kMotorPhasesInverted = 5 }
	Sub-entries of 0x2003 (motor specific settings). The enum value is the subindex. More...
enum	CommutationOffsetSetting : uint8_t {   kCommutationOffsetState = 1 , kCommutationOffsetAppliedTorquePercent = 2 , kCommutationOffsetMethod = 3 , kCommutationOffsetKp = 4 ,   kCommutationOffsetKi = 5 , kCommutationOffsetKd = 6 }
	Sub-entries of 0x2009 (commutation offset detection). The enum value is the subindex. More...
enum class	CommutationOffsetMethod : uint8_t { kRotating = 0 , kRotatingTuned = 1 , kStationary = 2 }
	How commutation offset measurement (command 5) is performed (0x2009:03). More...
enum class	EncoderOrdinal : uint8_t { kEncoder1 = 1 , kEncoder2 = 2 }
	Which of a drive's two encoders a command addresses. The enum value is the ordinal the firmware expects. More...
enum class	IcMuCalibrationMode : uint8_t { kConfiguration = 0 , kRaw = 1 , kStandard = 2 }
	How the BiSS service clocks and interprets an iC-MU encoder (OS command 1). The enum value is the "mode enable" field the firmware expects. More...
enum class	FirmwareService : uint8_t { kDriveControl = 0 , kMotionControl = 1 }
	One of the drive's two independently-scheduled control loops, as the firmware's FirmwareServiceId names them. The enum value is the byte the command carries. More...
enum class	KueblerRegisterFault : uint8_t {   kAsyncInProgress = 0 , kInvalidRegisterLength = 1 , kEncoderTimeout = 2 , kWrongByteCount = 3 ,   kEncoderBusy = 4 }
	What the Kübler encoder reported when a register access failed (OS command 19). More...
enum class	VelocitySource : uint8_t { kFirmware = 0 , kEncoder = 1 }
	Where the velocity control loop takes its feedback from (OS command 18). The enum value is the trigger bit the command carries. More...
enum class	FirmwareLatency : uint8_t { kSetpoint = 0 , kFeedback = 1 }
	Which internal firmware latency OS command 22 measures. The enum value is the latency index byte the command carries. More...
enum class	FirmwareErrorType : uint8_t {   kLinkError = 0 , kIllegalPc = 1 , kIllegalInstruction = 2 , kIllegalResource = 3 ,   kLoadStore = 4 , kIllegalPs = 5 , kArithmetic = 6 , kEcall = 7 ,   kResourceDependency = 8 , kKcall = 9 , kEndlessLoop = 10 , kResettableFirmwareError = 11 }
	The errors OS command 16 can provoke in a firmware service. The enum value is the error-type byte the command carries. More...
enum class	FirmwareErrorEffect : uint8_t { kNotImplemented , kStopsService , kRaisesResettableError }
	What a firmware error type actually does on this firmware — which is not what every one of them is named after. More...
enum class	SystemIdentificationParameter : uint8_t {   kStartFrequency = 0 , kTargetFrequency = 1 , kTargetAmplitude = 2 , kTransitionTime = 3 ,   kSignalType = 4 , kStartProcedure = 5 }
	The settings of the system-identification chirp (OS command 15). The enum value is the parameter index the command carries in byte 1. More...
enum class	ChirpSignalType : uint8_t { kLogarithmic = 0 , kLinear = 1 }
	Which excitation the system-identification run sweeps with (parameter 4). More...
enum class	SystemIdentificationStart : uint8_t { kNone = 0 , kImmediately = 1 , kAfterHrdStreamStart = 2 }
	What writing parameter 5 does — arm the run, and on what trigger. More...
enum class	EncoderRegisterFault : uint8_t { kInvalidResponse = 0 , kRegisterNotAllowed = 1 }
	The faults encoder register communication (command 0) reports as its command-specific OS error code. More...
enum class	HrdData : uint8_t { kEncoderRawData = 0 , kSystemIdentificationData = 1 }
	Which signal a high resolution data (HRD) stream records — OS command 3's data index. The enum value is the index the firmware expects. More...
enum class	HrdStreamFault : uint8_t {   kInitialization = 0 , kStreaming = 1 , kDuration = 2 , kDataIndex = 3 ,   kAction = 4 }
	The faults HRD streaming (command 3) reports as its command-specific OS error code. More...
enum	BrakeOption : uint8_t {   kBrakePullVoltage = 1 , kBrakeHoldVoltage = 2 , kBrakePullTime = 3 , kBrakeReleaseStrategy = 4 ,   kBrakeControllerDisableDelay = 5 , kBrakeDcBusVoltage = 6 , kBrakeStatus = 7 , kBrakeMinimumDisplacement = 8 ,   kBrakePinCurrentPercent = 9 , kBrakeOutputVoltage = 10 , kBrakeSwitchingFrequency = 11 , kBrakePinInitialDirection = 12 }
	Sub-entries of 0x2004 (brake options). The enum value is the subindex. More...
enum class	BrakeReleaseStrategy : uint8_t { kManualOutputVoltage = 0 , kClutch = 1 , kPin = 2 }
	How the brake is driven (0x2004:04). More...
enum class	BrakeStatus : uint8_t { kNotConfigured = 0 , kEngaged = 1 , kDisengaged = 2 }
	Brake state (0x2004:07), which both reports the brake and commands it when written. More...
enum class	OsCommandId : uint8_t {   kEncoderRegisterCommunication = 0 , kIcMuCalibrationMode = 1 , kHrdStreaming = 3 , kMotorPhaseOrderDetection = 4 ,   kCommutationOffsetMeasurement = 5 , kOpenPhaseDetection = 6 , kPolePairDetection = 7 , kPhaseResistanceMeasurement = 8 ,   kPhaseInductanceMeasurement = 9 , kTorqueConstantMeasurement = 10 , kSkippedCyclesCounter = 13 , kIgnoreBissStatusBits = 14 ,   kSystemIdentification = 15 , kTriggerError = 16 , kVelocitySource = 18 , kKueblerRegisterCommunication = 19 ,   kReadObjectDictionary = 21 , kMeasureFirmwareLatency = 22 }
	OS command IDs (byte 0 of 0x1023:01). More...
enum class	OpenPhaseFault : uint8_t {   kOpenTerminalA = 0 , kOpenTerminalB = 1 , kOpenTerminalC = 2 , kOpenFetAHigh = 3 ,   kOpenFetALow = 4 , kOpenFetBHigh = 5 , kOpenFetBLow = 6 , kOpenFetCHigh = 7 ,   kOpenFetCLow = 8 }
	The faults open phase detection (command 6) reports, as its command-specific OS error code. More...
enum class	MotorPhaseOrder : uint8_t { kNormal = 0 , kInverted = 1 }
	Which way round the motor's phases are wired, as motor phase order detection (command 4) reports it and as 0x2003:05 "Motor phases inverted" stores it. More...
enum class	MotorMeasurementFault : uint8_t { kCurrentAmplitudeError = 0 }
	The faults the current-injecting motor measurements report as their command-specific OS error code — pole pair (7), phase resistance (8) and phase inductance (9), which the firmware specification gives the same single-entry table. More...
enum class	OperationMode : int8_t {   kImpedance = -6 , kJointTorque = -5 , kSystemIdentification = -4 , kOpenLoopField = -3 ,   kDiagnostics = -2 , kCoggingCompensationRecording = -1 }
	SOMANET's manufacturer-specific operation modes — the negative half of 0x6060, which CiA402 leaves to the vendor. More...

Functions
void	to_json (nlohmann::json &j, const IcHausField &field)
	Serialises an IcHausField. Participates in nlohmann ADL.
void	to_json (nlohmann::json &j, const IcHausRegister &r)
	Serialises an IcHausRegister, layout() included. Participates in nlohmann ADL, so a span of them converts on its own.
void	to_json (nlohmann::json &j, const IcHausRegisterSpace &space)
	Serialises an IcHausRegisterSpace, registers included.
std::span< const IcHausRegisterSpace >	icHausRegisterSpaces ()
	Every register space of both chips, in the order a reader should meet them: the iC-MU's two, then the iC-PVL's three.
constexpr std::string_view	toString (IcHausChip chip)
	Name of a chip, as the console and logs should render it. Never returns nullptr.
void	to_json (nlohmann::json &j, const KueblerRegister &r)
	Serialises a KueblerRegister. Participates in nlohmann ADL, so nlohmann::json(kKueblerRegisters) works.
constexpr std::optional< KueblerRegister >	findKueblerRegister (uint8_t address)
	The register at address, or std::nullopt when the table has none.
std::optional< HrdData >	parseHrdData (std::string_view token)
	Parses an HRD data token ("encoder-raw" / "system-identification") — the inverse of toString. Returns std::nullopt for any other token.
std::optional< ChirpSignalType >	parseChirpSignalType (std::string_view token)
	Parses a signal-type token ("logarithmic" / "linear"). std::nullopt for any other.
std::optional< SystemIdentificationStart >	parseSystemIdentificationStart (std::string_view token)
	Parses a start token ("none" / "immediately" / "after-hrd-stream-start").
std::optional< VelocitySource >	parseVelocitySource (std::string_view token)
	Parses a velocity source token ("firmware" / "encoder"). std::nullopt otherwise.
std::optional< FirmwareLatency >	parseFirmwareLatency (std::string_view token)
	Parses a firmware latency token ("setpoint" / "feedback"). std::nullopt otherwise.
std::optional< FirmwareErrorType >	parseFirmwareErrorType (std::string_view token)
	Parses a firmware error type token — the inverse of toString.
std::optional< FirmwareService >	parseFirmwareService (std::string_view token)
	Parses a service token ("drive-control" / "motion-control") — the inverse of toString. Returns std::nullopt for any other token.
std::optional< IcMuCalibrationMode >	parseIcMuCalibrationMode (std::string_view token)
	Parses a mode token ("configuration" / "raw" / "standard") — the inverse of toString. Returns std::nullopt for any other token.
constexpr std::string_view	toString (CommutationOffsetMethod method)
	Name of a commutation offset method (for logging / JSON). Never returns nullptr.
constexpr bool	requiresBrakeReleased (CommutationOffsetMethod method)
	Whether the method needs the brake released, as opposed to engaged.
constexpr std::string_view	toString (EncoderOrdinal encoder)
	Name of an encoder ordinal, as a message should render it. Never returns nullptr.
constexpr std::string_view	toString (IcMuCalibrationMode mode)
	Name of an iC-MU calibration mode (for logging / JSON). Never returns nullptr.
constexpr std::string_view	toString (FirmwareService service)
	Name of a firmware service (for logging / JSON). Never returns nullptr.
constexpr std::string_view	toString (KueblerRegisterFault fault)
	Name of a Kübler register fault, as a message should render it. Never nullptr.
constexpr std::string_view	toString (VelocitySource source)
	Name of a velocity source (for logging / JSON). Never returns nullptr.
constexpr std::string_view	toString (FirmwareLatency latency)
	Name of a firmware latency (for logging / JSON). Never returns nullptr.
constexpr FirmwareErrorEffect	effectOf (FirmwareErrorType type)
	What type does, from the firmware's own case bodies rather than from its name.
constexpr std::string_view	toString (FirmwareErrorType type)
	Name of a firmware error type (for logging / JSON). Never returns nullptr.
constexpr std::string_view	toString (SystemIdentificationParameter parameter)
	Name of a system-identification parameter, as a message should render it. Never nullptr.
constexpr std::string_view	toString (ChirpSignalType type)
	Name of a chirp signal type (for logging / JSON). Never returns nullptr.
constexpr std::string_view	toString (SystemIdentificationStart start)
	Name of a start trigger (for logging / JSON). Never returns nullptr.
constexpr std::string_view	toString (EncoderRegisterFault fault)
	Name of an encoder register fault, as the console and logs should render it. Never nullptr.
constexpr std::string_view	describe (EncoderRegisterFault fault)
	What an encoder register fault means, for a message a user has to act on. Never nullptr.
constexpr std::string_view	toString (HrdData data)
	Name of an HRD data selection, as it appears on the wire. Never returns nullptr.
constexpr size_t	hrdSampleSize (HrdData data)
	How many bytes one recorded sample of data occupies in the drive's files.
constexpr std::chrono::milliseconds	maxHrdStreamDuration (HrdData data)
	The longest stream the drive will record for data.
constexpr std::string_view	toString (HrdStreamFault fault)
	Name of an HRD streaming fault, as the console and logs should render it. Never nullptr.
constexpr std::string_view	describe (HrdStreamFault fault)
	What an HRD streaming fault means, for a message a user has to act on. Never nullptr.
constexpr std::string_view	toString (BrakeStatus status)
	Human-readable name of a brake status (for logging / JSON). Never returns nullptr.
constexpr std::string_view	toString (BrakeReleaseStrategy strategy)
	Human-readable name of a release strategy (for logging / JSON). Never nullptr.
constexpr std::string_view	toString (OpenPhaseFault fault)
	Name of an open-phase fault, as the console and logs should render it. Never nullptr.
constexpr std::string_view	describe (OpenPhaseFault fault)
	What an open-phase fault means, for a message a user has to act on. Never nullptr.
constexpr std::string_view	toString (MotorPhaseOrder order)
	Name of a motor phase order (for logging / JSON). Never returns nullptr.
constexpr std::string_view	toString (MotorMeasurementFault fault)
	Name of a motor-measurement fault, as the console and logs should render it. Never nullptr.
constexpr std::string_view	describe (MotorMeasurementFault fault)
	What a motor-measurement fault means, for a message a user has to act on. Never nullptr.
constexpr std::string_view	toString (OperationMode mode)
	Name of a SOMANET operation mode, in the same PascalCase spelling the standard modes use (cia402::toString), so the two halves of a mode list read alike. Never nullptr.
constexpr std::string_view	describe (OperationMode mode)
	The drive's own wording for a mode, as its ESI documents 0x6060. Never nullptr.
constexpr bool	isDeprecated (OperationMode mode)
	Whether the firmware marks mode as deprecated — true for system identification alone, which both the firmware header and the ESI label that way.

Variables
constexpr size_t	kMaxFieldsPerRegister = 8
	How many fields one register row can name.
constexpr auto	kKueblerRegisters
	Every register known, ascending by address: the vendor's draft, plus the four the encoder calibration sequence reads and the draft leaves out.
constexpr uint8_t	kMaxKueblerRegisterBytes = 4
	The largest register width OS command 19 can transfer, in bytes: its length byte is capped at 4. Every register in the table fits, so readableInOneCommand is true for all of them today. It stays on the wire because the cap is real and a wider register would be reported rather than silently truncated.
constexpr FirmwareErrorType	kFirmwareErrorTypes []
	Every firmware error type, ascending.
constexpr uint32_t	kMinChirpFrequencyMilliHz = 100
	The bounds the firmware enforces on a chirp configuration.
constexpr uint32_t	kMaxChirpFrequencyMilliHz = 1'000'000
	1000 Hz.
constexpr uint32_t	kMinChirpTransitionTimeMs = 1'000
	1 s.
constexpr uint32_t	kMaxChirpTransitionTimeMs = 20'000
	20 s.
constexpr OperationMode	kOperationModes []
	Every SOMANET operation mode, ascending — the manufacturer half of a mode list.

Detailed Description

Pure SOMANET (Synapticon manufacturer-specific) vocabulary — object indices, sub-entry numbers and enumerations, with no dependency on Device.

The vendor counterpart of mm::node::cia402, and nested rather than flat for one concrete reason: SOMANET extends 0x6060 with modes CiA402 does not define, so somanet::OperationMode has to sit beside cia402::OperationMode without colliding with it.

Enumeration Type Documentation

BrakeOption

enum mm::node::somanet::BrakeOption : uint8_t

Sub-entries of 0x2004 (brake options). The enum value is the subindex.

Enumerator
kBrakePullVoltage	UNSIGNED32, mV — voltage that disengages the brake.
kBrakeHoldVoltage	UNSIGNED32, mV — lower voltage that keeps it disengaged.
kBrakePullTime	UNSIGNED16, ms — how long the pull voltage is applied.
kBrakeReleaseStrategy	UNSIGNED8 — how the brake is driven; see BrakeReleaseStrategy.
kBrakeControllerDisableDelay	UNSIGNED16, ms — engage-to-controller-off delay.
kBrakeDcBusVoltage	UNSIGNED16 — deprecated; the drive still lists it.
kBrakeStatus	UNSIGNED8 — reports and commands the brake; see BrakeStatus.
kBrakeMinimumDisplacement	UNSIGNED32 — pin-brake release travel threshold.
kBrakePinCurrentPercent	UNSIGNED16 — "Percentage of Rated Current": the current ceiling a pin-brake release works up to. A percentage of rated current, not a torque in mNm.
kBrakeOutputVoltage	UNSIGNED16, mV — phase-D voltage in manual mode.
kBrakeSwitchingFrequency	UNSIGNED8 — phase-D PWM rate (0: 16, 1: 32, 2: 64 kHz).
kBrakePinInitialDirection	INTEGER8 — which way a pin-brake release moves first.

BrakeReleaseStrategy

enum class mm::node::somanet::BrakeReleaseStrategy : uint8_t

strong

How the brake is driven (0x2004:04).

kManualOutputVoltage is the one that matters to a caller: the brake is not under firmware control at all, so commanding BrakeStatus does nothing and release/engage are no-ops.

Enumerator
kManualOutputVoltage	Not firmware-controlled — a raw phase-D voltage (0x2004:10).
kClutch	Standard brake: pull voltage for the pull time, then hold voltage.
kPin	Pin brake — releasing it moves the shaft (see releaseBrake).

BrakeStatus

enum class mm::node::somanet::BrakeStatus : uint8_t

strong

Brake state (0x2004:07), which both reports the brake and commands it when written.

Enumerator
kNotConfigured	No brake configured.
kEngaged	Holding. A brake is spring-engaged, so this is its powered-off state.
kDisengaged	Released.

ChirpSignalType

enum class mm::node::somanet::ChirpSignalType : uint8_t

strong

Which excitation the system-identification run sweeps with (parameter 4).

Enumerator
kLogarithmic	Logarithmic frequency sweep whose amplitude rises with it, from half the target to the target.
kLinear	Linear frequency sweep at a constant amplitude.

CommutationOffsetMethod

enum class mm::node::somanet::CommutationOffsetMethod : uint8_t

strong

How commutation offset measurement (command 5) is performed (0x2009:03).

The choice changes what the command physically does, not just its accuracy, which is why a caller has to read it rather than assume: the two rotating methods need the brake released, and the stationary one needs it engaged — the drive cannot hold the load itself under that method.

Enumerator
kRotating	Rotates the rotor by up to one pole pair. Holds the load, needs no tuning, good precision — the default, and the one to use unless there is a reason not to.
kRotatingTuned	Rotates the rotor only a few electrical degrees and holds the load, but requires the Kp/Ki/Kd gains in 0x2009:04-06 to be tuned already; intended for the prototype phase. How few depends entirely on the quality of that tuning, and the firmware documentation quotes two different figures for a well-tuned controller — "less than 5 degrees" in prose, "less than 20 electrical degrees" in its comparison table — so treat either as an order of magnitude rather than a bound, and method 0 as the predictable one.
kStationary	Does not rotate the rotor at all and completes in around 250 ms, at the cost of precision. Does not hold the load, so the brake stays engaged for the duration.

CommutationOffsetSetting

enum mm::node::somanet::CommutationOffsetSetting : uint8_t

Sub-entries of 0x2009 (commutation offset detection). The enum value is the subindex.

Types and names are the drive's own, read off a SOMANET Integro rather than assumed — and none of them is what a reader would guess. The method is signed (INTEGER8), the state and torque percentage are INTEGER16 rather than byte-sized, and the three gains are REAL32 floats.

Enumerator
kCommutationOffsetState	INTEGER16 — set to OFFSET_VALID by a successful command 5.
kCommutationOffsetAppliedTorquePercent	INTEGER16, 0-100, default 100 — how hard the measurement drives the motor. The drive names this entry "Applied percent of rated torque", which is the name used here, but its own description and the published documentation both call it a percentage of rated current. The two disagree in the source data, so do not read the name as settling the quantity.
kCommutationOffsetMethod	INTEGER8 — which method runs; see CommutationOffsetMethod.
kCommutationOffsetKp	REAL32 — phasing controller Kp; method 1 only.
kCommutationOffsetKi	REAL32 — phasing controller Ki; method 1 only.
kCommutationOffsetKd	REAL32 — phasing controller Kd; method 1 only.

EncoderOrdinal

enum class mm::node::somanet::EncoderOrdinal : uint8_t

strong

Which of a drive's two encoders a command addresses. The enum value is the ordinal the firmware expects.

The ordinal selects a configuration object, not a kind of encoder: encoder 1 is the encoder configured in 0x2110 and encoder 2 the one configured in 0x2112. A command addressed at an unconfigured encoder — or at one whose service does not support the command — is refused by the drive rather than misapplied to the other one.

Enumerator
kEncoder1	The encoder configured in 0x2110.
kEncoder2	The encoder configured in 0x2112.

EncoderRegisterFault

enum class mm::node::somanet::EncoderRegisterFault : uint8_t

strong

The faults encoder register communication (command 0) reports as its command-specific OS error code.

Command-specific codes count up from 0 and mean nothing outside their own command — general codes (OsCommandError) count down from 254 — so this table is only valid for command 0.

Enumerator
kInvalidResponse	The register transaction failed inside the encoder service.
kRegisterNotAllowed	The register cannot be accessed while the firmware is using it.

ErrorReportEntry

enum mm::node::somanet::ErrorReportEntry : uint8_t

Sub-entries of 0x203F (error report). The enum value is the subindex.

Enumerator
kErrorReportDescription	STRING — what the drive says about its most recent fault.

FirmwareErrorEffect

enum class mm::node::somanet::FirmwareErrorEffect : uint8_t

strong

What a firmware error type actually does on this firmware — which is not what every one of them is named after.

Enumerator
kNotImplemented	The firmware's case body is empty: the command is accepted, nothing happens, and the drive answers that it failed. Seven of the twelve are like this, and the specification marks them "(disabled)".
kStopsService	The service executes faulty code or hangs, and stops answering for good. Only a power cycle brings it back; the drive does not fault, it stops participating.
kRaisesResettableError	A resettable error is reported and the drive reacts as 0x605A says. Recoverable.

FirmwareErrorType

enum class mm::node::somanet::FirmwareErrorType : uint8_t

strong

The errors OS command 16 can provoke in a firmware service. The enum value is the error-type byte the command carries.

A test and diagnostic tool, and most of it is one-way. The XMOS exception types are raised by executing genuinely faulty code — an unaligned store, a divide by zero, an out-of-bounds index — and the service that executes it does not come back. Only kResettableFirmwareError leaves a drive you can carry on using.

Enumerator
kLinkError	ET_LINK_ERROR. Not implemented by the firmware.
kIllegalPc	ET_ILLEGAL_PC. Not implemented.
kIllegalInstruction	ET_ILLEGAL_INSTRUCTION. Not implemented.
kIllegalResource	ET_ILLEGAL_RESOURCE. Not implemented.
kLoadStore	ET_LOAD_STORE, by an unaligned 64-bit store. Stops the service.
kIllegalPs	ET_ILLEGAL_PS. Not implemented.
kArithmetic	ET_ARITHMETIC, by dividing by zero. Stops the service.
kEcall	ET_ECALL, by an out-of-bounds array index. Stops the service.
kResourceDependency	ET_RESOURCE_DEP. Not implemented.
kKcall	ET_KCALL. Not implemented.
kEndlessLoop	Spins forever in the service loop. Stops the service.
kResettableFirmwareError	Reports a resettable DiagErr with the drive's configured quick-stop reaction. The only type that leaves the drive usable — it faults, and a fault reset clears it.

FirmwareLatency

enum class mm::node::somanet::FirmwareLatency : uint8_t

strong

Which internal firmware latency OS command 22 measures. The enum value is the latency index byte the command carries.

Both are durations inside the drive control service's cycle, which is the only service that implements the command; the drive keeps one maximum per latency and measures them independently.

Enumerator
kSetpoint	From the start of the drive control service cycle until the setpoints are handed to the motion control service. The specification's use for it: deciding how far ahead of the motion control cycle the drive control cycle has to start.
kFeedback	From the request for control feedback until the end of the drive control service cycle. The specification's use for it: deciding whether there is time to wait for another motion control cycle before taking the feedback.

FirmwareService

enum class mm::node::somanet::FirmwareService : uint8_t

strong

One of the drive's two independently-scheduled control loops, as the firmware's FirmwareServiceId names them. The enum value is the byte the command carries.

They are separate loops with separate periods and separate counters, so a command addressed at one says nothing about the other. Each service answers only requests naming itself: a byte naming neither leaves the command unanswered by anything, and the drive's OS command handler eventually fails it as a timeout rather than as a bad parameter — which is why a caller validates this rather than passing a number through.

Enumerator
kDriveControl	The current/torque loop — the fast one, period per 0x60C2.
kMotionControl	The position/velocity loop above it.

HrdData

enum class mm::node::somanet::HrdData : uint8_t

strong

Which signal a high resolution data (HRD) stream records — OS command 3's data index. The enum value is the index the firmware expects.

The two formats differ in what a sample is, so the choice made when a stream is configured also decides how its files decode. Nothing on the drive records which one was used, which is why reading a recording back takes the same enum as configuring it did.

A recording is 1 kHz even on a drive that samples faster. The drive control loop runs at 250, 500 or 1000 µs, but the OS command 3 handler writes one sample per millisecond whatever the loop period is — it divides by its cycles-per-ms, which works because every supported loop period divides 1000 µs. Do not read a recording's length as the drive's resolution.

Not to be confused with object 0x20E1, also called high resolution data, which is a separate feature this code does not touch: a rolling OD array the drive fills every motion cycle with position, velocity and phase currents. Same name, different data, different transport.

Enumerator
kEncoderRawData	The raw position word an iC-MU encoder reports. Records zeros unless the encoder was first put into raw mode (IcMuCalibrationMode::kRaw, OS command 1) — the firmware streams whatever the encoder is currently clocked for.
kSystemIdentificationData	The velocity and torque actual values. Records the response to a system identification run (OS command 15), which has to be configured and started first; on its own this streams a drive that is not being excited.

HrdStreamFault

enum class mm::node::somanet::HrdStreamFault : uint8_t

strong

The faults HRD streaming (command 3) reports as its command-specific OS error code.

Command-specific codes count up from 0 and mean nothing outside their own command — general codes (OsCommandError) count down from 254 — so this table is only valid for command 3.

Enumerator
kInitialization	The command could not initialise.
kStreaming	Something failed while the stream was running.
kDuration	The requested duration is above the limit for the chosen data index.
kDataIndex	The requested data index is not one the drive knows.
kAction	The requested action is neither configure nor start.

IcHausChip

enum class mm::node::somanet::IcHausChip : uint8_t

strong

Which chip a register space belongs to.

Enumerator
kIcMu	The position encoder; BiSS-C to the drive.
kIcPvl	The battery-buffered multiturn counter, reached over I²C through the iC-MU.

IcMuCalibrationMode

enum class mm::node::somanet::IcMuCalibrationMode : uint8_t

strong

How the BiSS service clocks and interprets an iC-MU encoder (OS command 1). The enum value is the "mode enable" field the firmware expects.

The iC-MU is the chip behind a Circulo's internal encoder, and calibrating one means moving between these three modes rather than setting a single "calibration" switch.

Enumerator
kConfiguration	The service still clocks the encoder but uses only the register-communication bits and discards the rest, so position stops updating and the BiSS CRC error is not raised. It is what makes it possible to change the encoder's configuration registers without the drive faulting on the malformed frames that produces.
kRaw	The service clocks an encoder already configured for raw output, and averages the raw data into 0x2704 (user MISO) alongside the normal position calculation.
kStandard	Normal clocking — the mode an encoder runs in when nothing is being calibrated.

KueblerAccess

enum class mm::node::somanet::KueblerAccess : uint8_t

strong

Whether the encoder allows reading a register, writing it, or both.

Enumerator
kReadOnly
kWriteOnly
kReadWrite

KueblerFormat

enum class mm::node::somanet::KueblerFormat : uint8_t

strong

How a register's value should be read once assembled.

Enumerator
kUnsigned	One unsigned integer of the register's width.
kSigned	One two's-complement integer of the register's width.
kBitField	Named bits; the assembled number means nothing on its own. See definition.
kSignedHalves	Two signed 16-bit values packed into 32 bits — the high half is A, the low half B. Register 0x3C is the only one, and decoding it as a single signed 32-bit value would be meaningless.

KueblerRegisterFault

enum class mm::node::somanet::KueblerRegisterFault : uint8_t

strong

What the Kübler encoder reported when a register access failed (OS command 19).

Command-specific codes, so they mean nothing outside this command. The specification numbers the last one 5; the firmware sends 4, and there is no code 5 — OsCmd19ErrorCodes is the authority.

Enumerator
kAsyncInProgress	The encoder's asynchronous channel is busy with something else.
kInvalidRegisterLength	The length byte was below 1 or above 4.
kEncoderTimeout	The encoder returned no value within 10 ms. Reads only.
kWrongByteCount	It answered with a different width than was asked for. Reads only.
kEncoderBusy	The encoder is writing flash and will not service the access. Four addresses are exempt — 0x24, 0x25, 0x50 and 0x52, the POA and correction status/control pair — so those stay reachable during a correction-table operation, which is when the encoder is most likely to be busy.

MotorMeasurementFault

enum class mm::node::somanet::MotorMeasurementFault : uint8_t

strong

The faults the current-injecting motor measurements report as their command-specific OS error code — pole pair (7), phase resistance (8) and phase inductance (9), which the firmware specification gives the same single-entry table.

A table shared between commands is only safe because the specification gives them the same one; command-specific codes count up from 0 and otherwise mean nothing outside the command that issued them (general codes count down from 254 — see OsCommandError). Open phase detection's code 0 means "open terminal A", which is exactly why each command decodes its own table.

Enumerator
kCurrentAmplitudeError	The drive could not reach the current amplitude it needed.

MotorPhaseOrder

enum class mm::node::somanet::MotorPhaseOrder : uint8_t

strong

Which way round the motor's phases are wired, as motor phase order detection (command 4) reports it and as 0x2003:05 "Motor phases inverted" stores it.

"Inverted" means the sensor angle and the rotor angle move in opposite directions; normal means they increase together.

Enumerator
kNormal	Sensor and rotor angles change in the same direction.
kInverted	They change in opposite directions.

MotorSetting

enum mm::node::somanet::MotorSetting : uint8_t

Sub-entries of 0x2003 (motor specific settings). The enum value is the subindex.

Types are the drive's own, read off a SOMANET Integro's object dictionary rather than assumed. Worth knowing that this is where the motor measurements belong: pole pair detection (7), phase resistance (8), phase inductance (9) and torque constant measurement (10) report a value without storing it, and :01, :02, :03 and :04 are the entries it goes in.

Enumerator
kMotorPolePairs	UNSIGNED8 — where a pole pair count (command 7) belongs.
kMotorTorqueConstant	INTEGER32 — where a torque constant (command 10) belongs, in µNm/A_rms, which is not the unit the command reports. The drive's own description of this entry names the unit; the command answers in mNm/A_rms, a factor of 1000 coarser. See TorqueConstantResult.
kMotorPhaseResistance	INTEGER32 — where a phase resistance (command 8) belongs, in µΩ, which is not the unit the command reports either: it answers in mΩ, so this is the second of the three that needs multiplying by 1000 before it is stored. The firmware reads this object into a variable it calls phase_resistance_uOhm, which is what settles it.
kMotorPhaseInductance	INTEGER32 — where a phase inductance (command 9) belongs, in µH. The one that matches its command, which also reports µH, so a measurement is stored as it comes. The firmware's variable is phase_inductance_uH.
kMotorPhasesInverted	BOOLEAN — the phase order motor phase order detection (4) writes.

Object

enum mm::node::somanet::Object : uint16_t

Manufacturer-specific object indices (the 0x2000-0x5FFF vendor range).

Enumerator
kCommutationAngleOffset	INTEGER16 — the offset command 5 measures and writes.
kMotorSpecificSettings	RECORD — motor configuration; :05 is the phase order.
kBrakeOptions	RECORD — brake voltages, timing, release strategy, status.
kCommutationOffsetDetection	RECORD — how commutation offset (5) is measured.
kErrorReport	RECORD — :01 describes the drive's most recent fault.

OpenPhaseFault

enum class mm::node::somanet::OpenPhaseFault : uint8_t

strong

The faults open phase detection (command 6) reports, as its command-specific OS error code.

Command-specific codes count up from 0 and mean nothing outside their own command — general codes (OsCommandError) count down from 254 — so this table is only valid for command 6.

Enumerator
kOpenTerminalA	Terminal A of the drive is not connected.
kOpenTerminalB	Terminal B of the drive is not connected.
kOpenTerminalC	Terminal C of the drive is not connected.
kOpenFetAHigh	Upper FET in leg A is not conducting (open circuit fault).
kOpenFetALow	Lower FET in leg A is not conducting (open circuit fault).
kOpenFetBHigh	Upper FET in leg B is not conducting (open circuit fault).
kOpenFetBLow	Lower FET in leg B is not conducting (open circuit fault).
kOpenFetCHigh	Upper FET in leg C is not conducting (open circuit fault).
kOpenFetCLow	Lower FET in leg C is not conducting (open circuit fault).

OperationMode

enum class mm::node::somanet::OperationMode : int8_t

strong

SOMANET's manufacturer-specific operation modes — the negative half of 0x6060, which CiA402 leaves to the vendor.

Deliberately a separate enum rather than extra enumerators on cia402::OperationMode: that one is the standard set, and cia402::toOperationMode exists so an API boundary can reject a mode it does not know. Folding these in would make every vendor mode validate as a CiA402 mode everywhere the standard enum is used, including the console's mode list.

Enumerator
kImpedance	Impedance mode.
kJointTorque	Joint torque mode.
kSystemIdentification	System identification mode. Deprecated by the firmware.
kOpenLoopField	Open loop field control mode.
kDiagnostics	Where the master owns the brake and the measurement OS commands run.
kCoggingCompensationRecording	Cogging torque table recording.

OsCommandId

enum class mm::node::somanet::OsCommandId : uint8_t

strong

OS command IDs (byte 0 of 0x1023:01).

Only the commands this codebase issues are listed; the firmware implements more. The numbering is the firmware's, so gaps are real rather than reserved space.

Enumerator
kEncoderRegisterCommunication	Reads or writes one register of a BiSS encoder.
kIcMuCalibrationMode	Sets how the BiSS service clocks an iC-MU encoder.
kHrdStreaming	Records a signal into the drive's high resolution data files.
kMotorPhaseOrderDetection	Detects the motor phase order. Rotates the rotor.
kCommutationOffsetMeasurement	Measures the commutation angle offset; see somanet::CommutationOffsetMethod.
kOpenPhaseDetection	Checks every motor phase and FET leg for an open circuit.
kPolePairDetection	Detects the motor's pole pair count. Rotates the rotor.
kPhaseResistanceMeasurement	Measures the motor's phase resistance, in milliohms.
kPhaseInductanceMeasurement	Measures the motor's phase inductance, in microhenries.
kTorqueConstantMeasurement	Measures the motor's torque constant. Rotates the rotor.
kSkippedCyclesCounter	Reads a control loop's skipped-cycle counter. Harmless; no motion.
kIgnoreBissStatusBits	Suppresses a BiSS encoder's own error and warning bits.
kSystemIdentification	Configures and triggers the system-identification chirp.
kTriggerError	Provokes a firmware error or exception. Test tool only.
kVelocitySource	Chooses where the velocity loop's feedback comes from.
kKueblerRegisterCommunication	Reads or writes an Integro internal encoder register.
kReadObjectDictionary	Sends every object dictionary value at once. No motion.
kMeasureFirmwareLatency	Measures a duration inside the drive control cycle.

SystemIdentificationParameter

enum class mm::node::somanet::SystemIdentificationParameter : uint8_t

strong

The settings of the system-identification chirp (OS command 15). The enum value is the parameter index the command carries in byte 1.

One command sets one of these, so configuring a run means issuing the command once per setting. They are held on the drive until overwritten or it is power-cycled; nothing reads them back.

Enumerator
kStartFrequency	Where the sweep begins, in mHz.
kTargetFrequency	Where it ends, in mHz. Must not be below the start frequency.
kTargetAmplitude	Peak excitation, in per-mille of rated torque. See the note below.
kTransitionTime	How long the sweep takes, in ms.
kSignalType	Which chirp; see ChirpSignalType.
kStartProcedure	Arms the run; see SystemIdentificationStart.

SystemIdentificationStart

enum class mm::node::somanet::SystemIdentificationStart : uint8_t

strong

What writing parameter 5 does — arm the run, and on what trigger.

Enumerator
kNone	Do not arm. Writing this is also how an armed run is disarmed, which matters because the drive starts on the rising edge of this parameter: re-arming without clearing first is a write the firmware never sees as an edge.
kImmediately	Start on the next control cycle.
kAfterHrdStreamStart	Start when high resolution data streaming starts. This is the pairing that produces a usable recording — see HrdData::kSystemIdentificationData.

VelocitySource

enum class mm::node::somanet::VelocitySource : uint8_t

strong

Where the velocity control loop takes its feedback from (OS command 18). The enum value is the trigger bit the command carries.

Only the Integro's internal (Kübler) encoder provides its own velocity, so this decides anything only for that encoder, wherever it is configured. On a drive whose Kübler encoder is not configured for velocity control the command is accepted and changes nothing.

The velocity feedback filter is applied either way; this chooses what goes into it.

Enumerator
kFirmware	Differentiated from encoder position by the firmware. The default on every build except Integro — and the OS command specification calls it the default outright, which is wrong for the one product the command applies to.
kEncoder	Reported by the encoder itself, which integrates it in hardware. The default on an Integro build, where the firmware sets the flag at start-up with a comment saying so — so on an Integro the useful direction is towards kFirmware, not away from it.

Function Documentation

describe() [1/5]

constexpr std::string_view mm::node::somanet::describe ( EncoderRegisterFault  fault )

constexpr

What an encoder register fault means, for a message a user has to act on. Never nullptr.

describe() [2/5]

constexpr std::string_view mm::node::somanet::describe ( HrdStreamFault  fault )

constexpr

What an HRD streaming fault means, for a message a user has to act on. Never nullptr.

describe() [3/5]

constexpr std::string_view mm::node::somanet::describe ( MotorMeasurementFault  fault )

constexpr

What a motor-measurement fault means, for a message a user has to act on. Never nullptr.

describe() [4/5]

constexpr std::string_view mm::node::somanet::describe ( OpenPhaseFault  fault )

constexpr

What an open-phase fault means, for a message a user has to act on. Never nullptr.

describe() [5/5]

constexpr std::string_view mm::node::somanet::describe ( OperationMode  mode )

constexpr

The drive's own wording for a mode, as its ESI documents 0x6060. Never nullptr.

effectOf()

constexpr FirmwareErrorEffect mm::node::somanet::effectOf ( FirmwareErrorType  type )

constexpr

What type does, from the firmware's own case bodies rather than from its name.

findKueblerRegister()

constexpr std::optional< KueblerRegister > mm::node::somanet::findKueblerRegister ( uint8_t  address )

constexpr

The register at address, or std::nullopt when the table has none.

A missing entry is not an error: the draft is preliminary and the command addresses any byte, so an unknown address is read as an unnamed register rather than refused.

hrdSampleSize()

constexpr size_t mm::node::somanet::hrdSampleSize ( HrdData  data )

constexpr

How many bytes one recorded sample of data occupies in the drive's files.

Four for a raw encoder word, six for a velocity/torque pair. The firmware writes one sample per millisecond of the configured duration, so this is also what turns a duration into a size.

icHausRegisterSpaces()

std::span< const IcHausRegisterSpace > mm::node::somanet::icHausRegisterSpaces

(

)

Every register space of both chips, in the order a reader should meet them: the iC-MU's two, then the iC-PVL's three.

isDeprecated()

constexpr bool mm::node::somanet::isDeprecated ( OperationMode  mode )

constexpr

Whether the firmware marks mode as deprecated — true for system identification alone, which both the firmware header and the ESI label that way.

maxHrdStreamDuration()

constexpr std::chrono::milliseconds mm::node::somanet::maxHrdStreamDuration ( HrdData  data )

constexpr

The longest stream the drive will record for data.

Two different limits, because the recording is held in at most five 8032-byte files and the ceiling is whatever fills them: 10000 ms of 4-byte samples, or 6000 ms of 6-byte ones. The drive enforces both — it picks the limit from the data index and answers HrdStreamFault::kDuration — so applying them here only turns a rejected round trip into a caller error. (The firmware specification's error table describes that code as "larger than 10000 ms", which reads as though the narrower limit were unchecked; the drive application checks per data index.)

parseChirpSignalType()

std::optional< ChirpSignalType > mm::node::somanet::parseChirpSignalType

(

std::string_view

token

)

Parses a signal-type token ("logarithmic" / "linear"). std::nullopt for any other.

parseFirmwareErrorType()

std::optional< FirmwareErrorType > mm::node::somanet::parseFirmwareErrorType

(

std::string_view

token

)

Parses a firmware error type token — the inverse of toString.

parseFirmwareLatency()

std::optional< FirmwareLatency > mm::node::somanet::parseFirmwareLatency

(

std::string_view

token

)

Parses a firmware latency token ("setpoint" / "feedback"). std::nullopt otherwise.

parseFirmwareService()

std::optional< FirmwareService > mm::node::somanet::parseFirmwareService

(

std::string_view

token

)

Parses a service token ("drive-control" / "motion-control") — the inverse of toString. Returns std::nullopt for any other token.

parseHrdData()

std::optional< HrdData > mm::node::somanet::parseHrdData

(

std::string_view

token

)

Parses an HRD data token ("encoder-raw" / "system-identification") — the inverse of toString. Returns std::nullopt for any other token.

parseIcMuCalibrationMode()

std::optional< IcMuCalibrationMode > mm::node::somanet::parseIcMuCalibrationMode

(

std::string_view

token

)

Parses a mode token ("configuration" / "raw" / "standard") — the inverse of toString. Returns std::nullopt for any other token.

parseSystemIdentificationStart()

std::optional< SystemIdentificationStart > mm::node::somanet::parseSystemIdentificationStart

(

std::string_view

token

)

Parses a start token ("none" / "immediately" / "after-hrd-stream-start").

parseVelocitySource()

std::optional< VelocitySource > mm::node::somanet::parseVelocitySource

(

std::string_view

token

)

Parses a velocity source token ("firmware" / "encoder"). std::nullopt otherwise.

requiresBrakeReleased()

constexpr bool mm::node::somanet::requiresBrakeReleased ( CommutationOffsetMethod  method )

constexpr

Whether the method needs the brake released, as opposed to engaged.

True for the rotating methods, whose restrictions require a disengaged brake. False for kStationary, which is the one command in this family that wants the brake engaged — it cannot hold the load, so releasing the brake for it would be actively wrong rather than merely unnecessary.

to_json() [1/4]

void mm::node::somanet::to_json	(	nlohmann::json &	j,
		const IcHausField &	field
	)

Serialises an IcHausField. Participates in nlohmann ADL.

to_json() [2/4]

void mm::node::somanet::to_json	(	nlohmann::json &	j,
		const IcHausRegister &	r
	)

Serialises an IcHausRegister, layout() included. Participates in nlohmann ADL, so a span of them converts on its own.

to_json() [3/4]

void mm::node::somanet::to_json	(	nlohmann::json &	j,
		const IcHausRegisterSpace &	space
	)

Serialises an IcHausRegisterSpace, registers included.

to_json() [4/4]

void mm::node::somanet::to_json	(	nlohmann::json &	j,
		const KueblerRegister &	r
	)

Serialises a KueblerRegister. Participates in nlohmann ADL, so nlohmann::json(kKueblerRegisters) works.

toString() [1/21]

constexpr std::string_view mm::node::somanet::toString ( BrakeReleaseStrategy  strategy )

constexpr

Human-readable name of a release strategy (for logging / JSON). Never nullptr.

toString() [2/21]

constexpr std::string_view mm::node::somanet::toString ( BrakeStatus  status )

constexpr

Human-readable name of a brake status (for logging / JSON). Never returns nullptr.

toString() [3/21]

constexpr std::string_view mm::node::somanet::toString ( ChirpSignalType  type )

constexpr

Name of a chirp signal type (for logging / JSON). Never returns nullptr.

toString() [4/21]

constexpr std::string_view mm::node::somanet::toString ( CommutationOffsetMethod  method )

constexpr

Name of a commutation offset method (for logging / JSON). Never returns nullptr.

toString() [5/21]

constexpr std::string_view mm::node::somanet::toString ( EncoderOrdinal  encoder )

constexpr

Name of an encoder ordinal, as a message should render it. Never returns nullptr.

toString() [6/21]

constexpr std::string_view mm::node::somanet::toString ( EncoderRegisterFault  fault )

constexpr

Name of an encoder register fault, as the console and logs should render it. Never nullptr.

toString() [7/21]

constexpr std::string_view mm::node::somanet::toString ( FirmwareErrorType  type )

constexpr

Name of a firmware error type (for logging / JSON). Never returns nullptr.

toString() [8/21]

constexpr std::string_view mm::node::somanet::toString ( FirmwareLatency  latency )

constexpr

Name of a firmware latency (for logging / JSON). Never returns nullptr.

toString() [9/21]

constexpr std::string_view mm::node::somanet::toString ( FirmwareService  service )

constexpr

Name of a firmware service (for logging / JSON). Never returns nullptr.

toString() [10/21]

constexpr std::string_view mm::node::somanet::toString ( HrdData  data )

constexpr

Name of an HRD data selection, as it appears on the wire. Never returns nullptr.

toString() [11/21]

constexpr std::string_view mm::node::somanet::toString ( HrdStreamFault  fault )

constexpr

Name of an HRD streaming fault, as the console and logs should render it. Never nullptr.

toString() [12/21]

constexpr std::string_view mm::node::somanet::toString ( IcHausChip  chip )

constexpr

Name of a chip, as the console and logs should render it. Never returns nullptr.

toString() [13/21]

constexpr std::string_view mm::node::somanet::toString ( IcMuCalibrationMode  mode )

constexpr

Name of an iC-MU calibration mode (for logging / JSON). Never returns nullptr.

toString() [14/21]

constexpr std::string_view mm::node::somanet::toString ( KueblerRegisterFault  fault )

constexpr

Name of a Kübler register fault, as a message should render it. Never nullptr.

toString() [15/21]

constexpr std::string_view mm::node::somanet::toString ( MotorMeasurementFault  fault )

constexpr

Name of a motor-measurement fault, as the console and logs should render it. Never nullptr.

toString() [16/21]

constexpr std::string_view mm::node::somanet::toString ( MotorPhaseOrder  order )

constexpr

Name of a motor phase order (for logging / JSON). Never returns nullptr.

toString() [17/21]

constexpr std::string_view mm::node::somanet::toString ( OpenPhaseFault  fault )

constexpr

Name of an open-phase fault, as the console and logs should render it. Never nullptr.

toString() [18/21]

constexpr std::string_view mm::node::somanet::toString ( OperationMode  mode )

constexpr

Name of a SOMANET operation mode, in the same PascalCase spelling the standard modes use (cia402::toString), so the two halves of a mode list read alike. Never nullptr.

toString() [19/21]

constexpr std::string_view mm::node::somanet::toString ( SystemIdentificationParameter  parameter )

constexpr

Name of a system-identification parameter, as a message should render it. Never nullptr.

toString() [20/21]

constexpr std::string_view mm::node::somanet::toString ( SystemIdentificationStart  start )

constexpr

Name of a start trigger (for logging / JSON). Never returns nullptr.

toString() [21/21]

constexpr std::string_view mm::node::somanet::toString ( VelocitySource  source )

constexpr

Name of a velocity source (for logging / JSON). Never returns nullptr.

Variable Documentation

kFirmwareErrorTypes

constexpr FirmwareErrorType mm::node::somanet::kFirmwareErrorTypes[]

inlineconstexpr

Initial value:

= {
    FirmwareErrorType::kLinkError,          FirmwareErrorType::kIllegalPc,
    FirmwareErrorType::kIllegalInstruction, FirmwareErrorType::kIllegalResource,
    FirmwareErrorType::kLoadStore,          FirmwareErrorType::kIllegalPs,
    FirmwareErrorType::kArithmetic,         FirmwareErrorType::kEcall,
    FirmwareErrorType::kResourceDependency, FirmwareErrorType::kKcall,
    FirmwareErrorType::kEndlessLoop,        FirmwareErrorType::kResettableFirmwareError,
}

Every firmware error type, ascending.

kKueblerRegisters

constexpr auto mm::node::somanet::kKueblerRegisters

inlineconstexpr

Every register known, ascending by address: the vendor's draft, plus the four the encoder calibration sequence reads and the draft leaves out.

kMaxChirpFrequencyMilliHz

constexpr uint32_t mm::node::somanet::kMaxChirpFrequencyMilliHz = 1'000'000

inlineconstexpr

1000 Hz.

kMaxChirpTransitionTimeMs

constexpr uint32_t mm::node::somanet::kMaxChirpTransitionTimeMs = 20'000

inlineconstexpr

20 s.

kMaxFieldsPerRegister

constexpr size_t mm::node::somanet::kMaxFieldsPerRegister = 8

inlineconstexpr

How many fields one register row can name.

Eight: a status register the datasheet breaks out bit by bit is the widest case, and no register can name more than its own bits. A fixed array rather than a span so a register row and its fields are one literal — the alternative is a named array per register, which is 150 names for no gain.

kMaxKueblerRegisterBytes

constexpr uint8_t mm::node::somanet::kMaxKueblerRegisterBytes = 4

inlineconstexpr

The largest register width OS command 19 can transfer, in bytes: its length byte is capped at 4. Every register in the table fits, so readableInOneCommand is true for all of them today. It stays on the wire because the cap is real and a wider register would be reported rather than silently truncated.

kMinChirpFrequencyMilliHz

constexpr uint32_t mm::node::somanet::kMinChirpFrequencyMilliHz = 100

inlineconstexpr

The bounds the firmware enforces on a chirp configuration.

**Taken from the firmware's own are_sinewave_config_parameters_valid, not from the OS command specification**, which says only that an out-of-range value raises an "Invalid Parameter" error and points at another document for the numbers. They are the range within which its fixed-point arithmetic does not overflow, which is why they are hard limits rather than advice.

The amplitude is deliberately absent: the firmware does not check it. See SomanetDrive::setSystemIdentificationParameter. 0.1 Hz.

kMinChirpTransitionTimeMs

constexpr uint32_t mm::node::somanet::kMinChirpTransitionTimeMs = 1'000

inlineconstexpr

1 s.

kOperationModes

constexpr OperationMode mm::node::somanet::kOperationModes[]

inlineconstexpr

Initial value:

= {
    OperationMode::kImpedance,
    OperationMode::kJointTorque,
    OperationMode::kSystemIdentification,
    OperationMode::kOpenLoopField,
    OperationMode::kDiagnostics,
    OperationMode::kCoggingCompensationRecording,
}

Every SOMANET operation mode, ascending — the manufacturer half of a mode list.

Taken from two sources that agree exactly: the firmware's own state_modes.h and the enum the ESI publishes on 0x6060. Neither knows the -101/-103/-108/-109/-110 "output" modes an earlier table here carried, so they are not listed.