@duet3d/objectmodel 3.4.0

package/lib/move/Axis.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AxisLetter = void 0;
+const ModelObject_1 = require("../ModelObject");
+const ModelCollection_1 = require("../ModelCollection");
+const DriverId_1 = require("./DriverId");
+const Microstepping_1 = require("./Microstepping");
+var AxisLetter;
+(function (AxisLetter) {
+    AxisLetter["X"] = "X";
+    AxisLetter["Y"] = "Y";
+    AxisLetter["Z"] = "Z";
+    AxisLetter["U"] = "U";
+    AxisLetter["V"] = "V";
+    AxisLetter["W"] = "W";
+    AxisLetter["A"] = "A";
+    AxisLetter["B"] = "B";
+    AxisLetter["C"] = "C";
+    AxisLetter["D"] = "D";
+    AxisLetter["a"] = "a";
+    AxisLetter["b"] = "b";
+    AxisLetter["c"] = "c";
+    AxisLetter["d"] = "d";
+    AxisLetter["e"] = "e";
+    AxisLetter["f"] = "f";
+    AxisLetter["g"] = "g";
+    AxisLetter["h"] = "h";
+    AxisLetter["i"] = "i";
+    AxisLetter["j"] = "j";
+    AxisLetter["k"] = "k";
+    AxisLetter["l"] = "l";
+    AxisLetter["none"] = "";
+})(AxisLetter = exports.AxisLetter || (exports.AxisLetter = {}));
+class Axis extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.acceleration = 0;
+        this.babystep = 0;
+        this.current = 0;
+        this.drivers = new ModelCollection_1.default(DriverId_1.default);
+        this.homed = false;
+        this.jerk = 15;
+        this.letter = AxisLetter.none;
+        this.machinePosition = null;
+        this.max = 200;
+        this.maxProbed = false;
+        this.microstepping = new Microstepping_1.default();
+        this.min = 0;
+        this.minProbed = false;
+        this.percentCurrent = 100;
+        this.percentStstCurrent = null;
+        this.speed = 100;
+        this.stepsPerMm = 80;
+        this.userPosition = null;
+        this.visible = true;
+        this.workplaceOffsets = new Array();
+    }
+}
+exports.default = Axis;

package/lib/move/DriverId.d.ts

@@ -0,0 +1,7 @@
+import ModelObject, { IModelObject } from "../ModelObject";
+export default class DriverId extends ModelObject {
+    board: number;
+    driver: number;
+    update(jsonElement: any): IModelObject | null;
+    toString(): string;
+}

package/lib/move/DriverId.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ModelObject_1 = require("../ModelObject");
+class DriverId extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.board = 0;
+        this.driver = 0;
+    }
+    update(jsonElement) {
+        if (typeof jsonElement === "string") {
+            const matches = /(\d+)\.(\d+)/.exec(jsonElement);
+            if (matches !== null) {
+                this.board = Number(matches[1]);
+                this.driver = Number(matches[2]);
+            }
+            else {
+                this.board = 0;
+                this.driver = Number(jsonElement);
+            }
+            return this;
+        }
+        return null;
+    }
+    toString() {
+        return `${this.board}.${this.driver}`;
+    }
+}
+exports.default = DriverId;

package/lib/move/Extruder.d.ts

@@ -0,0 +1,26 @@
+import ModelObject from "../ModelObject";
+import DriverId from "./DriverId";
+import Microstepping from "./Microstepping";
+export declare class ExtruderNonlinear extends ModelObject {
+    a: number;
+    b: number;
+    upperLimit: number;
+}
+export default class Extruder extends ModelObject {
+    constructor();
+    acceleration: number;
+    current: number;
+    driver: DriverId | null;
+    filament: string;
+    factor: number;
+    jerk: number;
+    readonly microstepping: Microstepping;
+    readonly nonlinear: ExtruderNonlinear;
+    percentCurrent: number;
+    percentStstCurrent: number | null;
+    position: number;
+    pressureAdvance: number;
+    rawPosition: number;
+    speed: number;
+    stepsPerMm: number;
+}

