@duet3d/objectmodel 3.7.0-beta.9 → 3.7.0-rc.2

package/dist/ModelCollection.d.ts

@@ -1,15 +1,25 @@
 import type { IModelObject } from "./ModelObject";
+/**
+ * Factory creating the item for a given index
+ */
+export type ItemFactory<T> = (index: number) => T;
 /**
  * Class for storing model object items in an array
  */
 export declare class ModelCollection<T extends IModelObject | null> extends Array<T> implements IModelObject {
+    /**
+     * Derived arrays from filter, map, slice etc. would otherwise be constructed as
+     * new ModelCollection(length), leaving $itemConstructor set to a number
+     */
+    static get [Symbol.species](): ArrayConstructor;
     /**
      * Constructor of this class
      * @param itemConstructor Item constructor type that items must derive from
+     * @param itemFactory Factory to use for collections whose item class depends on the position, e.g. boards
      */
     constructor(itemConstructor: {
         new (): T;
-    });
+    }, itemFactory?: ItemFactory<T> | null);
     /**
      * Overridden push method to perform better type checks
      * @param items Items to add

package/dist/ModelCollection.js

@@ -1,16 +1,36 @@
 import { isModelObject } from "./ModelObject";
+/**
+ * Create the item for a given index. This is deliberately not a method of the collection because
+ * a non-public member would make the class nominally typed, which breaks assignability of the
+ * reactive proxies consumers wrap the object model in
+ * @param collection Collection the item is created for
+ * @param index Index the new item is going to be stored at
+ * @returns New item
+ */
+function createItem(collection, index) {
+    return (collection.$itemFactory !== null) ? collection.$itemFactory(index) : new collection.$itemConstructor();
+}
 /**
  * Class for storing model object items in an array
  */
 export class ModelCollection extends Array {
+    /**
+     * Derived arrays from filter, map, slice etc. would otherwise be constructed as
+     * new ModelCollection(length), leaving $itemConstructor set to a number
+     */
+    static get [Symbol.species]() {
+        return Array;
+    }
     /**
      * Constructor of this class
      * @param itemConstructor Item constructor type that items must derive from
+     * @param itemFactory Factory to use for collections whose item class depends on the position, e.g. boards
      */
-    constructor(itemConstructor) {
+    constructor(itemConstructor, itemFactory = null) {
         super();
         Object.setPrototypeOf(this, ModelCollection.prototype);
         Object.defineProperty(this, "$itemConstructor", { enumerable: false, value: itemConstructor });
+        Object.defineProperty(this, "$itemFactory", { enumerable: false, value: itemFactory });
     }
     // Unfortunately it isn't possible to override index operators in JS/TS
     /**
@@ -24,7 +44,7 @@ export class ModelCollection extends Array {
                 super.push(item);
             }
             else {
-                const newItem = new that.$itemConstructor();
+                const newItem = createItem(that, this.length);
                 super.push(newItem.update(item));
             }
         }
@@ -55,7 +75,7 @@ export class ModelCollection extends Array {
                     this[i] = jsonElement[i];
                 }
                 else {
-                    const refItem = new that.$itemConstructor();
+                    const refItem = createItem(that, i);
                     this[i] = refItem.update(newItem, authoritative);
                 }
             }
@@ -79,7 +99,7 @@ export class ModelCollection extends Array {
                 super.push(itemToAdd);
             }
             else {
-                const newItem = new that.$itemConstructor();
+                const newItem = createItem(that, i);
                 super.push(newItem.update(itemToAdd, authoritative));
             }
         }

package/dist/ObjectModel.js

@@ -1,7 +1,7 @@
 import ModelCollection from "./ModelCollection";
 import ModelDictionary from "./ModelDictionary";
 import ModelObject from "./ModelObject";
-import Board from "./boards";
+import Board, { getBoard } from "./boards";
 import Directories from "./directories";
 import Fan from "./fans";
 import Heat from "./heat";
@@ -25,7 +25,7 @@ import LedStrip from "./ledStrips";
 export class ObjectModel extends ModelObject {
     constructor() {
         super();
-        this.boards = new ModelCollection(Board);
+        this.boards = new ModelCollection(Board, getBoard);
         this.directories = new Directories();
         this.fans = new ModelCollection(Fan);
         this.global = new ModelDictionary(false);

package/dist/boards/Driver.d.ts

@@ -17,7 +17,8 @@ export declare enum DriverMode {
     spreadCycle = 2,
     stealthChop = 3,
     direct = 4,
-    unknown = 5
+    assistedOpen = 5,
+    unknown = 6
 }
 export declare class DriverConfig extends ModelObject {
     direction: boolean;

package/dist/boards/Driver.js

@@ -27,7 +27,8 @@ export var DriverMode;
     DriverMode[DriverMode["spreadCycle"] = 2] = "spreadCycle";
     DriverMode[DriverMode["stealthChop"] = 3] = "stealthChop";
     DriverMode[DriverMode["direct"] = 4] = "direct";
-    DriverMode[DriverMode["unknown"] = 5] = "unknown";
+    DriverMode[DriverMode["assistedOpen"] = 5] = "assistedOpen";
+    DriverMode[DriverMode["unknown"] = 6] = "unknown";
 })(DriverMode || (DriverMode = {}));
 export class DriverConfig extends ModelObject {
     constructor() {

package/dist/boards/directDisplay/DirectDisplayScreen.d.ts

@@ -1,6 +1,6 @@
 import type { IModelObject } from "../../ModelObject";
 import DirectDisplayScreenBase from "./DirectDisplayScreenBase";
 export declare class DirectDisplayScreen extends DirectDisplayScreenBase {
-    update(jsonElement: any): IModelObject | null;
+    update(jsonElement: any, authoritative?: boolean): IModelObject | null;
 }
 export default DirectDisplayScreen;

package/dist/boards/directDisplay/DirectDisplayScreen.js

@@ -1,14 +1,14 @@
 import { getDirectDisplayScreen } from ".";
 import DirectDisplayScreenBase from "./DirectDisplayScreenBase";
 export class DirectDisplayScreen extends DirectDisplayScreenBase {
-    update(jsonElement) {
+    update(jsonElement, authoritative = false) {
         if (jsonElement === null) {
             return null;
         }
         if (typeof jsonElement.controller === "string" && jsonElement.controller !== this.controller) {
-            return getDirectDisplayScreen(jsonElement.controller).update(jsonElement);
+            return getDirectDisplayScreen(jsonElement.controller).update(jsonElement, authoritative);
         }
-        return super.update(jsonElement);
+        return super.update(jsonElement, authoritative);
     }
 }
 export default DirectDisplayScreen;

package/dist/boards/directDisplay/DirectDisplayScreenST7567.d.ts

@@ -4,6 +4,6 @@ export declare class DirectDisplayScreenST7567 extends DirectDisplayScreenBase {
     constructor();
     contrast: number;
     resistorRatio: number;
-    update(jsonElement: any): IModelObject | null;
+    update(jsonElement: any, authoritative?: boolean): IModelObject | null;
 }
 export default DirectDisplayScreenST7567;

package/dist/boards/directDisplay/DirectDisplayScreenST7567.js

@@ -6,14 +6,14 @@ export class DirectDisplayScreenST7567 extends DirectDisplayScreenBase {
         this.contrast = 30;
         this.resistorRatio = 6;
     }
-    update(jsonElement) {
+    update(jsonElement, authoritative = false) {
         if (jsonElement === null) {
             return null;
         }
         if (typeof jsonElement.controller === "string" && jsonElement.controller !== this.controller) {
-            return getDirectDisplayScreen(jsonElement.controller).update(jsonElement);
+            return getDirectDisplayScreen(jsonElement.controller).update(jsonElement, authoritative);
         }
-        return super.update(jsonElement);
+        return super.update(jsonElement, authoritative);
     }
 }
 export default DirectDisplayScreenST7567;

package/dist/boards/index.d.ts

@@ -5,7 +5,9 @@ import Driver from "./Driver";
 export declare class Accelerometer extends ModelObject {
     orientation: number;
     points: number;
+    resolution: number;
     runs: number;
+    samplingRate: number;
 }
 export declare class BoardClosedLoop extends ModelObject {
     points: number;
@@ -30,30 +32,43 @@ export declare class Board extends ModelObject {
     constructor();
     accelerometer: Accelerometer | null;
     canAddress: number | null;
-    closedLoop: BoardClosedLoop | null;
-    directDisplay: DirectDisplay | null;
     drivers: ModelCollection<Driver> | null;
     firmwareDate: string;
     firmwareFileName: string;
-    firmwareName: string;
     firmwareVersion: string;
     freeRam: number | null;
-    iapFileNameSBC: string | null;
-    iapFileNameSD: string | null;
-    inductiveSensor: InductiveSensor | null;
-    maxHeaters: number;
     maxMotors: number;
     mcuTemp: MinMaxCurrent | null;
     name: string;
     shortName: string;
-    state: BoardState;
-    supportsDirectDisplay: boolean;
-    timeout: number;
     uniqueId: string | null;
     v12: MinMaxCurrent | null;
     vIn: MinMaxCurrent | null;
+}
+export declare class MainBoard extends Board {
+    constructor();
+    directDisplay: DirectDisplay | null;
+    firmwareName: string;
+    iapFileNameSBC: string | null;
+    iapFileNameSD: string | null;
+    maxHeaters: number;
+    supportsDirectDisplay: boolean;
     wifiFirmwareFileName: string | null;
 }
+export declare class ExpansionBoard extends Board {
+    constructor();
+    closedLoop: BoardClosedLoop | null;
+    inductiveSensor: InductiveSensor | null;
+    state: BoardState;
+    timeout: number;
+}
 export default Board;
+/**
+ * Create the board instance for a given index. The first item is always the mainboard,
+ * every other item is an expansion board connected over CAN
+ * @param index Index in the boards array
+ * @returns New board instance
+ */
+export declare function getBoard(index: number): Board;
 export * from "./directDisplay";
 export * from "./Driver";

package/dist/boards/index.js

@@ -7,7 +7,9 @@ export class Accelerometer extends ModelObject {
         super(...arguments);
         this.orientation = 20;
         this.points = 0;
+        this.resolution = 0;
         this.runs = 0;
+        this.samplingRate = 0;
     }
 }
 export class BoardClosedLoop extends ModelObject {
@@ -41,39 +43,58 @@ export class Board extends ModelObject {
         super();
         this.accelerometer = null;
         this.canAddress = null;
-        this.closedLoop = null;
-        this.directDisplay = null;
         this.drivers = null;
         this.firmwareDate = "";
         this.firmwareFileName = "";
-        this.firmwareName = "";
         this.firmwareVersion = "";
         this.freeRam = null;
-        this.iapFileNameSBC = null;
-        this.iapFileNameSD = null;
-        this.inductiveSensor = null;
-        this.maxHeaters = 0;
         this.maxMotors = 0;
         this.mcuTemp = null;
         this.name = "";
         this.shortName = "";
-        this.state = BoardState.unknown;
-        this.supportsDirectDisplay = false;
-        this.timeout = 10;
         this.uniqueId = null;
         this.v12 = null;
         this.vIn = null;
-        this.wifiFirmwareFileName = null;
         ModelObject.wrapModelProperty(this, "accelerometer", Accelerometer);
-        ModelObject.wrapModelProperty(this, "closedLoop", BoardClosedLoop);
-        ModelObject.wrapModelProperty(this, "directDisplay", DirectDisplay);
         ModelObject.wrapModelCollectionProperty(this, "drivers", Driver);
-        ModelObject.wrapModelProperty(this, "inductiveSensor", InductiveSensor);
         ModelObject.wrapModelProperty(this, "mcuTemp", MinMaxCurrent);
         ModelObject.wrapModelProperty(this, "v12", MinMaxCurrent);
         ModelObject.wrapModelProperty(this, "vIn", MinMaxCurrent);
     }
 }
+export class MainBoard extends Board {
+    constructor() {
+        super();
+        this.directDisplay = null;
+        this.firmwareName = "";
+        this.iapFileNameSBC = null;
+        this.iapFileNameSD = null;
+        this.maxHeaters = 0;
+        this.supportsDirectDisplay = false;
+        this.wifiFirmwareFileName = null;
+        ModelObject.wrapModelProperty(this, "directDisplay", DirectDisplay);
+    }
+}
+export class ExpansionBoard extends Board {
+    constructor() {
+        super();
+        this.closedLoop = null;
+        this.inductiveSensor = null;
+        this.state = BoardState.unknown;
+        this.timeout = 10;
+        ModelObject.wrapModelProperty(this, "closedLoop", BoardClosedLoop);
+        ModelObject.wrapModelProperty(this, "inductiveSensor", InductiveSensor);
+    }
+}
 export default Board;
+/**
+ * Create the board instance for a given index. The first item is always the mainboard,
+ * every other item is an expansion board connected over CAN
+ * @param index Index in the boards array
+ * @returns New board instance
+ */
+export function getBoard(index) {
+    return (index === 0) ? new MainBoard() : new ExpansionBoard();
+}
 export * from "./directDisplay";
 export * from "./Driver";

package/dist/documentation.json

@@ -9,7 +9,12 @@
 		"remarks": "See https://docs.duet3d.com/en/Duet3D_hardware/Accessories/Duet3D_Accelerometer#orientation for a list of orientations"
 	},
 	"boards[].accelerometer.points": "Number of collected data points in the last run or 0 if it failed",
