@leonardojc/capacitor-ioboard 1.1.0

package/dist/esm/definitions.d.ts

@@ -0,0 +1,154 @@
+export interface CapacitorIoboardPlugin {
+    /**
+     * Open serial connection to IOBOARD device
+     * @param options Serial connection parameters
+     */
+    connect(options: SerialConnectionOptions): Promise<IOBoardResponse>;
+    /**
+     * Close serial connection
+     */
+    disconnect(): Promise<IOBoardResponse>;
+    /**
+     * Check if serial connection is active
+     */
+    isConnected(): Promise<{
+        connected: boolean;
+    }>;
+    /**
+     * Query the status of an IOBOARD device
+     * @param options Device address and timeout
+     */
+    getStatus(options: DeviceOptions): Promise<IOBoardStatusResponse>;
+    /**
+     * Unlock a specific pallet with LED feedback
+     * @param options Pallet control parameters
+     */
+    unlockPallet(options: UnlockPalletOptions): Promise<IOBoardResponse>;
+    /**
+     * Control multiple pallets simultaneously
+     * @param options Full pallet control parameters
+     */
+    controlMultiplePallets(options: MultiplePalletOptions): Promise<IOBoardResponse>;
+    /**
+     * Scan for IOBOARD devices on the network
+     * @param options Scan parameters
+     */
+    scanDevices(options: ScanOptions): Promise<ScanResponse>;
+    /**
+     * Send OTA update notification to IOBOARD
+     * @param options OTA notification parameters
+     */
+    sendOTANotification(options: OTANotificationOptions): Promise<IOBoardResponse>;
+    /**
+     * Send OTA data packet to IOBOARD
+     * @param options OTA data parameters
+     */
+    sendOTAData(options: OTADataOptions): Promise<IOBoardResponse>;
+}
+export interface IOBoardResponse {
+    success: boolean;
+    message?: string;
+    data?: any;
+}
+export interface IOBoardStatusResponse extends IOBoardResponse {
+    data?: {
+        doorLockStatus: number;
+        softwareVersion: {
+            major: number;
+            minor: number;
+            patch: number;
+        };
+    };
+}
+export interface SerialConnectionOptions {
+    portPath?: string;
+    baudRate?: number;
+    dataBits?: number;
+    stopBits?: number;
+    parity?: 'none' | 'even' | 'odd';
+    flowControl?: 'none' | 'hardware' | 'software';
+    timeout?: number;
+}
+export interface DeviceOptions {
+    address: number;
+    timeout?: number;
+}
+export interface UnlockPalletOptions extends DeviceOptions {
+    palletNumber: number;
+    ledColor?: 'red' | 'green' | 'blue' | 'yellow' | 'white' | 'off';
+    blinkTimes?: number;
+    blinkSpeed?: number;
+}
+export interface MultiplePalletOptions extends DeviceOptions {
+    doorLockMask: number;
+    ledControls?: LEDControlOptions[];
+}
+export interface ScanOptions {
+    startAddress?: number;
+    endAddress?: number;
+    timeout?: number;
+}
+export interface ScanResponse extends IOBoardResponse {
+    devices?: Array<{
+        address: number;
+        responding: boolean;
+        status?: any;
+    }>;
+}
+export interface LEDControlOptions {
+    red: number;
+    green: number;
+    blue: number;
+    intensity: number;
+    blinkTimes: number;
+    blinkSpeed: number;
+}
+export interface OTANotificationOptions {
+    address: number;
+    majorVersion: number;
+    minorVersion: number;
+    patchVersion: number;
+    firmwareSize: number;
+}
+export interface OTADataOptions {
+    address: number;
+    packetNumber: number;
+    data: string;
+}
+export declare const IOBOARD_PROTOCOL: {
+    SOI: number;
+    EOI: number;
+    FRAME_TYPES: {
+        STATUS_QUERY: number;
+        SINGLE_PALLET: number;
+        FULL_PALLET: number;
+        OTA_REQUEST: number;
+        OTA_DATA: number;
+        OTA_RESPONSE: number;
+    };
+    DEFAULT_BAUD_RATE: number;
+    DEFAULT_DATA_BITS: number;
+    DEFAULT_STOP_BITS: number;
+    DEFAULT_PARITY: "none";
+    DEFAULT_TIMEOUT: number;
+    MIN_ADDRESS: number;
+    MAX_ADDRESS: number;
+    MIN_PALLET: number;
+    MAX_PALLET: number;
+    OTA_PACKET_SIZE: number;
+    OTA_RESPONSES: {
+        AREA_REQUEST: number;
+        REQUEST_A_ZONE: number;
+        REQUEST_B_ZONE: number;
+        DATA_REQUEST: number;
+        COMPLETION: number;
+        ERROR: number;
+    };
+    OTA_ERROR_CODES: {
+        ILLEGAL_VERSION: number;
+        NON_OTA_STATUS: number;
+        WRITE_FAILED: number;
+        VERIFICATION_FAILED: number;
+        TRANSFER_FAILED: number;
+    };
+};

