motion-master-client 0.0.21 → 0.0.22

package/package.json

@@ -1,21 +1,6 @@
 {
   "name": "motion-master-client",
-  "version": "0.0.21",
+  "version": "0.0.22",
   "type": "commonjs",
-  "description": "A library and CLI program used for communicating with Motion Master.",
-  "dependencies": {
-    "fast-deep-equal": "^3.1.3",
-    "lodash": "^4.17.21",
-    "papaparse": "^5.4.1",
-    "protobufjs": "^7.2.3",
-    "roarr": "^7.15.0",
-    "rxjs": "^7.8.1",
-    "semver": "7.4.0",
-    "uuid": "^9.0.0"
-  },
-  "peerDependencies": {
-    "tslib": "2.5.2"
-  },
-  "main": "./src/index.js",
-  "types": "./src/index.d.ts"
+  "description": "A library and CLI program used for communicating with Motion Master."
 }

package/project.json

@@ -0,0 +1,45 @@
+{
+  "name": "motion-master-client",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/motion-master-client/src",
+  "projectType": "library",
+  "targets": {
+    "build": {
+      "executor": "@nrwl/js:tsc",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/libs/motion-master-client",
+        "main": "libs/motion-master-client/src/index.ts",
+        "tsConfig": "libs/motion-master-client/tsconfig.lib.json",
+        "assets": [
+          "libs/motion-master-client/*.md",
+          "libs/motion-master-client/src/lib/motion-master.proto.js",
+          "libs/motion-master-client/src/lib/motion-master.proto.d.ts"
+        ]
+      }
+    },
+    "publish": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "node tools/scripts/publish.mjs motion-master-client {args.ver} {args.tag}"
+      },
+      "dependsOn": ["build"]
+    },
+    "lint": {
+      "executor": "@nx/linter:eslint",
+      "outputs": ["{options.outputFile}"],
+      "options": {
+        "lintFilePatterns": ["libs/motion-master-client/**/*.ts"]
+      }
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/libs/motion-master-client"],
+      "options": {
+        "jestConfig": "libs/motion-master-client/jest.config.ts",
+        "passWithNoTests": true
+      }
+    }
+  },
+  "tags": []
+}

package/src/lib/cia402.spec.ts

