elero-usb-transmitter-client 1.0.6 → 1.1.2

package/dist/src/cli.js

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var commander_1 = require("commander");
+var inquirer = require("inquirer");
+var UsbTransmitterClient_1 = require("./UsbTransmitterClient");
+var enums_1 = require("./domain/enums");
+var serialport_1 = require("serialport");
+var program = new commander_1.Command();
+var client = null;
+program
+    .version('1.0.0')
+    .option('-p, --port <path>', 'Path to serial port')
+    .parse(process.argv);
+var options = program.opts();
+function main() {
+    return __awaiter(this, void 0, void 0, function () {
+        var portPath, ports, portChoices, answer, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    portPath = options.port;
+                    if (!!portPath) return [3 /*break*/, 3];
+                    return [4 /*yield*/, serialport_1.SerialPort.list()];
+                case 1:
+                    ports = _a.sent();
+                    portChoices = ports.map(function (p) { return ({ name: p.path + " " + (p.manufacturer || ''), value: p.path }); });
+                    if (portChoices.length === 0) {
+                        console.error('No serial ports found. Please specify one with --port.');
+                        process.exit(1);
+                    }
+                    return [4 /*yield*/, inquirer.prompt([
+                            {
+                                type: 'list',
+                                name: 'port',
+                                message: 'Select Serial Port',
+                                choices: portChoices,
+                            },
+                        ])];
+                case 2:
+                    answer = _a.sent();
+                    portPath = answer.port;
+                    _a.label = 3;
+                case 3:
+                    client = new UsbTransmitterClient_1.UsbTransmitterClient(portPath);
+                    _a.label = 4;
+                case 4:
+                    _a.trys.push([4, 7, , 8]);
+                    return [4 /*yield*/, client.open()];
+                case 5:
+                    _a.sent();
+                    console.log("Connected to " + portPath);
+                    return [4 /*yield*/, mainMenu()];
+                case 6:
+                    _a.sent();
+                    return [3 /*break*/, 8];
+                case 7:
+                    error_1 = _a.sent();
+                    console.error('Error connecting to device:', error_1);
+                    process.exit(1);
+                    return [3 /*break*/, 8];
+                case 8: return [2 /*return*/];
+            }
+        });
+    });
+}
+function mainMenu() {
+    return __awaiter(this, void 0, void 0, function () {
+        var answer, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, inquirer.prompt([
+                        {
+                            type: 'list',
+                            name: 'action',
+                            message: 'Main Menu',
+                            choices: [
+                                { name: 'Check Channels', value: 'check' },
+                                { name: 'Select Channel', value: 'select' },
+                                new inquirer.Separator(),
+                                { name: 'Exit', value: 'exit' },
+                            ],
+                        },
+                    ])];
+                case 1:
+                    answer = _b.sent();
+                    _a = answer.action;
+                    switch (_a) {
+                        case 'check': return [3 /*break*/, 2];
+                        case 'select': return [3 /*break*/, 4];
+                        case 'exit': return [3 /*break*/, 6];
+                    }
+                    return [3 /*break*/, 8];
+                case 2: return [4 /*yield*/, checkChannels()];
+                case 3:
+                    _b.sent();
+                    return [3 /*break*/, 8];
+                case 4: return [4 /*yield*/, selectChannel()];
+                case 5:
+                    _b.sent();
+                    return [3 /*break*/, 8];
+                case 6: return [4 /*yield*/, client.close()];
+                case 7:
+                    _b.sent();
+                    process.exit(0);
+                    _b.label = 8;
+                case 8: return [2 /*return*/];
+            }
+        });
+    });
+}
+function checkChannels() {
+    return __awaiter(this, void 0, void 0, function () {
+        var channels, error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    console.log('Checking channels...');
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, client.checkChannels()];
+                case 2:
+                    channels = _a.sent();
+                    console.log('Active Channels:', channels.join(', '));
+                    return [3 /*break*/, 4];
+                case 3:
+                    error_2 = _a.sent();
+                    console.error('Error checking channels:', error_2);
+                    return [3 /*break*/, 4];
+                case 4: return [4 /*yield*/, mainMenu()];
+                case 5:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function selectChannel() {
+    return __awaiter(this, void 0, void 0, function () {
+        var answer, channel;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, inquirer.prompt([
+                        {
+                            type: 'input',
+                            name: 'channel',
+                            message: 'Enter Channel Number (1-9):',
+                            validate: function (input) {
+                                var num = parseInt(input, 10);
+                                if (isNaN(num) || num < 1 || num > 9) {
+                                    return 'Please enter a number between 1 and 9';
+                                }
+                                return true;
+                            },
+                        },
+                    ])];
+                case 1:
+                    answer = _a.sent();
+                    channel = parseInt(answer.channel, 10);
+                    return [4 /*yield*/, channelMenu(channel)];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function channelMenu(channel) {
+    return __awaiter(this, void 0, void 0, function () {
+        var answer, info, cmd, response, error_3;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, inquirer.prompt([
+                        {
+                            type: 'list',
+                            name: 'action',
+                            message: "Channel " + channel + " Actions",
+                            choices: [
+                                { name: 'Get Info', value: 'info' },
+                                { name: 'Move Up', value: 'up' },
+                                { name: 'Move Down', value: 'down' },
+                                { name: 'Stop', value: 'stop' },
+                                new inquirer.Separator(),
+                                { name: 'Back to Main Menu', value: 'back' },
+                            ],
+                        },
+                    ])];
+                case 1:
+                    answer = _a.sent();
+                    if (!(answer.action === 'back')) return [3 /*break*/, 3];
+                    return [4 /*yield*/, mainMenu()];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+                case 3:
+                    _a.trys.push([3, 8, , 9]);
+                    if (!(answer.action === 'info')) return [3 /*break*/, 5];
+                    return [4 /*yield*/, client.getInfo(channel)];
+                case 4:
+                    info = _a.sent();
+                    console.log('Channel Info:', info);
+                    return [3 /*break*/, 7];
+                case 5:
+                    cmd = void 0;
+                    switch (answer.action) {
+                        case 'up':
+                            cmd = enums_1.ControlCommand.up;
+                            break;
+                        case 'down':
+                            cmd = enums_1.ControlCommand.down;
+                            break;
+                        case 'stop':
+                            cmd = enums_1.ControlCommand.stop;
+                            break;
+                        default:
+                            throw new Error('Unknown command');
+                    }
+                    console.log("Sending " + answer.action + " command to channel " + channel + "...");
+                    return [4 /*yield*/, client.sendControlCommand(channel, cmd)];
+                case 6:
+                    response = _a.sent();
+                    console.log('Response:', response);
+                    _a.label = 7;
+                case 7: return [3 /*break*/, 9];
+                case 8:
+                    error_3 = _a.sent();
+                    console.error('Error executing command:', error_3);
+                    return [3 /*break*/, 9];
+                case 9: return [4 /*yield*/, channelMenu(channel)];
+                case 10:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+main().catch(function (err) {
+    console.error('Unexpected error:', err);
+    process.exit(1);
+});

package/jest.json

@@ -2,7 +2,7 @@
     "transform": {
         "^.+\\.(t|j)sx?$": "ts-jest"
     },
-    "testRegex": "(/__tests__/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$",
+    "testRegex": "(/test/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$",
     "testPathIgnorePatterns": [
         "/node_modules/",
         "/dist/"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "elero-usb-transmitter-client",
-  "version": "1.0.6",
+  "version": "1.1.2",
   "description": "",
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
@@ -9,6 +9,10 @@
     "build": "tsc",
     "setup": "npm install"
   },
+  "bin": {
+    "elero-usb-transmitter-client": "./dist/src/cli.js",
+    "elero-cli": "./dist/src/cli.js"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/marc2016/elero-usb-transmitter-client.git"
@@ -20,16 +24,19 @@
   },
   "homepage": "https://github.com/marc2016/elero-usb-transmitter-client#readme",
   "devDependencies": {
+    "@types/inquirer": "^8.2.12",
     "@types/jest": "^24.0.25",
     "@types/lodash": "^4.14.149",
     "@types/node": "^13.1.5",
     "@types/serialport": "^8.0.1",
     "@typescript-eslint/eslint-plugin": "^2.23.0",
     "@typescript-eslint/parser": "^2.23.0",
+    "commander": "^14.0.2",
     "eslint": "^6.8.0",
     "eslint-config-google": "^0.14.0",
     "eslint-config-prettier": "^6.10.1",
     "eslint-plugin-prettier": "^3.1.2",
+    "inquirer": "^8.2.7",
     "jest": "^24.9.0",
     "prettier": "^2.0.2",
     "ts-jest": "^24.2.0",
@@ -40,4 +47,4 @@
     "lodash": "^4.17.15",
     "serialport": "^13.0.0"
   }
-}
+}

package/src/UsbTransmitterClient.ts

@@ -60,20 +60,14 @@ export class UsbTransmitterClient {
   public async checkChannels(): Promise<number[]> {
     const data = [BYTE_HEADER, BYTE_LENGTH_2, EasyCommand.EASY_CHECK]
     const release = await mutex.acquire()
-    await this.sendCommand(data)
-    return new Promise((resolve, reject) => {
-      const that = this
-      this.serialPort.once('readable', function () {
-        const responseBytes = that.readResponseBytes(RESPONSE_LENGTH_CHECK)
-        if (responseBytes == null) {
-          release()
-          return reject('responseBytes are null.')
-        }
-        const response = that.parseResponse(responseBytes as Buffer)
-        release()
-        return resolve(response.activeChannels)
-      })
-    })
+    try {
+      await this.sendCommand(data)
+      const responseBytes = await this.waitForResponse(RESPONSE_LENGTH_CHECK)
+      const response = this.parseResponse(responseBytes)
+      return response.activeChannels
+    } finally {
+      release()
+    }
   }
 
   public async getInfo(channel: number): Promise<Response> {
@@ -88,20 +82,14 @@ export class UsbTransmitterClient {
       lowChannels,
     ]
     const release = await mutex.acquire()
-    await this.sendCommand(data)
-    return new Promise((resolve, reject) => {
-      const that = this
-      this.serialPort.once('readable', function () {
-        const responseBytes = that.readResponseBytes(RESPONSE_LENGTH_INFO)
-        if (responseBytes == null) {
-          release()
-          return reject('responseBytes are null.')
-        }
-        const response = that.parseResponse(responseBytes as Buffer)
-        release()
-        return resolve(response)
-      })
-    })
+    try {
+      await this.sendCommand(data)
+      const responseBytes = await this.waitForResponse(RESPONSE_LENGTH_INFO)
+      const response = this.parseResponse(responseBytes)
+      return response
+    } finally {
+      release()
+    }
   }
 
   public async sendControlCommand(
@@ -120,19 +108,38 @@ export class UsbTransmitterClient {
       controlCommand,
     ]
     const release = await mutex.acquire()
-    await this.sendCommand(data)
+    try {
+      await this.sendCommand(data)
+      const responseBytes = await this.waitForResponse(RESPONSE_LENGTH_INFO)
+      const response = this.parseResponse(responseBytes)
+      return response
+    } finally {
+      release()
+    }
+  }
+
+  private waitForResponse(length: number): Promise<Buffer> {
     return new Promise((resolve, reject) => {
-      const that = this
-      this.serialPort.once('readable', function () {
-        const responseBytes = that.readResponseBytes(RESPONSE_LENGTH_INFO)
-        if (responseBytes == null) {
-          release()
-          return reject('responseBytes are null.')
+      const timeout = setTimeout(() => {
+        cleanup()
+        reject(new Error('Timeout waiting for response'))
+      }, 2000)
+
+      const tryRead = () => {
+        const buffer = this.serialPort.read(length)
+        if (buffer) {
+          cleanup()
+          resolve(buffer)
         }
-        const response = that.parseResponse(responseBytes as Buffer)
-        release()
-        return resolve(response)
-      })
+      }
+
+      const cleanup = () => {
+        clearTimeout(timeout)
+        this.serialPort.removeListener('readable', tryRead)
+      }
+
+      this.serialPort.on('readable', tryRead)
+      tryRead()
     })
   }
 

package/src/cli.ts

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+import { Command } from 'commander'
+import * as inquirer from 'inquirer'
+import { UsbTransmitterClient } from './UsbTransmitterClient'
+import { ControlCommand } from './domain/enums'
+import { SerialPort } from 'serialport'
+
+const program = new Command()
+let client: UsbTransmitterClient | null = null
+
+program
+    .version('1.0.0')
+    .option('-p, --port <path>', 'Path to serial port')
+    .parse(process.argv)
+
+const options = program.opts()
+
+async function main() {
+    let portPath = options.port
+
+    if (!portPath) {
+        const ports = await SerialPort.list()
+        const portChoices = ports.map((p) => ({ name: `${p.path} ${p.manufacturer || ''}`, value: p.path }))
+        
+        if (portChoices.length === 0) {
+            console.error('No serial ports found. Please specify one with --port.')
+            process.exit(1)
+        }
+
+        const answer = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'port',
+                message: 'Select Serial Port',
+                choices: portChoices,
+            },
+        ])
+        portPath = answer.port
+    }
+
+    client = new UsbTransmitterClient(portPath)
+
+    try {
+        await client.open()
+        console.log(`Connected to ${portPath}`)
+        await mainMenu()
+    } catch (error) {
+        console.error('Error connecting to device:', error)
+        process.exit(1)
+    }
+}
+
+async function mainMenu() {
+    const answer = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'action',
+            message: 'Main Menu',
+            choices: [
+                { name: 'Check Channels', value: 'check' },
+                { name: 'Select Channel', value: 'select' },
+                new inquirer.Separator(),
+                { name: 'Exit', value: 'exit' },
+            ],
+        },
+    ])
+
+    switch (answer.action) {
+        case 'check':
+            await checkChannels()
+            break
+        case 'select':
+            await selectChannel()
+            break
+        case 'exit':
+            await client!.close()
+            process.exit(0)
+    }
+}
+
+async function checkChannels() {
+    console.log('Checking channels...')
+    try {
+        const channels = await client!.checkChannels()
+        console.log('Active Channels:', channels.join(', '))
+    } catch (error) {
+        console.error('Error checking channels:', error)
+    }
+    await mainMenu()
+}
+
+async function selectChannel() {
+    const answer = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'channel',
+            message: 'Enter Channel Number (1-9):',
+            validate: (input) => {
+                const num = parseInt(input, 10)
+                if (isNaN(num) || num < 1 || num > 9) {
+                    return 'Please enter a number between 1 and 9'
+                }
+                return true
+            },
+        },
+    ])
+
+    const channel = parseInt(answer.channel, 10)
+    await channelMenu(channel)
+}
+
+async function channelMenu(channel: number) {
+    const answer = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'action',
+            message: `Channel ${channel} Actions`,
+            choices: [
+                { name: 'Get Info', value: 'info' },
+                { name: 'Move Up', value: 'up' },
+                { name: 'Move Down', value: 'down' },
+                { name: 'Stop', value: 'stop' },
+                new inquirer.Separator(),
+                { name: 'Back to Main Menu', value: 'back' },
+            ],
+        },
+    ])
+
+    if (answer.action === 'back') {
+        await mainMenu()
+        return
+    }
+
+    try {
+        if (answer.action === 'info') {
+            const info = await client!.getInfo(channel)
+            console.log('Channel Info:', info)
+        } else {
+            let cmd: ControlCommand
+            switch (answer.action) {
+                case 'up':
+                    cmd = ControlCommand.up
+                    break
+                case 'down':
+                    cmd = ControlCommand.down
+                    break
+                case 'stop':
+                    cmd = ControlCommand.stop
+                    break
+                default:
+                    throw new Error('Unknown command')
+            }
+            console.log(`Sending ${answer.action} command to channel ${channel}...`)
+            const response = await client!.sendControlCommand(channel, cmd)
+            console.log('Response:', response)
+        }
+    } catch (error) {
+        console.error('Error executing command:', error)
+    }
+
+    await channelMenu(channel)
+}
+
+main().catch((err) => {
+    console.error('Unexpected error:', err)
+    process.exit(1)
+})

