@zimo-elektronik/zcan 1.0.0

package/src/util/extended-ascii.ts

@@ -0,0 +1,179 @@
+/**
+ * (Nonstandard) String utility function for 8-bit ASCII with the extended
+ * character set. Unlike the ASCII above, we do not mask the high bits.
+ *
+ * Placed into a separate file so it can be used with other Buffer implementations.
+ * @see http://en.wikipedia.org/wiki/Extended_ASCII
+ */
+import {Buffer} from 'buffer';
+
+export default class ExtendedASCII {
+  private static extendedChars = [
+    '\u00C7',
+    '\u00FC',
+    '\u00E9',
+    '\u00E2',
+    '\u00E4',
+    '\u00E0',
+    '\u00E5',
+    '\u00E7',
+    '\u00EA',
+    '\u00EB',
+    '\u00E8',
+    '\u00EF',
+    '\u00EE',
+    '\u00EC',
+    '\u00C4',
+    '\u00C5',
+    '\u00C9',
+    '\u00E6',
+    '\u00C6',
+    '\u00F4',
+    '\u00F6',
+    '\u00F2',
+    '\u00FB',
+    '\u00F9',
+    '\u00FF',
+    '\u00D6',
+    '\u00DC',
+    '\u00F8',
+    '\u00A3',
+    '\u00D8',
+    '\u00D7',
+    '\u0192',
+    '\u00E1',
+    '\u00ED',
+    '\u00F3',
+    '\u00FA',
+    '\u00F1',
+    '\u00D1',
+    '\u00AA',
+    '\u00BA',
+    '\u00BF',
+    '\u00AE',
+    '\u00AC',
+    '\u00BD',
+    '\u00BC',
+    '\u00A1',
+    '\u00AB',
+    '\u00BB',
+    '_',
+    '_',
+    '_',
+    '\u00A6',
+    '\u00A6',
+    '\u00C1',
+    '\u00C2',
+    '\u00C0',
+    '\u00A9',
+    '\u00A6',
+    '\u00A6',
+    '+',
+    '+',
+    '\u00A2',
+    '\u00A5',
+    '+',
+    '+',
+    '-',
+    '-',
+    '+',
+    '-',
+    '+',
+    '\u00E3',
+    '\u00C3',
+    '+',
+    '+',
+    '-',
+    '-',
+    '\u00A6',
+    '-',
+    '+',
+    '\u00A4',
+    '\u00F0',
+    '\u00D0',
+    '\u00CA',
+    '\u00CB',
+    '\u00C8',
+    'i',
+    '\u00CD',
+    '\u00CE',
+    '\u00CF',
+    '+',
+    '+',
+    '_',
+    '_',
+    '\u00A6',
+    '\u00CC',
+    '_',
+    '\u00D3',
+    '\u00DF',
+    '\u00D4',
+    '\u00D2',
+    '\u00F5',
+    '\u00D5',
+    '\u00B5',
+    '\u00FE',
+    '\u00DE',
+    '\u00DA',
+    '\u00DB',
+    '\u00D9',
+    '\u00FD',
+    '\u00DD',
+    '\u00AF',
+    '\u00B4',
+    '\u00AD',
+    '\u00B1',
+    '_',
+    '\u00BE',
+    '\u00B6',
+    '\u00A7',
+    '\u00F7',
+    '\u00B8',
+    '\u00B0',
+    '\u00A8',
+    '\u00B7',
+    '\u00B9',
+    '\u00B3',
+    '\u00B2',
+    '_',
+    ' ',
+  ];
+
+  public static str2byte(
+    str: string,
+    buf: Buffer,
+    offset = 0,
+    length = str.length,
+  ): number {
+    for (let i = 0; i < length; i++) {
+      let charCode = str.charCodeAt(i);
+      if (charCode > 0x7f) {
+        // Check if extended ASCII.
+        const charIdx = ExtendedASCII.extendedChars.indexOf(str.charAt(i));
+        if (charIdx > -1) {
+          charCode = charIdx + 0x80;
+        }
+        // Otherwise, keep it as-is.
+      }
+      buf.writeUInt8(charCode, offset + i);
+    }
+    return length;
+  }
+
+  public static byte2str(buff: Buffer): string {
+    const chars = new Array(buff.length);
+    for (let i = 0; i < buff.length; i++) {
+      const charCode = buff[i];
+      if (charCode > 0x7f) {
+        chars[i] = ExtendedASCII.extendedChars[charCode - 128];
+      } else {
+        chars[i] = String.fromCharCode(charCode);
+      }
+    }
+    return chars.filter((o) => o.charCodeAt(0)).join('');
+  }
+
+  public static byteLength(str: string): number {
+    return str.length;
+  }
+}

package/src/zcan/accessoryCommandGroup.ts

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