@@ -0,0 +1,77 @@
+import { Cia402State, ControlwordCommand, createControlwordCommand, getCia402State, getCommandFromControlword } from "./cia402";
+
+describe('cia402', () => {
+  describe('getControlwordState', () => {
+    test.each([
+      [0b0000110, ControlwordCommand.SHUTDOWN],
+      [0b0001110, ControlwordCommand.SHUTDOWN],
+      [0b0000111, ControlwordCommand.SWITCH_ON],
+      [0b0001111, ControlwordCommand.SWITCH_ON_ENABLE_OPERATION],
+      [0b0000000, ControlwordCommand.DISABLE_VOLTAGE],
+      [0b0000001, ControlwordCommand.DISABLE_VOLTAGE],
+      [0b0001100, ControlwordCommand.DISABLE_VOLTAGE],
+      [0b0001101, ControlwordCommand.DISABLE_VOLTAGE],
+      [0b0000010, ControlwordCommand.QUICK_STOP],
+      [0b0000011, ControlwordCommand.QUICK_STOP],
+      [0b0001010, ControlwordCommand.QUICK_STOP],
+      [0b0001011, ControlwordCommand.QUICK_STOP],
+      // [0b0000111, ControlwordCommand.DISABLE_OPERATION], // NOTE: never returned, same as SWITCH_ON, depends on transition
+      // [0b0001111, ControlwordCommand.ENABLE_OPERATION], // NOTE: never returned, same as SWITCH_ON_ENABLE_OPERATION, depends on transition
+      [0b1000000, ControlwordCommand.FAULT_RESET],
+      [0b1001111, ControlwordCommand.FAULT_RESET],
+      [0b1001001, ControlwordCommand.FAULT_RESET],
+    ])('for the value %d it should return the correct controlword state %d', (controlword, expected) => {
+      expect(getCommandFromControlword(controlword)).toBe(expected);
+    });
+  });
+
+  describe('getStatuswordState', () => {
+    test.each([
+      [0b0000000, Cia402State.NOT_READY_TO_SWITCH_ON],
+      [0b0110000, Cia402State.NOT_READY_TO_SWITCH_ON],
+      [0b0010000, Cia402State.NOT_READY_TO_SWITCH_ON],
+      [0b1000000, Cia402State.SWITCH_ON_DISABLED],
+      [0b1110000, Cia402State.SWITCH_ON_DISABLED],
+      [0b0100001, Cia402State.READY_TO_SWITCH_ON],
+      [0b0110001, Cia402State.READY_TO_SWITCH_ON],
+      [0b0100011, Cia402State.SWITCHED_ON],
+      [0b0110011, Cia402State.SWITCHED_ON],
+      [0b0100111, Cia402State.OPERATION_ENABLED],
+      [0b0110111, Cia402State.OPERATION_ENABLED],
+      [0b0000111, Cia402State.QUICK_STOP_ACTIVE],
+      [0b0010111, Cia402State.QUICK_STOP_ACTIVE],
+      [0b0001111, Cia402State.FAULT_REACTION_ACTIVE],
+      [0b0111111, Cia402State.FAULT_REACTION_ACTIVE],
+      [0b0001000, Cia402State.FAULT],
+      [0b0111000, Cia402State.FAULT],
+    ])('for the value %d it should return the correct statusword state %d', (value, expected) => {
+      expect(getCia402State(value)).toBe(expected);
+    });
+  });
+
+  describe('createControlwordCommand', () => {
+    test.each([
+      [0b0000000000000000, ControlwordCommand.SHUTDOWN, 0b0000000000000110],
+      [0b0000000000001000, ControlwordCommand.SHUTDOWN, 0b0000000000001110],
+      [0b0000000010000000, ControlwordCommand.SHUTDOWN, 0b0000000000000110],
+      [0b1011000010000000, ControlwordCommand.SHUTDOWN, 0b1011000000000110],
+      [0b0000000000000000, ControlwordCommand.SWITCH_ON, 0b0000000000000111],
+      [0b1100000010000000, ControlwordCommand.SWITCH_ON, 0b1100000000000111],
+      [0b0000000000000000, ControlwordCommand.SWITCH_ON_ENABLE_OPERATION, 0b0000000000001111],
+      [0b1100000010000000, ControlwordCommand.SWITCH_ON_ENABLE_OPERATION, 0b1100000000001111],
+      [0b0000000000000000, ControlwordCommand.DISABLE_VOLTAGE, 0b0000000000000000],
+      [0b0000000010000010, ControlwordCommand.DISABLE_VOLTAGE, 0b0000000000000000],
+      [0b0100000000001111, ControlwordCommand.DISABLE_VOLTAGE, 0b0100000000001101],
+      [0b0000000000000000, ControlwordCommand.QUICK_STOP, 0b0000000000000010],
+      [0b1100000010001101, ControlwordCommand.QUICK_STOP, 0b1100000000001011],
+      [0b0000000000000000, ControlwordCommand.DISABLE_OPERATION, 0b0000000000000111],
+      [0b1100000010000000, ControlwordCommand.DISABLE_OPERATION, 0b1100000000000111],
+      [0b0000000000000000, ControlwordCommand.ENABLE_OPERATION, 0b0000000000001111],
+      [0b1100000010000000, ControlwordCommand.ENABLE_OPERATION, 0b1100000000001111],
+      [0b0000000000000000, ControlwordCommand.FAULT_RESET, 0b0000000010000000],
+      [0b1110000000000111, ControlwordCommand.FAULT_RESET, 0b1110000010000111],
+    ])('for the value %d and command %s it should create controlword %d', (value, state, expected) => {
+      expect(createControlwordCommand(value, state)).toBe(expected);
+    });
+  });
+});