package/dist/esm/definitions.js

@@ -0,0 +1,43 @@
+// Protocol Constants
+export const IOBOARD_PROTOCOL = {
+    SOI: 0x0D,
+    EOI: 0x0A,
+    FRAME_TYPES: {
+        STATUS_QUERY: 0x00,
+        SINGLE_PALLET: 0x01,
+        FULL_PALLET: 0x02,
+        OTA_REQUEST: 0xF1,
+        OTA_DATA: 0xF2,
+        OTA_RESPONSE: 0xF3
+    },
+    DEFAULT_BAUD_RATE: 115200,
+    DEFAULT_DATA_BITS: 8,
+    DEFAULT_STOP_BITS: 1,
+    DEFAULT_PARITY: 'none',
+    DEFAULT_TIMEOUT: 5000,
+    // Address range
+    MIN_ADDRESS: 1,
+    MAX_ADDRESS: 63,
+    // Pallet range
+    MIN_PALLET: 0,
+    MAX_PALLET: 7,
+    // OTA Constants
+    OTA_PACKET_SIZE: 128,
+    // Response codes
+    OTA_RESPONSES: {
+        AREA_REQUEST: 0x26,
+        REQUEST_A_ZONE: 0x41,
+        REQUEST_B_ZONE: 0x42,
+        DATA_REQUEST: 0x23,
+        COMPLETION: 0x4F,
+        ERROR: 0x45, // 'E'
+    },
+    // Error codes
+    OTA_ERROR_CODES: {
+        ILLEGAL_VERSION: 9,
+        NON_OTA_STATUS: 8,
+        WRITE_FAILED: 7,
+        VERIFICATION_FAILED: 6,
+        TRANSFER_FAILED: 5
+    }
+};

package/dist/esm/index.d.ts

@@ -0,0 +1,5 @@
+import type { CapacitorIoboardPlugin } from './definitions';
+declare const CapacitorIoboard: CapacitorIoboardPlugin;
+export * from './definitions';
+export * from './protocol';
+export { CapacitorIoboard };

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+import { registerPlugin } from '@capacitor/core';
+const CapacitorIoboard = registerPlugin('CapacitorIoboard', {
+    web: () => import('./web').then(m => new m.CapacitorIoboardWeb()),
+});
+export * from './definitions';
+export * from './protocol';
+export { CapacitorIoboard };

package/dist/esm/protocol.d.ts

@@ -0,0 +1,62 @@
+/**
+ * IOBOARD Protocol utilities for frame construction and parsing
+ */
+export declare class IOBoardProtocol {
+    /**
+     * Calculate CRC-16 CCITT checksum
+     */
+    static calculateCRC16(data: number[]): number;
+    /**
+     * Build a command frame for IOBOARD
+     */
+    static buildFrame(address: number, frameType: number, data: number[]): number[];
+    /**
+     * Parse a response frame from IOBOARD
+     */
+    static parseFrame(frame: number[]): {
+        success: boolean;
+        address?: number;
+        frameType?: number;
+        data?: number[];
+        error?: string;
+    };
+    /**
+     * Build status query frame
+     */
+    static buildStatusQuery(address: number): number[];
+    /**
+     * Build single pallet control frame
+     */
+    static buildSinglePalletControl(address: number, palletNumber: number, doorLock: boolean, ledControl: any): number[];
+    /**
+     * Build full pallet control frame
+     */
+    static buildFullPalletControl(address: number, doorLockControl: number, extendedControl: number, ledControls: any[]): number[];
+    /**
+     * Build OTA notification frame
+     */
+    static buildOTANotification(address: number, majorVersion: number, minorVersion: number, patchVersion: number, firmwareSize: number): number[];
+    /**
+     * Build OTA data frame
+     */
+    static buildOTAData(address: number, packetNumber: number, data: Uint8Array): number[];
+    /**
+     * Parse status response
+     */
+    static parseStatusResponse(data: number[]): {
+        doorLockStatus: number;
+        softwareVersion: {
+            major: number;
+            minor: number;
+            patch: number;
+        };
+    } | null;
+    /**
+     * Convert frame to hex string for debugging
+     */
+    static frameToHex(frame: number[]): string;
+    /**
+     * Convert hex string to frame
+     */
+    static hexToFrame(hex: string): number[];
+}