package/src/zcan/dataGroup.ts

@@ -0,0 +1,342 @@
+// 0x07
+import MX10 from '../MX10';
+import {Buffer} from 'buffer';
+import {Subject} from 'rxjs';
+import {
+  RemoveLocomotiveData,
+  DataNameExtended,
+  DataNameValue1,
+  GroupCountData,
+  ItemFxInfo,
+  ItemImageData,
+  ItemListByIndexData,
+  ItemListByNidData,
+} from '../@types/models';
+import {FxInfoType, ImageType, NameType} from '../util/enums';
+import ExtendedASCII from '../util/extended-ascii';
+
+/**
+ *
+ * @category Groups
+ */
+export default class DataGroup {
+  public readonly onGroupCount = new Subject<GroupCountData>();
+  public readonly onListItemsByIndex = new Subject<ItemListByIndexData>();
+  public readonly onListItemsByNID = new Subject<ItemListByNidData>();
+  public readonly onRemoveLocomotive = new Subject<RemoveLocomotiveData>();
+  public readonly onItemImageConfig = new Subject<ItemImageData>();
+  public readonly onItemFxInfo = new Subject<ItemFxInfo>();
+  public readonly onDataNameExtended = new Subject<DataNameExtended>();
+
+  private mx10: MX10;
+
+  constructor(mx10: MX10) {
+    this.mx10 = mx10;
+  }
+
+  groupCount(objType = 0x0000) {
+    this.mx10.sendData(
+      0x07,
+      0x00,
+      [
+        {value: this.mx10.mx10NID, length: 2},
+        {value: objType, length: 2},
+      ],
+      0b00,
+    );
+  }
+
+  listItemsByIndex(groupNID: number, index: number) {
+    this.mx10.sendData(
+      0x07,
+      0x01,
+      [
+        {value: this.mx10.mx10NID, length: 2},
+        {value: groupNID, length: 2},
+        {value: index, length: 2},
+      ],
+      0b00,
+    );
+  }
+
+  listItemsByNID(searchAfterValue: number) {
+    this.mx10.sendData(
+      0x07,
+      0x02,
+      [
+        {value: this.mx10.mx10NID, length: 2},
+        {value: searchAfterValue, length: 2},
+      ],
+      0b00,
+    );
+  }
+
+  removeLocomotive(toRemove: number, removeFrom = this.mx10.mx10NID) {
+    this.mx10.sendData(0x07, 0x1f, [
+      {value: removeFrom, length: 2},
+      {value: toRemove, length: 2},
+    ]);
+  }
+
+  itemImageConfig(nid: number, type: ImageType, imageId: number) {
+    this.mx10.sendData(0x07, 0x12, [
+      {value: nid, length: 2},
+      {value: type, length: 2},
+      {value: imageId, length: 2},
+    ]);
+  }
+
+  itemFxInfo(nid: number, fx: number, type: FxInfoType, data: number) {
+    this.mx10.sendData(0x07, 0x15, [
+      {value: nid, length: 2},
+      {value: fx, length: 2},
+      {value: 0, length: 1},
+      {value: type, length: 1},
+      {value: data, length: 2},
+    ]);
+  }
+
+  dataNameExtended(NID: number, subID: number, name: string) {
+    this.mx10.sendData(
+      0x07,
+      0x21,
+      [
+        {value: NID, length: 2},
+        {value: subID, length: 2},
+        {value: 0, length: 4},
+        {value: 0, length: 4},
+        {value: name, length: name.length},
+        {value: 0, length: 1},
+      ],
+      0b01,
+    );
+  }
+
+  parse(
+    size: number,
+    command: number,
+    mode: number,
+    nid: number,
+    buffer: Buffer,
+  ) {
+    switch (command) {
+      case 0x00:
+        this.parseGroupCount(size, mode, nid, buffer);
+        break;
+      case 0x01:
+        this.parseItemListByIndex(size, mode, nid, buffer);
+        break;
+      case 0x02:
+        this.parseItemListByNid(size, mode, nid, buffer);
+        break;
+      case 0x12:
+        this.parseItemImageConfig(size, mode, nid, buffer);
+        break;
+      case 0x15:
+        this.parseItemFxInfo(size, mode, nid, buffer);
+        break;
+      case 0x1f:
+        this.parseDataClear(size, mode, nid, buffer);
+        break;
+      case 0x21:
+        this.parseDataNameExtended(size, mode, nid, buffer);
+        break;
+      default:
+        // eslint-disable-next-line no-console
+        console.warn('command not parsed: ' + command.toString());
+    }
+  }
+
+  // 0x07.0x00
+  private parseGroupCount(
+    size: number,
+    mode: number,
+    nid: number,
+    buffer: Buffer,
+  ) {
+    if (this.onGroupCount.observed) {
+      const objectType = buffer.readUInt16LE(0);
+      const number = buffer.readUInt16LE(2);
+
+      this.onGroupCount.next({
+        objectType,
+        number,
+      });
+    }
+  }
+
+  // 0x07.0x01
+  private parseItemListByIndex(
+    size: number,
+    mode: number,
+    nid: number,
+    buffer: Buffer,
+  ) {
+    if (this.onListItemsByIndex.observed) {
+      const index = buffer.readUInt16LE(0);
+      const deviceNID = buffer.readUInt16LE(2);
+      const msSinceLastCommunication = buffer.readUInt16LE(4);
+      if (deviceNID) {
+        this.onListItemsByIndex.next({
+          index,
+          nid: deviceNID,
+          msSinceLastCommunication,
+        });
+      }
+    }
+  }
+
+  // 0x07.0x02
+  private parseItemListByNid(
+    size: number,
+    mode: number,
+    nid: number,
+    buffer: Buffer,
+  ) {
+    if (this.onListItemsByNID.observed) {
+      const NID = buffer.readUInt16LE(0);
+      const index = buffer.readUInt16LE(2);
+      const itemState = buffer.readUInt16LE(4);
+      const lastTick = buffer.readUInt16LE(6);
+
+      this.onListItemsByNID.next({
+        nid: NID,
+        index,
+        itemState,
+        lastTick,
+      });
+    }
+  }
+
+  // 0x07.0x04
+  private parseDataClear(
+    size: number,
+    mode: number,
+    nid: number,
+    buffer: Buffer,
+  ) {
+    if (this.onRemoveLocomotive.observed) {
+      const NID = buffer.readUInt16LE(0);
+      const state = buffer.readUInt16LE(2);
+
+      this.onRemoveLocomotive.next({
+        nid: NID,
+        state: state,
+      });
+    }
+  }
+
+  // 0x07.0x12
+  private parseItemImageConfig(
+    size: number,
+    mode: number,
+    nid: number,
+    buffer: Buffer,
+  ) {
+    if (this.onItemImageConfig.observed) {
+      const NID = buffer.readUInt16LE(0);
+      const type = buffer.readUInt16LE(2);
+      const imageId = buffer.readUInt16LE(4);
+
+      this.onItemImageConfig.next({
+        nid: NID,
+        type,
+        imageId,
+      });
+    }
+  }
+
+  private parseItemFxInfo(
+    size: number,
+    mode: number,
+    nid: number,
+    buffer: Buffer,
+  ) {
+    if (this.onItemFxInfo.observed) {
+      const NID = buffer.readUInt16LE(0);
+      const fx = buffer.readUInt16LE(2);
+      // const base = buffer.readUInt8(4);
+      const type = buffer.readUInt8(5);
+      const data = buffer.readUInt16LE(6);
+
+      this.onItemFxInfo.next({
+        nid: NID,
+        function: fx,
+        type,
+        data,
+      });
+    }
+  }
+
+  // 0x07.0x21
+  private parseDataNameExtended(
+    size: number,
+    mode: number,
+    nid: number,
+    buffer: Buffer,
+  ) {
+    if (this.onDataNameExtended.observed) {
+      const NID = buffer.readUInt16LE(0);
+      const subID = buffer.readUInt16LE(2);
+      const name = ExtendedASCII.byte2str(buffer.subarray(12, 203));
+
+      let value1: DataNameValue1 | undefined;
+      const value2 = buffer.readUInt32LE(8);
+      let type: NameType;
+
+      switch (NID) {
+        case 0x7f00:
+          type = NameType.MANUFACTURER;
+          break;
+        case 0x7f02:
+          type = NameType.DECODER;
+          break;
+        case 0x7f04:
+          type = NameType.DESIGNATION;
+          value1 = {
+            type: buffer.subarray(4).toString('ascii').trim(),
+            cfgNum: parseInt(buffer.subarray(5, 7).toString('ascii')),
+          };
+          break;
+        case 0x7f06:
+          type = NameType.CFGDB;
+          break;
+        case 0x7f10:
+          type = NameType.ICON;
+          break;
+        case 0x7f11:
+          type = NameType.ICON;
+          break;
+        case 0x7f18:
+          type = NameType.ZIMO_PARTNER;
+          break;
+        case 0x7f20:
+          type = NameType.LAND;
+          break;
+        case 0x7f21:
+          type = NameType.COMPANY_CV;
+          break;
+        case 0xc2:
+          type = NameType.CONNECTION;
+          break;
+        default:
+          if (subID == 1) {
+            type = NameType.COMPANY_CV;
+          } else if (subID == 0) {
+            type = NameType.VEHICLE;
+          } else {
+            type = NameType.CONNECTION;
+          }
+      }
+
+      this.onDataNameExtended.next({
+        nid: NID,
+        type,
+        subID,
+        value1,
+        value2,
+        name,
+      });
+    }
+  }
+}

