elero-usb-transmitter-client 1.0.6 → 1.1.1

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()
+  })
+})

package/test/UsbTransmitterClientMock.test.ts

@@ -0,0 +1,182 @@
+
+import { UsbTransmitterClient } from '../src/UsbTransmitterClient'
+import { ControlCommand, EasyCommand, InfoData } from '../src/domain/enums'
+import { SerialPort } from 'serialport'
+import { BYTE_HEADER } from '../src/domain/constants'
+
+// Mock entire serialport module
+jest.mock('serialport')
+
+describe('UsbTransmitterClient (Mocked)', () => {
+    let client: UsbTransmitterClient
+    let mockSerialPortInstance: any
+
+    beforeEach(() => {
+        // Reset mocks
+        jest.clearAllMocks()
+
+        // Setup mock instance
+        mockSerialPortInstance = {
+            isOpen: false,
+            open: jest.fn((cb) => {
+                mockSerialPortInstance.isOpen = true
+                if (cb) cb(null)
+            }),
+            close: jest.fn((cb) => {
+                mockSerialPortInstance.isOpen = false
+                if (cb) cb(null)
+            }),
+            write: jest.fn((data, cb) => {
+                if (cb) cb(null)
+            }),
+            flush: jest.fn((cb) => {
+                if (cb) cb(null)
+            }),
+            once: jest.fn(),
+            read: jest.fn(),
+            pipe: jest.fn(),
+            on: jest.fn(),
+            removeListener: jest.fn()
+        }
+
+            // When new SerialPort() is called, return our mock instance
+            ; (SerialPort as unknown as jest.Mock).mockImplementation(() => mockSerialPortInstance)
+
+        client = new UsbTransmitterClient('/dev/ttyMOCKED')
+    })
+
+    test('open() should open the serial port', async () => {
+        await client.open()
+        expect(mockSerialPortInstance.open).toHaveBeenCalled()
+        expect(mockSerialPortInstance.flush).toHaveBeenCalled()
+    })
+
+    test('close() should close the serial port', async () => {
+        await client.close()
+        expect(mockSerialPortInstance.close).toHaveBeenCalled()
+    })
+
+    test('checkChannels() calls correct command and parses response', async () => {
+        await client.open()
+
+        // Simulate "readable" event and data read
+        mockSerialPortInstance.once.mockImplementation((event: string, cb: Function) => {
+            if (event === 'readable') {
+                // Trigger the callback immediately to simulate data ready
+                cb()
+            }
+        })
+
+        // Mock response for check channels (Head, Len, Cmd, Byte3...CS)
+        // Response length check is 6 bytes.
+        // Byte 3 is bitmap of active channels (1-8). let's say ch 1 and 2 are active (binary 00000011 = 3)
+        const responseBuffer = Buffer.from([
+            BYTE_HEADER, // 0xAA
+            0x04, // Length
+            EasyCommand.EASY_CHECK,
+            0x00, // High channels (starts at 9)
+            0x03, // Low channels (starts at 1, so 1 & 2)
+            0x00 // Checksum (ignored for now in mock, or we calculate it if logic is strict)
+        ])
+        // Fix checksum if logic requires it: 256 - sum
+        const sum = responseBuffer[0] + responseBuffer[1] + responseBuffer[2] + responseBuffer[3] + responseBuffer[4]
+        responseBuffer[5] = (256 - (sum % 256)) % 256
+
+        mockSerialPortInstance.read.mockReturnValue(responseBuffer)
+
+        const channels = await client.checkChannels()
+        expect(channels).toEqual(expect.arrayContaining([1, 2]))
+        expect(mockSerialPortInstance.write).toHaveBeenCalledWith(
+            expect.arrayContaining([BYTE_HEADER, 0x02, EasyCommand.EASY_CHECK]),
+            expect.any(Function)
+        )
+    })
+
+    test('sendControlCommand() sends correct bytes', async () => {
+        await client.open()
+
+        mockSerialPortInstance.once.mockImplementation((event: string, cb: Function) => {
+            if (event === 'readable') cb()
+        })
+
+        // Response for Info (length 7)
+        // 0: AA, 1: 05, 2: EASY_SEND, 3: high, 4: low, 5: status, 6: CS
+        const responseBuffer = Buffer.from([
+            BYTE_HEADER,
+            0x05,
+            EasyCommand.EASY_SEND,
+            0x00,
+            0x01, // Channel 1 bit mask
+            InfoData.INFO_MOVING_DOWN,
+            0x00
+        ])
+        const sum = responseBuffer.slice(0, 6).reduce((a, b) => a + b, 0)
+        responseBuffer[6] = (256 - (sum % 256)) % 256
+
+        mockSerialPortInstance.read.mockReturnValue(responseBuffer)
+
+        const response = await client.sendControlCommand(1, ControlCommand.down)
+
+        expect(response.status).toBe(InfoData.INFO_MOVING_DOWN)
+
+        // Verify write arguments
+        // Data: [AA, 05, EASY_SEND, high, low, cmd, CS]
+        // Channel 1 -> low=1, high=0
+        expect(mockSerialPortInstance.write).toHaveBeenCalledWith(
+            expect.arrayContaining([
+                BYTE_HEADER,
+                0x05,
+                EasyCommand.EASY_SEND,
+                0,
+                1,
+                ControlCommand.down
+            ]),
+            expect.any(Function)
+        )
+    })
+    test('getInfo() should handle fragmented packets (reproduction fix)', async () => {
+        await client.open()
+
+        let readableCallback: Function | null = null;
+        mockSerialPortInstance.on.mockImplementation((event: string, cb: Function) => {
+            if (event === 'readable') {
+                readableCallback = cb
+            }
+        })
+
+        let readCallCount = 0
+        mockSerialPortInstance.read.mockImplementation((len: number) => {
+            readCallCount++
+            if (readCallCount === 1) {
+                return null // Not enough data yet
+            }
+            // Return dummy response buffer for getInfo call
+            const responseBuffer = Buffer.from([
+                BYTE_HEADER,
+                0x05,
+                EasyCommand.EASY_SEND,
+                0x00,
+                0x01,
+                InfoData.INFO_MOVING_DOWN,
+                0x00
+            ])
+            const sum = responseBuffer.slice(0, 6).reduce((a, b) => a + b, 0)
+            responseBuffer[6] = (256 - (sum % 256)) % 256
+            return responseBuffer
+        })
+
+        const infoPromise = client.getInfo(1)
+
+        // Wait a tick to ensure tryRead() ran once and failed
+        await new Promise(r => process.nextTick(r))
+
+        // Now trigger readable event again (simulation of second packet arriving)
+        if (readableCallback) {
+            (readableCallback as Function)()
+        }
+
+        const response = await infoPromise
+        expect(response.status).toBe(InfoData.INFO_MOVING_DOWN)
+        expect(readCallCount).toBeGreaterThanOrEqual(2)
+    })
+})

package/__test__/UsbTransmitterClient.test.ts

@@ -1,31 +0,0 @@
-import { UsbTransmitterClient } from "../src/UsbTransmitterClient"
-import { ControlCommand, EasyCommand, InfoData } from "../src/domain/enums"
-
-jest.setTimeout(200000)
-
-const client = new UsbTransmitterClient('/dev/ttyUSB0')
-
-const aktiveChannelsForTest = [1, 2]
-
-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()
-})