package/dist/esm/protocol.js

@@ -0,0 +1,191 @@
+/**
+ * IOBOARD Protocol utilities for frame construction and parsing
+ */
+export class IOBoardProtocol {
+    /**
+     * Calculate CRC-16 CCITT checksum
+     */
+    static calculateCRC16(data) {
+        let crc = 0xFFFF;
+        for (const byte of data) {
+            crc ^= (byte << 8);
+            for (let bit = 0; bit < 8; bit++) {
+                if (crc & 0x8000) {
+                    crc = (crc << 1) ^ 0x1021;
+                }
+                else {
+                    crc = crc << 1;
+                }
+                crc &= 0xFFFF;
+            }
+        }
+        return crc;
+    }
+    /**
+     * Build a command frame for IOBOARD
+     */
+    static buildFrame(address, frameType, data) {
+        const frame = [];
+        // SOI
+        frame.push(0x0D);
+        // Address
+        frame.push(address);
+        // Frame Type
+        frame.push(frameType);
+        // Data
+        frame.push(...data);
+        // Calculate CRC for address + frameType + data
+        const crcData = [address, frameType, ...data];
+        const crc = this.calculateCRC16(crcData);
+        // CRC (high byte first)
+        frame.push((crc >> 8) & 0xFF);
+        frame.push(crc & 0xFF);
+        // EOI
+        frame.push(0x0A);
+        return frame;
+    }
+    /**
+     * Parse a response frame from IOBOARD
+     */
+    static parseFrame(frame) {
+        if (frame.length < 6) {
+            return { success: false, error: 'Frame too short' };
+        }
+        // Check SOI and EOI
+        if (frame[0] !== 0x0D || frame[frame.length - 1] !== 0x0A) {
+            return { success: false, error: 'Invalid frame markers' };
+        }
+        const address = frame[1];
+        const frameType = frame[2];
+        const dataLength = frame.length - 6; // SOI + Address + FrameType + CRC(2) + EOI
+        const data = frame.slice(3, 3 + dataLength);
+        // Extract CRC from frame
+        const receivedCRC = (frame[frame.length - 3] << 8) | frame[frame.length - 2];
+        // Calculate expected CRC
+        const crcData = [address, frameType, ...data];
+        const expectedCRC = this.calculateCRC16(crcData);
+        if (receivedCRC !== expectedCRC) {
+            return {
+                success: false,
+                error: `CRC mismatch: expected ${expectedCRC.toString(16)}, got ${receivedCRC.toString(16)}`
+            };
+        }
+        return {
+            success: true,
+            address,
+            frameType,
+            data
+        };
+    }
+    /**
+     * Build status query frame
+     */
+    static buildStatusQuery(address) {
+        return this.buildFrame(address, 0x00, []);
+    }
+    /**
+     * Build single pallet control frame
+     */
+    static buildSinglePalletControl(address, palletNumber, doorLock, ledControl) {
+        const data = [];
+        // Pallet number
+        data.push(palletNumber);
+        // Door lock control (1 = unlock, 0 = no action)
+        data.push(doorLock ? 1 : 0);
+        // LED control (6 bytes)
+        data.push(ledControl.red);
+        data.push(ledControl.green);
+        data.push(ledControl.blue);
+        data.push(ledControl.intensity);
+        data.push(ledControl.blinkTimes);
+        data.push(ledControl.blinkSpeed);
+        return this.buildFrame(address, 0x01, data);
+    }
+    /**
+     * Build full pallet control frame
+     */
+    static buildFullPalletControl(address, doorLockControl, extendedControl, ledControls) {
+        const data = [];
+        // Door lock control (8-bit mask)
+        data.push(doorLockControl);
+        // Extended control
+        data.push(extendedControl);
+        // LED controls for 8 pallets (48 bytes total)
+        for (let i = 0; i < 8; i++) {
+            const led = ledControls[i] || {
+                red: 0, green: 0, blue: 0,
+                intensity: 0, blinkTimes: 0, blinkSpeed: 0
+            };
+            data.push(led.red);
+            data.push(led.green);
+            data.push(led.blue);
+            data.push(led.intensity);
+            data.push(led.blinkTimes);
+            data.push(led.blinkSpeed);
+        }
+        return this.buildFrame(address, 0x02, data);
+    }
+    /**
+     * Build OTA notification frame
+     */
+    static buildOTANotification(address, majorVersion, minorVersion, patchVersion, firmwareSize) {
+        const data = [];
+        // Version (3 bytes)
+        data.push(majorVersion);
+        data.push(minorVersion);
+        data.push(patchVersion);
+        // Firmware size (4 bytes, little-endian)
+        data.push(firmwareSize & 0xFF);
+        data.push((firmwareSize >> 8) & 0xFF);
+        data.push((firmwareSize >> 16) & 0xFF);
+        data.push((firmwareSize >> 24) & 0xFF);
+        return this.buildFrame(address, 0xF1, data);
+    }
+    /**
+     * Build OTA data frame
+     */
+    static buildOTAData(address, packetNumber, data) {
+        const frameData = [];
+        // Packet number (4 bytes, little-endian)
+        frameData.push(packetNumber & 0xFF);
+        frameData.push((packetNumber >> 8) & 0xFF);
+        frameData.push((packetNumber >> 16) & 0xFF);
+        frameData.push((packetNumber >> 24) & 0xFF);
+        // Data bytes (up to 128 bytes)
+        for (let i = 0; i < data.length; i++) {
+            frameData.push(data[i]);
+        }
+        return this.buildFrame(address, 0xF2, frameData);
+    }
+    /**
+     * Parse status response
+     */
+    static parseStatusResponse(data) {
+        if (data.length < 4) {
+            return null;
+        }
+        return {
+            doorLockStatus: data[0],
+            softwareVersion: {
+                major: data[1],
+                minor: data[2],
+                patch: data[3]
+            }
+        };
+    }
+    /**
+     * Convert frame to hex string for debugging
+     */
+    static frameToHex(frame) {
+        return frame.map(b => b.toString(16).padStart(2, '0')).join(' ').toUpperCase();
+    }
+    /**
+     * Convert hex string to frame
+     */
+    static hexToFrame(hex) {
+        return hex.split(' ')
+            .map(h => h.trim())
+            .filter(h => h.length > 0)
+            .map(h => parseInt(h, 16));
+    }
+}

