@leonardojc/capacitor-ioboard 1.1.0 → 1.2.0

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

@@ -3,26 +3,21 @@ package com.leonardojc.capacitor.ioboard;
 import android.util.Log;
 import android.util.Base64;
 import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.concurrent.TimeUnit;
 
 /**
  * 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;
     
     private boolean isConnected = false;
+    private String currentSerialPortId = null;
 
     // Response classes
     public static class IOBoardResponse {
@@ -127,89 +122,18 @@ public class IOBoardManager {
     }
 
     /**
-     * Calculate CRC-16 CCITT checksum
-     */
-    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;
-            }
-        }
-        
-        return crc;
-    }
-
-    /**
-     * Build a command frame for IOBOARD
-     */
-    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;
-        }
-        
-        // 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;
-    }
-
-    /**
-     * Convert frame to byte array for serial transmission
-     */
-    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);
-        }
-        return bytes;
-    }
-
-    /**
-     * Convert frame to hex string for debugging
+     * Send command via SerialPort plugin 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]));
-        }
-        return sb.toString();
+    private String sendCommandAndWaitResponse(byte[] command, int timeoutMs) throws Exception {
+        // TODO: Integrate with @leonardojc/capacitor-serial-port plugin
+        // This method should:
+        // 1. Convert command to appropriate format for SerialPort plugin
+        // 2. Call SerialPort.writeData(portId, data)
+        // 3. Wait for response using SerialPort.readData() or data listeners
+        // 4. Return response string
+        
+        // For now, return mock response for testing
+        throw new Exception("SerialPort integration not yet implemented");
     }
 
     // New simplified API methods
@@ -221,9 +145,13 @@ public class IOBoardManager {
         Log.d(TAG, "Connecting to serial port: " + config.portPath + " at " + config.baudRate + " baud");
         
         try {
-            // TODO: Initialize connection with serial port plugin
+            // TODO: Initialize connection with SerialPort plugin
+            // Call SerialPort.openConnection() with config parameters
+            // Store the returned port ID for future operations
+            
             // For now, just set the connected flag
             isConnected = true;
+            currentSerialPortId = "mock_port_id";
             
             return new IOBoardResponse(true, "Connected to " + config.portPath + " successfully");
             
@@ -240,8 +168,11 @@ public class IOBoardManager {
         Log.d(TAG, "Disconnecting from serial port");
         
         try {
-            // TODO: Close connection with serial port plugin
+            // TODO: Close connection with SerialPort plugin
+            // Call SerialPort.closeConnection(currentSerialPortId)
+            
             isConnected = false;
+            currentSerialPortId = null;
             
             return new IOBoardResponse(true, "Disconnected successfully");
             
@@ -262,15 +193,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);
             
-            // 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);
+            // 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 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 +241,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 +282,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: " + IOBoardProtocolUtils.frameToHex(frame));
+            
+            // Send frame and wait for response
+            String response = sendCommandAndWaitResponse(frame, timeout);
             
-            Log.d(TAG, "Sending multiple pallets 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, "Multiple pallets controlled successfully");
             
         } catch (Exception e) {
@@ -374,17 +331,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 +438,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));
+            
+            // Send frame and wait for response
+            String response = sendCommandAndWaitResponse(frame, 5000);
             
-            Log.d(TAG, "Sending status query frame: " + frameToHex(frame));
+            // 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(0x00, new SoftwareVersion(1, 0, 0));
-            return new StatusResponse(true, "Status queried 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 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 +483,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 +521,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));
             
-            Log.d(TAG, "Sending full pallet control frame: " + 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, "Full pallet controlled successfully");
             
         } catch (Exception e) {
@@ -550,21 +567,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,22 +615,39 @@ 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: " + IOBoardProtocolUtils.frameToHex(frame));
+            
+            // Send frame and wait for response
+            String response = sendCommandAndWaitResponse(frame, 5000);
             
-            Log.d(TAG, "Sending OTA data 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, "OTA data sent successfully");
             
         } catch (Exception e) {
@@ -615,12 +660,15 @@ public class IOBoardManager {
      * Open serial connection
      */
     public IOBoardResponse openConnection(SerialConfig config) {
-        Log.d(TAG, "Opening serial connection - BaudRate: " + config.baudRate);
+        Log.d(TAG, "Opening serial connection - Port: " + config.portPath + ", BaudRate: " + config.baudRate);
         
         try {
-            // TODO: Initialize connection with serial port plugin
-            // For now, just set the connected flag
+            // TODO: Initialize connection with SerialPort plugin
+            // Call SerialPort.openConnection() with config parameters
+            // Store the returned port ID for future operations
+            
             isConnected = true;
+            currentSerialPortId = "mock_port_id";
             
             return new IOBoardResponse(true, "Serial connection opened successfully");
             
@@ -637,8 +685,11 @@ public class IOBoardManager {
         Log.d(TAG, "Closing serial connection");
         
         try {
-            // TODO: Close connection with serial port plugin
+            // TODO: Close connection with SerialPort plugin
+            // Call SerialPort.closeConnection(currentSerialPortId)
+            
             isConnected = false;
+            currentSerialPortId = null;
             
             return new IOBoardResponse(true, "Serial connection closed successfully");
             

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

@@ -0,0 +1,278 @@
+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();
+    }
+}

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.0",
+  "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",