package/lib/move/Extruder.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtruderNonlinear = void 0;
+const ModelObject_1 = require("../ModelObject");
+const DriverId_1 = require("./DriverId");
+const Microstepping_1 = require("./Microstepping");
+class ExtruderNonlinear extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.a = 0;
+        this.b = 0;
+        this.upperLimit = 0.2;
+    }
+}
+exports.ExtruderNonlinear = ExtruderNonlinear;
+class Extruder extends ModelObject_1.default {
+    constructor() {
+        super();
+        this.acceleration = 500;
+        this.current = 0;
+        this.driver = null;
+        this.filament = "";
+        this.factor = 1;
+        this.jerk = 15;
+        this.microstepping = new Microstepping_1.default();
+        this.nonlinear = new ExtruderNonlinear();
+        this.percentCurrent = 100;
+        this.percentStstCurrent = null;
+        this.position = 0;
+        this.pressureAdvance = 0;
+        this.rawPosition = 0;
+        this.speed = 100;
+        this.stepsPerMm = 420;
+        this.wrapModelProperty("driver", DriverId_1.default);
+    }
+}
+exports.default = Extruder;

package/lib/move/InputShaping.d.ts

@@ -0,0 +1,18 @@
+import ModelObject from "../ModelObject";
+export declare enum InputShapingType {
+    none = "none",
+    mzv = "mzv",
+    zvd = "zvd",
+    zvdd = "zvddd",
+    zvddd = "zvddd",
+    ei2 = "ei2",
+    ei3 = "ei3"
+}
+export default class InputShaping extends ModelObject {
+    amplitudes: Array<number>;
+    damping: number;
+    durations: Array<number>;
+    frequency: number;
+    minAcceleration: number;
+    type: InputShapingType;
+}

package/lib/move/InputShaping.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputShapingType = void 0;
+const ModelObject_1 = require("../ModelObject");
+var InputShapingType;
+(function (InputShapingType) {
+    InputShapingType["none"] = "none";
+    InputShapingType["mzv"] = "mzv";
+    InputShapingType["zvd"] = "zvd";
+    InputShapingType["zvdd"] = "zvddd";
+    InputShapingType["zvddd"] = "zvddd";
+    InputShapingType["ei2"] = "ei2";
+    InputShapingType["ei3"] = "ei3";
+})(InputShapingType = exports.InputShapingType || (exports.InputShapingType = {}));
+class InputShaping extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.amplitudes = [];
+        this.damping = 0.2;
+        this.durations = [];
+        this.frequency = 40;
+        this.minAcceleration = 10;
+        this.type = InputShapingType.none;
+    }
+}
+exports.default = InputShaping;

package/lib/move/Microstepping.d.ts

@@ -0,0 +1,5 @@
+import ModelObject from "../ModelObject";
+export default class Microstepping extends ModelObject {
+    interpolated: boolean;
+    value: number;
+}

package/lib/move/Microstepping.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ModelObject_1 = require("../ModelObject");
+class Microstepping extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.interpolated = false;
+        this.value = 16;
+    }
+}
+exports.default = Microstepping;

package/lib/move/MoveCalibration.d.ts

@@ -0,0 +1,10 @@
+import ModelObject from "../ModelObject";
+export declare class MoveDeviations extends ModelObject {
+    deviation: number;
+    mean: number;
+}
+export default class MoveCalibration extends ModelObject {
+    readonly final: MoveDeviations;
+    readonly initial: MoveDeviations;
+    numFactors: number;
+}

package/lib/move/MoveCalibration.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoveDeviations = void 0;
+const ModelObject_1 = require("../ModelObject");
+class MoveDeviations extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.deviation = 0;
+        this.mean = 0;
+    }
+}
+exports.MoveDeviations = MoveDeviations;
+class MoveCalibration extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.final = new MoveDeviations();
+        this.initial = new MoveDeviations();
+        this.numFactors = 0;
+    }
+}
+exports.default = MoveCalibration;

package/lib/move/MoveCompensation.d.ts