package/src/zcan/fileControlGroup.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 FileControlGroup {
+  private mx10: MX10;
+
+  constructor(mx10: MX10) {
+    this.mx10 = mx10;
+  }
+
+  parse(
+    size: number,
+    command: number,
+    mode: number,
+    nid: number,
+    buffer: Buffer,
+  ) {
+    // console.log('parse file control group');
+  }
+}

package/src/zcan/fileTransferGroup.ts

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

package/src/zcan/index.ts

@@ -0,0 +1,37 @@
+import LanNetworkGroup from './lanNetworkGroup';
+import NetworkGroup from './networkGroup';
+import VehicleGroup from './vehicleGroup';
+import SystemControlGroup from './systemControlGroup';
+import AccessoryCommandGroup from './accessoryCommandGroup';
+import TrainControlGroup from './trainControlGroup';
+import TrackCfgGroup from './trackCfgGroup';
+import DataGroup from './dataGroup';
+import InfoGroup from './infoGroup';
+import PropertyConfigGroup from './propertyConfigGroup';
+import RailwayControlGroup from './railwayControlGroup';
+import ZimoProgrammableScriptGroup from './zimoProgrammableScriptGroup';
+import FileControlGroup from './fileControlGroup';
+import FileTransferGroup from './fileTransferGroup';
+import LanZimoProgrammableScriptGroup from './lanZimoProgrammableScriptGroup';
+import LanInfoGroup from './lanInfoGroup';
+import LanDataGroup from './lanDataGroup';
+
+export {
+  LanNetworkGroup,
+  NetworkGroup,
+  VehicleGroup,
+  SystemControlGroup,
+  AccessoryCommandGroup,
+  TrainControlGroup,
+  TrackCfgGroup,
+  DataGroup,
+  InfoGroup,
+  PropertyConfigGroup,
+  RailwayControlGroup,
+  ZimoProgrammableScriptGroup,
+  FileControlGroup,
+  FileTransferGroup,
+  LanZimoProgrammableScriptGroup,
+  LanInfoGroup,
+  LanDataGroup,
+};