package/dist/esm/web.d.ts

@@ -0,0 +1,17 @@
+import { WebPlugin } from '@capacitor/core';
+import type { CapacitorIoboardPlugin, IOBoardResponse, IOBoardStatusResponse, DeviceOptions, UnlockPalletOptions, MultiplePalletOptions, ScanOptions, ScanResponse, OTANotificationOptions, OTADataOptions, SerialConnectionOptions } from './definitions';
+export declare class CapacitorIoboardWeb extends WebPlugin implements CapacitorIoboardPlugin {
+    private isConnectedState;
+    connect(options: SerialConnectionOptions): Promise<IOBoardResponse>;
+    disconnect(): Promise<IOBoardResponse>;
+    isConnected(): Promise<{
+        connected: boolean;
+    }>;
+    getStatus(options: DeviceOptions): Promise<IOBoardStatusResponse>;
+    unlockPallet(options: UnlockPalletOptions): Promise<IOBoardResponse>;
+    controlMultiplePallets(options: MultiplePalletOptions): Promise<IOBoardResponse>;
+    scanDevices(options: ScanOptions): Promise<ScanResponse>;
+    sendOTANotification(options: OTANotificationOptions): Promise<IOBoardResponse>;
+    sendOTAData(options: OTADataOptions): Promise<IOBoardResponse>;
+    private getMaskBits;
+}

package/dist/esm/web.js