package/test/UsbTransmitterClient.test.ts

@@ -0,0 +1,39 @@
+import { UsbTransmitterClient } from "../src/UsbTransmitterClient"
+import { ControlCommand, EasyCommand, InfoData } from "../src/domain/enums"
+import * as fs from 'fs'
+
+jest.setTimeout(200000)
+
+const devPath = '/dev/ttyUSB0'
+const client = new UsbTransmitterClient(devPath)
+
+const aktiveChannelsForTest = [1, 2]
+
+// Skip tests if hardware not present
+const describeHardware = fs.existsSync(devPath) ? describe : describe.skip
+
+describeHardware('Integration Tests (Hardware)', () => {
+
+  test('checkChannels', async () => {
+    await client.open()
+    const channels = await client.checkChannels()
+    expect(channels).toEqual(aktiveChannelsForTest)
+    await client.close()
+  })
+
+  test('getInfo', async () => {
+    await client.open()
+    const response = await client.getInfo(1)
+    console.log(response)
+    expect(response.command).toEqual(EasyCommand.EASY_ACK)
+    await client.close()
+  })
+
+  test('sendControlCommand', async () => {
+    await client.open()
+    const response = await client.sendControlCommand(1, ControlCommand.down)
+    console.log(response)
+    expect(response.status).toEqual(InfoData.INFO_MOVING_DOWN)
+    await client.close()
+  })
+})