@zimo-elektronik/zcan 1.0.0

package/src/zcan/systemControlGroup.ts

@@ -0,0 +1,62 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import MX10 from '../MX10';
+import {SystemStateMode} from '../util/enums';
+import {Buffer} from 'buffer';
+import {Subject} from 'rxjs';
+import {SystemStateData} from '../@types/models';
+
+/**
+ *
+ * @category Groups
+ */
+export default class SystemControlGroup {
+  private mx10: MX10;
+
+  public readonly onSystemStateChange = new Subject<SystemStateData>();
+
+  constructor(mx10: MX10) {
+    this.mx10 = mx10;
+  }
+
+  //0x00.0x00
+  systemState(mode: SystemStateMode, port = 0xff, device = this.mx10.mx10NID) {
+    this.mx10.sendData(0x00, 0x00, [
+      {value: device, length: 2},
+      {value: port, length: 1},
+      {value: mode, length: 1},
+    ]);
+  }
+
+  parse(
+    size: number,
+    command: number,
+    mode: number,
+    nid: number,
+    buffer: Buffer,
+  ) {
+    switch (command) {
+      case 0x00:
+        this.parseSystemState(size, mode, nid, buffer);
+        break;
+    }
+  }
+
+  private parseSystemState(
+    size: number,
+    mode: number,
+    nid: number,
+    buffer: Buffer,
+  ) {
+    if (this.onSystemStateChange.observed) {
+      const deviceNID = buffer.readUInt16LE(0);
+      const port = buffer.readUInt8(2);
+      const modeState = buffer.readUInt8(3);
+
+      this.onSystemStateChange.next({
+        nid: deviceNID,
+        port,
+        mode: modeState,
+      });
+    }
+  }
+}

package/src/zcan/trackCfgGroup.ts

@@ -0,0 +1,109 @@
+import {
+  TseInfoExtended,
+  TseProgReadExtended,
+  TseProgWriteExtended,
+} from 'src/@types/models';
+import MX10 from '../MX10';
+import {Subject} from 'rxjs';
+
+/**
+ *
+ * @category Groups
+ */
+export default class TrackCfgGroup {
+  public readonly onTseInfoExtended = new Subject<TseInfoExtended>();
+  public readonly onTseProgReadExtended = new Subject<TseProgReadExtended>();
+  public readonly onTseProgWriteExtended = new Subject<TseProgWriteExtended>();
+
+  private mx10: MX10;
+
+  constructor(mx10: MX10) {
+    this.mx10 = mx10;
+  }
+
+  tseProgRead(NID: number, CV: number) {
+    this.mx10.sendData(0x16, 0x08, [
+      {value: this.mx10.mx10NID, length: 2},
+      {value: NID, length: 2},
+      {value: CV, length: 4},
+    ]);
+  }
+
+  tseProgWrite(NID: number, CV: number, value: number) {
+    this.mx10.sendData(0x16, 0x09, [
+      {value: this.mx10.mx10NID, length: 2},
+      {value: NID, length: 2},
+      {value: CV, length: 4},
+      {value: value, length: 1},
+    ]);
+  }
+
+  parse(
+    size: number,
+    command: number,
+    mode: number,
+    nid: number,
+    buffer: Buffer,
+  ) {
+    switch (command) {
+      case 0x02:
+        this.parseTseInfo(size, mode, nid, buffer);
+        break;
+      case 0x08:
+        this.parseTseProgRead(size, mode, nid, buffer);
+        break;
+      case 0x09:
+        this.parseTseProgWrite(size, mode, nid, buffer);
+        break;
+    }
+  }
+
+  // 0x16.0x02
+  parseTseInfo(size: number, mode: number, nid: number, buffer: Buffer) {
+    if (this.onTseInfoExtended.observed) {
+      // const sysNid = buffer.readUInt16LE(0);
+      const NID = buffer.readUInt16LE(2);
+      const cfgNum = buffer.readUInt32LE(4);
+      const cvState = buffer.readUint8(8);
+      const cvCode = buffer.readUint8(9);
+
+      this.onTseInfoExtended.next({
+        nid: NID,
+        cfgNum,
+        cvState,
+        cvCode,
+      });
+    }
+  }
+
+  // 0x16.0x08
+  parseTseProgRead(size: number, mode: number, nid: number, buffer: Buffer) {
+    if (this.onTseProgReadExtended.observed) {
+      // const sysNid = buffer.readUInt16LE(0);
+      const NID = buffer.readUInt16LE(2);
+      const cfgNum = buffer.readUInt32LE(4);
+      const cvValue = buffer.readUInt16LE(8);
+
+      this.onTseProgReadExtended.next({
+        nid: NID,
+        cfgNum,
+        cvValue,
+      });
+    }
+  }
+
+  // 0x16.0x09
+  parseTseProgWrite(size: number, mode: number, nid: number, buffer: Buffer) {
+    if (this.onTseProgWriteExtended.observed) {
+      const NID = buffer.readUInt16LE(0);
+      const cfgNum = buffer.readUInt32LE(2);
+      const cvValue = buffer.readUint8(6);
+
+      this.onTseProgWriteExtended.next({
+        nid: NID,
+        cfgNum,
+        cvValue,
+      });
+    }
+  }
+}