+	"boards[].accelerometer.resolution": "Resolution the accelerometer is programmed for (in bits) or 0 if unknown",
 	"boards[].accelerometer.runs": "Number of completed sampling runs",
+	"boards[].accelerometer.samplingRate": {
+		"summary": "Rate the accelerometer is programmed for (in Hz) or 0 if unknown",
+		"remarks": "This is the rate the accelerometer settled on, which may be lower than the one M955 asked for. Once it has completed a run, the rate measured during that run is reported instead"
+	},
 	"boards[].canAddress": "CAN address of this board or null if not applicable",
 	"boards[].closedLoop": "Closed loop data of this board or null if unknown",
 	"boards[].closedLoop.points": "Number of collected data points in the last run or 0 if it failed",
@@ -18,6 +23,7 @@
 	"boards[].directDisplay.encoder": "Encoder of this screen or null if none",
 	"boards[].directDisplay.encoder.pulsesPerClick": "Number of pulses per click of the rotary encoder",
 	"boards[].directDisplay.screen": "Screen information",
+	"boards[].directDisplay.screen.contrast": "Configured contrast",
 	"boards[].directDisplay.screen.controller": {
 		"values": {
 			"ST7920": "ST7920 controller",
@@ -25,6 +31,7 @@
 			"ILI9488": "ILI9488 controller"
 		}
 	},