@@ -0,0 +1,29 @@
+import ModelObject from "../ModelObject";
+import { MoveDeviations } from "./MoveCalibration";
+export declare class ProbeGrid extends ModelObject {
+    axes: Array<string>;
+    maxs: Array<number>;
+    mins: Array<number>;
+    radius: number;
+    spacings: Array<number>;
+}
+export declare class Skew extends ModelObject {
+    compensateXY: boolean;
+    tanXY: number;
+    tanXZ: number;
+    tanYZ: number;
+}
+export declare enum MoveCompensationType {
+    none = "none",
+    mesh = "mesh"
+}
+export default class MoveCompensation extends ModelObject {
+    constructor();
+    fadeHeight: number | null;
+    file: string | null;
+    liveGrid: ProbeGrid | null;
+    meshDeviation: MoveDeviations | null;
+    readonly probeGrid: ProbeGrid;
+    readonly skew: Skew;
+    type: MoveCompensationType;
+}

package/lib/move/MoveCompensation.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoveCompensationType = exports.Skew = exports.ProbeGrid = void 0;
+const ModelObject_1 = require("../ModelObject");
+const MoveCalibration_1 = require("./MoveCalibration");
+class ProbeGrid extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.axes = ['X', 'Y'];
+        this.maxs = [-1, -1];
+        this.mins = [0, 0];
+        this.radius = 0;
+        this.spacings = [0, 0];
+    }
+}
+exports.ProbeGrid = ProbeGrid;
+class Skew extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.compensateXY = true;
+        this.tanXY = 0;
+        this.tanXZ = 0;
+        this.tanYZ = 0;
+    }
+}
+exports.Skew = Skew;
+var MoveCompensationType;
+(function (MoveCompensationType) {
+    MoveCompensationType["none"] = "none";
+    MoveCompensationType["mesh"] = "mesh";
+})(MoveCompensationType = exports.MoveCompensationType || (exports.MoveCompensationType = {}));
+class MoveCompensation extends ModelObject_1.default {
+    constructor() {
+        super();
+        this.fadeHeight = null;
+        this.file = null;
+        this.liveGrid = null;
+        this.meshDeviation = null;
+        this.probeGrid = new ProbeGrid();
+        this.skew = new Skew();
+        this.type = MoveCompensationType.none;
+        this.wrapModelProperty("liveGrid", ProbeGrid);
+        this.wrapModelProperty("meshDeviation", MoveCalibration_1.MoveDeviations);
+    }
+}
+exports.default = MoveCompensation;

package/lib/move/index.d.ts

@@ -0,0 +1,46 @@
+import ModelObject from "../ModelObject";
+import ModelCollection from "../ModelCollection";
+import Axis from "./Axis";
+import MoveCalibration from "./MoveCalibration";
+import MoveCompensation from "./MoveCompensation";
+import Extruder from "./Extruder";
+import InputShaping from "./InputShaping";
+import Kinematics from "./kinematics";
+export declare class CurrentMove extends ModelObject {
+    acceleration: number;
+    deceleration: number;
+    laserPwm: number | null;
+    requestedSpeed: number;
+    topSpeed: number;
+}
+export declare class MotorsIdleControl extends ModelObject {
+    factor: number;
+    timeout: number;
+}
+export declare class MoveQueueItem extends ModelObject {
+    gracePeriod: number;
+    length: number;
+}
+export declare class MoveRotation extends ModelObject {
+    angle: number;
+    centre: Array<number>;
+}
+export default class Move extends ModelObject {
+    readonly axes: ModelCollection<Axis>;
+    readonly calibration: MoveCalibration;
+    readonly compensation: MoveCompensation;
+    readonly currentMove: CurrentMove;
+    readonly extruders: ModelCollection<Extruder>;
+    readonly idle: MotorsIdleControl;
+    kinematics: Kinematics;
+    limitAxes: boolean;
+    noMovesBeforeHoming: boolean;
+    printingAcceleration: number;
+    readonly queue: ModelCollection<MoveQueueItem>;
+    readonly rotation: MoveRotation;
+    readonly shaping: InputShaping;
+    speedFactor: number;
+    travelAcceleration: number;
+    virtualEPos: number;
+    workplaceNumber: number;
+}