package/src/zcan/trainControlGroup.ts

@@ -0,0 +1,48 @@
+import MX10 from '../MX10';
+
+/**
+ *
+ * @category Groups
+ */
+export default class TrainControlGroup {
+  private mx10: MX10;
+
+  constructor(mx10: MX10) {
+    this.mx10 = mx10;
+  }
+
+  trainPartFind(NID: number) {
+    //Check if loco is in a traction
+    this.mx10.sendData(0x05, 0x02, [{value: NID, length: 2}], 0b00);
+  }
+
+  parse(
+    size: number,
+    command: number,
+    mode: number,
+    nid: number,
+    buffer: Buffer,
+  ) {
+    switch (command) {
+      case 0x02:
+        this.parseTrainPartFind(size, mode, nid, buffer);
+        break;
+    }
+  }
+
+  // 0x05.0x02
+  /* eslint-disable @typescript-eslint/no-unused-vars */
+  parseTrainPartFind(size: number, mode: number, nid: number, buffer: Buffer) {
+    // const NID = buffer.readUInt16LE(0);
+    // const trainNID = buffer.readUInt16LE(2);
+    // const ownerNID = buffer.readUInt16LE(4);
+    // const state = buffer.readUInt16LE(6);
+    //
+    // return {
+    //   NID,
+    //   trainNID,
+    //   ownerNID,
+    //   state,
+    // };
+  }
+}

package/src/zcan/vehicleGroup.ts