+	"boards[].directDisplay.screen.resistorRatio": "Configured resistor ratio",
 	"boards[].drivers": "Drivers of this board",
 	"boards[].drivers[].closedLoop.currentFraction": "Current fraction of the configured motor current used",
 	"boards[].drivers[].closedLoop.positionError": "Position error in full steps of the motor",
@@ -37,7 +44,8 @@
 			"2": "SpreadCycle",
 			"3": "StealthChop (includes stealthChop2)",
 			"4": "Field-oriented control (direct)",
-			"5": "Driver mode is unknown"
+			"5": "Assisted open loop",
+			"6": "Driver mode is unknown"
 		}
 	},
 	"boards[].firmwareDate": "Date of the firmware build",
@@ -45,14 +53,8 @@
 	"boards[].firmwareName": "Name of the firmware build",
 	"boards[].firmwareVersion": "Version of the firmware build",
 	"boards[].freeRam": "Amount of free RAM on this board (in bytes or null if unknown)",
-	"boards[].iapFileNameSBC": {
-		"summary": "Filename of the IAP binary that is used for updates from the SBC or null if unsupported",
-		"remarks": "This is only available for the mainboard (first board item)"
-	},
-	"boards[].iapFileNameSD": {
-		"summary": "Filename of the IAP binary that is used for updates from the SD card or null if unsupported",
-		"remarks": "This is only available for the mainboard (first board item)"
-	},
+	"boards[].iapFileNameSBC": "Filename of the IAP binary that is used for updates from the SBC or null if unsupported",
+	"boards[].iapFileNameSD": "Filename of the IAP binary that is used for updates from the SD card or null if unsupported",
 	"boards[].inductiveSensor": "Information about an inductive sensor or null if not present",
 	"boards[].maxHeaters": "Maximum number of heaters this board can control",
 	"boards[].maxMotors": "Maximum number of motors this board can drive",
@@ -538,6 +540,14 @@
 	"move.keepout[].coords[].max": "Maximum axis coordinate",
 	"move.keepout[].coords[].min": "Minimum axis coordinate",
 	"move.kinematics": "Configured kinematics options",
+	"move.kinematics.anchors": "Anchor configurations for A, B, C, Dz",
+	"move.kinematics.crosstalk": "Proximal to distal, proximal to Z and distal to Z crosstalk",
+	"move.kinematics.deltaRadius": "Delta radius (in mm)",
+	"move.kinematics.distalLength": "Distal arm length (in mm)",
+	"move.kinematics.forwardMatrix": "Forward matrix",
+	"move.kinematics.homedHeight": "Homed height of a delta printer in mm",
+	"move.kinematics.inverseMatrix": "Inverse matrix",
+	"move.kinematics.minRadius": "Requested minimum radius (in mm)",
 	"move.kinematics.name": {
 		"summary": "Name of the configured kinematics",
 		"values": {
@@ -547,19 +557,46 @@
 			"coreXYUV": "CoreXY with extra UV axes",
 			"coreXZ": "CoreXZ",
 			"markForged": "MarkForged",
-			"fiveBarScara": "Five-bar SCARA",
-			"hangprinter": "Hangprinter",
-			"linearDelta": "Linear delta",
-			"polar": "Polar",
-			"rotaryDelta": "Rotary delta",
-			"scara": "SCARA",
+			"FiveBarScara": "Five-bar SCARA",
+			"Hangprinter": "Hangprinter",
+			"delta": "Linear delta",
+			"Polar": "Polar",
+			"Rotary delta": "Rotary delta",
+			"Scara": "SCARA",
 			"unknown": "Unknown"
 		}
 	},
