@synapticon/motion-master-client 6.0.0-alpha.78 → 6.0.0-alpha.82

package/dist/generated/Api.d.ts

@@ -1,4 +1,4 @@
-import { AlStatusCode, BrakeState, Cia402Status, DcSyncStatus, DeviceDiagnostics, DeviceFile, DeviceParameter, EscRegister, EsiParseResult, FirmwareCompatibility, FirmwarePackageName, FoeErrorCode, GameLoopHealth, HardwareDescription, HrdRecording, IntegroVariant, IntegroVariantOption, MailboxErrorCode, Monitoring, ObjectDataTypeInfo, OperationModes, OutputStageResult, ParameterCacheEntry, PdoMapping, PdoMappingRequest, ProcedureListing, ProcedureRequest, ProcedureSnapshot, ProcessDataWatchdog, ProcessImageObject, SdoAbortCode, SlaveConfig, SlaveInformationInterface, UserCacheListing } from "./data-contracts.js";
+import { AlStatusCode, AutoTuningError, AutoTuningRunRequest, AutoTuningRunResponse, AutoTuningStatus, BrakeState, Cia402Status, DcSyncStatus, DeviceDiagnostics, DeviceFile, DeviceParameter, EscRegister, EsiParseResult, FirmwareCompatibility, FirmwarePackageName, FoeErrorCode, GameLoopHealth, HardwareDescription, HrdRecording, IntegroVariant, IntegroVariantOption, MailboxErrorCode, Monitoring, ObjectDataTypeInfo, OperationModes, OutputStageResult, ParameterCacheEntry, PdoMapping, PdoMappingRequest, ProcedureListing, ProcedureRequest, ProcedureSnapshot, ProcessDataWatchdog, ProcessImageObject, SdoAbortCode, SlaveConfig, SlaveInformationInterface, UserCacheListing } from "./data-contracts.js";
 import { HttpClient, RequestParams } from "./http-client.js";
 export declare class Api<SecurityDataType = unknown> extends HttpClient<SecurityDataType> {
     /**
@@ -336,7 +336,7 @@ export declare class Api<SecurityDataType = unknown> extends HttpClient<Security
         error: string;
     }>>;
     /**
-     * @description Scans the fieldbus for slaves and configures their sync managers and FMMUs. Must be called after a successful POST /api/init. Slaves remain in INIT state after this call; state transitions are driven by subsequent API calls. An empty bus is a successful scan returning 0 slaves, not an error: the master cannot distinguish a bus with no devices powered from a disconnected one, and the user recovers by powering devices on and scanning again. A 500 is returned only on a genuine driver failure (e.g. no driver initialised).
+     * @description Scans the fieldbus for slaves and configures their sync managers and FMMUs. Must be called after a successful POST /api/init. Slaves remain in INIT state after this call; state transitions are driven by subsequent API calls. An empty bus is a successful scan returning 0 slaves, not an error: the master cannot distinguish a bus with no devices powered from a disconnected one, and the user recovers by powering devices on and scanning again. A 500 is returned only on a genuine driver failure (e.g. no driver initialised). A scan does not wait for work already in flight. A procedure that is running keeps running against the devices it started on, and fails at its next bus transfer. Retained procedure snapshots are discarded, because a position may name different hardware after a scan. A scan frees the recording, the retained process images and the previous device set, so it first waits up to 200 ms for the real-time loop to leave the cycle it is in. If the loop is stalled — a cyclic task that overruns, or severe CPU contention — the scan fails with 500 and changes nothing, rather than freeing memory the loop is still reading. `GET /api/game-loop` shows the stall. The same applies to `POST /api/process-data`, which re-allocates the recorder. `POST /api/reset` never fails this way: it holds the memory back instead and reclaims it later.
      *
      * @name Scan
      * @summary Scan the bus for slaves
@@ -374,6 +374,34 @@ export declare class Api<SecurityDataType = unknown> extends HttpClient<Security
      * @request GET:/api/log
      */
     getLog: (params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<string, any>>;
+    /**
+     * @description Reports what Motion Master knows about the auto-tuning process. The tuning calculations run in a separate executable, which Motion Master starts at startup and reaches over loopback. That executable is downloaded by the install scripts rather than shipped in a release, so a machine may not have it — this endpoint is how a client tells the four cases apart: switched off in the configuration, not installed, installed but would not start, or running. The values are a startup snapshot. `started` says the process answered when Motion Master waited for it, not that it is alive now. Nothing polls it: a call is the honest test, and `POST /api/auto-tuning/run` makes one.
+     *
+     * @name GetAutoTuning
+     * @summary Auto-tuning process status
+     * @request GET:/api/auto-tuning
+     */
+    getAutoTuning: (params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<AutoTuningStatus, any>>;
+    /**
+     * @description Forwards the request to the auto-tuning process and returns its reply unchanged. The body is a JSON object with `run`, naming the function, and `data`, holding that function's inputs — the same shape the auto-tuning program takes on its own API. **A rejected input is reported with 200 and an `error` property**, not with a 4xx. The auto-tuning program keeps 4xx and 5xx for a malformed request, an unknown function name, and a routine that threw, so a client tests for `error` in the body rather than relying on the status alone. Motion Master passes both through untouched; only 400, 502 and 503 below are its own. Measurement data travels in the body. `identify_plant_model` takes the chirp measurements as `data.csv` text, and the bode data comes back inline as `bode`, so no file is written and nothing needs a shared filesystem view. The schemas here are a copy of the auto-tuning program's own, taken from version 3.1.1, and they exist so that the generated clients are typed. That program's current description is served verbatim at `GET /api/auto-tuning/swagger.yml`, which is the authority if the two ever disagree.
+     *
+     * @name RunAutoTuning
+     * @summary Run an auto-tuning function
+     * @request POST:/api/auto-tuning/run
+     */
+    runAutoTuning: (data: AutoTuningRunRequest, params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<AutoTuningRunResponse, AutoTuningError | {
+        error: string;
+    }>>;
+    /**
+     * @description Serves the OpenAPI document the auto-tuning process carries, fetched from it on each request. The schemas under `/api/auto-tuning/run` above are a copy of these, so this is where to look when a version of the program disagrees with them.
+     *
+     * @name GetAutoTuningSpec
+     * @summary The auto-tuning program's own API description
+     * @request GET:/api/auto-tuning/swagger.yml
+     */
+    getAutoTuningSpec: (params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<string, {
+        error: string;
+    }>>;
     /**
      * @description Returns the static catalogue of EtherCAT AL Status Codes defined in ETG.1000.6 §6.4.1. These codes appear in the alStatusCode field of the device state response when an error is present and identify the cause of the state transition failure.
      *
@@ -406,6 +434,66 @@ export declare class Api<SecurityDataType = unknown> extends HttpClient<Security
      * @request GET:/api/meta/sdo-abort-codes
      */
     getSdoAbortCodes: (params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<SdoAbortCode[], any>>;
+    /**
+     * @description The register maps of the two iC-Haus chips inside a Circulo's internal encoder — the reference tables for POST /api/devices/{slavePosition}/procedures/encoder-register-communication, and documentation in their own right. Static: they describe the chips, not any connected device, so no bus and no scan are needed. Two chips, and the iC-MU is the one in charge. The iC-MU is the position encoder proper, a magnetic off-axis absolute chip speaking BiSS-C to the drive. The iC-PVL is a battery-buffered Hall multiturn counter behind it, reached over I2C through the iC-MU rather than directly. The response is a list of register *spaces*, not of registers, because an address alone names nothing: the same iC-PVL address 0x00 is a configuration register in one space and the status register in another, depending on which I2C device id addressed it. Each space says which chip it belongs to and how it is reached. A row is one address, or the range the datasheet prints as one row — `address` and `lastAddress` are equal in the ordinary case. `fields` lists the named pieces of the register, most significant bit first, each with the datasheet's own one-line description; it is empty exactly when `reserved` is true. `layout` is those same fields rendered as the datasheet prints the row, e.g. `GC_M(1:0) | GF_M(5:0)`, derived rather than stored so it cannot disagree with them. `spiOnly` marks the iC-MU's 0x80-0xAF, which is reachable over SPI only and so beyond the drive's register communication service. A field's `bits` is its own bit slice as the register map prints it, not its position within the byte: `GC_M(1:0)` occupies bits 7:6 of address 0x00 and reads "1:0" because those are the field's two bits. A value wider than one register is spread across several, which is why `RESABZ` reads "7:0" at 0x13 and "15:8" at 0x14. Granularity follows each datasheet's own register map. The iC-PVL prints its status registers bit by bit, so those arrive as eight fields; the iC-MU prints its own as `STATUS0(7:0)`, so that is one field. Transcribed from the vendors' datasheets: iC-MU Series Rev B1 (Tables 90 and 91) and iC-PVL Rev F2 (Tables 5, 6 and 7), with descriptions from their CONFIGURATION PARAMETERS indexes and, for the iC-PVL status bytes, its status tables. The prose behind those one-liners is not reproduced.
+     *
+     * @name GetIcHausRegisters
+     * @summary The Circulo internal encoder's register maps
+     * @request GET:/api/meta/ic-haus-registers
+     */
+    getIcHausRegisters: (params?: RequestParams) => Promise<import("./http-client.js").HttpResponse<{
+        /** @example "iC-MU" */
+        chip: "iC-MU" | "iC-PVL";
+        /**
+         * The datasheet's own name for the space.
+         * @example "CONF, bank 0, addresses 0x00-0x3F"
+         */
+        name: string;
+        /** How the space is reached, which is what decides whether the register communication service can read it at all. */
+        addressing: string;
+        registers: {
+            /**
+             * The address, or the first of a printed range.
+             * @example 15
+             */
+            address: number;
+            /**
+             * The last address of the range; equal to address for a single-address row.
+             * @example 15
+             */
+            lastAddress: number;
+            /**
+             * The fields rendered as the datasheet prints the row. "RESERVED" for a reserved row.
+             * @example "SPO_MT(3:0) | MPC(3:0)"
+             */
+            layout: string;
+            /** The named pieces of this register, most significant bit first. Empty when reserved. */
+            fields: {
+                /**
+                 * The datasheet's own name for the field.
+                 * @example "SPO_MT"
+                 */
+                name: string;
+                /**
+                 * The field's own bit slice as the register map prints it, empty where it prints a bare name. Not the position within the byte.
+                 * @example "3:0"
+                 */
+                bits: string;
+                /**
+                 * The datasheet's one-line description of the field.
+                 * @example "Offset external multiturn"
+                 */
+                description: string;
+            }[];
+            /** @example false */
+            reserved: boolean;
+            /**
+             * Reachable over SPI only, so the register communication service cannot touch it.
+             * @example false
+             */
+            spiOnly: boolean;
+        }[];
+    }[], any>>;
     /**
      * @description The register map of the Integro's internal (Kübler) encoder — the reference table for POST /api/devices/{slavePosition}/procedures/kuebler-register-communication, and documentation in its own right. Static: it describes the encoder type, not any connected device, so it needs no bus and no scan. Transcribed from the vendor's own draft table. Each entry carries the width, the access type, whether the encoder actually implements it — seven are documented but not implemented — and the vendor's bit definitions verbatim, which for a bit-field register is the only place its meaning is recorded. `format` says how to read the assembled value, because signedness is not uniform and one register is not a single number at all: `unsigned`, `signed`, `bitField` (the number means nothing on its own), or `signedHalves` — two signed 16-bit values packed into 32 bits, which register 0x3C is the only case of. `readableInOneCommand` is false for the one 64-bit register, since the command's length byte caps at 4 bytes.
      *

package/dist/generated/Api.js

@@ -130,7 +130,7 @@ export class Api extends HttpClient {
         ...params,
     });
     /**
-     * @description Scans the fieldbus for slaves and configures their sync managers and FMMUs. Must be called after a successful POST /api/init. Slaves remain in INIT state after this call; state transitions are driven by subsequent API calls. An empty bus is a successful scan returning 0 slaves, not an error: the master cannot distinguish a bus with no devices powered from a disconnected one, and the user recovers by powering devices on and scanning again. A 500 is returned only on a genuine driver failure (e.g. no driver initialised).
+     * @description Scans the fieldbus for slaves and configures their sync managers and FMMUs. Must be called after a successful POST /api/init. Slaves remain in INIT state after this call; state transitions are driven by subsequent API calls. An empty bus is a successful scan returning 0 slaves, not an error: the master cannot distinguish a bus with no devices powered from a disconnected one, and the user recovers by powering devices on and scanning again. A 500 is returned only on a genuine driver failure (e.g. no driver initialised). A scan does not wait for work already in flight. A procedure that is running keeps running against the devices it started on, and fails at its next bus transfer. Retained procedure snapshots are discarded, because a position may name different hardware after a scan. A scan frees the recording, the retained process images and the previous device set, so it first waits up to 200 ms for the real-time loop to leave the cycle it is in. If the loop is stalled — a cyclic task that overruns, or severe CPU contention — the scan fails with 500 and changes nothing, rather than freeing memory the loop is still reading. `GET /api/game-loop` shows the stall. The same applies to `POST /api/process-data`, which re-allocates the recorder. `POST /api/reset` never fails this way: it holds the memory back instead and reclaims it later.
      *
      * @name Scan
      * @summary Scan the bus for slaves
@@ -167,6 +167,46 @@ export class Api extends HttpClient {
         method: "GET",
         ...params,
     });
+    /**
+     * @description Reports what Motion Master knows about the auto-tuning process. The tuning calculations run in a separate executable, which Motion Master starts at startup and reaches over loopback. That executable is downloaded by the install scripts rather than shipped in a release, so a machine may not have it — this endpoint is how a client tells the four cases apart: switched off in the configuration, not installed, installed but would not start, or running. The values are a startup snapshot. `started` says the process answered when Motion Master waited for it, not that it is alive now. Nothing polls it: a call is the honest test, and `POST /api/auto-tuning/run` makes one.
+     *
+     * @name GetAutoTuning
+     * @summary Auto-tuning process status
+     * @request GET:/api/auto-tuning
+     */
+    getAutoTuning = (params = {}) => this.request({
+        path: `/api/auto-tuning`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Forwards the request to the auto-tuning process and returns its reply unchanged. The body is a JSON object with `run`, naming the function, and `data`, holding that function's inputs — the same shape the auto-tuning program takes on its own API. **A rejected input is reported with 200 and an `error` property**, not with a 4xx. The auto-tuning program keeps 4xx and 5xx for a malformed request, an unknown function name, and a routine that threw, so a client tests for `error` in the body rather than relying on the status alone. Motion Master passes both through untouched; only 400, 502 and 503 below are its own. Measurement data travels in the body. `identify_plant_model` takes the chirp measurements as `data.csv` text, and the bode data comes back inline as `bode`, so no file is written and nothing needs a shared filesystem view. The schemas here are a copy of the auto-tuning program's own, taken from version 3.1.1, and they exist so that the generated clients are typed. That program's current description is served verbatim at `GET /api/auto-tuning/swagger.yml`, which is the authority if the two ever disagree.
+     *
+     * @name RunAutoTuning
+     * @summary Run an auto-tuning function
+     * @request POST:/api/auto-tuning/run
+     */
+    runAutoTuning = (data, params = {}) => this.request({
+        path: `/api/auto-tuning/run`,
+        method: "POST",
+        body: data,
+        type: ContentType.Json,
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Serves the OpenAPI document the auto-tuning process carries, fetched from it on each request. The schemas under `/api/auto-tuning/run` above are a copy of these, so this is where to look when a version of the program disagrees with them.
+     *
+     * @name GetAutoTuningSpec
+     * @summary The auto-tuning program's own API description
+     * @request GET:/api/auto-tuning/swagger.yml
+     */
+    getAutoTuningSpec = (params = {}) => this.request({
+        path: `/api/auto-tuning/swagger.yml`,
+        method: "GET",
+        ...params,
+    });
     /**
      * @description Returns the static catalogue of EtherCAT AL Status Codes defined in ETG.1000.6 §6.4.1. These codes appear in the alStatusCode field of the device state response when an error is present and identify the cause of the state transition failure.
      *
@@ -219,6 +259,19 @@ export class Api extends HttpClient {
         format: "json",
         ...params,
     });
+    /**
+     * @description The register maps of the two iC-Haus chips inside a Circulo's internal encoder — the reference tables for POST /api/devices/{slavePosition}/procedures/encoder-register-communication, and documentation in their own right. Static: they describe the chips, not any connected device, so no bus and no scan are needed. Two chips, and the iC-MU is the one in charge. The iC-MU is the position encoder proper, a magnetic off-axis absolute chip speaking BiSS-C to the drive. The iC-PVL is a battery-buffered Hall multiturn counter behind it, reached over I2C through the iC-MU rather than directly. The response is a list of register *spaces*, not of registers, because an address alone names nothing: the same iC-PVL address 0x00 is a configuration register in one space and the status register in another, depending on which I2C device id addressed it. Each space says which chip it belongs to and how it is reached. A row is one address, or the range the datasheet prints as one row — `address` and `lastAddress` are equal in the ordinary case. `fields` lists the named pieces of the register, most significant bit first, each with the datasheet's own one-line description; it is empty exactly when `reserved` is true. `layout` is those same fields rendered as the datasheet prints the row, e.g. `GC_M(1:0) | GF_M(5:0)`, derived rather than stored so it cannot disagree with them. `spiOnly` marks the iC-MU's 0x80-0xAF, which is reachable over SPI only and so beyond the drive's register communication service. A field's `bits` is its own bit slice as the register map prints it, not its position within the byte: `GC_M(1:0)` occupies bits 7:6 of address 0x00 and reads "1:0" because those are the field's two bits. A value wider than one register is spread across several, which is why `RESABZ` reads "7:0" at 0x13 and "15:8" at 0x14. Granularity follows each datasheet's own register map. The iC-PVL prints its status registers bit by bit, so those arrive as eight fields; the iC-MU prints its own as `STATUS0(7:0)`, so that is one field. Transcribed from the vendors' datasheets: iC-MU Series Rev B1 (Tables 90 and 91) and iC-PVL Rev F2 (Tables 5, 6 and 7), with descriptions from their CONFIGURATION PARAMETERS indexes and, for the iC-PVL status bytes, its status tables. The prose behind those one-liners is not reproduced.
+     *
+     * @name GetIcHausRegisters
+     * @summary The Circulo internal encoder's register maps
+     * @request GET:/api/meta/ic-haus-registers
+     */
+    getIcHausRegisters = (params = {}) => this.request({
+        path: `/api/meta/ic-haus-registers`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
     /**
      * @description The register map of the Integro's internal (Kübler) encoder — the reference table for POST /api/devices/{slavePosition}/procedures/kuebler-register-communication, and documentation in its own right. Static: it describes the encoder type, not any connected device, so it needs no bus and no scan. Transcribed from the vendor's own draft table. Each entry carries the width, the access type, whether the encoder actually implements it — seven are documented but not implemented — and the vendor's bit definitions verbatim, which for a bit-field register is the only place its meaning is recorded. `format` says how to read the assembled value, because signedness is not uniform and one register is not a single number at all: `unsigned`, `signed`, `bitField` (the number means nothing on its own), or `signedHalves` — two signed 16-bit values packed into 32 bits, which register 0x3C is the only case of. `readableInOneCommand` is false for the one 64-bit register, since the command's length byte caps at 4 bytes.
      *

package/dist/generated/data-contracts.d.ts

@@ -898,7 +898,7 @@ export interface ProcedureRequest {
      */
     pollIntervalMs?: number;
     /**
-     * `encoder-register-communication` and `ic-mu-calibration-mode`: which of the drive's encoders to address. Encoder 1 is whatever 0x2110 configures and encoder 2 whatever 0x2112 does, so the ordinal picks a configured slot rather than a kind of encoder.
+     * `encoder-register-communication` and `ic-mu-calibration-mode`: which of the drive's encoders to address. Encoder 1 is the encoder configured in 0x2110 and encoder 2 the one configured in 0x2112, so the ordinal picks a configuration object rather than a kind of encoder.
      * @default 1
      * @example 1
      */
@@ -1724,4 +1724,275 @@ export interface EsiParseResult {
     /** Recoverable problems in the document itself — a skipped malformed object, an unparsable value. A file with warnings still parses. Per-device assembly problems are reported on the device instead. */
     warnings?: string[];
 }
+/** What Motion Master knows about the auto-tuning process, as a startup snapshot. */
+export interface AutoTuningStatus {
+    /**
+     * The `autoTuning.enabled` setting from the configuration file.
+     * @example true
+     */
+    enabled: boolean;
+    /**
+     * The executable Motion Master looked for, as an absolute path.
+     * @example "/opt/motion-master/auto-tuning"
+     */
+    binaryPath: string;
+    /**
+     * Whether a file exists at that path.
+     * @example true
+     */
+    installed: boolean;
+    /**
+     * Whether the process started and answered its health endpoint. Not a liveness check: nothing polls the process after startup.
+     * @example true
+     */
+    started: boolean;
+    /**
+     * The version the process reported, empty unless it started. A build older than that program's version reporting starts and reports nothing, which is why an empty string here does not mean it failed.
+     * @example "3.1.1"
+     */
+    version: string;
+    /**
+     * The loopback port the process was told to serve on.
+     * @example 63528
+     */
+    port: number;
+    /**
+     * Why it is not running. Empty when it is.
+     * @example ""
+     */
+    error: string;
+}
+/** The auto-tuning program's error shape. Returned with 200 when a function rejected its inputs, and with 404 or 500 for an unknown function or an unhandled exception. */
+export interface AutoTuningError {
+    error: {
+        /** @example "A linear model can't be fit in the recorded data." */
+        message: string;
+    };
+}
+/**
+ * Transfer function coefficients, highest order first.
+ * @example {"numerator":[1],"denominator":[0.00015,0.000206]}
+ */
+export interface PlantModel {
+    numerator: number[];
+    denominator: number[];
+}
+/** One controller's gains. */
+export interface Pid {
+    kp?: number;
+    ki?: number;
+    kd?: number;
+}
+/** Controller gains. A function that tunes only the velocity loop leaves the position gains at zero. */
+export interface Gains {
+    /** One controller's gains. */
+    position?: Pid;
+    /** One controller's gains. */
+    velocity?: Pid;
+}
+/**
+ * Bode diagram data, keyed by column name, every array the same length. This comes back in the response body instead of a written CSV, which is why no auto-tuning call needs a shared filesystem. A non-finite value is null.
+ * @example {"Frequency_Hz":[0.5,1],"Plant_Mag_dB":[65.77570877159437,59.79191013147556],"Plant_Phase_deg":[-66.38766900151838,-76.55997369096534]}
+ */
+export type Bode = Record<string, (number | null)[]>;
+/** Drive configuration, as read from the drive. */
+export interface DriveConfig {
+    vel_lp_type?: number;
+    vel_lp_fc?: number;
+    pos_lp_type?: number;
+    pos_lp_fc?: number;
+    notch_en?: number;
+    notch_fw?: number;
+    notch_fc?: number;
+    notch_dp?: number;
+    vel_ff_gain?: number;
+    vel_ff_fc?: number;
+    /** Winding inductance. */
+    L?: number;
+    /** Winding resistance. */
+    R?: number;
+    /** DC link voltage. */
+    vdc?: number;
+    current_ratio?: number;
+    tc_kp?: number;
+    tc_ki?: number;
+    switch_F?: number;
+    tc_st?: number;
+    tc_damping?: number;
+    software_version?: string;
+    rated_torque?: number;
+    max_vel_noise?: number;
+}
+/** The `data` schema depends on the value of `run`. Each variant pairs one `run` value with the inputs that function reads. `run: exit` is deliberately absent: it shuts the process down, and this endpoint refuses it with 400. */
+export type AutoTuningRunRequest = AutoTuneVelocityController | AutoTunePositionController | FullAutoTuneVelocityController | FullAutoTunePositionController | AutoTuneNotch | AutoTuneFeedbackFilters | ComputePositionControllerGains | IdentifyPlantModel | GeneratePlantBode;
+export interface AutoTuneVelocityController {
+    run: "auto_tune_velocity_controller";
+    data: {
+        /** Transfer function coefficients, highest order first. */
+        plant_model: PlantModel;
+        /** Damping ratio. */
+        zeta: number;
+        /** Demanded bandwidth in Hz. */
+        demanded_bw: number;
+    };
+}
+export interface AutoTunePositionController {
+    run: "auto_tune_position_controller";
+    data: {
+        /** Transfer function coefficients, highest order first. */
+        plant_model: PlantModel;
+        /** @example "PI-P" */
+        controller_type: string;
+        zeta: number;
+        /** Demanded settling time in seconds. */
+        demanded_st: number;
+        /** Optional. Absent means the standard tuning rule. */
+        highFrictionGain?: number;
+    };
+}
+export interface FullAutoTuneVelocityController {
+    run: "full_auto_tune_velocity_controller";
+    data: {
+        /** Transfer function coefficients, highest order first. */
+        plant_model: PlantModel;
+        /** Drive configuration, as read from the drive. */
+        drive_config: DriveConfig;
+    };
+}
+export interface FullAutoTunePositionController {
+    run: "full_auto_tune_position_controller";
+    data: {
+        /** Transfer function coefficients, highest order first. */
+        plant_model: PlantModel;
+        /** @example "PI-P" */
+        controller_type: string;
+        /** Drive configuration, as read from the drive. */
+        drive_config: DriveConfig;
+        highFriction: 0 | 1;
+    };
+}
+export interface AutoTuneNotch {
+    run: "auto_tune_notch";
+    data: {
+        /** Transfer function coefficients, highest order first. */
+        plant_model: PlantModel;
+    };
+}
+export interface AutoTuneFeedbackFilters {
+    run: "auto_tune_feedback_filters";
+    data: {
+        sigma_v: number;
+        sigma_p: number;
+        resVel: number;
+        resPos: number;
+        gearRatio: number;
+    };
+}
+export interface ComputePositionControllerGains {
+    run: "compute_position_controller_gains";
+    data: {
+        pk: number;
+        pt: number;
+        omega: number;
+        alpha: number;
+        zeta: number;
+        /** @example "PI-P" */
+        controller_type: string;
+    };
+}
+/** Identifies a plant model from chirp measurements. The measurements are uploaded in `data.csv`; `data.filepath` names a file on the auto-tuning process's own machine instead, and is a fallback that Motion Master has no use for. */
+export interface IdentifyPlantModel {
+    run: "identify_plant_model" | "identify_plant_model_inline";
+    data: {
+        /** Contents of the measurement CSV. Three columns, no header: time, torque in Nm, velocity in rad/s, sampled at 1000 Hz. */
+        csv?: string;
+        /** Path to that CSV instead of its contents. */
+        filepath?: string;
+        /** Chirp start frequency in Hz. */
+        f0: number;
+        /** Chirp end frequency in Hz. */
+        f1: number;
+    };
+}
+/** Computes the bode data of a plant model and returns it inline. */
+export interface GeneratePlantBode {
+    run: "generate_plant_bode_file" | "generate_plant_bode";
+    data: {
+        /** Transfer function coefficients, highest order first. */
+        plant_model: PlantModel;
+    };
+}
+/** Which variant comes back depends on the request's `run`. Every result carries `duration`, the function's execution time in seconds. A function that rejected its inputs answers with `AutoTuningError` and status 200. */
+export type AutoTuningRunResponse = GainsResult | FullVelocityResult | FullPositionResult | NotchResult | FeedbackFiltersResult | IdentifyPlantModelResult | BodeResult | AutoTuningError;
+export interface GainsResult {
+    /** Controller gains. A function that tunes only the velocity loop leaves the position gains at zero. */
+    gains?: Gains;
+    duration?: number;
+}
+export interface FullVelocityResult {
+    /** Controller gains. A function that tunes only the velocity loop leaves the position gains at zero. */
+    gains?: Gains;
+    demanded_bw?: number;
+    demanded_zeta?: number;
+    /** Stability margins and closed-loop metrics. */
+    state?: {
+        gm?: number;
+        pm?: number;
+        msens?: number;
+        act_bw?: number;
+        vel_cl?: number;
+        noise_resp?: number;
+        max_KS?: number;
+    };
+    duration?: number;
+}
+export interface FullPositionResult {
+    /** Controller gains. A function that tunes only the velocity loop leaves the position gains at zero. */
+    gains?: Gains;
+    demanded_st?: number;
+    demanded_zeta?: number;
+    highFrictionGain?: number;
+    /** Stability margins and closed-loop metrics, position and velocity loop. */
+    state?: {
+        gm_p?: number;
+        pm_p?: number;
+        msens_p?: number;
+        gm_v?: number;
+        pm_v?: number;
+        msens_v?: number;
+        noise_resp?: number;
+        max_KS?: number;
+        bw_p?: number;
+        bw_v?: number;
+        act_st?: number;
+        pos_cl?: number;
+    };
+    duration?: number;
+}
+export interface NotchResult {
+    notch_en?: boolean;
+    notch_fc?: number | null;
+    notch_fw?: number | null;
+    notch_dp?: number | null;
+    duration?: number;
+}
+export interface FeedbackFiltersResult {
+    /** Velocity feedback filter cut-off in Hz. */
+    fcv?: number;
+    /** Position feedback filter cut-off in Hz. */
+    fcp?: number;
+    duration?: number;
+}
+export interface IdentifyPlantModelResult {
+    numerators?: number[];
+    denominators?: number[];
+    /** Bode diagram data, keyed by column name, every array the same length. This comes back in the response body instead of a written CSV, which is why no auto-tuning call needs a shared filesystem. A non-finite value is null. */
+    bode?: Bode;
+    duration?: number;
+}
+export interface BodeResult {
+    /** Bode diagram data, keyed by column name, every array the same length. This comes back in the response body instead of a written CSV, which is why no auto-tuning call needs a shared filesystem. A non-finite value is null. */
+    bode?: Bode;
+    duration?: number;
+}
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synapticon/motion-master-client",
-  "version": "6.0.0-alpha.78",
+  "version": "6.0.0-alpha.82",
   "description": "Isomorphic TypeScript client for Motion Master: the generated HTTP API client, the WebSocket connection, and helpers.",
   "license": "MIT",
   "repository": {