@@ -0,0 +1,167 @@
+import { WebPlugin } from '@capacitor/core';
+export class CapacitorIoboardWeb extends WebPlugin {
+    constructor() {
+        super(...arguments);
+        this.isConnectedState = false;
+    }
+    async connect(options) {
+        console.log('IOBOARD Web: Connect', options);
+        // Simulate connection delay
+        await new Promise(resolve => setTimeout(resolve, 500));
+        this.isConnectedState = true;
+        return {
+            success: true,
+            message: `Connected to ${options.portPath || '/dev/ttyS2'} (web mock)`
+        };
+    }
+    async disconnect() {
+        console.log('IOBOARD Web: Disconnect');
+        this.isConnectedState = false;
+        return {
+            success: true,
+            message: 'Disconnected successfully (web mock)'
+        };
+    }
+    async isConnected() {
+        return { connected: this.isConnectedState };
+    }
+    async getStatus(options) {
+        console.log('IOBOARD Web: Get Status', options);
+        if (!this.isConnectedState) {
+            return {
+                success: false,
+                message: 'No serial connection established'
+            };
+        }
+        // Mock response
+        return {
+            success: true,
+            message: 'Status retrieved successfully (web mock)',
+            data: {
+                doorLockStatus: 0b11010001,
+                softwareVersion: {
+                    major: 1,
+                    minor: 2,
+                    patch: 3
+                }
+            }
+        };
+    }
+    async unlockPallet(options) {
+        console.log('IOBOARD Web: Unlock Pallet', options);
+        if (!this.isConnectedState) {
+            return {
+                success: false,
+                message: 'No serial connection established'
+            };
+        }
+        // Validate pallet number
+        if (options.palletNumber < 0 || options.palletNumber > 7) {
+            return {
+                success: false,
+                message: 'Invalid pallet number. Must be 0-7'
+            };
+        }
+        // Mock response
+        return {
+            success: true,
+            message: `Pallet ${options.palletNumber} unlocked successfully (web mock)`,
+            data: {
+                address: options.address,
+                palletNumber: options.palletNumber,
+                ledColor: options.ledColor || 'green'
+            }
+        };
+    }
+    async controlMultiplePallets(options) {
+        console.log('IOBOARD Web: Control Multiple Pallets', options);
+        if (!this.isConnectedState) {
+            return {
+                success: false,
+                message: 'No serial connection established'
+            };
+        }
+        // Mock response
+        return {
+            success: true,
+            message: 'Multiple pallets controlled successfully (web mock)',
+            data: {
+                address: options.address,
+                doorLockMask: options.doorLockMask,
+                affectedPallets: this.getMaskBits(options.doorLockMask)
+            }
+        };
+    }
+    async scanDevices(options) {
+        console.log('IOBOARD Web: Scan Devices', options);
+        if (!this.isConnectedState) {
+            return {
+                success: false,
+                message: 'No serial connection established'
+            };
+        }
+        // Mock scan results
+        const devices = [];
+        const start = options.startAddress || 1;
+        const end = Math.min(options.endAddress || 63, start + 5); // Mock max 5 devices
+        for (let addr = start; addr <= end; addr++) {
+            devices.push({
+                address: addr,
+                responding: Math.random() > 0.7,
+                status: Math.random() > 0.7 ? { doorLockStatus: Math.floor(Math.random() * 256) } : undefined
+            });
+        }
+        return {
+            success: true,
+            message: `Scanned addresses ${start}-${end} (web mock)`,
+            devices
+        };
+    }
+    async sendOTANotification(options) {
+        console.log('IOBOARD Web: Send OTA Notification', options);
+        if (!this.isConnectedState) {
+            return {
+                success: false,
+                message: 'No serial connection established'
+            };
+        }
+        // Mock response
+        return {
+            success: true,
+            message: 'OTA notification sent successfully (web mock)',
+            data: {
+                address: options.address,
+                version: `${options.majorVersion}.${options.minorVersion}.${options.patchVersion}`,
+                firmwareSize: options.firmwareSize
+            }
+        };
+    }
+    async sendOTAData(options) {
+        console.log('IOBOARD Web: Send OTA Data', options);
+        if (!this.isConnectedState) {
+            return {
+                success: false,
+                message: 'No serial connection established'
+            };
+        }
+        // Mock response
+        return {
+            success: true,
+            message: `OTA data packet ${options.packetNumber} sent successfully (web mock)`,
+            data: {
+                address: options.address,
+                packetNumber: options.packetNumber,
+                dataLength: options.data.length
+            }
+        };
+    }
+    getMaskBits(mask) {
+        const bits = [];
+        for (let i = 0; i < 8; i++) {
+            if (mask & (1 << i)) {
+                bits.push(i);
+            }
+        }
+        return bits;
+    }
+}