+	"move.kinematics.printRadius": "Print radius for Hangprinter and Delta geometries (in mm)",
+	"move.kinematics.proximalLength": "Proximal arm length (in mm)",
+	"move.kinematics.psiLimits": "Psi limits (in degrees)",
+	"move.kinematics.radiusHomed": "Homed radius (in mm)",
+	"move.kinematics.radiusMax": "Maximum radius (in mm)",
+	"move.kinematics.radiusMin": "Minimum radius (in mm)",
 	"move.kinematics.segmentation": "Segmentation parameters or null if not configured",
 	"move.kinematics.segmentation.minSegLength": "Minimum length of a segment (in mm)",
 	"move.kinematics.segmentation.segmentsPerSec": "Number of segments per second",
+	"move.kinematics.thetaLimits": "Theta limits (in degrees)",
+	"move.kinematics.tiltCorrection": "Parameters describing the tilt correction",
+	"move.kinematics.tiltCorrection.correctionFactor": "Correction factor",
+	"move.kinematics.tiltCorrection.lastCorrections": "Last corrections (in mm)",
+	"move.kinematics.tiltCorrection.maxCorrection": "Maximum Z correction (in mm)",
+	"move.kinematics.tiltCorrection.screwPitch": "Pitch of the Z leadscrews (in mm)",
+	"move.kinematics.tiltCorrection.screwX": "X positions of the leadscrews (in mm)",
+	"move.kinematics.tiltCorrection.screwY": "Y positions of the leadscrews (in mm)",
+	"move.kinematics.towers": "Delta tower properties",
+	"move.kinematics.towers[].angleCorrection": "Tower position corrections (in degrees)",
+	"move.kinematics.towers[].diagonal": "Diagonal rod length (in mm)",
+	"move.kinematics.towers[].endstopAdjustment": "Deviation of the ideal endstop position (in mm)",
+	"move.kinematics.towers[].xPos": "X coordinate of this tower (in mm)",
+	"move.kinematics.towers[].yPos": "Y coordinate of this tower (in mm)",
+	"move.kinematics.ttAccMax": "Maximum turntable acceleration (in mm/s^2)",
+	"move.kinematics.ttSpeedMax": "Maximum turntable speed (in mm/s)",
+	"move.kinematics.xOffset": "X offset (in mm)",
+	"move.kinematics.xTilt": "How much Z needs to be raised for each unit of movement in the +X direction",
+	"move.kinematics.yOffset": "Y offset (in mm)",
+	"move.kinematics.yTilt": "How much Z needs to be raised for each unit of movement in the +Y direction",
 	"move.limitAxes": "Limit axis positions by their minima and maxima",
+	"move.minSpeed": "Minimum allowed movement speed (in mm/min)",
 	"move.motionSystems": "List of configured motion systems",
 	"move.motionSystems[].currentMove": "Information about the current move",
 	"move.motionSystems[].currentMove.acceleration": "Acceleration of the current move (in mm/s^2)",
@@ -876,10 +913,28 @@
 			"zProbeAsEndstop": "Z-probe acts as an endstop",
 			"motorStallAny": "Motor stall detection stops all the drives when triggered",
 			"motorStallIndividual": "Motor stall detection stops individual drives when triggered",
+			"motorStallEncoder": "Encoder position error stops all the drives when triggered",
 			"unknown": "Unknown type"
 		}
 	},
 	"sensors.filamentMonitors": "List of configured filament monitors",