package/src/lib/cia402.ts

@@ -0,0 +1,414 @@
+export const statuswordBits = [
+  'rtso = ready to switch on',
+  'so = switched on',
+  'oe = operation enabled',
+  'f = fault',
+  've = voltage enabled',
+  'qs = quick stop',
+  'sod = switch on disabled',
+  'w = warning',
+  'ms = manufacturer-specific',
+  'rm = remote',
+  'tr = target reached',
+  'ila = internal limit active',
+  'oms = operation-mode-specific',
+  'oms = operation-mode-specific',
+  'ms = manufacturer-specific',
+  'ms = manufacturer-specific',
+];
+
+/**
+ * CIA402 refers to the CANopen application profile for drives and motion control.
+ * It defines various states that a CiA402-compliant device, such as a motor drive, can be in.
+ *
+ * @enum
+ */
+export enum Cia402State {
+  /**
+   * Not ready to switch on (NRS).
+   *
+   * This is the initial state where the drive is not ready to be switched on.
+   * In this state, the drive is not powered or initialized.
+   */
+  NOT_READY_TO_SWITCH_ON = 'NOT_READY_TO_SWITCH_ON',
+
+  /**
+   * Switch on disabled (SOD).
+   *
+   * In this state, the drive is powered and initialized but cannot be switched on.
+   * This state is usually used for safety purposes or when certain conditions need to be met before enabling the drive.
+   */
+  SWITCH_ON_DISABLED = 'SWITCH_ON_DISABLED',
+
+  /**
+   * Ready to switch on (RTS).
+   *
+   * In this state, the drive is ready to be switched on.
+   * It has been powered and initialized, and it is waiting for the switch-on command.
+   */
+  READY_TO_SWITCH_ON = 'READY_TO_SWITCH_ON',
+
+  /**
+   * Switched on (SWO).
+   *
+   * When the switch-on command is received, the drive enters this state.
+   * In this state, the drive is energized and ready to start motion.
+   */
+  SWITCHED_ON = 'SWITCHED_ON',
+
+  /**
+   * Operation enabled (OP).
+   *
+   * This state indicates that the drive is enabled and ready to perform its intended operation.
+   * It can receive motion commands and execute them.
+   */
+  OPERATION_ENABLED = 'OPERATION_ENABLED',
+
+  /**
+   * Quick stop active (QSA).
+   *
+   * This state is used to bring the drive to an immediate stop.
+   * It is typically triggered by an emergency stop or a quick stop command.
+   */
+  QUICK_STOP_ACTIVE = 'QUICK_STOP_ACTIVE',
+
+  /**
+   * Fault reaction active (FRA).
+   *
+   * When a fault or error condition occurs, the drive enters this state.
+   * It indicates that the drive is responding to the fault by taking appropriate actions,
+   * such as shutting down or entering a safe state.
+   */
+  FAULT_REACTION_ACTIVE = 'FAULT_REACTION_ACTIVE',
+
+  /**
+   * Fault (FLT).
+   *
+   * This state signifies that a fault condition has been detected and the drive is no longer operational.
+   * It requires manual intervention or troubleshooting to resolve the fault
+   * and bring the drive back to a functional state.
+   */
+  FAULT = 'FAULT',
+};
+
+export const cia402StateMap = new Map([
+  [0b00000000, Cia402State.NOT_READY_TO_SWITCH_ON],
+  [0b01000000, Cia402State.SWITCH_ON_DISABLED],
+  [0b00100001, Cia402State.READY_TO_SWITCH_ON],
+  [0b00100011, Cia402State.SWITCHED_ON],
+  [0b00100111, Cia402State.OPERATION_ENABLED],
+  [0b00000111, Cia402State.QUICK_STOP_ACTIVE],
+  [0b00001111, Cia402State.FAULT_REACTION_ACTIVE],
+  [0b00001000, Cia402State.FAULT],
+]);
+
+export function getCia402State(value: number) {
+  return (cia402StateMap.get(value & 0b01101111)
+    ?? cia402StateMap.get(value & 0b01001111)) ?? Cia402State.NOT_READY_TO_SWITCH_ON;
+}
+
+export function isInternalLimitActive(statusword: number) {
+  return (0x800 & statusword) === 0x800;
+}
+
+export const controlwordBits = [
+  'so = switch on',
+  'ev = enable voltage',
+  'qs = quick stop',
+  'eo = enable operation',
+  'oms = operation mode specific',
+  'oms = operation mode specific',
+  'oms = operation mode specific',
+  'fr = fault reset',
+  'h = halt',
+  'oms = operation mode specific',
+  'r = reserved',
+  'ms = manufacturer-specific',
+  'ms = manufacturer-specific',
+  'ms = manufacturer-specific',
+  'ms = manufacturer-specific',
+  'ms = manufacturer-specific',
+];
+
+/**
+ * In the CiA402 standard for drives and motion control, the controlword is a key component
+ * used to command and control the operation of a CiA402-compliant device, such as a motor drive.
+ * The controlword is typically a 16-bit value,
+ * and it consists of several bits that represent different control commands.
+ *
+ * @enum
+ */
+export enum ControlwordCommand {
+  SHUTDOWN = 'SHUTDOWN',
+  SWITCH_ON = 'SWITCH_ON',
+  SWITCH_ON_ENABLE_OPERATION = 'SWITCH_ON_ENABLE_OPERATION',
+  DISABLE_VOLTAGE = 'DISABLE_VOLTAGE',
+
+  /**
+   * Quick Stop.
+   *
+   * This command initiates a quick stop of the drive.
+   * When this bit is set to 1, the drive enters the "Quick stop active" state,
+   * causing the motor to decelerate and come to a stop as quickly as possible.
+   */
+  QUICK_STOP = 'QUICK_STOP',
+
+  DISABLE_OPERATION = 'DISABLE_OPERATION',
+
+  /**
+   * Enable Operation.
+   *
+   * This command enables the drive to perform its intended operation.
+   * When this bit is set to 1, the drive transitions from the "Ready to switch on" state to the "Operation enabled" state.
+   */
+  ENABLE_OPERATION = 'ENABLE_OPERATION',
+
+  /**
+   * Fault Reset.
+   *
+   * This command resets a fault condition and clears any fault flags or errors that may have occurred.
+   * When this bit is set to 1, the drive attempts to recover from a fault and return to an operational state.
+   */
+  FAULT_RESET = 'FAULT_RESET',
+}
+
+/**
+ * Return one of the controlword commands based its value.
+ *
+ * NOTE: DISABLE_OPERATION and ENABLE_OPERATION are never returned.
+ * Their values are the same as SWITCH_ON and SWITCH_ON_ENABLE_OPERATION.
+ * What controlword is commanded depends on the transition.
+ */
+export function getCommandFromControlword(value: number) {
+  if ((value & 0b1000111) === 0b0000110) {
+    return ControlwordCommand.SHUTDOWN;
+  }
+
+  if ((value & 0b1001111) === 0b0000111) {
+    return ControlwordCommand.SWITCH_ON;
+  }
+
+  if ((value & 0b1001111) === 0b0001111) {
+    return ControlwordCommand.SWITCH_ON_ENABLE_OPERATION;
+  }
+
+  if ((value & 0b1000010) === 0b0000000) {
+    return ControlwordCommand.DISABLE_VOLTAGE;
+  }
+
+  if ((value & 0b1000110) === 0b0000010) {
+    return ControlwordCommand.QUICK_STOP;
+  }
+
+  if ((value & 0b1001111) === 0b0000111) {
+    return ControlwordCommand.DISABLE_OPERATION;
+  }
+
+  if ((value & 0b1001111) === 0b0001111) {
+    return ControlwordCommand.ENABLE_OPERATION;
+  }
+
+  if ((value & 0b1000000) === 0b1000000) {
+    return ControlwordCommand.FAULT_RESET;
+  }
+
+  return;
+}
+
+export const controlwordOptions = {
+  'Shutdown': 0b00000110, // transitions 2, 6, 8
+  'Switch on': 0b00000111, // transitions 3
+  'Switch on + enable operation': 0b00001111, // transitions 3 + 4, automatic transition to Enable Operation state after executing SWITCHED ON state functionality
+  'Disable voltage': 0b00000000, // transitions 7, 9, 10, 12
+  'Quick stop': 0b00000010, // transitions 7, 10, 11
+  'Disable operation': 0b00000111, // transitions 5
+  'Enable operation': 0b00001111, // transitions 4, 16
+  'Fault reset': 0b10000000, // fault reset 15
+};
+
+export const controlwordCommandOptions = Object.values(ControlwordCommand);
+
+export const controlwordCommandBitmasks = {
+  [ControlwordCommand.SHUTDOWN]: [
+    0b1111111101111110,
+    0b0000000000000110,
+  ],
+  [ControlwordCommand.SWITCH_ON]: [
+    0b1111111101110111,
+    0b0000000000000111,
+  ],
+  [ControlwordCommand.SWITCH_ON_ENABLE_OPERATION]: [
+    0b1111111101111111,
+    0b0000000000001111,
+  ],
+  [ControlwordCommand.DISABLE_VOLTAGE]: [
+    0b1111111101111101,
+    0b0000000000000000,
+  ],
+  [ControlwordCommand.QUICK_STOP]: [
+    0b1111111101111011,
+    0b0000000000000010,
+  ],
+  [ControlwordCommand.DISABLE_OPERATION]: [
+    0b1111111101110111,
+    0b0000000000000111,
+  ],
+  [ControlwordCommand.ENABLE_OPERATION]: [
+    0b1111111101111111,
+    0b0000000000001111,
+  ],
+  [ControlwordCommand.FAULT_RESET]: [
+    0b1111111111111111,
+    0b0000000010000000,
+  ],
+};
+
+export function createControlwordCommand(value: number, command: ControlwordCommand) {
+  const bitmasks = controlwordCommandBitmasks[command];
+  return ((value & bitmasks[0]) | bitmasks[1]);
+}
+
+/**
+ * CiA402 transitions.
+ *
+ * List of allowed transitions with controlword command.
+ *
+ * The following transitions are automatic:
+ * - 0: START -> NOT_READY_TO_SWITCH_ON
+ * - 1: NOT_READY_TO_SWITCH_ON -> SWITCH_ON_DISABLED
+ * - 13: ANY -> FAULT_REACTION_ACTIVE
+ * - 14: FAULT_REACTION_ACTIVE -> FAULT
+ */
+export const cia402Transitions = [
+  {
+    from: Cia402State.SWITCH_ON_DISABLED,
+    to: Cia402State.READY_TO_SWITCH_ON,
+    transitions: [2],
+    command: ControlwordCommand.SHUTDOWN,
+  },
+  {
+    from: Cia402State.READY_TO_SWITCH_ON,
+    to: Cia402State.SWITCHED_ON,
+    transitions: [3],
+    command: ControlwordCommand.SWITCH_ON,
+  },
+  {
+    from: Cia402State.READY_TO_SWITCH_ON,
+    to: Cia402State.OPERATION_ENABLED,
+    transitions: [3, 4],
+    command: ControlwordCommand.SWITCH_ON_ENABLE_OPERATION,
+  },
+  {
+    from: Cia402State.SWITCHED_ON,
+    to: Cia402State.OPERATION_ENABLED,
+    transitions: [4],
+    command: ControlwordCommand.ENABLE_OPERATION,
+  },
+  {
+    from: Cia402State.OPERATION_ENABLED,
+    to: Cia402State.SWITCHED_ON,
+    transitions: [5],
+    command: ControlwordCommand.DISABLE_OPERATION,
+  },
+  {
+    from: Cia402State.SWITCHED_ON,
+    to: Cia402State.READY_TO_SWITCH_ON,
+    transitions: [6],
+    command: ControlwordCommand.SHUTDOWN,
+  },
+  {
+    from: Cia402State.READY_TO_SWITCH_ON,
+    to: Cia402State.SWITCH_ON_DISABLED,
+    transitions: [7],
+    command: ControlwordCommand.DISABLE_VOLTAGE,
+  },
+  {
+    from: Cia402State.OPERATION_ENABLED,
+    to: Cia402State.READY_TO_SWITCH_ON,
+    transitions: [8],
+    command: ControlwordCommand.SHUTDOWN,
+  },
+  {
+    from: Cia402State.OPERATION_ENABLED,
+    to: Cia402State.SWITCH_ON_DISABLED,
+    transitions: [9],
+    command: ControlwordCommand.DISABLE_VOLTAGE,
+  },
+  {
+    from: Cia402State.SWITCHED_ON,
+    to: Cia402State.SWITCH_ON_DISABLED,
+    transitions: [10],
+    command: ControlwordCommand.DISABLE_VOLTAGE,
+  },
+  {
+    from: Cia402State.OPERATION_ENABLED,
+    to: Cia402State.QUICK_STOP_ACTIVE,
+    transitions: [11],
+    command: ControlwordCommand.QUICK_STOP,
+  },
+  {
+    from: Cia402State.QUICK_STOP_ACTIVE,
+    to: Cia402State.SWITCH_ON_DISABLED,
+    transitions: [12],
+    command: ControlwordCommand.DISABLE_VOLTAGE,
+  },
+  {
+    from: Cia402State.FAULT,
+    to: Cia402State.SWITCH_ON_DISABLED,
+    transitions: [15],
+    command: ControlwordCommand.FAULT_RESET,
+  },
+  {
+    from: Cia402State.QUICK_STOP_ACTIVE,
+    to: Cia402State.OPERATION_ENABLED,
+    transitions: [16],
+    command: ControlwordCommand.ENABLE_OPERATION,
+  },
+];
+
+export enum ModesOfOperation {
+  OPEN_LOOP_FIELD_MODE = -3,
+  DIAGNOSTICS_MODE = -2,
+  COGGING_COMPENSATION_RECORDING_MODE = -1,
+  NO_MODE_ASSIGNED = 0,
+  PROFILE_POSITION_MODE = 1,
+  PROFILE_VELOCITY_MODE = 3,
+  TORQUE_PROFILE_MODE = 4,
+  HOMING_MODE = 6,
+  CYCLIC_SYNC_POSITION_MODE = 8,
+  CYCLIC_SYNC_VELOCITY_MODE = 9,
+  CYCLIC_SYNC_TORQUE_MODE = 10,
+}
+
+export const modesOfOperationOptions = {
+  'Open loop field mode': ModesOfOperation.OPEN_LOOP_FIELD_MODE,
+  'Diagnostics mode': ModesOfOperation.DIAGNOSTICS_MODE,
+  'Cogging compensation recording mode': ModesOfOperation.COGGING_COMPENSATION_RECORDING_MODE,
+  'No mode assigned': ModesOfOperation.NO_MODE_ASSIGNED,
+  'Profile position mode': ModesOfOperation.PROFILE_POSITION_MODE,
+  'Profile velocity mode': ModesOfOperation.PROFILE_VELOCITY_MODE,
+  'Torque profile mode': ModesOfOperation.TORQUE_PROFILE_MODE,
+  'Homing mode': ModesOfOperation.HOMING_MODE,
+  'Cyclic synchronous position mode': ModesOfOperation.CYCLIC_SYNC_POSITION_MODE,
+  'Cyclic synchronous velocity mode': ModesOfOperation.CYCLIC_SYNC_VELOCITY_MODE,
+  'Cyclic synchronous torque mode': ModesOfOperation.CYCLIC_SYNC_TORQUE_MODE,
+};
+
+export const supportedDriveModesBits = [
+  'pp = profile position mode',
+  'vl = velocity mode',
+  'pv = profile velocity mode',
+  'tq = torque mode',
+  'r = reserved',
+  'hm = homing mode',
+  'ip = interpolated position mode',
+  'csp = cyclic synchronous position mode',
+  'csv = cyclic synchronous velocity mode',
+  'cst = cyclic synchronous torque mode',
+  'r = reserved',
+  'r = reserved',
+  'r = reserved',
+  'r = reserved',
+  'r = reserved',
+  'r = reserved',
+];