package/lib/move/index.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoveRotation = exports.MoveQueueItem = exports.MotorsIdleControl = exports.CurrentMove = void 0;
+const ModelObject_1 = require("../ModelObject");
+const ModelCollection_1 = require("../ModelCollection");
+const Axis_1 = require("./Axis");
+const MoveCalibration_1 = require("./MoveCalibration");
+const MoveCompensation_1 = require("./MoveCompensation");
+const Extruder_1 = require("./Extruder");
+const InputShaping_1 = require("./InputShaping");
+const kinematics_1 = require("./kinematics");
+class CurrentMove extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.acceleration = 0;
+        this.deceleration = 0;
+        this.laserPwm = null;
+        this.requestedSpeed = 0;
+        this.topSpeed = 0;
+    }
+}
+exports.CurrentMove = CurrentMove;
+class MotorsIdleControl extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.factor = 0.3;
+        this.timeout = 30;
+    }
+}
+exports.MotorsIdleControl = MotorsIdleControl;
+class MoveQueueItem extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.gracePeriod = 0;
+        this.length = 0;
+    }
+}
+exports.MoveQueueItem = MoveQueueItem;
+class MoveRotation extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.angle = 0;
+        this.centre = [0, 0];
+    }
+}
+exports.MoveRotation = MoveRotation;
+class Move extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.axes = new ModelCollection_1.default(Axis_1.default);
+        this.calibration = new MoveCalibration_1.default();
+        this.compensation = new MoveCompensation_1.default();
+        this.currentMove = new CurrentMove();
+        this.extruders = new ModelCollection_1.default(Extruder_1.default);
+        this.idle = new MotorsIdleControl();
+        this.kinematics = new kinematics_1.default();
+        this.limitAxes = true;
+        this.noMovesBeforeHoming = true;
+        this.printingAcceleration = 10000;
+        this.queue = new ModelCollection_1.default(MoveQueueItem);
+        this.rotation = new MoveRotation();
+        this.shaping = new InputShaping_1.default();
+        this.speedFactor = 1;
+        this.travelAcceleration = 10000;
+        this.virtualEPos = 0;
+        this.workplaceNumber = 0;
+    }
+}
+exports.default = Move;

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

@@ -0,0 +1,8 @@
+import { IModelObject } from "../../ModelObject";
+import { KinematicsName, ZLeadscrewKinematics } from "./KinematicsBase";
+export default class CoreKinematics extends ZLeadscrewKinematics {
+    constructor(name: KinematicsName);
+    forwardMatrix: Array<Array<number>>;
+    inverseMatrix: Array<Array<number>>;
+    update(jsonElement: any): IModelObject | null;
+}

package/lib/move/kinematics/CoreKinematics.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const KinematicsBase_1 = require("./KinematicsBase");
+const index_1 = require("./index");
+class CoreKinematics extends KinematicsBase_1.ZLeadscrewKinematics {
+    constructor(name) {
+        super(name);
+        this.forwardMatrix = [
+            [1, 0, 0],
+            [0, 1, 0],
+            [0, 0, 1]
+        ];
+        this.inverseMatrix = [
+            [1, 0, 0],
+            [0, 1, 0],
+            [0, 0, 1]
+        ];
+    }
+    update(jsonElement) {
+        if (jsonElement === null) {
+            throw new Error("Kinematics must not be null");
+        }
+        if (typeof jsonElement.name === "string" && this.name !== jsonElement.name) {
+            return (0, index_1.getKinematics)(jsonElement.name).update(jsonElement);
+        }
+        return super.update(jsonElement);
+    }
+}
+exports.default = CoreKinematics;

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

@@ -0,0 +1,19 @@
+import ModelCollection from "../../ModelCollection";
+import ModelObject, { IModelObject } from "../../ModelObject";
+import KinematicsBase from "./KinematicsBase";
+export declare class DeltaTower extends ModelObject {
+    angleCorrection: number;
+    diagonal: number;
+    endstopAdjustment: number;
+    xPos: number;
+    yPos: number;
+}
+export default class DeltaKinematics extends KinematicsBase {
+    deltaRadius: number;
+    homedHeight: number;
+    printRadius: number;
+    readonly towers: ModelCollection<DeltaTower>;
+    xTilt: number;
+    yTilt: number;
+    update(jsonElement: any): IModelObject | null;
+}