package/src/zcan/infoGroup.ts

@@ -0,0 +1,90 @@
+import {Buffer} from 'buffer';
+import MX10 from '../MX10';
+import {Subject} from 'rxjs';
+import {BidiInfoData, BidiDirectionData} from '../@types/models';
+import {BidiType, Direction, ForwardOrReverse} from '../util/enums';
+
+/**
+ *
+ * @category Groups
+ */
+export default class InfoGroup {
+  private mx10: MX10;
+
+  public readonly onBidiInfoChange = new Subject<BidiInfoData>();
+
+  constructor(mx10: MX10) {
+    this.mx10 = mx10;
+  }
+
+  parse(
+    size: number,
+    command: number,
+    mode: number,
+    nid: number,
+    buffer: Buffer,
+  ) {
+    switch (command) {
+      case 0x05:
+        this.parseBidiInfo(size, mode, nid, buffer);
+        break;
+      default:
+        // eslint-disable-next-line no-console
+        console.log('command not parsed: ' + command.toString());
+    }
+  }
+
+  private parseBidiInfo(
+    size: number,
+    mode: number,
+    nid: number,
+    buffer: Buffer,
+  ) {
+    if (this.onBidiInfoChange.observed) {
+      const NID = buffer.readUInt16LE(0);
+      const type = buffer.readUInt16LE(2);
+      const info = buffer.readUInt32LE(4);
+
+      let data: BidiDirectionData | number = {};
+      switch (type) {
+        case BidiType.DIRECTION:
+          data.direction = this.parseEastWest(info);
+          data.directionChange = this.parseDirChange(info);
+          data.directionConfirm = this.parseDirectionConfirm(info);
+          data.forwardOrReverse = this.parseFwdRev(info);
+          break;
+        default:
+          data = info;
+      }
+
+      this.onBidiInfoChange.next({
+        nid: NID,
+        type,
+        data,
+      });
+    }
+  }
+
+  private parseEastWest(data: number) {
+    if ((data & 0x02) == 0x02) {
+      return Direction.EAST;
+    } else {
+      return Direction.WEST;
+    }
+  }
+
+  private parseDirChange(data: number) {
+    return (data & 0x04) == 0x04;
+  }
+
+  private parseFwdRev(data: number) {
+    if ((data & 0x01) == 0) {
+      return ForwardOrReverse.REVERSE;
+    } else {
+      return ForwardOrReverse.FORWARD;
+    }
+  }
+  private parseDirectionConfirm(data: number) {
+    return (data & 0x08) == 0x08;
+  }
+}