package/src/lib/config-file.spec.ts

@@ -0,0 +1,114 @@
+import { ConfigFile } from './config-file';
+
+const content = `META,FORMAT,2
+# 8502-03
+# v5.1.0-rc.4
+0x2001,  0, 2969
+0x2002,  0, 2
+0x2003,  1, 4
+0x2003,  2, 100000
+0x2003,  3, 250000
+0x2003,  4, 300
+0x2213,  1, 0
+0x2213,  2, 0
+0x2213,  3, 0
+0x2214,  1, 1
+0x2003,  5, 1
+0x6080,  0, 3750000
+0x6081,  0, 20000
+0x6083,  0, 30000
+0x2004,  1, 0
+0x2004,  2, 0
+0x2004,  3, 0
+0x2004,  4, 0
+0x20f2,  0, YOCTO
+0x2004,  5, 100
+0x2004,  6, 20
+0x6092,  1, 4294967295
+0x6092,  2, 1
+0x6098,  0, 0
+0x6099,  1, 0
+`;
+
+const contentNoHeader = `0x2001,  0, 2969
+0x2002,  0, 2
+0x2003,  1, 4
+`;
+
+describe('ConfigFile', () => {
+
+  describe('constructor', () => {
+
+    it('should parse the config file with header', () => {
+      const configFile = new ConfigFile(content);
+
+      expect(configFile.apiId).toBe('8502-03');
+      expect(configFile.firmwareVersion).toBe('v5.1.0-rc.4');
+      expect(configFile.toString()).toBe(`META,FORMAT,2
+# 8502-03
+# v5.1.0-rc.4
+0x2001, 0, 2969
+0x2002, 0, 2
+0x2003, 1, 4
+0x2003, 2, 100000
+0x2003, 3, 250000
+0x2003, 4, 300
+0x2003, 5, 1
+0x2004, 1, 0
+0x2004, 2, 0
+0x2004, 3, 0
+0x2004, 4, 0
+0x2004, 5, 100
+0x2004, 6, 20
+0x20f2, 0, YOCTO
+0x2213, 1, 0
+0x2213, 2, 0
+0x2213, 3, 0
+0x2214, 1, 1
+0x6080, 0, 3750000
+0x6081, 0, 20000
+0x6083, 0, 30000
+0x6092, 1, 4294967295
+0x6092, 2, 1
+0x6098, 0, 0
+0x6099, 1, 0
+`);
+    });
+
+    it('should throw an exception if parse fails', () => {
+      const t = () => {
+        new ConfigFile(`
+asdfasdf
+`);
+      };
+      expect(t).toThrow('Failed to parse the config csv file');
+    });
+
+    it('should parse a config file without header', () => {
+      const configFile = new ConfigFile(contentNoHeader);
+
+      expect(configFile.toString()).toBe(`0x2001, 0, 2969
+0x2002, 0, 2
+0x2003, 1, 4
+`)
+    });
+
+  });
+
+  describe('toString', () => {
+    it('should assemble the config file from changed parameters', () => {
+      const configFile = new ConfigFile(content);
+      configFile.parameters = configFile.parameters.slice(0, 3);
+      configFile.parameters[1].value = 123;
+
+      expect(configFile.toString()).toBe(`META,FORMAT,2
+# 8502-03
+# v5.1.0-rc.4
+0x2001, 0, 2969
+0x2002, 0, 123
+0x2003, 1, 4
+`);
+    });
+  })
+
+});