package/lib/move/kinematics/DeltaKinematics.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeltaTower = void 0;
+const ModelCollection_1 = require("../../ModelCollection");
+const ModelObject_1 = require("../../ModelObject");
+const KinematicsBase_1 = require("./KinematicsBase");
+const index_1 = require("./index");
+class DeltaTower extends ModelObject_1.default {
+    constructor() {
+        super(...arguments);
+        this.angleCorrection = 0;
+        this.diagonal = 0;
+        this.endstopAdjustment = 0;
+        this.xPos = 0;
+        this.yPos = 0;
+    }
+}
+exports.DeltaTower = DeltaTower;
+class DeltaKinematics extends KinematicsBase_1.default {
+    constructor() {
+        super(...arguments);
+        this.deltaRadius = 0;
+        this.homedHeight = 0;
+        this.printRadius = 0;
+        this.towers = new ModelCollection_1.default(DeltaTower);
+        this.xTilt = 0;
+        this.yTilt = 0;
+    }
+    update(jsonElement) {
+        if (jsonElement === null) {
+            throw new Error("Kinematics must not be null");
+        }
+        if (typeof jsonElement.name === "string" && this.name !== jsonElement.name) {
+            return (0, index_1.getKinematics)(jsonElement.name).update(jsonElement);
+        }
+        return super.update(jsonElement);
+    }
+}
+exports.default = DeltaKinematics;

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

@@ -0,0 +1,8 @@
+import { IModelObject } from "../../ModelObject";
+import KinematicsBase from "./KinematicsBase";
+export default class HangprinterKinematics extends KinematicsBase {
+    anchors: Array<Array<number>>;
+    printRadius: number;
+    constructor();
+    update(jsonElement: any): IModelObject | null;
+}

package/lib/move/kinematics/HangprinterKinematics.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const KinematicsBase_1 = require("./KinematicsBase");
+const index_1 = require("./index");
+class HangprinterKinematics extends KinematicsBase_1.default {
+    constructor() {
+        super(KinematicsBase_1.KinematicsName.hangprinter);
+        this.anchors = [
+            [0, -2000, -100],
+            [2000, 1000, -100],
+            [0, 0, 3000]
+        ];
+        this.printRadius = 1500;
+    }
+    update(jsonElement) {
+        if (jsonElement === null) {
+            throw new Error("Kinematics must not be null");
+        }
+        if (typeof jsonElement.name === "string" && this.name !== jsonElement.name) {
+            return (0, index_1.getKinematics)(jsonElement.name).update(jsonElement);
+        }
+        return super.update(jsonElement);
+    }
+}
+exports.default = HangprinterKinematics;

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

@@ -0,0 +1,36 @@
+import ModelObject from "../../ModelObject";
+export declare enum KinematicsName {
+    cartesian = "cartesian",
+    coreXY = "corexy",
+    coreXYU = "corexyu",
+    coreXYUV = "corexyuv",
+    coreXZ = "corexz",
+    markForged = "markforged",
+    fiveBarScara = "fivebarscara",
+    hangprinter = "hangprinter",
+    delta = "delta",
+    polar = "polar",
+    rotaryDelta = "rotary delta",
+    scara = "scara",
+    unknown = "unknown"
+}
+export declare class MoveSegmentation extends ModelObject {
+    segmentsPerSec: number;
+    minSegmentLength: number;
+}
+export default abstract class KinematicsBase extends ModelObject {
+    readonly name: KinematicsName;
+    readonly segmentation: MoveSegmentation;
+    constructor(name: KinematicsName);
+}
+export declare class TiltCorrection extends ModelObject {
+    correctionFactor: number;
+    lastCorrections: Array<number>;
+    maxCorrection: number;
+    screwPitch: number;
+    screwX: Array<number>;
+    screwY: Array<number>;
+}
+export declare abstract class ZLeadscrewKinematics extends KinematicsBase {
+    readonly tiltCorrection: TiltCorrection;
+}