+	"sensors.filamentMonitors[].agc": "AGC reading of this filament monitor (null if unknown)",
+	"sensors.filamentMonitors[].avgPercentage": "Average ratio of measured vs. commanded movement",
+	"sensors.filamentMonitors[].calibrated": "Calibrated properties of this filament monitor",
+	"sensors.filamentMonitors[].calibrated.mmPerPulse": "Extruded distance per pulse (in mm)",
+	"sensors.filamentMonitors[].calibrated.mmPerRev": "Extruded distance per revolution (in mm)",
+	"sensors.filamentMonitors[].calibrated.percentMax": "Maximum percentage (0..1 or greater)",
+	"sensors.filamentMonitors[].calibrated.percentMin": "Minimum percentage (0..1)",
+	"sensors.filamentMonitors[].calibrated.sensitivity": "Calibrated sensitivity",
+	"sensors.filamentMonitors[].calibrated.totalDistance": "Total extruded distance (in mm)",
+	"sensors.filamentMonitors[].configured": "Configured properties of this filament monitor",
+	"sensors.filamentMonitors[].configured.allMoves": "Whether all moves and not only printing moves are supposed to be checked",
+	"sensors.filamentMonitors[].configured.calibrationFactor": "Calibration factor of this sensor",
+	"sensors.filamentMonitors[].configured.mmPerPulse": "Extruded distance per pulse (in mm)",
+	"sensors.filamentMonitors[].configured.mmPerRev": "Extruded distance per revolution (in mm)",
+	"sensors.filamentMonitors[].configured.percentMax": "Maximum percentage (0..1 or greater)",
+	"sensors.filamentMonitors[].configured.percentMin": "Minimum percentage (0..1)",
+	"sensors.filamentMonitors[].configured.sampleDistance": "Sample distance (in mm)",
 	"sensors.filamentMonitors[].enableMode": {
 		"summary": "Enable mode of this filament monitor",
 		"values": {
@@ -890,6 +945,10 @@
 	},
 	"sensors.filamentMonitors[].enabled": "Whether this filament monitor is enabled",
 	"sensors.filamentMonitors[].filamentPresent": "Indicates if filament is present in this filament monitor (null if unknown)",
+	"sensors.filamentMonitors[].lastPercentage": "Last ratio of measured vs. commanded movement",
+	"sensors.filamentMonitors[].maxPercentage": "Maximum ratio of measured vs. commanded movement",
+	"sensors.filamentMonitors[].minPercentage": "Minimum ratio of measured vs. commanded movement",
+	"sensors.filamentMonitors[].position": "Reported sensor position of this filament monitor. The maximum value depends on the type of the sensor, e.g. 0..1023 for a Duet3D MFM.",
 	"sensors.filamentMonitors[].status": {
 		"summary": "Last reported status of this filament monitor",
 		"values": {
@@ -902,6 +961,7 @@
 			"sensorError": "Sensor encountered an error"
 		}
 	},
+	"sensors.filamentMonitors[].totalExtrusion": "Total extrusion commanded (in mm)",
 	"sensors.filamentMonitors[].type": {
 		"summary": "Type of this filament monitor",
 		"values": {
@@ -922,6 +982,11 @@
 	"sensors.probes[].diveHeights": "Dive heights of the probe (in mm). The first element is the dive height for the first tap; the second element is used for subsequent taps when multi-tapping",
 	"sensors.probes[].isCalibrated": "Indicates if the scanning probe is calibrated",
 	"sensors.probes[].lastStopHeight": "Height of the probe where it stopped last time (in mm)",
+	"sensors.probes[].loadCell": "Load cell parameters (only applicable for load cell probes, otherwise null)",
+	"sensors.probes[].loadCell.force": "Force measured by the load cell relative to the last tare (in g)",
+	"sensors.probes[].loadCell.gramsPerCount": "Scale of the load cell (in g per count)",
+	"sensors.probes[].loadCell.preload": "Preload of the load cell at the last tare (in g)",
+	"sensors.probes[].loadCell.preloadWindow": "Safe window for the preload (in g, low and high limit). Two equal values disable the check",
 	"sensors.probes[].maxProbeCount": "Maximum number of times to probe after a bad reading was determined",
 	"sensors.probes[].measuredHeight": "Measured height (only applicable for scanning probes, in mm or null)",
 	"sensors.probes[].offsets": "X+Y offsets (in mm)",
@@ -952,7 +1017,8 @@
 			"8": "A switch that is triggered when the probe is activated (unfiltered)",
 			"9": "A BLTouch probe",
 			"10": "Z motor stall detection",
-			"11": "Analog scanning probe"
+			"11": "Analog scanning probe",
+			"12": "Load cell probe measuring the contact force"
 		}
 	},
 	"sensors.probes[].value": "Current analog values of the probe",

package/dist/enums.json

@@ -10,7 +10,8 @@
 		"2",
 		"3",
 		"4",
-		"5"
+		"5",
+		"6"
 	],
 	"boards[].state": [
 		"unknown",
@@ -127,12 +128,12 @@
 		"coreXYUV",
 		"coreXZ",
 		"markForged",
-		"fiveBarScara",
-		"hangprinter",
-		"linearDelta",
-		"polar",
-		"rotaryDelta",
-		"scara",
+		"FiveBarScara",
+		"Hangprinter",
+		"delta",
+		"Polar",
+		"Rotary delta",
+		"Scara",
 		"unknown"
 	],
 	"move.shaping.type": [
@@ -241,6 +242,7 @@
 		"zProbeAsEndstop",
 		"motorStallAny",
 		"motorStallIndividual",
+		"motorStallEncoder",
 		"unknown"
 	],
 	"sensors.filamentMonitors[].enableMode": [
@@ -276,7 +278,8 @@
 		"8",
 		"9",
 		"10",
-		"11"
+		"11",
+		"12"
 	],
 	"spindles[].state": [
 		"unconfigured",

package/dist/move/index.d.ts

@@ -43,6 +43,7 @@ export declare class Move extends ModelObject {
     readonly keepout: ModelCollection<KeepoutZone | null>;
     kinematics: Kinematics;
     limitAxes: boolean;
+    minSpeed: number;
     noMovesBeforeHoming: boolean;
     readonly motionSystems: ModelCollection<MotionSystem>;
     /**

package/dist/move/index.js

@@ -57,6 +57,7 @@ export class Move extends ModelObject {
         this.keepout = new ModelCollection(KeepoutZone);
         this.kinematics = new CoreKinematics(KinematicsName.cartesian);
         this.limitAxes = true;
+        this.minSpeed = 30;
         this.noMovesBeforeHoming = true;
         this.motionSystems = new ModelCollection(MotionSystem);
         /**

package/dist/move/kinematics/CoreKinematics.d.ts

@@ -4,6 +4,6 @@ export declare class CoreKinematics extends ZLeadscrewKinematics {
     constructor(name: KinematicsName);
     forwardMatrix: Array<Array<number>>;
     inverseMatrix: Array<Array<number>>;
-    update(jsonElement: any): IModelObject | null;
+    update(jsonElement: any, authoritative?: boolean): IModelObject | null;
 }
 export default CoreKinematics;

package/dist/move/kinematics/CoreKinematics.js

@@ -14,14 +14,14 @@ export class CoreKinematics extends ZLeadscrewKinematics {
             [0, 0, 1]
         ];
     }
-    update(jsonElement) {
+    update(jsonElement, authoritative = false) {
         if (jsonElement === null) {
             throw new Error("Kinematics must not be null");
         }
         if (typeof jsonElement.name === "string" && this.name !== jsonElement.name) {
-            return getKinematics(jsonElement.name).update(jsonElement);
+            return getKinematics(jsonElement.name).update(jsonElement, authoritative);
         }
-        return super.update(jsonElement);
+        return super.update(jsonElement, authoritative);
     }
 }
 export default CoreKinematics;

package/dist/move/kinematics/DeltaKinematics.d.ts

@@ -16,6 +16,6 @@ export declare class DeltaKinematics extends KinematicsBase {
     readonly towers: ModelCollection<DeltaTower>;
     xTilt: number;
     yTilt: number;
-    update(jsonElement: any): IModelObject | null;
+    update(jsonElement: any, authoritative?: boolean): IModelObject | null;
 }
 export default DeltaKinematics;

package/dist/move/kinematics/DeltaKinematics.js

@@ -22,14 +22,14 @@ export class DeltaKinematics extends KinematicsBase {
         this.xTilt = 0;
         this.yTilt = 0;
     }
-    update(jsonElement) {
+    update(jsonElement, authoritative = false) {
         if (jsonElement === null) {
             throw new Error("Kinematics must not be null");
         }
         if (typeof jsonElement.name === "string" && this.name !== jsonElement.name) {
-            return getKinematics(jsonElement.name).update(jsonElement);
+            return getKinematics(jsonElement.name).update(jsonElement, authoritative);
         }
-        return super.update(jsonElement);
+        return super.update(jsonElement, authoritative);
     }
 }
 export default DeltaKinematics;

package/dist/move/kinematics/HangprinterKinematics.d.ts

@@ -4,6 +4,6 @@ export declare class HangprinterKinematics extends KinematicsBase {
     anchors: Array<Array<number>>;
     printRadius: number;
     constructor();
-    update(jsonElement: any): IModelObject | null;
+    update(jsonElement: any, authoritative?: boolean): IModelObject | null;
 }
 export default HangprinterKinematics;

package/dist/move/kinematics/HangprinterKinematics.js

@@ -11,14 +11,14 @@ export class HangprinterKinematics extends KinematicsBase {
         ];
         this.printRadius = 1500;
     }
-    update(jsonElement) {
+    update(jsonElement, authoritative = false) {
         if (jsonElement === null) {
             throw new Error("Kinematics must not be null");
         }
         if (typeof jsonElement.name === "string" && this.name !== jsonElement.name) {
-            return getKinematics(jsonElement.name).update(jsonElement);
+            return getKinematics(jsonElement.name).update(jsonElement, authoritative);
         }
-        return super.update(jsonElement);
+        return super.update(jsonElement, authoritative);
     }
 }
 export default HangprinterKinematics;

package/dist/move/kinematics/KinematicsBase.d.ts

@@ -6,12 +6,12 @@ export declare enum KinematicsName {
     coreXYUV = "coreXYUV",
     coreXZ = "coreXZ",
     markForged = "markForged",
-    fiveBarScara = "fiveBarScara",
-    hangprinter = "hangprinter",
-    linearDelta = "linearDelta",
-    polar = "polar",
-    rotaryDelta = "rotaryDelta",
-    scara = "scara",
+    fiveBarScara = "FiveBarScara",
+    hangprinter = "Hangprinter",
+    linearDelta = "delta",
+    polar = "Polar",
+    rotaryDelta = "Rotary delta",
+    scara = "Scara",
     unknown = "unknown"
 }
 export declare class MoveSegmentation extends ModelObject {

package/dist/move/kinematics/KinematicsBase.js

@@ -1,4 +1,5 @@
 import ModelObject from "../../ModelObject";
+// Values are the spellings reported by RepRapFirmware, which are inconsistently capitalized
 export var KinematicsName;
 (function (KinematicsName) {
     KinematicsName["cartesian"] = "cartesian";
@@ -7,12 +8,12 @@ export var KinematicsName;
     KinematicsName["coreXYUV"] = "coreXYUV";
     KinematicsName["coreXZ"] = "coreXZ";
     KinematicsName["markForged"] = "markForged";
-    KinematicsName["fiveBarScara"] = "fiveBarScara";
-    KinematicsName["hangprinter"] = "hangprinter";
-    KinematicsName["linearDelta"] = "linearDelta";
-    KinematicsName["polar"] = "polar";
-    KinematicsName["rotaryDelta"] = "rotaryDelta";
-    KinematicsName["scara"] = "scara";
+    KinematicsName["fiveBarScara"] = "FiveBarScara";
+    KinematicsName["hangprinter"] = "Hangprinter";
+    KinematicsName["linearDelta"] = "delta";
+    KinematicsName["polar"] = "Polar";
+    KinematicsName["rotaryDelta"] = "Rotary delta";
+    KinematicsName["scara"] = "Scara";
     KinematicsName["unknown"] = "unknown";
 })(KinematicsName || (KinematicsName = {}));
 export class MoveSegmentation extends ModelObject {

package/dist/move/kinematics/PolarKinematics.d.ts

@@ -7,6 +7,6 @@ export declare class PolarKinematics extends KinematicsBase {
     radiusMin: number;
     ttAccMax: number;
     ttSpeedMax: number;
-    update(jsonElement: any): IModelObject | null;
+    update(jsonElement: any, authoritative?: boolean): IModelObject | null;
 }
 export default PolarKinematics;

package/dist/move/kinematics/PolarKinematics.js

@@ -9,14 +9,14 @@ export class PolarKinematics extends KinematicsBase {
         this.ttAccMax = 0;
         this.ttSpeedMax = 0;
     }
-    update(jsonElement) {
+    update(jsonElement, authoritative = false) {
         if (jsonElement === null) {
             throw new Error("Kinematics must not be null");
         }
         if (typeof jsonElement.name === "string" && this.name !== jsonElement.name) {
-            return getKinematics(jsonElement.name).update(jsonElement);
+            return getKinematics(jsonElement.name).update(jsonElement, authoritative);
         }
-        return super.update(jsonElement);
+        return super.update(jsonElement, authoritative);
     }
 }
 export default PolarKinematics;

package/dist/move/kinematics/ScaraKinematics.d.ts

@@ -9,6 +9,6 @@ export declare class ScaraKinematics extends ZLeadscrewKinematics {
     thetaLimits: number[];
     xOffset: number;
     yOffset: number;
-    update(jsonElement: any): IModelObject | null;
+    update(jsonElement: any, authoritative?: boolean): IModelObject | null;
 }
 export default ScaraKinematics;

package/dist/move/kinematics/ScaraKinematics.js

@@ -12,14 +12,14 @@ export class ScaraKinematics extends ZLeadscrewKinematics {
         this.xOffset = 0;
         this.yOffset = 0;
     }
-    update(jsonElement) {
+    update(jsonElement, authoritative = false) {
         if (jsonElement === null) {
             throw new Error("Kinematics must not be null");
         }
         if (typeof jsonElement.name === "string" && this.name !== jsonElement.name) {
-            return getKinematics(jsonElement.name).update(jsonElement);
+            return getKinematics(jsonElement.name).update(jsonElement, authoritative);
         }
-        return super.update(jsonElement);
+        return super.update(jsonElement, authoritative);
     }
 }
 export default ScaraKinematics;

package/dist/move/kinematics/index.d.ts

@@ -2,7 +2,7 @@ import type { IModelObject } from "../../ModelObject";
 import KinematicsBase, { KinematicsName } from "./KinematicsBase";
 export declare class Kinematics extends KinematicsBase {
     constructor(name?: KinematicsName);
-    update(jsonElement: any): IModelObject | null;
+    update(jsonElement: any, authoritative?: boolean): IModelObject | null;
 }
 export default Kinematics;
 export declare function getKinematics(name: KinematicsName): KinematicsBase;

package/dist/move/kinematics/index.js

@@ -8,14 +8,14 @@ export class Kinematics extends KinematicsBase {
     constructor(name = KinematicsName.cartesian) {
         super(name);
     }
-    update(jsonElement) {
+    update(jsonElement, authoritative = false) {
         if (jsonElement === null) {
             throw new Error("Kinematics must not be null");
         }
         if (typeof jsonElement.name === "string" && this.name !== jsonElement.name) {
-            return getKinematics(jsonElement.name).update(jsonElement);
+            return getKinematics(jsonElement.name).update(jsonElement, authoritative);
         }
-        return super.update(jsonElement);
+        return super.update(jsonElement, authoritative);
     }
 }
 export default Kinematics;

package/dist/plugins/PluginManifest.d.ts

@@ -64,6 +64,6 @@ export declare class PluginManifest extends ModelObject {
     rrfVersion: string | null;
     data: Map<string, any>;
     static checkVersion(actual: string, required: string): boolean;
-    update(jsonElement: any): IModelObject | null;
+    update(jsonElement: any, authoritative?: boolean): IModelObject | null;
 }
 export default PluginManifest;

package/dist/plugins/PluginManifest.js

@@ -109,14 +109,14 @@ export class PluginManifest extends ModelObject {
         }
         return true;
     }
-    update(jsonElement) {
+    update(jsonElement, authoritative = false) {
         if (typeof jsonElement.data === "object") {
             for (const key in jsonElement.data) {
                 this.data.set(key, jsonElement.data[key]);
             }
             delete jsonElement.data;
         }
-        return super.update(jsonElement);
+        return super.update(jsonElement, authoritative);
     }
 }
 export default PluginManifest;

package/dist/sensors/Endstop.d.ts

@@ -4,6 +4,7 @@ export declare enum EndstopType {
     ZProbeAsEndstop = "zProbeAsEndstop",
     motorStallAny = "motorStallAny",
     motorStallIndividual = "motorStallIndividual",
+    motorStallEncoder = "motorStallEncoder",
     unknown = "unknown"
 }
 export declare class Endstop extends ModelObject {

package/dist/sensors/Endstop.js

@@ -5,6 +5,7 @@ export var EndstopType;
     EndstopType["ZProbeAsEndstop"] = "zProbeAsEndstop";
     EndstopType["motorStallAny"] = "motorStallAny";
     EndstopType["motorStallIndividual"] = "motorStallIndividual";
+    EndstopType["motorStallEncoder"] = "motorStallEncoder";
     EndstopType["unknown"] = "unknown";
 })(EndstopType || (EndstopType = {}));
 export class Endstop extends ModelObject {

package/dist/sensors/FilamentMonitors/LaserFilamentMonitor.d.ts

@@ -18,6 +18,6 @@ export declare class LaserFilamentMonitor extends Duet3DFilamentMonitor {
     constructor();
     calibrated: LaserFilamentMonitorCalibrated | null;
     readonly configured: LaserFilamentMonitorConfigured;
-    update(jsonElement: any): IModelObject | null;
+    update(jsonElement: any, authoritative?: boolean): IModelObject | null;
 }
 export default LaserFilamentMonitor;

package/dist/sensors/FilamentMonitors/LaserFilamentMonitor.js

@@ -28,14 +28,14 @@ export class LaserFilamentMonitor extends Duet3DFilamentMonitor {
         this.configured = new LaserFilamentMonitorConfigured();
         ModelObject.wrapModelProperty(this, "calibrated", LaserFilamentMonitorCalibrated);
     }
-    update(jsonElement) {
+    update(jsonElement, authoritative = false) {
         if (jsonElement === null) {
             return null;
         }
         if (typeof jsonElement.type === "string" && jsonElement.type !== this.type) {
-            return getFilamentMonitor(jsonElement.type).update(jsonElement);
+            return getFilamentMonitor(jsonElement.type).update(jsonElement, authoritative);
         }
-        return super.update(jsonElement);
+        return super.update(jsonElement, authoritative);
     }
 }
 export default LaserFilamentMonitor;

package/dist/sensors/FilamentMonitors/PulsedFilamentMonitor.d.ts

@@ -18,6 +18,6 @@ export declare class PulsedFilamentMonitor extends FilamentMonitorBase {
     calibrated: PulsedFilamentMonitorCalibrated | null;
     readonly configured: PulsedFilamentMonitorConfigured;
     position: number;
-    update(jsonElement: any): IModelObject | null;
+    update(jsonElement: any, authoritative?: boolean): IModelObject | null;
 }
 export default PulsedFilamentMonitor;

package/dist/sensors/FilamentMonitors/PulsedFilamentMonitor.js

@@ -27,14 +27,14 @@ export class PulsedFilamentMonitor extends FilamentMonitorBase {
         this.position = 0;
         ModelObject.wrapModelProperty(this, "calibrated", PulsedFilamentMonitorCalibrated);
     }
-    update(jsonElement) {
+    update(jsonElement, authoritative = false) {
         if (jsonElement === null) {
             return null;
         }
         if (typeof jsonElement.type === "string" && jsonElement.type !== this.type) {
-            return getFilamentMonitor(jsonElement.type).update(jsonElement);
+            return getFilamentMonitor(jsonElement.type).update(jsonElement, authoritative);
         }
-        return super.update(jsonElement);
+        return super.update(jsonElement, authoritative);
     }
 }
 export default PulsedFilamentMonitor;

package/dist/sensors/FilamentMonitors/RotatingMagnetFilamentMonitor.d.ts

@@ -19,6 +19,6 @@ export declare class RotatingMagnetFilamentMonitor extends Duet3DFilamentMonitor
     agc: number | null;
     calibrated: RotatingMagnetFilamentMonitorCalibrated | null;
     readonly configured: RotatingMagnetFilamentMonitorConfigured;
-    update(jsonElement: any): IModelObject | null;
+    update(jsonElement: any, authoritative?: boolean): IModelObject | null;
 }
 export default RotatingMagnetFilamentMonitor;

package/dist/sensors/FilamentMonitors/RotatingMagnetFilamentMonitor.js

@@ -29,14 +29,14 @@ export class RotatingMagnetFilamentMonitor extends Duet3DFilamentMonitor {
         this.configured = new RotatingMagnetFilamentMonitorConfigured();
         ModelObject.wrapModelProperty(this, "calibrated", RotatingMagnetFilamentMonitorCalibrated);
     }
-    update(jsonElement) {
+    update(jsonElement, authoritative = false) {
         if (jsonElement === null) {
             return null;
         }
         if (typeof jsonElement.type === "string" && jsonElement.type !== this.type) {
-            return getFilamentMonitor(jsonElement.type).update(jsonElement);
+            return getFilamentMonitor(jsonElement.type).update(jsonElement, authoritative);
         }
-        return super.update(jsonElement);
+        return super.update(jsonElement, authoritative);
     }
 }
 export default RotatingMagnetFilamentMonitor;

package/dist/sensors/FilamentMonitors/index.d.ts

@@ -1,7 +1,7 @@
 import type { IModelObject } from "../../ModelObject";
 import FilamentMonitorBase, { FilamentMonitorType } from "./FilamentMonitorBase";
 export declare class FilamentMonitor extends FilamentMonitorBase {
-    update(jsonElement: any): IModelObject | null;
+    update(jsonElement: any, authoritative?: boolean): IModelObject | null;
 }
 export default FilamentMonitor;
 export declare function getFilamentMonitor(type: FilamentMonitorType): FilamentMonitorBase;

package/dist/sensors/FilamentMonitors/index.js

@@ -3,14 +3,14 @@ import LaserFilamentMonitor from "./LaserFilamentMonitor";
 import PulsedFilamentMonitor from "./PulsedFilamentMonitor";
 import RotatingMagnetFilamentMonitor from "./RotatingMagnetFilamentMonitor";
 export class FilamentMonitor extends FilamentMonitorBase {
-    update(jsonElement) {
+    update(jsonElement, authoritative = false) {
         if (jsonElement === null) {
             return null;
         }
         if (typeof jsonElement.type === "string" && jsonElement.type !== this.type) {
-            return getFilamentMonitor(jsonElement.type).update(jsonElement);
+            return getFilamentMonitor(jsonElement.type).update(jsonElement, authoritative);
         }
-        return super.update(jsonElement);
+        return super.update(jsonElement, authoritative);
     }
 }
 export default FilamentMonitor;

package/dist/sensors/Probe.d.ts

@@ -11,7 +11,14 @@ export declare enum ProbeType {
     unfilteredDigital = 8,
     blTouch = 9,
     zMotorStall = 10,
-    scanningAnalog = 11
+    scanningAnalog = 11,
+    loadCell = 12
+}
+export declare class ProbeLoadCell extends ModelObject {
+    force: number;
+    gramsPerCount: number;
+    preload: number;
+    preloadWindow: Array<number>;
 }
 export declare class ProbeTouchMode extends ModelObject {
     active: boolean;
@@ -31,6 +38,7 @@ export declare class Probe extends ModelObject {
     diveHeights: Array<number>;
     isCalibrated: boolean | null;
     lastStopHeight: number;
+    loadCell: ProbeLoadCell | null;
     maxProbeCount: number;
     measuredHeight: number | null;
     offsets: Array<number>;

package/dist/sensors/Probe.js

@@ -13,7 +13,17 @@ export var ProbeType;
     ProbeType[ProbeType["blTouch"] = 9] = "blTouch";
     ProbeType[ProbeType["zMotorStall"] = 10] = "zMotorStall";
     ProbeType[ProbeType["scanningAnalog"] = 11] = "scanningAnalog";
+    ProbeType[ProbeType["loadCell"] = 12] = "loadCell";
 })(ProbeType || (ProbeType = {}));
+export class ProbeLoadCell extends ModelObject {
+    constructor() {
+        super(...arguments);
+        this.force = 0;
+        this.gramsPerCount = 0;
+        this.preload = 0;
+        this.preloadWindow = [0, 0];
+    }
+}
 export class ProbeTouchMode extends ModelObject {
     constructor() {
         super(...arguments);
@@ -36,6 +46,7 @@ export class Probe extends ModelObject {
         this.diveHeights = [0, 0];
         this.isCalibrated = null;
         this.lastStopHeight = 0;
+        this.loadCell = null;
         this.maxProbeCount = 1;
         this.measuredHeight = null;
         this.offsets = [0, 0];
@@ -50,6 +61,7 @@ export class Probe extends ModelObject {
         this.triggerHeight = 0.7;
         this.type = ProbeType.none;
         this.value = [];
+        ModelObject.wrapModelProperty(this, "loadCell", ProbeLoadCell);
         ModelObject.wrapModelProperty(this, "touchMode", ProbeTouchMode);
     }
 }

package/dist/state/MessageBox.d.ts

@@ -22,6 +22,6 @@ export declare class MessageBox extends ModelObject {
     seq: number;
     timeout: number;
     title: string;
-    update(jsonElement: any): IModelObject | null;
+    update(jsonElement: any, authoritative?: boolean): IModelObject | null;
 }
 export default MessageBox;

package/dist/state/MessageBox.js

@@ -25,11 +25,11 @@ export class MessageBox extends ModelObject {
         this.timeout = 0;
         this.title = "";
     }
-    update(jsonElement) {
+    update(jsonElement, authoritative = false) {
         if (jsonElement instanceof Object && (typeof jsonElement.default === "number" || typeof jsonElement.default === "string")) {
             this.default = jsonElement.default;
         }
-        return super.update(jsonElement);
+        return super.update(jsonElement, authoritative);
     }
 }
 export default MessageBox;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duet3d/objectmodel",
-  "version": "3.7.0-beta.9",
+  "version": "3.7.0-rc.2",
   "description": "TypeScript implementation of the Duet3D Object Model",
   "type": "module",
   "main": "dist/index.js",