@@ -0,0 +1,267 @@
+/* eslint-disable  @typescript-eslint/no-unused-vars */
+import MX10 from '../MX10';
+import {Subject} from 'rxjs';
+import {
+  CallFunctionData,
+  CallSpecialFunctionData,
+  VehicleStateData,
+  VehicleModeData,
+  VehicleSpeedData,
+} from '../@types/models';
+import {
+  Direction,
+  DirectionDefault,
+  getOperatingMode,
+  Manual,
+  ShuntingFunction,
+  SpecialFunctionMode,
+} from '../util/enums';
+import {
+  combineSpeedAndDirection,
+  getSpeedSteps,
+  parseSpeed,
+} from '../internal/speedUtils';
+
+/**
+ *
+ * @category Groups
+ */
+export default class VehicleGroup {
+  private mx10: MX10;
+
+  public readonly onVehicleState = new Subject<VehicleStateData>();
+  public readonly onVehicleMode = new Subject<VehicleModeData>();
+  public readonly onChangeSpeed = new Subject<VehicleSpeedData>();
+  public readonly onCallFunction = new Subject<CallFunctionData>();
+  public readonly onCallSpecialFunction =
+    new Subject<CallSpecialFunctionData>();
+
+  constructor(mx10: MX10) {
+    this.mx10 = mx10;
+  }
+
+  vehicleMode(vehicleAddress: number) {
+    this.mx10.sendData(0x02, 0x01, [{value: vehicleAddress, length: 2}]);
+  }
+
+  changeSpeed(
+    vehicleAddress: number,
+    speedStep: number,
+    forward: boolean,
+    eastWest?: Direction,
+    emergencyStop?: boolean,
+  ) {
+    const speedAndDirection = combineSpeedAndDirection(
+      speedStep,
+      forward,
+      eastWest,
+      emergencyStop,
+    );
+
+    this.mx10.sendData(0x02, 0x02, [
+      {value: vehicleAddress, length: 2},
+      {value: speedAndDirection, length: 2},
+      {value: 0x0000, length: 2},
+    ]);
+  }
+
+  callFunction(
+    vehicleAddress: number,
+    functionId: number,
+    functionStatus: boolean,
+  ) {
+    this.mx10.sendData(0x02, 0x04, [
+      {value: vehicleAddress, length: 2},
+      {value: functionId, length: 2},
+      {value: Number(functionStatus), length: 2},
+    ]);
+  }
+
+  changeSpecialFunction(
+    vehicleAddress: number,
+    specialFunctionMode: SpecialFunctionMode,
+    specialFunctionStatus: Manual | ShuntingFunction | DirectionDefault,
+  ) {
+    this.mx10.sendData(0x02, 0x05, [
+      {value: vehicleAddress, length: 2},
+      {value: specialFunctionMode, length: 2},
+      {value: specialFunctionStatus, length: 2},
+    ]);
+  }
+
+  //0x02.0x00
+  vehicleState(vehicleAddress: number) {
+    return this.mx10.sendData(
+      0x02,
+      0x00,
+      [{value: vehicleAddress, length: 2}],
+      0b00,
+    );
+  }
+
+  // 0x02.0x10
+  activeModeTrain(vehicleAddress: number) {
+    return this.mx10.sendData(
+      0x02,
+      0x10,
+      [
+        {value: vehicleAddress, length: 2},
+        {value: 0x01, length: 2},
+      ],
+      0b01,
+    );
+  }
+
+  activeModeTakeOver(vehicleAddress: number) {
+    return this.mx10.sendData(
+      0x02,
+      0x10,
+      [
+        {value: vehicleAddress, length: 2},
+        {value: 0x10, length: 2},
+      ],
+      0b01,
+    );
+  }
+
+  parse(
+    size: number,
+    command: number,
+    mode: number,
+    nid: number,
+    buffer: Buffer,
+  ) {
+    switch (command) {
+      case 0x00:
+        this.parseVehicleState(size, mode, nid, buffer);
+        break;
+      case 0x01:
+        this.parseVehicleMode(size, mode, nid, buffer);
+        break;
+      case 0x02:
+        this.parseVehicleSpeed(size, mode, nid, buffer);
+        break;
+      case 0x04:
+        this.parseVehicleFunction(size, mode, nid, buffer);
+        break;
+      case 0x05:
+        this.parseVehicleSpecialFunction(size, mode, nid, buffer);
+        break;
+    }
+  }
+
+  // 0x02.0x00
+  private parseVehicleState(
+    size: number,
+    mode: number,
+    nid: number,
+    buffer: Buffer,
+  ) {
+    if (this.onVehicleState.observed) {
+      const NID = buffer.readUInt16LE(0);
+      const stateFlags = buffer.readUInt16LE(2); // TODO: add
+      const ctrlTick = buffer.readUInt16LE(4);
+      const ctrlDevice = buffer.readUInt16LE(6);
+
+      this.onVehicleState.next({
+        nid: NID,
+        ctrlTick,
+        ctrlDevice,
+      });
+    }
+  }
+
+  // 0x02.0x01
+  private parseVehicleMode(
+    size: number,
+    mode: number,
+    nid: number,
+    buffer: Buffer,
+  ) {
+    if (this.onVehicleMode.observed) {
+      const NID = buffer.readUInt16LE(0);
+      const mode1 = buffer.readUInt8(2);
+      const mode2 = buffer.readUInt8(3);
+      const mode3 = buffer.readUInt8(4);
+
+      const operatingMode = getOperatingMode(mode1);
+      const speedSteps = getSpeedSteps(mode1);
+
+      this.onVehicleMode.next({
+        nid: NID,
+        speedSteps,
+        operatingMode,
+        mode2,
+        mode3,
+      });
+    }
+  }
+
+  // 0x02.0x02
+  private parseVehicleSpeed(
+    size: number,
+    mode: number,
+    nid: number,
+    buffer: Buffer,
+  ) {
+    if (this.onChangeSpeed.observed) {
+      const NID = buffer.readUInt16LE(0);
+      const speedAndDirection = buffer.readUInt16LE(2);
+      const divisor = buffer.readUint8(4);
+
+      const {speedStep, forward, eastWest, emergencyStop} =
+        parseSpeed(speedAndDirection);
+
+      this.onChangeSpeed.next({
+        nid: NID,
+        divisor,
+        speedStep,
+        forward,
+        eastWest,
+        emergencyStop,
+      });
+    }
+  }
+
+  // 0x02.0x04
+  private parseVehicleFunction(
+    size: number,
+    mode: number,
+    nid: number,
+    buffer: Buffer,
+  ) {
+    if (this.onCallFunction.observed) {
+      const NID = buffer.readUInt16LE(0);
+      const functionNumber = buffer.readUInt16LE(2);
+      const functionState = buffer.readUInt16LE(4);
+
+      const functionActive = functionState !== 0x00;
+
+      this.onCallFunction.next({
+        nid: NID,
+        functionNumber,
+        functionState: functionActive,
+      });
+    }
+  }
+
+  // 0x02.0x05
+  private parseVehicleSpecialFunction(
+    size: number,
+    mode: number,
+    nid: number,
+    buffer: Buffer,
+  ) {
+    if (this.onCallSpecialFunction.observed) {
+      const NID = buffer.readUInt16LE(0);
+      const specialFunctionMode = buffer.readUInt16LE(2);
+      const specialFunctionState = buffer.readUInt16LE(4);
+
+      this.onCallSpecialFunction.next({
+        nid: NID,
+        specialFunctionMode,
+        specialFunctionState,
+      });
+    }
+  }
+}

