@leonardojc/capacitor-ioboard 1.1.0 → 1.2.1

package/android/src/main/java/com/leonardojc/capacitor/ioboard/IOBoardManager.java

@@ -2,27 +2,36 @@ package com.leonardojc.capacitor.ioboard;
 
 import android.util.Log;
 import android.util.Base64;
+import android.os.Handler;
+import android.os.Looper;
 import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.CountDownLatch;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
 
 /**
  * Manager class for IOBOARD communication protocol
  * This class integrates with the @leonardojc/capacitor-serial-port plugin
+ * Uses IOBoardProtocolUtils for MTC3P08L protocol implementation
  */
 public class IOBoardManager {
     
     private static final String TAG = "IOBoardManager";
-    private static final int SOI = 0x0D; // Start of frame
-    private static final int EOI = 0x0A; // End of frame
-    
-    // Frame types
-    private static final int FRAME_TYPE_STATUS_QUERY = 0x00;
-    private static final int FRAME_TYPE_SINGLE_PALLET = 0x01;
-    private static final int FRAME_TYPE_FULL_PALLET = 0x02;
-    private static final int FRAME_TYPE_OTA_REQUEST = 0xF1;
-    private static final int FRAME_TYPE_OTA_DATA = 0xF2;
     
+    // Serial communication variables
+    private FileInputStream serialInputStream;
+    private FileOutputStream serialOutputStream;
+    private String currentPortPath;
     private boolean isConnected = false;
+    private Thread readerThread;
+    private Handler mainHandler;
+    private String responseBuffer = "";
+    private CountDownLatch responseLatch;
 
     // Response classes
     public static class IOBoardResponse {
@@ -127,89 +136,177 @@ public class IOBoardManager {
     }
 
     /**
-     * Calculate CRC-16 CCITT checksum
+     * Constructor - Initialize the manager
      */
-    private int calculateCRC16(int[] data) {
-        int crc = 0xFFFF;
-        
-        for (int dataByte : data) {
-            crc ^= (dataByte << 8);
-            
-            for (int bit = 0; bit < 8; bit++) {
-                if ((crc & 0x8000) != 0) {
-                    crc = (crc << 1) ^ 0x1021;
-                } else {
-                    crc = crc << 1;
-                }
-                crc &= 0xFFFF;
+    public IOBoardManager() {
+        mainHandler = new Handler(Looper.getMainLooper());
+        Log.d(TAG, "IOBoardManager initialized");
+    }
+
+    /**
+     * Open serial port for communication
+     */
+    public boolean openSerialPort(String portPath, int baudRate) {
+        if (isConnected) {
+            Log.w(TAG, "Port already connected. Close current connection first.");
+            return false;
+        }
+
+        try {
+            // Verificar que el puerto existe
+            File portFile = new File(portPath);
+            if (!portFile.exists()) {
+                Log.e(TAG, "Port " + portPath + " does not exist");
+                return false;
             }
+
+            // Intentar abrir streams
+            serialInputStream = new FileInputStream(portFile);
+            serialOutputStream = new FileOutputStream(portFile);
+
+            currentPortPath = portPath;
+            isConnected = true;
+
+            // Iniciar hilo de lectura
+            startReaderThread();
+
+            Log.d(TAG, "Port opened successfully: " + portPath + " at " + baudRate + " baud");
+            return true;
+
+        } catch (IOException e) {
+            Log.e(TAG, "Error opening port: " + e.getMessage());
+            isConnected = false;
+            return false;
         }
-        
-        return crc;
     }
 
     /**
-     * Build a command frame for IOBOARD
+     * Close serial port
      */
-    private int[] buildFrame(int address, int frameType, int[] data) {
-        // Calculate frame size: SOI + Address + FrameType + Data + CRC(2) + EOI
-        int frameSize = 1 + 1 + 1 + data.length + 2 + 1;
-        int[] frame = new int[frameSize];
-        int index = 0;
-        
-        // SOI
-        frame[index++] = SOI;
-        
-        // Address
-        frame[index++] = address;
-        
-        // Frame Type
-        frame[index++] = frameType;
-        
-        // Data
-        for (int dataByte : data) {
-            frame[index++] = dataByte;
+    public void closeSerialPort() {
+        if (!isConnected) return;
+
+        try {
+            // Detener hilo de lectura
+            stopReaderThread();
+
+            // Cerrar streams
+            if (serialInputStream != null) {
+                serialInputStream.close();
+                serialInputStream = null;
+            }
+            if (serialOutputStream != null) {
+                serialOutputStream.close();
+                serialOutputStream = null;
+            }
+
+            isConnected = false;
+            currentPortPath = null;
+            Log.d(TAG, "Port closed successfully");
+
+        } catch (IOException e) {
+            Log.e(TAG, "Error closing port: " + e.getMessage());
         }
+    }
+
+    /**
+     * Start reader thread for incoming data
+     */
+    private void startReaderThread() {
+        if (readerThread != null && readerThread.isAlive()) {
+            return;
+        }
+
+        readerThread = new Thread(() -> {
+            byte[] buffer = new byte[1024];
+            
+            while (isConnected && !Thread.currentThread().isInterrupted()) {
+                try {
+                    if (serialInputStream.available() > 0) {
+                        int bytesRead = serialInputStream.read(buffer);
+                        if (bytesRead > 0) {
+                            String receivedData = new String(buffer, 0, bytesRead, "ISO-8859-1");
+                            synchronized (this) {
+                                responseBuffer += receivedData;
+                                if (responseLatch != null) {
+                                    responseLatch.countDown();
+                                }
+                            }
+                            Log.d(TAG, "Data received (length): " + bytesRead);
+                        }
+                    }
+                    Thread.sleep(10); // Small delay to prevent excessive CPU usage
+                } catch (IOException | InterruptedException e) {
+                    if (isConnected) {
+                        Log.e(TAG, "Error in reader thread: " + e.getMessage());
+                    }
+                    break;
+                }
+            }
+        });
         
-        // Calculate CRC for address + frameType + data
-        int[] crcData = new int[1 + 1 + data.length];
-        crcData[0] = address;
-        crcData[1] = frameType;
-        System.arraycopy(data, 0, crcData, 2, data.length);
-        
-        int crc = calculateCRC16(crcData);
-        
-        // CRC (high byte first)
-        frame[index++] = (crc >> 8) & 0xFF;
-        frame[index++] = crc & 0xFF;
-        
-        // EOI
-        frame[index] = EOI;
-        
-        return frame;
+        readerThread.start();
     }
 
     /**
-     * Convert frame to byte array for serial transmission
+     * Stop reader thread
      */
-    private byte[] frameToBytes(int[] frame) {
-        byte[] bytes = new byte[frame.length];
-        for (int i = 0; i < frame.length; i++) {
-            bytes[i] = (byte) (frame[i] & 0xFF);
+    private void stopReaderThread() {
+        if (readerThread != null && readerThread.isAlive()) {
+            readerThread.interrupt();
+            try {
+                readerThread.join(1000); // Wait up to 1 second
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
         }
-        return bytes;
     }
 
     /**
-     * Convert frame to hex string for debugging
+     * Send command via serial port and wait for response
      */
-    private String frameToHex(int[] frame) {
-        StringBuilder sb = new StringBuilder();
-        for (int i = 0; i < frame.length; i++) {
-            if (i > 0) sb.append(" ");
-            sb.append(String.format("%02X", frame[i]));
+    private String sendCommandAndWaitResponse(byte[] command, int timeoutMs) throws Exception {
+        if (!isConnected || serialOutputStream == null) {
+            throw new Exception("Serial port not connected");
+        }
+
+        String hexCommand = IOBoardProtocolUtils.frameToHex(command);
+        Log.d(TAG, "Sending command (HEX): " + hexCommand);
+
+        synchronized (this) {
+            // Clear response buffer
+            responseBuffer = "";
+            responseLatch = new CountDownLatch(1);
+        }
+
+        try {
+            // Convert command to Latin-1 string and write to serial port
+            String commandString = IOBoardProtocolUtils.frameToLatin1String(command);
+            byte[] bytes = commandString.getBytes("ISO-8859-1");
+            serialOutputStream.write(bytes);
+            serialOutputStream.flush();
+
+            Log.d(TAG, "Command sent, waiting for response...");
+
+            // Wait for response with timeout
+            boolean responseReceived = responseLatch.await(timeoutMs, TimeUnit.MILLISECONDS);
+            
+            if (responseReceived) {
+                synchronized (this) {
+                    String response = responseBuffer;
+                    Log.d(TAG, "Response received (length): " + response.length());
+                    return response;
+                }
+            } else {
+                throw new Exception("Timeout waiting for response");
+            }
+
+        } catch (IOException e) {
+            throw new Exception("Error sending command: " + e.getMessage());
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            throw new Exception("Command interrupted");
         }
-        return sb.toString();
     }
 
     // New simplified API methods
@@ -221,11 +318,12 @@ public class IOBoardManager {
         Log.d(TAG, "Connecting to serial port: " + config.portPath + " at " + config.baudRate + " baud");
         
         try {
-            // TODO: Initialize connection with serial port plugin
-            // For now, just set the connected flag
-            isConnected = true;
-            
-            return new IOBoardResponse(true, "Connected to " + config.portPath + " successfully");
+            boolean success = openSerialPort(config.portPath, config.baudRate);
+            if (success) {
+                return new IOBoardResponse(true, "Connected to " + config.portPath + " successfully");
+            } else {
+                return new IOBoardResponse(false, "Failed to open serial port: " + config.portPath);
+            }
             
         } catch (Exception e) {
             Log.e(TAG, "Error connecting", e);
@@ -240,9 +338,7 @@ public class IOBoardManager {
         Log.d(TAG, "Disconnecting from serial port");
         
         try {
-            // TODO: Close connection with serial port plugin
-            isConnected = false;
-            
+            closeSerialPort();
             return new IOBoardResponse(true, "Disconnected successfully");
             
         } catch (Exception e) {
@@ -262,15 +358,33 @@ public class IOBoardManager {
         }
         
         try {
-            // Build status query frame
-            int[] frame = buildFrame(address, FRAME_TYPE_STATUS_QUERY, new int[0]);
+            // Build status query frame using IOBoardProtocolUtils
+            byte[] frame = IOBoardProtocolUtils.createStatusQuery((byte) address);
+            
+            Log.d(TAG, "Sending status query frame: " + IOBoardProtocolUtils.frameToHex(frame));
             
-            Log.d(TAG, "Sending status query frame: " + frameToHex(frame));
+            // Send frame and wait for response
+            String response = sendCommandAndWaitResponse(frame, timeout);
+            
+            // Parse response
+            IOBoardProtocolUtils.ParsedResponse parsedResponse = IOBoardProtocolUtils.parseResponse(response);
+            
+            if (!parsedResponse.success) {
+                return new StatusResponse(false, "Failed to parse response: " + parsedResponse.message, null);
+            }
             
-            // TODO: Send frame via serial port plugin and receive response
-            // For now, return a mock response
-            StatusData mockData = new StatusData(0b11010001, new SoftwareVersion(1, 2, 3));
-            return new StatusResponse(true, "Status retrieved successfully", mockData);
+            // Extract status data from response
+            if (parsedResponse.data.length >= 4) {
+                int doorLockStatus = parsedResponse.data[0] & 0xFF;
+                int majorVersion = parsedResponse.data[1] & 0xFF;
+                int minorVersion = parsedResponse.data[2] & 0xFF;
+                int patchVersion = parsedResponse.data[3] & 0xFF;
+                
+                StatusData statusData = new StatusData(doorLockStatus, new SoftwareVersion(majorVersion, minorVersion, patchVersion));
+                return new StatusResponse(true, "Status retrieved successfully", statusData);
+            } else {
+                return new StatusResponse(false, "Invalid response data length", null);
+            }
             
         } catch (Exception e) {
             Log.e(TAG, "Error getting status", e);
@@ -292,22 +406,25 @@ public class IOBoardManager {
             // Convert LED color to RGB values
             LEDControl ledControl = getLEDControlFromColor(ledColor);
             
-            // Build data array for single pallet control
-            int[] data = new int[8];
-            data[0] = palletNumber;
-            data[1] = 1; // doorLock = true (unlock)
-            data[2] = ledControl.red;
-            data[3] = ledControl.green;
-            data[4] = ledControl.blue;
-            data[5] = ledControl.intensity;
-            data[6] = ledControl.blinkTimes;
-            data[7] = ledControl.blinkSpeed;
+            // Build single pallet control frame using IOBoardProtocolUtils
+            byte[] frame = IOBoardProtocolUtils.createSinglePalletControl(
+                (byte) address, palletNumber, true, 
+                ledControl.red, ledControl.green, ledControl.blue, 
+                ledControl.intensity, ledControl.blinkTimes, ledControl.blinkSpeed
+            );
+            
+            Log.d(TAG, "Sending unlock pallet frame: " + IOBoardProtocolUtils.frameToHex(frame));
             
-            int[] frame = buildFrame(address, FRAME_TYPE_SINGLE_PALLET, data);
+            // Send frame and wait for response
+            String response = sendCommandAndWaitResponse(frame, timeout);
             
-            Log.d(TAG, "Sending unlock pallet frame: " + frameToHex(frame));
+            // Parse response
+            IOBoardProtocolUtils.ParsedResponse parsedResponse = IOBoardProtocolUtils.parseResponse(response);
+            
+            if (!parsedResponse.success) {
+                return new IOBoardResponse(false, "Failed to parse response: " + parsedResponse.message);
+            }
             
-            // TODO: Send frame via serial port plugin and receive response
             return new IOBoardResponse(true, "Pallet " + palletNumber + " unlocked successfully");
             
         } catch (Exception e) {
@@ -330,30 +447,35 @@ public class IOBoardManager {
             // Convert LED color to RGB values
             LEDControl ledControl = getLEDControlFromColor(ledColor);
             
-            // Build data array for full pallet control
-            int[] data = new int[2 + (8 * 6)];
-            int index = 0;
-            
-            data[index++] = doorLockMask;
-            data[index++] = 0; // extendedControl
-            
-            // Add LED controls for 8 pallets
+            // Build LED controls array for 8 pallets
+            int[][] ledControls = new int[8][6];
             for (int i = 0; i < 8; i++) {
                 // If pallet is affected by mask, use specified LED color, otherwise turn off
-                LEDControl led = ((doorLockMask & (1 << i)) != 0) ? ledControl : new LEDControl(0, 0, 0, 0, 0, 0);
-                data[index++] = led.red;
-                data[index++] = led.green;
-                data[index++] = led.blue;
-                data[index++] = led.intensity;
-                data[index++] = led.blinkTimes;
-                data[index++] = led.blinkSpeed;
+                if ((doorLockMask & (1 << i)) != 0) {
+                    ledControls[i] = new int[]{ledControl.red, ledControl.green, ledControl.blue, 
+                                              ledControl.intensity, ledControl.blinkTimes, ledControl.blinkSpeed};
+                } else {
+                    ledControls[i] = new int[]{0, 0, 0, 0, 0, 1}; // Off
+                }
             }
             
-            int[] frame = buildFrame(address, FRAME_TYPE_FULL_PALLET, data);
+            // Build full pallet control frame using IOBoardProtocolUtils
+            byte[] frame = IOBoardProtocolUtils.createFullPalletControl(
+                (byte) address, doorLockMask, 0, ledControls
+            );
             
-            Log.d(TAG, "Sending multiple pallets control frame: " + frameToHex(frame));
+            Log.d(TAG, "Sending multiple pallets control frame: " + IOBoardProtocolUtils.frameToHex(frame));
+            
+            // Send frame and wait for response
+            String response = sendCommandAndWaitResponse(frame, timeout);
+            
+            // Parse response
+            IOBoardProtocolUtils.ParsedResponse parsedResponse = IOBoardProtocolUtils.parseResponse(response);
+            
+            if (!parsedResponse.success) {
+                return new IOBoardResponse(false, "Failed to parse response: " + parsedResponse.message);
+            }
             
-            // TODO: Send frame via serial port plugin and receive response
             return new IOBoardResponse(true, "Multiple pallets controlled successfully");
             
         } catch (Exception e) {
@@ -374,17 +496,52 @@ public class IOBoardManager {
         
         try {
             int deviceCount = endAddress - startAddress + 1;
-            DeviceInfo[] devices = new DeviceInfo[deviceCount];
+            List<DeviceInfo> deviceList = new ArrayList<>();
             
-            // TODO: Actually scan devices by sending status queries
-            // For now, create mock responses
+            // Scan each address by sending status queries
             for (int i = 0; i < deviceCount; i++) {
                 int address = startAddress + i;
-                boolean responding = (i % 3 == 0); // Mock: every 3rd device responds
-                StatusData status = responding ? new StatusData(0x00, new SoftwareVersion(1, 0, 0)) : null;
-                devices[i] = new DeviceInfo(address, responding, status);
+                
+                try {
+                    // Build status query frame using IOBoardProtocolUtils
+                    byte[] frame = IOBoardProtocolUtils.createStatusQuery((byte) address);
+                    
+                    Log.d(TAG, "Scanning address " + address + ": " + IOBoardProtocolUtils.frameToHex(frame));
+                    
+                    // Send frame and wait for response (with shorter timeout for scanning)
+                    String response = sendCommandAndWaitResponse(frame, Math.min(timeout, 1000));
+                    
+                    // Parse response
+                    IOBoardProtocolUtils.ParsedResponse parsedResponse = IOBoardProtocolUtils.parseResponse(response);
+                    
+                    if (parsedResponse.success) {
+                        // Device responded - extract status data
+                        StatusData status = null;
+                        if (parsedResponse.data.length >= 4) {
+                            int doorLockStatus = parsedResponse.data[0] & 0xFF;
+                            int majorVersion = parsedResponse.data[1] & 0xFF;
+                            int minorVersion = parsedResponse.data[2] & 0xFF;
+                            int patchVersion = parsedResponse.data[3] & 0xFF;
+                            
+                            status = new StatusData(doorLockStatus, new SoftwareVersion(majorVersion, minorVersion, patchVersion));
+                        }
+                        
+                        deviceList.add(new DeviceInfo(address, true, status));
+                        Log.d(TAG, "Device found at address " + address);
+                    } else {
+                        // No response or invalid response
+                        deviceList.add(new DeviceInfo(address, false, null));
+                        Log.d(TAG, "No response from address " + address);
+                    }
+                    
+                } catch (Exception e) {
+                    // Device not responding
+                    deviceList.add(new DeviceInfo(address, false, null));
+                    Log.d(TAG, "Error scanning address " + address + ": " + e.getMessage());
+                }
             }
             
+            DeviceInfo[] devices = deviceList.toArray(new DeviceInfo[0]);
             return new ScanResponse(true, "Scanned addresses " + startAddress + "-" + endAddress, devices);
             
         } catch (Exception e) {
@@ -446,15 +603,33 @@ public class IOBoardManager {
         }
         
         try {
-            // Build status query frame
-            int[] frame = buildFrame(address, FRAME_TYPE_STATUS_QUERY, new int[0]);
+            // Build status query frame using IOBoardProtocolUtils
+            byte[] frame = IOBoardProtocolUtils.createStatusQuery((byte) address);
+            
+            Log.d(TAG, "Sending status query frame: " + IOBoardProtocolUtils.frameToHex(frame));
             
-            Log.d(TAG, "Sending status query frame: " + frameToHex(frame));
+            // Send frame and wait for response
+            String response = sendCommandAndWaitResponse(frame, 5000);
             
-            // TODO: Send frame via serial port plugin and receive response
-            // For now, return a mock response
-            StatusData mockData = new StatusData(0x00, new SoftwareVersion(1, 0, 0));
-            return new StatusResponse(true, "Status queried successfully", mockData);
+            // Parse response
+            IOBoardProtocolUtils.ParsedResponse parsedResponse = IOBoardProtocolUtils.parseResponse(response);
+            
+            if (!parsedResponse.success) {
+                return new StatusResponse(false, "Failed to parse response: " + parsedResponse.message, null);
+            }
+            
+            // Extract status data from response
+            if (parsedResponse.data.length >= 4) {
+                int doorLockStatus = parsedResponse.data[0] & 0xFF;
+                int majorVersion = parsedResponse.data[1] & 0xFF;
+                int minorVersion = parsedResponse.data[2] & 0xFF;
+                int patchVersion = parsedResponse.data[3] & 0xFF;
+                
+                StatusData statusData = new StatusData(doorLockStatus, new SoftwareVersion(majorVersion, minorVersion, patchVersion));
+                return new StatusResponse(true, "Status queried successfully", statusData);
+            } else {
+                return new StatusResponse(false, "Invalid response data length", null);
+            }
             
         } catch (Exception e) {
             Log.e(TAG, "Error querying status", e);
@@ -473,22 +648,25 @@ public class IOBoardManager {
         }
         
         try {
-            // Build data array
-            int[] data = new int[8];
-            data[0] = palletNumber;
-            data[1] = doorLock ? 1 : 0;
-            data[2] = ledControl.red;
-            data[3] = ledControl.green;
-            data[4] = ledControl.blue;
-            data[5] = ledControl.intensity;
-            data[6] = ledControl.blinkTimes;
-            data[7] = ledControl.blinkSpeed;
-            
-            int[] frame = buildFrame(address, FRAME_TYPE_SINGLE_PALLET, data);
-            
-            Log.d(TAG, "Sending single pallet control frame: " + frameToHex(frame));
-            
-            // TODO: Send frame via serial port plugin and receive response
+            // Build single pallet control frame using IOBoardProtocolUtils
+            byte[] frame = IOBoardProtocolUtils.createSinglePalletControl(
+                (byte) address, palletNumber, doorLock,
+                ledControl.red, ledControl.green, ledControl.blue,
+                ledControl.intensity, ledControl.blinkTimes, ledControl.blinkSpeed
+            );
+            
+            Log.d(TAG, "Sending single pallet control frame: " + IOBoardProtocolUtils.frameToHex(frame));
+            
+            // Send frame and wait for response
+            String response = sendCommandAndWaitResponse(frame, 5000);
+            
+            // Parse response
+            IOBoardProtocolUtils.ParsedResponse parsedResponse = IOBoardProtocolUtils.parseResponse(response);
+            
+            if (!parsedResponse.success) {
+                return new IOBoardResponse(false, "Failed to parse response: " + parsedResponse.message);
+            }
+            
             return new IOBoardResponse(true, "Single pallet controlled successfully");
             
         } catch (Exception e) {
@@ -508,29 +686,33 @@ public class IOBoardManager {
         }
         
         try {
-            // Build data array: doorLockControl + extendedControl + 8 LED controls (6 bytes each)
-            int[] data = new int[2 + (8 * 6)];
-            int index = 0;
-            
-            data[index++] = doorLockControl;
-            data[index++] = extendedControl;
-            
-            // Add LED controls for 8 pallets
+            // Convert LEDControl array to int[][] for IOBoardProtocolUtils
+            int[][] ledControlsArray = new int[8][6];
             for (int i = 0; i < 8; i++) {
                 LEDControl led = (i < ledControls.length) ? ledControls[i] : new LEDControl(0, 0, 0, 0, 0, 0);
-                data[index++] = led.red;
-                data[index++] = led.green;
-                data[index++] = led.blue;
-                data[index++] = led.intensity;
-                data[index++] = led.blinkTimes;
-                data[index++] = led.blinkSpeed;
+                ledControlsArray[i] = new int[]{
+                    led.red, led.green, led.blue, 
+                    led.intensity, led.blinkTimes, led.blinkSpeed
+                };
             }
             
-            int[] frame = buildFrame(address, FRAME_TYPE_FULL_PALLET, data);
+            // Build full pallet control frame using IOBoardProtocolUtils
+            byte[] frame = IOBoardProtocolUtils.createFullPalletControl(
+                (byte) address, doorLockControl, extendedControl, ledControlsArray
+            );
+            
+            Log.d(TAG, "Sending full pallet control frame: " + IOBoardProtocolUtils.frameToHex(frame));
+            
+            // Send frame and wait for response
+            String response = sendCommandAndWaitResponse(frame, 5000);
             
-            Log.d(TAG, "Sending full pallet control frame: " + frameToHex(frame));
+            // Parse response
+            IOBoardProtocolUtils.ParsedResponse parsedResponse = IOBoardProtocolUtils.parseResponse(response);
+            
+            if (!parsedResponse.success) {
+                return new IOBoardResponse(false, "Failed to parse response: " + parsedResponse.message);
+            }
             
-            // TODO: Send frame via serial port plugin and receive response
             return new IOBoardResponse(true, "Full pallet controlled successfully");
             
         } catch (Exception e) {
@@ -550,21 +732,32 @@ public class IOBoardManager {
         }
         
         try {
-            // Build OTA notification data: version(3) + firmware size(4)
-            int[] data = new int[7];
-            data[0] = majorVersion;
-            data[1] = minorVersion;
-            data[2] = patchVersion;
-            data[3] = firmwareSize & 0xFF;
-            data[4] = (firmwareSize >> 8) & 0xFF;
-            data[5] = (firmwareSize >> 16) & 0xFF;
-            data[6] = (firmwareSize >> 24) & 0xFF;
-            
-            int[] frame = buildFrame(address, FRAME_TYPE_OTA_REQUEST, data);
-            
-            Log.d(TAG, "Sending OTA notification frame: " + frameToHex(frame));
+            // TODO: Add OTA notification method to IOBoardProtocolUtils
+            // For now, use manual frame building based on protocol specs
+            byte[] data = new byte[8]; // '?' + version(3) + firmware size(4)
+            data[0] = 0x3F; // '?' Notification header
+            data[1] = (byte) majorVersion;
+            data[2] = (byte) minorVersion;
+            data[3] = (byte) patchVersion;
+            data[4] = (byte) (firmwareSize & 0xFF);
+            data[5] = (byte) ((firmwareSize >> 8) & 0xFF);
+            data[6] = (byte) ((firmwareSize >> 16) & 0xFF);
+            data[7] = (byte) ((firmwareSize >> 24) & 0xFF);
+            
+            byte[] frame = IOBoardProtocolUtils.createFrame((byte) address, IOBoardProtocolUtils.FRAME_TYPE_OTA_REQUEST, data);
+            
+            Log.d(TAG, "Sending OTA notification frame: " + IOBoardProtocolUtils.frameToHex(frame));
+            
+            // Send frame and wait for response
+            String response = sendCommandAndWaitResponse(frame, 5000);
+            
+            // Parse response
+            IOBoardProtocolUtils.ParsedResponse parsedResponse = IOBoardProtocolUtils.parseResponse(response);
+            
+            if (!parsedResponse.success) {
+                return new IOBoardResponse(false, "Failed to parse response: " + parsedResponse.message);
+            }
             
-            // TODO: Send frame via serial port plugin and receive response
             return new IOBoardResponse(true, "OTA notification sent successfully");
             
         } catch (Exception e) {
@@ -587,64 +780,44 @@ public class IOBoardManager {
             // Decode base64 data
             byte[] firmwareData = Base64.decode(dataBase64, Base64.DEFAULT);
             
-            // Build OTA data: packet number(4) + data
-            int[] data = new int[4 + firmwareData.length];
-            data[0] = packetNumber & 0xFF;
-            data[1] = (packetNumber >> 8) & 0xFF;
-            data[2] = (packetNumber >> 16) & 0xFF;
-            data[3] = (packetNumber >> 24) & 0xFF;
-            
-            for (int i = 0; i < firmwareData.length; i++) {
-                data[4 + i] = firmwareData[i] & 0xFF;
+            // TODO: Add OTA data method to IOBoardProtocolUtils
+            // For now, use manual frame building based on protocol specs
+            byte[] data = new byte[4 + Math.min(firmwareData.length, 128)]; // Packet number(4) + Data content (max 128 bytes)
+            data[0] = (byte) (packetNumber & 0xFF);
+            data[1] = (byte) ((packetNumber >> 8) & 0xFF);
+            data[2] = (byte) ((packetNumber >> 16) & 0xFF);
+            data[3] = (byte) ((packetNumber >> 24) & 0xFF);
+            
+            // Copy firmware data (max 128 bytes as per protocol)
+            int dataLength = Math.min(firmwareData.length, 128);
+            System.arraycopy(firmwareData, 0, data, 4, dataLength);
+            
+            // Pad with zeros if needed
+            if (dataLength < 128) {
+                for (int i = 4 + dataLength; i < 4 + 128 && i < data.length; i++) {
+                    data[i] = 0;
+                }
             }
             
-            int[] frame = buildFrame(address, FRAME_TYPE_OTA_DATA, data);
+            byte[] frame = IOBoardProtocolUtils.createFrame((byte) address, IOBoardProtocolUtils.FRAME_TYPE_OTA_DATA, data);
             
-            Log.d(TAG, "Sending OTA data frame: " + frameToHex(frame));
+            Log.d(TAG, "Sending OTA data frame: " + IOBoardProtocolUtils.frameToHex(frame));
             
-            // TODO: Send frame via serial port plugin and receive response
-            return new IOBoardResponse(true, "OTA data sent successfully");
-            
-        } catch (Exception e) {
-            Log.e(TAG, "Error sending OTA data", e);
-            return new IOBoardResponse(false, "Error sending OTA data: " + e.getMessage());
-        }
-    }
-
-    /**
-     * Open serial connection
-     */
-    public IOBoardResponse openConnection(SerialConfig config) {
-        Log.d(TAG, "Opening serial connection - BaudRate: " + config.baudRate);
-        
-        try {
-            // TODO: Initialize connection with serial port plugin
-            // For now, just set the connected flag
-            isConnected = true;
+            // Send frame and wait for response
+            String response = sendCommandAndWaitResponse(frame, 5000);
             
-            return new IOBoardResponse(true, "Serial connection opened successfully");
+            // Parse response
+            IOBoardProtocolUtils.ParsedResponse parsedResponse = IOBoardProtocolUtils.parseResponse(response);
             
-        } catch (Exception e) {
-            Log.e(TAG, "Error opening connection", e);
-            return new IOBoardResponse(false, "Error opening connection: " + e.getMessage());
-        }
-    }
-
-    /**
-     * Close serial connection
-     */
-    public IOBoardResponse closeConnection() {
-        Log.d(TAG, "Closing serial connection");
-        
-        try {
-            // TODO: Close connection with serial port plugin
-            isConnected = false;
+            if (!parsedResponse.success) {
+                return new IOBoardResponse(false, "Failed to parse response: " + parsedResponse.message);
+            }
             
-            return new IOBoardResponse(true, "Serial connection closed successfully");
+            return new IOBoardResponse(true, "OTA data sent successfully");
             
         } catch (Exception e) {
-            Log.e(TAG, "Error closing connection", e);
-            return new IOBoardResponse(false, "Error closing connection: " + e.getMessage());
+            Log.e(TAG, "Error sending OTA data", e);
+            return new IOBoardResponse(false, "Error sending OTA data: " + e.getMessage());
         }
     }
 

package/android/src/main/java/com/leonardojc/capacitor/ioboard/IOBoardProtocolUtils.java

@@ -0,0 +1,290 @@
+package com.leonardojc.capacitor.ioboard;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * IOBOARD Protocol Helper Functions
+ * Protocolo actualizado según manual MTC3P08L
+ * Frame format: SOI | LEN | ADDR | TYPE | DATA | CRC | EOI
+ */
+public class IOBoardProtocolUtils {
+    
+    // Frame constants
+    public static final byte SOI = 0x0D; // Start of frame
+    public static final byte EOI = 0x0A; // End of frame
+    
+    // Frame types según manual actualizado
+    public static final byte FRAME_TYPE_STATUS_QUERY = 0x00;  // Status query
+    public static final byte FRAME_TYPE_SINGLE_PALLET = 0x01; // Parameter settings (single pallet)
+    public static final byte FRAME_TYPE_FULL_PALLET = 0x02;   // Parameter settings (full pallet)
+    public static final byte FRAME_TYPE_OTA_REQUEST = (byte) 0xF1; // OTA request
+    public static final byte FRAME_TYPE_OTA_DATA = (byte) 0xF2;    // OTA data
+    public static final byte FRAME_TYPE_OTA_RESPONSE = (byte) 0xF3; // OTA response
+    
+    /**
+     * CRC-16/Modbus (x16+x15+x2+1) según manual
+     */
+    public static int calculateCRC16(byte[] data) {
+        int crc = 0xFFFF;
+        for (byte b : data) {
+            crc ^= (b & 0xFF);
+            for (int j = 0; j < 8; j++) {
+                if ((crc & 0x0001) != 0) {
+                    crc = (crc >> 1) ^ 0xA001;
+                } else {
+                    crc = crc >> 1;
+                }
+            }
+        }
+        return crc & 0xFFFF;
+    }
+    
+    /**
+     * Formato de frame según manual: SOI | LEN | ADDR | TYPE | DATA | CRC | EOI
+     */
+    public static byte[] createFrame(byte address, byte frameType, byte[] data) {
+        if (data == null) data = new byte[0];
+        
+        int frameLength = 7 + data.length; // SOI(1) + LEN(1) + ADDR(1) + TYPE(1) + DATA(n) + CRC(2) + EOI(1)
+        byte[] frame = new byte[frameLength];
+        int index = 0;
+        
+        // SOI (Frame Header)
+        frame[index++] = SOI;
+        
+        // LEN (Data Length) - longitud completa del frame
+        frame[index++] = (byte) frameLength;
+        
+        // ADDR (Target Address)
+        frame[index++] = address;
+        
+        // TYPE (Frame Type)
+        frame[index++] = frameType;
+        
+        // DATA (Data Content)
+        for (byte b : data) {
+            frame[index++] = b;
+        }
+        
+        // Calculate CRC para todos los datos desde SOI hasta antes del CRC
+        byte[] crcData = new byte[index];
+        System.arraycopy(frame, 0, crcData, 0, index);
+        int crc = calculateCRC16(crcData);
+        
+        // CRC (Check Field) - Low byte first, High byte second según manual
+        frame[index++] = (byte) (crc & 0xFF);        // Low byte
+        frame[index++] = (byte) ((crc >> 8) & 0xFF); // High byte
+        
+        // EOI (Frame End)
+        frame[index] = EOI;
+        
+        return frame;
+    }
+    
+    /**
+     * Convert frame to hexadecimal string for debugging
+     */
+    public static String frameToHex(byte[] frame) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < frame.length; i++) {
+            if (i > 0) sb.append(" ");
+            sb.append(String.format("%02X", frame[i] & 0xFF));
+        }
+        return sb.toString();
+    }
+    
+    /**
+     * Convert frame to Latin-1 string preserving exact byte values
+     */
+    public static String frameToLatin1String(byte[] frame) {
+        StringBuilder result = new StringBuilder();
+        for (byte b : frame) {
+            result.append((char) (b & 0xFF));
+        }
+        return result.toString();
+    }
+    
+    /**
+     * Create status query frame
+     */
+    public static byte[] createStatusQuery(byte address) {
+        return createFrame(address, FRAME_TYPE_STATUS_QUERY, null);
+    }
+    
+    /**
+     * Single Pallet Control según manual: NUM | LOCK | LED (8 bytes)
+     */
+    public static byte[] createSinglePalletControl(byte address, int palletNumber, boolean doorLock, 
+                                                  int red, int green, int blue, int intensity, 
+                                                  int blinkTimes, int blinkSpeed) {
+        byte[] data = new byte[8];
+        data[0] = (byte) palletNumber;        // Pallet number (0-7)
+        data[1] = (byte) (doorLock ? 1 : 0);  // Door lock control (1=unlock, 0=no action)
+        data[2] = (byte) (red & 0xFF);        // RGB Red (0-255)
+        data[3] = (byte) (green & 0xFF);      // RGB Green (0-255)
+        data[4] = (byte) (blue & 0xFF);       // RGB Blue (0-255)
+        data[5] = (byte) (intensity & 0xFF);  // Intensity (0-100 percentage, >100 = max)
+        data[6] = (byte) (blinkTimes & 0xFF); // Blink times (0=no flash, 255=forever, 1-254=times)
+        data[7] = (byte) (blinkSpeed & 0xFF); // Blink speed (1-30 seconds interval)
+        
+        return createFrame(address, FRAME_TYPE_SINGLE_PALLET, data);
+    }
+    
+    /**
+     * Full Pallet Control según manual: LOCK | EXT | LED (8 x 6 bytes = 50 bytes total)
+     */
+    public static byte[] createFullPalletControl(byte address, int doorLockControl, int extendedControl, 
+                                               int[][] ledControls) {
+        byte[] data = new byte[50]; // 2 + (8 * 6)
+        int index = 0;
+        
+        data[index++] = (byte) (doorLockControl & 0xFF);  // Door lock control (8 bits)
+        data[index++] = (byte) (extendedControl & 0xFF);  // Extended control (8 bits)
+        
+        // Add LED controls (8 LEDs * 6 bytes each)
+        for (int i = 0; i < 8; i++) {
+            int[] led = (ledControls != null && i < ledControls.length && ledControls[i] != null) 
+                       ? ledControls[i] 
+                       : new int[]{0, 0, 0, 0, 0, 1}; // Default: off
+            
+            data[index++] = (byte) (led[0] & 0xFF); // RGB Red
+            data[index++] = (byte) (led[1] & 0xFF); // RGB Green
+            data[index++] = (byte) (led[2] & 0xFF); // RGB Blue
+            data[index++] = (byte) (led[3] & 0xFF); // Intensity
+            data[index++] = (byte) (led[4] & 0xFF); // Blink times
+            data[index++] = (byte) (led[5] & 0xFF); // Blink speed
+        }
+        
+        return createFrame(address, FRAME_TYPE_FULL_PALLET, data);
+    }
+    
+    /**
+     * Response parsing result
+     */
+    public static class ParsedResponse {
+        public boolean success;
+        public String message;
+        public byte address;
+        public byte frameType;
+        public byte[] data;
+        
+        public ParsedResponse(boolean success, String message) {
+            this.success = success;
+            this.message = message;
+        }
+        
+        public ParsedResponse(boolean success, String message, byte address, byte frameType, byte[] data) {
+            this.success = success;
+            this.message = message;
+            this.address = address;
+            this.frameType = frameType;
+            this.data = data;
+        }
+    }
+    
+    /**
+     * Parse response frame según formato: SOI | LEN | ADDR | TYPE | DATA | CRC | EOI
+     */
+    public static ParsedResponse parseResponse(String responseString) {
+        if (responseString == null || responseString.length() < 7) {
+            return new ParsedResponse(false, "Response too short");
+        }
+        
+        byte[] allBytes = responseString.getBytes(java.nio.charset.StandardCharsets.ISO_8859_1);
+        
+        byte soi = allBytes[0];
+        if (soi != SOI) {
+            return new ParsedResponse(false, "Invalid SOI");
+        }
+        
+        int len = allBytes[1] & 0xFF;
+        if (len > allBytes.length) {
+            return new ParsedResponse(false, "Invalid frame length");
+        }
+        
+        // Extraer solo los bytes que corresponden al frame
+        byte[] bytes = new byte[len];
+        System.arraycopy(allBytes, 0, bytes, 0, len);
+        
+        byte address = bytes[2];
+        byte frameType = bytes[3];
+        byte eoi = bytes[len - 1];
+        
+        if (eoi != EOI) {
+            return new ParsedResponse(false, "Invalid EOI");
+        }
+        
+        // Extract data (excluding SOI, LEN, ADDR, TYPE, CRC, CRC, EOI)
+        int dataLength = len - 7;
+        byte[] data = new byte[dataLength];
+        if (dataLength > 0) {
+            System.arraycopy(bytes, 4, data, 0, dataLength);
+        }
+        
+        // Extract CRC
+        int receivedCrcLow = bytes[4 + dataLength] & 0xFF;
+        int receivedCrcHigh = bytes[4 + dataLength + 1] & 0xFF;
+        int receivedCrc = receivedCrcLow | (receivedCrcHigh << 8);
+        
+        // Verify CRC
+        byte[] crcData = new byte[4 + dataLength];
+        System.arraycopy(bytes, 0, crcData, 0, 4 + dataLength);
+        int calculatedCrc = calculateCRC16(crcData);
+        
+        if (receivedCrc != calculatedCrc) {
+            return new ParsedResponse(false, "CRC verification failed");
+        }
+        
+        return new ParsedResponse(true, "Response parsed successfully", address, frameType, data);
+    }
+    
+    /**
+     * Create test frames based on manual examples
+     */
+    public static byte[] createTestStatusQuery() {
+        return createStatusQuery((byte) 1); // Address 01
+    }
+    
+    public static byte[] createTestSinglePallet() {
+        return createSinglePalletControl((byte) 1, 0, true, 255, 0, 0, 255, 16, 1);
+    }
+    
+    /**
+     * Validate that our commands match manual examples
+     */
+    public static String validateExamples() {
+        StringBuilder results = new StringBuilder();
+        
+        // Test Status Query
+        byte[] statusFrame = createTestStatusQuery();
+        String statusHex = frameToHex(statusFrame);
+        String expectedStatus = "0D 07 01 00 B2 D9 0A";
+        results.append("Status Query - Expected: ").append(expectedStatus)
+               .append(", Actual: ").append(statusHex)
+               .append(", Match: ").append(statusHex.equals(expectedStatus))
+               .append("\n");
+        
+        // Test Single Pallet
+        byte[] singleFrame = createTestSinglePallet();
+        String singleHex = frameToHex(singleFrame);
+        String expectedSingle = "0D 0F 01 01 00 01 FF 00 00 FF 10 01 1D 6F 0A";
+        results.append("Single Pallet - Expected: ").append(expectedSingle)
+               .append(", Actual: ").append(singleHex)
+               .append(", Match: ").append(singleHex.equals(expectedSingle));
+        
+        return results.toString();
+    }
+    
+    /**
+     * Convert frame bytes to Latin-1 encoded string for transmission
+     */
+    public static String frameToLatin1String(byte[] frame) {
+        try {
+            return new String(frame, "ISO-8859-1");
+        } catch (Exception e) {
+            // Fallback to default encoding
+            return new String(frame, java.nio.charset.StandardCharsets.ISO_8859_1);
+        }
+    }
+}

package/dist/esm/definitions.d.ts

@@ -81,6 +81,7 @@ export interface UnlockPalletOptions extends DeviceOptions {
 }
 export interface MultiplePalletOptions extends DeviceOptions {
     doorLockMask: number;
+    ledColor?: 'red' | 'green' | 'blue' | 'yellow' | 'white' | 'off';
     ledControls?: LEDControlOptions[];
 }
 export interface ScanOptions {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@leonardojc/capacitor-ioboard",
-  "version": "1.1.0",
-  "description": "A Capacitor plugin for controlling custom IOBOARD devices via RS485 serial communication with simplified native API",
+  "version": "1.2.1",
+  "description": "A Capacitor plugin for controlling custom IOBOARD devices via RS485 serial communication with full native protocol implementation",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
   "types": "dist/esm/index.d.ts",