elero-usb-transmitter-client 1.0.6 → 1.1.2

package/.github/workflows/nodejs.yml

@@ -0,0 +1,27 @@
+name: Node.js CI
+
+on:
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [18.x, 20.x, 22.x]
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    - run: npm ci
+    - run: npm run build
+    - run: npm test

package/README.md

@@ -1,7 +1,8 @@
 # elero-usb-transmitter-client
 
 [![npm version](https://img.shields.io/npm/v/elero-usb-transmitter-client.svg?style=flat-square)](https://www.npmjs.com/package/elero-usb-transmitter-client)
-[![build status](https://img.shields.io/travis/marc2016/elero-usb-transmitter-client/master.svg?style=flat-square)](https://travis-ci.org/github/marc2016/elero-usb-transmitter-client)
+[![Node.js CI](https://github.com/marc2016/elero-usb-transmitter-client/actions/workflows/nodejs.yml/badge.svg)](https://github.com/marc2016/elero-usb-transmitter-client/actions/workflows/nodejs.yml)
+
 
 Elero USB Transmitter Client for node.js to send commands to Elero USB Stick and receive information. This libaray needs Elero Transmitter Stick (https://www.der-sonnenschutz-shop.de/elero-221250001-centero-transmitter-stick.html).
 
@@ -18,6 +19,30 @@ Using npm:
 $ npm install elero-usb-transmitter-client
 ```
 
+## CLI Usage
+
+You can use the interactive CLI to control the transmitter directly.
+
+### Installation
+
+**Globally (if published to npm):**
+```bash
+npm install -g elero-usb-transmitter-client
+elero-cli
+```
+
+**Via npx (if published to npm):**
+```bash
+npx elero-usb-transmitter-client
+```
+
+**From Source (Development):**
+1. Clone the repository
+2. Install dependencies: `npm install`
+3. Build the project: `npm run build`
+4. Link command: `npm link`
+5. Run: `elero-cli`
+
 ## Example
 
 ### Initialize
@@ -57,6 +82,42 @@ console.log(response)
 await client.close()
 ```
 
+## Changelog
+
+### 1.1.2
+
+- Fix CLI entry point name in `package.json`
+
+### 1.1.1
+
+- Fixed `responseBytes are null` error by handling fragmented serial packets
+- Added detailed unit tests with mocks
+
+### 1.1.0
+
+- Added interactive CLI (`elero-cli`)
+- Added `inquirer` and `commander` dependencies
+
+### 1.0.6
+
+- Updated `serialport` dependency
+- Fixed errors in response handling
+
+### 1.0.5
+
+- Improved mutex handling (release added)
+
+### 1.0.4
+
+- Fixed promise rejection logic
+- Added null checks for response bytes
+
+### 1.0.0
+
+- Initial release with `getInfo`, `sendControlCommand`, and `checkChannels`
+- Implemented `UsbTransmitterClient`
+
+
 ## License
 
 [MIT](LICENSE)

package/dist/UsbTransmitterClient.d.ts

@@ -0,0 +1,18 @@
+import { SerialPort } from 'serialport';
+import { Response } from './model/Response';
+import { ControlCommand } from './domain/enums';
+export declare class UsbTransmitterClient {
+    serialPort: SerialPort<any>;
+    constructor(devPath: string);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    checkChannels(): Promise<number[]>;
+    getInfo(channel: number): Promise<Response>;
+    sendControlCommand(channel: number, controlCommand: ControlCommand): Promise<Response>;
+    private waitForResponse;
+    private sendCommand;
+    private readResponseBytes;
+    private calculateChecksum;
+    private getActiveChannels;
+    private parseResponse;
+}

package/dist/UsbTransmitterClient.js

@@ -0,0 +1,284 @@
+"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 });
+exports.UsbTransmitterClient = void 0;
+var serialport_1 = require("serialport");
+var _ = require("lodash");
+var constants_1 = require("./domain/constants");
+var enums_1 = require("./domain/enums");
+var async_mutex_1 = require("async-mutex");
+var DEFAULT_BAUDRATE = 38400;
+var DEFAULT_BYTESIZE = 8;
+var DEFAULT_PARITY = 'none';
+var DEFAULT_STOPBITS = 1;
+var mutex = new async_mutex_1.Mutex();
+var UsbTransmitterClient = /** @class */ (function () {
+    function UsbTransmitterClient(devPath) {
+        this.serialPort = new serialport_1.SerialPort({
+            path: devPath,
+            baudRate: DEFAULT_BAUDRATE,
+            dataBits: DEFAULT_BYTESIZE,
+            parity: DEFAULT_PARITY,
+            stopBits: DEFAULT_STOPBITS,
+            autoOpen: false,
+        });
+    }
+    UsbTransmitterClient.prototype.open = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            if (!_this.serialPort.isOpen) {
+                _this.serialPort.open(function (error) {
+                    if (error)
+                        reject(error);
+                    _this.serialPort.flush(function (error) {
+                        if (error)
+                            reject(error);
+                        resolve();
+                    });
+                });
+            }
+        });
+    };
+    UsbTransmitterClient.prototype.close = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this.serialPort.close(function (error) {
+                if (error)
+                    reject(error);
+                resolve();
+            });
+        });
+    };
+    UsbTransmitterClient.prototype.checkChannels = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var data, release, responseBytes, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        data = [constants_1.BYTE_HEADER, constants_1.BYTE_LENGTH_2, enums_1.EasyCommand.EASY_CHECK];
+                        return [4 /*yield*/, mutex.acquire()];
+                    case 1:
+                        release = _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, , 5, 6]);
+                        return [4 /*yield*/, this.sendCommand(data)];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, this.waitForResponse(constants_1.RESPONSE_LENGTH_CHECK)];
+                    case 4:
+                        responseBytes = _a.sent();
+                        response = this.parseResponse(responseBytes);
+                        return [2 /*return*/, response.activeChannels];
+                    case 5:
+                        release();
+                        return [7 /*endfinally*/];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    UsbTransmitterClient.prototype.getInfo = function (channel) {
+        return __awaiter(this, void 0, void 0, function () {
+            var lowChannels, highChannels, data, release, responseBytes, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        lowChannels = (1 << (channel - 1)) & 0xff;
+                        highChannels = (1 << (channel - 1)) >> 8;
+                        data = [
+                            constants_1.BYTE_HEADER,
+                            constants_1.BYTE_LENGTH_4,
+                            enums_1.EasyCommand.EASY_INFO,
+                            highChannels,
+                            lowChannels,
+                        ];
+                        return [4 /*yield*/, mutex.acquire()];
+                    case 1:
+                        release = _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, , 5, 6]);
+                        return [4 /*yield*/, this.sendCommand(data)];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, this.waitForResponse(constants_1.RESPONSE_LENGTH_INFO)];
+                    case 4:
+                        responseBytes = _a.sent();
+                        response = this.parseResponse(responseBytes);
+                        return [2 /*return*/, response];
+                    case 5:
+                        release();
+                        return [7 /*endfinally*/];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    UsbTransmitterClient.prototype.sendControlCommand = function (channel, controlCommand) {
+        return __awaiter(this, void 0, void 0, function () {
+            var lowChannels, highChannels, data, release, responseBytes, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        lowChannels = (1 << (channel - 1)) & 0xff;
+                        highChannels = (1 << (channel - 1)) >> 8;
+                        data = [
+                            constants_1.BYTE_HEADER,
+                            constants_1.BYTE_LENGTH_5,
+                            enums_1.EasyCommand.EASY_SEND,
+                            highChannels,
+                            lowChannels,
+                            controlCommand,
+                        ];
+                        return [4 /*yield*/, mutex.acquire()];
+                    case 1:
+                        release = _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, , 5, 6]);
+                        return [4 /*yield*/, this.sendCommand(data)];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, this.waitForResponse(constants_1.RESPONSE_LENGTH_INFO)];
+                    case 4:
+                        responseBytes = _a.sent();
+                        response = this.parseResponse(responseBytes);
+                        return [2 /*return*/, response];
+                    case 5:
+                        release();
+                        return [7 /*endfinally*/];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    UsbTransmitterClient.prototype.waitForResponse = function (length) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var timeout = setTimeout(function () {
+                cleanup();
+                reject(new Error('Timeout waiting for response'));
+            }, 2000);
+            var tryRead = function () {
+                var buffer = _this.serialPort.read(length);
+                if (buffer) {
+                    cleanup();
+                    resolve(buffer);
+                }
+            };
+            var cleanup = function () {
+                clearTimeout(timeout);
+                _this.serialPort.removeListener('readable', tryRead);
+            };
+            _this.serialPort.on('readable', tryRead);
+            tryRead();
+        });
+    };
+    UsbTransmitterClient.prototype.sendCommand = function (data) {
+        var _this = this;
+        var checksum = this.calculateChecksum(data);
+        data.push(checksum);
+        return new Promise(function (resolve, reject) {
+            _this.serialPort.flush(function (error) {
+                if (error)
+                    reject(error);
+                _this.serialPort.write(data, function (error) {
+                    if (error)
+                        reject(error);
+                    resolve(data.length);
+                });
+            });
+        });
+    };
+    UsbTransmitterClient.prototype.readResponseBytes = function (length) {
+        //Get the serial data from the serial port.
+        var response = this.serialPort.read(length);
+        return response;
+    };
+    UsbTransmitterClient.prototype.calculateChecksum = function (data) {
+        //Calculate checksum.
+        //All the sum of all bytes (Header to CS) must be 0x00.
+        var sum = _.sum(data);
+        var result = (256 - sum) % 256;
+        return result;
+    };
+    UsbTransmitterClient.prototype.getActiveChannels = function (byte, start) {
+        var channels = new Array();
+        for (var i = 0; i < 9; i++) {
+            if (((byte >> i) & 1) == 1) {
+                var channel = i + start;
+                channels.push(channel);
+            }
+        }
+        return channels;
+    };
+    UsbTransmitterClient.prototype.parseResponse = function (bytes) {
+        var activeHighChannels = this.getActiveChannels(bytes[3], 9);
+        var activeLowChannels = this.getActiveChannels(bytes[4], 1);
+        var activeChannels = _.concat(activeLowChannels, activeHighChannels);
+        var response = {
+            header: bytes[0],
+            length: bytes[1],
+            command: bytes[2],
+            activeChannels: activeChannels,
+            checksum: -1,
+            status: null,
+            statusCode: -1,
+        };
+        if (bytes.length == constants_1.RESPONSE_LENGTH_CHECK) {
+            response.checksum = bytes[5];
+            //Easy Ack (the answer on Easy Info)
+        }
+        else if (bytes.length == constants_1.RESPONSE_LENGTH_SEND) {
+            if (bytes[5] in enums_1.InfoData) {
+                response.status = bytes[5];
+            }
+            else {
+                response.status = enums_1.InfoData.INFO_UNKNOWN;
+            }
+            response.checksum = bytes[6];
+        }
+        else {
+            response.status = enums_1.InfoData.INFO_UNKNOWN;
+        }
+        return response;
+    };
+    return UsbTransmitterClient;
+}());
+exports.UsbTransmitterClient = UsbTransmitterClient;

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};