package/src/zcan/zimoProgrammableScriptGroup.ts

@@ -0,0 +1,25 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import MX10 from '../MX10';
+import {Buffer} from 'buffer';
+
+/**
+ *
+ * @category Groups
+ */
+export default class ZimoProgrammableScriptGroup {
+  private mx10: MX10;
+
+  constructor(mx10: MX10) {
+    this.mx10 = mx10;
+  }
+
+  parse(
+    size: number,
+    command: number,
+    mode: number,
+    nid: number,
+    buffer: Buffer,
+  ) {
+    // console.log('parse zcs group');
+  }
+}

package/tsconfig.build.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": [
+    "dist",
+    "node_modules",
+    "__test",
+    "**/*.spec.ts",
+    "**/*.spec.js",
+    "*.spec.ts",
+    "**/spec.ts"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,49 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ES2022",
+    "moduleResolution": "Node",
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "importHelpers": true,
+    "resolveJsonModule": true,
+    "sourceMap": true,
+    "declaration": true,
+
+    "alwaysStrict": true,
+    "forceConsistentCasingInFileNames": true,
+    "removeComments": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "noImplicitThis": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noImplicitReturns": true,
+    "strict": true,
+    "noFallthroughCasesInSwitch": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "composite": true,
+    "skipLibCheck": true,
+    "noEmitHelpers": false,
+
+    "outDir": "dist",
+    "rootDir": "src",
+    "baseUrl": ".",
+    "paths": {
+      "@types": ["./@types/"]
+    }
+  },
+  "exclude": [
+    "dist",
+    "node_modules"
+  ],
+  "include": ["src"],
+  "typedocOptions": {
+    "entryPoints": ["src/docs_entrypoint.ts"],
+    "out": "docs",
+    "excludePrivate": true,
+    "githubPages": false
+  }
+}

package/tsconfig.test.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noUnusedParameters": false,
+    "noUnusedLocals": false,
+    "allowUnusedLabels": true,
+    "outDir": "dist"
+  }
+}