@leonardojc/capacitor-ioboard 1.2.7 → 2.0.0

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

@@ -1,381 +1,926 @@
-package com.leonardojc.capacitor.ioboard;
-
-import com.getcapacitor.JSArray;
-import com.getcapacitor.JSObject;
-import com.getcapacitor.Plugin;
-import com.getcapacitor.PluginCall;
-import com.getcapacitor.PluginMethod;
-import com.getcapacitor.annotation.CapacitorPlugin;
-import android.util.Log;
-import java.util.Arrays;
-import org.json.JSONObject;
-
-@CapacitorPlugin(name = "CapacitorIoboard")
-public class CapacitorIoboardPlugin extends Plugin implements IOBoardManager.SerialPortInterface {
-
-    private static final String TAG = "CapacitorIoboard";
-    private IOBoardManager ioboardManager;
-
-    @Override
-    public void load() {
-        super.load();
-        ioboardManager = new IOBoardManager(this); // Pass this plugin as SerialPortInterface
-    }
-
-    // SerialPortInterface implementation - simplified approach
-    @Override
-    public void openPort(String portPath, int baudRate, IOBoardManager.SerialPortCallback callback) {
-        Log.d(TAG, "SerialPortInterface: Opening port " + portPath + " at " + baudRate + " baud");
-        
-        // For now, we'll simulate a successful connection
-        // In a real implementation, this would call the actual SerialPort plugin
-        JSObject result = new JSObject();
-        result.put("success", true);
-        result.put("message", "Port opened successfully");
-        callback.onSuccess(result);
-    }
-
-    @Override
-    public void closePort(IOBoardManager.SerialPortCallback callback) {
-        Log.d(TAG, "SerialPortInterface: Closing port");
-        
-        JSObject result = new JSObject();
-        result.put("success", true);
-        result.put("message", "Port closed successfully");
-        callback.onSuccess(result);
-    }
-
-    @Override
-    public void sendData(byte[] data, IOBoardManager.SerialPortCallback callback) {
-        Log.d(TAG, "SerialPortInterface: Sending data: " + IOBoardProtocolUtils.frameToHex(data));
-        
-        JSObject result = new JSObject();
-        result.put("success", true);
-        result.put("message", "Data sent successfully");
-        callback.onSuccess(result);
-    }
-
-    @Override
-    public void readData(int timeout, IOBoardManager.SerialPortCallback callback) {
-        Log.d(TAG, "SerialPortInterface: Reading data with timeout " + timeout + "ms");
-        
-        // For now, simulate a response - in reality this would read from SerialPort
-        // This should return a hex string of the response data
-        JSObject result = new JSObject();
-        result.put("success", true);
-        result.put("data", "0D0701018A750A"); // Example response
-        callback.onSuccess(result);
-    }
-
-    // New simplified API methods
-    @PluginMethod
-    public void connect(PluginCall call) {
-        String portPath = call.getString("portPath", "/dev/ttyS2");
-        Integer baudRate = call.getInt("baudRate", 115200);
-        Integer dataBits = call.getInt("dataBits", 8);
-        Integer stopBits = call.getInt("stopBits", 1);
-        String parity = call.getString("parity", "none");
-        String flowControl = call.getString("flowControl", "none");
-        Integer timeout = call.getInt("timeout", 5000);
-
-        try {
-            IOBoardManager.SerialConfig config = new IOBoardManager.SerialConfig(
-                portPath, baudRate, dataBits, stopBits, parity, flowControl, timeout
-            );
-
-            IOBoardManager.IOBoardResponse response = ioboardManager.connect(config);
-
-            JSObject result = new JSObject();
-            result.put("success", response.success);
-            result.put("message", response.message);
-            
-            call.resolve(result);
-        } catch (Exception e) {
-            Log.e(TAG, "Error connecting", e);
-            call.reject("Failed to connect: " + e.getMessage());
-        }
-    }
-
-    @PluginMethod
-    public void disconnect(PluginCall call) {
-        try {
-            IOBoardManager.IOBoardResponse response = ioboardManager.disconnect();
-
-            JSObject result = new JSObject();
-            result.put("success", response.success);
-            result.put("message", response.message);
-            
-            call.resolve(result);
-        } catch (Exception e) {
-            Log.e(TAG, "Error disconnecting", e);
-            call.reject("Failed to disconnect: " + e.getMessage());
-        }
-    }
-
-    @PluginMethod
-    public void isConnected(PluginCall call) {
-        try {
-            boolean connected = ioboardManager.isConnected();
-            JSObject result = new JSObject();
-            result.put("connected", connected);
-            call.resolve(result);
-        } catch (Exception e) {
-            Log.e(TAG, "Error checking connection status", e);
-            call.reject("Failed to check connection status: " + e.getMessage());
-        }
-    }
-
-    @PluginMethod
-    public void getStatus(PluginCall call) {
-        Integer address = call.getInt("address");
-        Integer timeout = call.getInt("timeout", 5000);
-        
-        if (address == null || address < 1 || address > 63) {
-            call.reject("Invalid address. Must be between 1 and 63");
-            return;
-        }
-
-        try {
-            IOBoardManager.StatusResponse response = ioboardManager.getStatus(address, timeout);
-            
-            JSObject result = new JSObject();
-            result.put("success", response.success);
-            result.put("message", response.message);
-            
-            if (response.success && response.data != null) {
-                JSObject data = new JSObject();
-                data.put("doorLockStatus", response.data.doorLockStatus);
-                
-                JSObject version = new JSObject();
-                version.put("major", response.data.softwareVersion.major);
-                version.put("minor", response.data.softwareVersion.minor);
-                version.put("patch", response.data.softwareVersion.patch);
-                data.put("softwareVersion", version);
-                
-                result.put("data", data);
-            }
-            
-            call.resolve(result);
-        } catch (Exception e) {
-            Log.e(TAG, "Error getting status", e);
-            call.reject("Failed to get status: " + e.getMessage());
-        }
-    }
-
-    @PluginMethod
-    public void unlockPallet(PluginCall call) {
-        Integer address = call.getInt("address");
-        Integer palletNumber = call.getInt("palletNumber");
-        String ledColor = call.getString("ledColor", "green");
-        Integer timeout = call.getInt("timeout", 5000);
-
-        if (address == null || address < 1 || address > 63) {
-            call.reject("Invalid address. Must be between 1 and 63");
-            return;
-        }
-
-        if (palletNumber == null || palletNumber < 0 || palletNumber > 7) {
-            call.reject("Invalid pallet number. Must be between 0 and 7");
-            return;
-        }
-
-        try {
-            IOBoardManager.IOBoardResponse response = ioboardManager.unlockPallet(
-                address, palletNumber, ledColor, timeout
-            );
-
-            JSObject result = new JSObject();
-            result.put("success", response.success);
-            result.put("message", response.message);
-            
-            if (response.success) {
-                JSObject data = new JSObject();
-                data.put("address", address);
-                data.put("palletNumber", palletNumber);
-                data.put("ledColor", ledColor);
-                result.put("data", data);
-            }
-            
-            call.resolve(result);
-        } catch (Exception e) {
-            Log.e(TAG, "Error unlocking pallet", e);
-            call.reject("Failed to unlock pallet: " + e.getMessage());
-        }
-    }
-
-    @PluginMethod
-    public void controlMultiplePallets(PluginCall call) {
-        Integer address = call.getInt("address");
-        Integer doorLockMask = call.getInt("doorLockMask", 0);
-        String ledColor = call.getString("ledColor", "green");
-        Integer timeout = call.getInt("timeout", 5000);
-
-        if (address == null || address < 1 || address > 63) {
-            call.reject("Invalid address. Must be between 1 and 63");
-            return;
-        }
-
-        try {
-            IOBoardManager.IOBoardResponse response = ioboardManager.controlMultiplePallets(
-                address, doorLockMask, ledColor, timeout
-            );
-
-            JSObject result = new JSObject();
-            result.put("success", response.success);
-            result.put("message", response.message);
-            
-            if (response.success) {
-                JSObject data = new JSObject();
-                data.put("address", address);
-                data.put("doorLockMask", doorLockMask);
-                
-                // Calculate affected pallets from mask
-                JSArray affectedPallets = new JSArray();
-                for (int i = 0; i < 8; i++) {
-                    if ((doorLockMask & (1 << i)) != 0) {
-                        affectedPallets.put(i);
-                    }
-                }
-                data.put("affectedPallets", affectedPallets);
-                result.put("data", data);
-            }
-            
-            call.resolve(result);
-        } catch (Exception e) {
-            Log.e(TAG, "Error controlling multiple pallets", e);
-            call.reject("Failed to control multiple pallets: " + e.getMessage());
-        }
-    }
-
-    @PluginMethod
-    public void scanDevices(PluginCall call) {
-        Integer startAddress = call.getInt("startAddress", 1);
-        Integer endAddress = call.getInt("endAddress", 63);
-        Integer timeout = call.getInt("timeout", 1000);
-
-        if (startAddress < 1 || startAddress > 63) {
-            call.reject("Invalid start address. Must be between 1 and 63");
-            return;
-        }
-
-        if (endAddress < 1 || endAddress > 63 || endAddress < startAddress) {
-            call.reject("Invalid end address. Must be between 1 and 63 and >= start address");
-            return;
-        }
-
-        try {
-            IOBoardManager.ScanResponse response = ioboardManager.scanDevices(
-                startAddress, endAddress, timeout
-            );
-
-            JSObject result = new JSObject();
-            result.put("success", response.success);
-            result.put("message", response.message);
-            
-            if (response.success && response.devices != null) {
-                JSArray devicesArray = new JSArray();
-                for (IOBoardManager.DeviceInfo device : response.devices) {
-                    JSObject deviceObj = new JSObject();
-                    deviceObj.put("address", device.address);
-                    deviceObj.put("responding", device.responding);
-                    
-                    if (device.status != null) {
-                        JSObject statusObj = new JSObject();
-                        statusObj.put("doorLockStatus", device.status.doorLockStatus);
-                        deviceObj.put("status", statusObj);
-                    }
-                    
-                    devicesArray.put(deviceObj);
-                }
-                result.put("devices", devicesArray);
-            }
-            
-            call.resolve(result);
-        } catch (Exception e) {
-            Log.e(TAG, "Error scanning devices", e);
-            call.reject("Failed to scan devices: " + e.getMessage());
-        }
-    }
-
-    @PluginMethod
-    public void sendOTANotification(PluginCall call) {
-        Integer address = call.getInt("address");
-        Integer majorVersion = call.getInt("majorVersion");
-        Integer minorVersion = call.getInt("minorVersion");
-        Integer patchVersion = call.getInt("patchVersion");
-        Integer firmwareSize = call.getInt("firmwareSize");
-
-        if (address == null || address < 1 || address > 63) {
-            call.reject("Invalid address. Must be between 1 and 63");
-            return;
-        }
-
-        if (majorVersion == null || minorVersion == null || patchVersion == null || firmwareSize == null) {
-            call.reject("All OTA parameters are required");
-            return;
-        }
-
-        try {
-            IOBoardManager.IOBoardResponse response = ioboardManager.sendOTANotification(
-                address, majorVersion, minorVersion, patchVersion, firmwareSize
-            );
-
-            JSObject result = new JSObject();
-            result.put("success", response.success);
-            result.put("message", response.message);
-            
-            if (response.success) {
-                JSObject data = new JSObject();
-                data.put("address", address);
-                data.put("version", majorVersion + "." + minorVersion + "." + patchVersion);
-                data.put("firmwareSize", firmwareSize);
-                result.put("data", data);
-            }
-            
-            call.resolve(result);
-        } catch (Exception e) {
-            Log.e(TAG, "Error sending OTA notification", e);
-            call.reject("Failed to send OTA notification: " + e.getMessage());
-        }
-    }
-
-    @PluginMethod
-    public void sendOTAData(PluginCall call) {
-        Integer address = call.getInt("address");
-        Integer packetNumber = call.getInt("packetNumber");
-        String dataBase64 = call.getString("data");
-
-        if (address == null || address < 1 || address > 63) {
-            call.reject("Invalid address. Must be between 1 and 63");
-            return;
-        }
-
-        if (packetNumber == null || dataBase64 == null) {
-            call.reject("Packet number and data are required");
-            return;
-        }
-
-        try {
-            IOBoardManager.IOBoardResponse response = ioboardManager.sendOTAData(
-                address, packetNumber, dataBase64
-            );
-
-            JSObject result = new JSObject();
-            result.put("success", response.success);
-            result.put("message", response.message);
-            
-            if (response.success) {
-                JSObject data = new JSObject();
-                data.put("address", address);
-                data.put("packetNumber", packetNumber);
-                data.put("dataLength", dataBase64.length());
-                result.put("data", data);
-            }
-            
-            call.resolve(result);
-        } catch (Exception e) {
-            Log.e(TAG, "Error sending OTA data", e);
-            call.reject("Failed to send OTA data: " + e.getMessage());
-        }
-    }
-}
+package com.leonardojc.capacitor.ioboard;
+
+import android.util.Log;
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import java.util.List;
+import java.util.ArrayList;
+
+@CapacitorPlugin(name = "CapacitorIoboard")
+public class CapacitorIoboardPlugin extends Plugin implements SerialConnectionManager.SerialDataListener {
+
+    private static final String TAG = "CapacitorIoboard";
+    private SerialConnectionManager serialManager;
+    private IOBoardManager ioBoardManager;
+    private boolean isConnected = false;
+    private String currentDeviceInfo = "";
+    private String lastError = "";
+
+    // Helper method to convert bytes to hex string for debugging
+    private String bytesToHex(byte[] bytes) {
+        StringBuilder hexString = new StringBuilder();
+        for (byte b : bytes) {
+            String hex = Integer.toHexString(0xFF & b);
+            if (hex.length() == 1) {
+                hexString.append('0');
+            }
+            hexString.append(hex.toUpperCase()).append(" ");
+        }
+        return hexString.toString().trim();
+    }
+
+    // Helper method to convert string to detailed debug info
+    private String getDetailedCommandInfo(String command) {
+        StringBuilder info = new StringBuilder();
+        info.append("String: '").append(command).append("'");
+        info.append(", Length: ").append(command.length());
+        info.append(", Chars: [");
+        for (int i = 0; i < command.length(); i++) {
+            char c = command.charAt(i);
+            if (i > 0) info.append(", ");
+            if (c == '\n') {
+                info.append("\\n(10)");
+            } else if (c == '\r') {
+                info.append("\\r(13)");
+            } else if (c >= 32 && c <= 126) {
+                info.append("'").append(c).append("'(").append((int)c).append(")");
+            } else {
+                info.append("(").append((int)c).append(")");
+            }
+        }
+        info.append("]");
+        return info.toString();
+    }
+
+    @Override
+    public void load() {
+        Log.d(TAG, "Plugin loaded");
+        serialManager = new SerialConnectionManager();
+        serialManager.setDataListener(this);
+        ioBoardManager = new IOBoardManager();
+    }
+
+    @PluginMethod
+    public void connect(PluginCall call) {
+        String portName = call.getString("portName");
+        Integer baudRate = call.getInt("baudRate", 115200);
+
+        if (portName == null) {
+            call.reject("Port name is required");
+            return;
+        }
+
+        try {
+            boolean connected = serialManager.openPort(portName, baudRate, 8, 1, "none");
+            if (connected) {
+                isConnected = true;
+                currentDeviceInfo = "Connected to " + portName + " at " + baudRate + " baud";
+                
+                JSObject result = new JSObject();
+                result.put("success", true);
+                result.put("deviceInfo", currentDeviceInfo);
+                call.resolve(result);
+                
+                notifyListeners("connectionStatusChanged", result);
+            } else {
+                lastError = "Failed to connect to " + portName;
+                call.reject(lastError);
+            }
+        } catch (Exception e) {
+            lastError = "Connection error: " + e.getMessage();
+            Log.e(TAG, lastError, e);
+            call.reject(lastError);
+        }
+    }
+
+    @PluginMethod
+    public void disconnect(PluginCall call) {
+        try {
+            serialManager.closePort();
+            isConnected = false;
+            currentDeviceInfo = "";
+            
+            JSObject result = new JSObject();
+            result.put("success", true);
+            call.resolve(result);
+            
+            notifyListeners("connectionStatusChanged", result);
+        } catch (Exception e) {
+            lastError = "Disconnect error: " + e.getMessage();
+            Log.e(TAG, lastError, e);
+            call.reject(lastError);
+        }
+    }
+
+        @PluginMethod
+    public void getStatus(PluginCall call) {
+        Log.d(TAG, "📊 getStatus called");
+        
+        if (serialManager == null) {
+            call.reject("Serial connection not initialized");
+            return;
+        }
+        
+        if (!serialManager.isConnected()) {
+            call.reject("Not connected to serial port");
+            return;
+        }
+        
+        try {
+            int address = call.getInt("address", 1);
+            byte[] statusFrame = createStatusQueryFrame(address);
+            boolean success = serialManager.writeData(statusFrame);
+            
+            if (success) {
+                JSObject result = new JSObject();
+                result.put("success", true);
+                result.put("message", "Status query sent successfully");
+                result.put("address", address);
+                call.resolve(result);
+            } else {
+                call.reject("Failed to send status query");
+            }
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error in getStatus: " + e.getMessage(), e);
+            call.reject("Error getting status: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void getConnectionInfo(PluginCall call) {
+        Log.d(TAG, "🔌 getConnectionInfo called");
+        
+        try {
+            List<String> ports = serialManager.listAvailablePorts();
+            boolean isConnected = serialManager.isConnected();
+            String currentPort = serialManager.getCurrentPortPath();
+            
+            JSObject result = new JSObject();
+            result.put("connected", isConnected);
+            result.put("currentPort", currentPort != null ? currentPort : "");
+            result.put("availablePorts", new JSArray(ports));
+            
+            call.resolve(result);
+        } catch (Exception e) {
+            Log.e(TAG, "Error getting connection info: " + e.getMessage(), e);
+            call.reject("Error getting connection info: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void controlMultiplePallets(PluginCall call) {
+        Log.d(TAG, "🎯 controlMultiplePallets called");
+        
+        if (serialManager == null) {
+            call.reject("Serial connection not initialized");
+            return;
+        }
+        
+        if (!serialManager.isConnected()) {
+            call.reject("Not connected to serial port");
+            return;
+        }
+        
+        try {
+            // TEMPORAL: Generar exactamente el frame de la documentación
+            // Address: 01; Unlock: 01; Extended output: 80; 
+            // All 8 LEDs: flashing red, brightness 255, flashing 16 times, interval 1 second
+            Log.d(TAG, "🧪 TESTING: Generating exact documentation frame");
+            
+            int address = 1;
+            String color = "RED";
+            int intensity = 255;  // FF en hex
+            int blinkTimes = 16;  // 10 en hex
+            int blinkSpeed = 1;   // 01 en hex
+            
+            // Usar todos los pallets (1-8) como en el ejemplo
+            List<Integer> allPallets = new ArrayList<>();
+            for (int i = 1; i <= 8; i++) {
+                allPallets.add(i);
+            }
+            
+            byte[] frame = createMultiplePalletsFrame(address, color, intensity, blinkTimes, blinkSpeed, allPallets);
+            boolean success = serialManager.writeData(frame);
+            
+            if (success) {
+                JSObject result = new JSObject();
+                result.put("success", true);
+                result.put("message", String.format("TEST: Documentation frame sent - %d pallets with %s LEDs (intensity=%d, blink=%d)", 
+                    allPallets.size(), color, intensity, blinkTimes));
+                result.put("address", address);
+                result.put("palletsCount", allPallets.size());
+                call.resolve(result);
+            } else {
+                call.reject("Failed to send multiple pallets command");
+            }
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error in controlMultiplePallets: " + e.getMessage(), e);
+            call.reject("Error controlling multiple pallets: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void listPorts(PluginCall call) {
+        try {
+            List<String> ports = serialManager.listAvailablePorts();
+            Log.d(TAG, "Found " + ports.size() + " ports: " + ports.toString());
+            
+            JSArray portsArray = new JSArray();
+            for (String port : ports) {
+                portsArray.put(port);
+            }
+            
+            JSObject result = new JSObject();
+            result.put("success", true);
+            result.put("ports", portsArray);
+            call.resolve(result);
+        } catch (Exception e) {
+            Log.e(TAG, "Error listing ports", e);
+            JSObject errorResult = new JSObject();
+            errorResult.put("success", false);
+            errorResult.put("error", "Error listing ports: " + e.getMessage());
+            call.resolve(errorResult);
+        }
+    }
+
+    @PluginMethod
+    public void sendRawCommand(PluginCall call) {
+        if (!isConnected) {
+            JSObject errorResult = new JSObject();
+            errorResult.put("success", false);
+            errorResult.put("error", "Not connected to device");
+            call.resolve(errorResult);
+            return;
+        }
+
+        String command = call.getString("command");
+        if (command == null) {
+            JSObject errorResult = new JSObject();
+            errorResult.put("success", false);
+            errorResult.put("error", "Command is required");
+            call.resolve(errorResult);
+            return;
+        }
+
+        try {
+            // Detailed logging before sending
+            Log.d(TAG, "=== SENDING COMMAND ===");
+            Log.d(TAG, "Command details: " + getDetailedCommandInfo(command));
+            
+            byte[] commandBytes = command.getBytes();
+            Log.d(TAG, "Bytes to send (length=" + commandBytes.length + "): " + bytesToHex(commandBytes));
+            Log.d(TAG, "Raw bytes: " + java.util.Arrays.toString(commandBytes));
+            
+            boolean sent = serialManager.writeData(commandBytes);
+            
+            if (sent) {
+                Log.i(TAG, "✅ Command successfully written to serial port");
+                Log.i(TAG, "HEX sent: " + bytesToHex(commandBytes));
+            } else {
+                Log.e(TAG, "❌ Failed to write command to serial port");
+            }
+            
+            JSObject result = new JSObject();
+            result.put("success", sent);
+            result.put("command", command);
+            result.put("hexSent", bytesToHex(commandBytes));
+            result.put("bytesLength", commandBytes.length);
+            if (!sent) {
+                result.put("error", "Failed to send command");
+            }
+            call.resolve(result);
+        } catch (Exception e) {
+            String error = "Error sending raw command: " + e.getMessage();
+            Log.e(TAG, error, e);
+            JSObject errorResult = new JSObject();
+            errorResult.put("success", false);
+            errorResult.put("error", error);
+            call.resolve(errorResult);
+        }
+    }
+
+    // SerialDataListener implementation
+    @Override
+    public void onDataReceived(byte[] data) {
+        String dataString = new String(data);
+        Log.d(TAG, "Data received: " + dataString);
+        
+        JSObject result = new JSObject();
+        result.put("rawData", dataString);
+        result.put("timestamp", System.currentTimeMillis());
+        
+        notifyListeners("dataReceived", result);
+    }
+
+    @Override
+    public void onConnectionStateChanged(boolean connected) {
+        Log.d(TAG, "Connection state changed: " + connected);
+        isConnected = connected;
+        
+        if (!connected) {
+            currentDeviceInfo = "";
+            lastError = "Connection lost";
+        }
+        
+        JSObject result = new JSObject();
+        result.put("isConnected", connected);
+        result.put("timestamp", System.currentTimeMillis());
+        notifyListeners("connectionStatusChanged", result);
+    }
+
+    @Override
+    public void onError(String error) {
+        Log.e(TAG, "Serial error: " + error);
+        lastError = error;
+        
+        JSObject result = new JSObject();
+        result.put("error", error);
+        result.put("timestamp", System.currentTimeMillis());
+        notifyListeners("serialError", result);
+    }
+
+        @PluginMethod
+    public void unlockPallet(PluginCall call) {
+        Log.d(TAG, "🔓 unlockPallet called");
+        
+        int address = call.getInt("address", 1);
+        int pallet = call.getInt("pallet", 1);
+        String color = call.getString("color", "FF0000");
+        
+        Log.d(TAG, String.format("Parameters - address: %d, pallet: %d, color: %s", address, pallet, color));
+        
+        if (serialManager == null) {
+            call.reject("Serial connection not initialized");
+            return;
+        }
+        
+        if (!serialManager.isConnected()) {
+            call.reject("Not connected to serial port");
+            return;
+        }
+        
+        try {
+            byte[] frame = createUnlockPalletFrame(address, pallet, color);
+            boolean success = serialManager.writeData(frame);
+            
+            if (success) {
+                JSObject result = new JSObject();
+                result.put("success", true);
+                result.put("message", "Unlock command sent successfully");
+                call.resolve(result);
+            } else {
+                call.reject("Failed to send unlock command");
+            }
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error in unlockPallet: " + e.getMessage(), e);
+            call.reject("Error sending unlock command: " + e.getMessage());
+        }
+    }
+
+    // Parser de respuestas del IOBoard
+    public static class IOBoardResponse {
+        public boolean isValid = false;
+        public int address = 0;
+        public int type = 0;
+        public byte[] data = new byte[0];
+        public String firmware = "";
+        public int doorStatus = 0;
+        public String rawHex = "";
+        
+        public String toString() {
+            return String.format("IOBoardResponse{valid=%s, addr=%d, type=%d, firmware='%s', doorStatus=0x%02X, rawHex='%s'}", 
+                isValid, address, type, firmware, doorStatus, rawHex);
+        }
+    }
+    
+    public static IOBoardResponse parseIOBoardResponse(byte[] response) {
+        IOBoardResponse result = new IOBoardResponse();
+        
+        // Convertir a hex para logging
+        StringBuilder hexBuilder = new StringBuilder();
+        for (byte b : response) {
+            hexBuilder.append(String.format("%02X ", b & 0xFF));
+        }
+        result.rawHex = hexBuilder.toString().trim();
+        
+        Log.d(TAG, String.format("📥 Parsing IOBoard response: %s (%d bytes)", result.rawHex, response.length));
+        
+        // Verificar longitud mínima (SOI + LEN + ADDR + TYPE + CRC = 6 bytes mínimo)
+        if (response.length < 6) {
+            Log.w(TAG, "❌ Response too short: " + response.length + " bytes");
+            return result;
+        }
+        
+        // Verificar SOI (Start of Information = 0x0A para respuestas)
+        if ((response[0] & 0xFF) != 0x0A) {
+            Log.w(TAG, String.format("❌ Invalid SOI: expected 0x0A, got 0x%02X", response[0] & 0xFF));
+            return result;
+        }
+        
+        // Obtener longitud del payload (incluye LEN + ADDRESS + TYPE + DATA + CRC + EOI)
+        int payloadLength = response[1] & 0xFF;
+        Log.d(TAG, String.format("📏 Payload length: %d bytes (includes LEN byte itself)", payloadLength));
+        
+        // Calcular el tamaño del frame válido según documentación: SOI + payload
+        // El payloadLength ya incluye todo desde LEN hasta EOI
+        int expectedFrameLength = 1 + payloadLength; // SOI(1) + payload_completo(que incluye EOI)
+        
+        // Detectar y eliminar byte FC extra si está presente
+        byte[] cleanResponse = response;
+        if (response.length > expectedFrameLength) {
+            // Verificar si el último byte es FC (0xFC)
+            int lastByte = response[response.length - 1] & 0xFF;
+            if (lastByte == 0xFC) {
+                Log.d(TAG, String.format("🔧 Detected FC byte at end, removing: got %d bytes, expected %d", 
+                    response.length, expectedFrameLength));
+                cleanResponse = new byte[response.length - 1];
+                System.arraycopy(response, 0, cleanResponse, 0, cleanResponse.length);
+            } else {
+                Log.d(TAG, String.format("⚠️ Frame longer than expected but last byte is not FC: 0x%02X", lastByte));
+            }
+        }
+        
+        // Calcular el tamaño del frame válido: SOI + payload_completo
+        // Según documentación MTC3P08L: [SOI][LEN][ADDR][TYPE][DATA][CRC][EOI]
+        // El payloadLength ya incluye desde LEN hasta EOI
+        int validFrameLength = 1 + payloadLength; // SOI(1) + payload_completo(LEN_value que incluye EOI)
+        
+        // Usar el frame limpio (sin FC)
+        byte[] validFrame;
+        if (cleanResponse.length >= validFrameLength) {
+            validFrame = new byte[validFrameLength];
+            System.arraycopy(cleanResponse, 0, validFrame, 0, validFrameLength);
+        } else {
+            validFrame = response;
+        }
+        
+        // Verificar que tengamos suficientes bytes para el frame válido
+        if (validFrame.length < validFrameLength) {
+            Log.w(TAG, String.format("❌ Incomplete frame: expected %d bytes, got %d", validFrameLength, validFrame.length));
+            return result;
+        }
+        
+        // Verificar EOI al final del frame (según documentación debe ser 0x0A)
+        int eoiPos = validFrameLength - 1;
+        if ((validFrame[eoiPos] & 0xFF) != 0x0A) {
+            Log.w(TAG, String.format("❌ Invalid EOI: expected 0x0A at position %d, got 0x%02X", 
+                eoiPos, validFrame[eoiPos] & 0xFF));
+        }
+        
+        // Extraer campos del payload (saltando SOI y LEN)
+        result.address = validFrame[2] & 0xFF;
+        result.type = validFrame[3] & 0xFF;
+        
+        // Calcular longitud de datos basado en el tipo de frame
+        // TYPE 00 (Status): usa checksum de 8 bits (1 byte)
+        // TYPE 01: usa checksum de 8 bits (1 byte)  
+        // TYPE 02: usa CRC16-Modbus (2 bytes)
+        int checksumLength = (result.type == 0x02) ? 2 : 1; // TYPE 02 usa CRC16, otros usan checksum de 8 bits
+        int dataLength = payloadLength - (3 + checksumLength); // payload - LEN(1) - ADDR(1) - TYPE(1) - CHECKSUM/CRC
+        if (dataLength > 0) {
+            result.data = new byte[dataLength];
+            System.arraycopy(validFrame, 4, result.data, 0, dataLength);
+        }
+        
+        Log.d(TAG, String.format("🔍 Parsed - Address: %d, Type: %d, Data length: %d", 
+            result.address, result.type, dataLength));
+        
+        // Verificar CRC (antes del EOI final)
+        // Frame estructura: [SOI][LEN][ADDR][TYPE][DATA][CRC_LOW][CRC_HIGH][EOI]
+        // CRC está justo antes del EOI
+        int crcPos = validFrameLength - 3; // EOI(-1) + CRC_HIGH(-1) + CRC_LOW = -3
+        if (crcPos + 1 < validFrame.length) {
+            // Probar ambos órdenes de bytes para el CRC
+            int receivedCRC_BE = ((validFrame[crcPos + 1] & 0xFF) << 8) | (validFrame[crcPos] & 0xFF); // Big-endian
+            int receivedCRC_LE = ((validFrame[crcPos] & 0xFF) << 8) | (validFrame[crcPos + 1] & 0xFF); // Little-endian
+            
+            // Probar diferentes variantes del CRC para encontrar la correcta
+            
+            // Variante 1: Desde LEN hasta antes del CRC (actual)
+            byte[] frameForCRC1 = new byte[payloadLength - 2]; // payload_length - CRC(2)
+            System.arraycopy(validFrame, 1, frameForCRC1, 0, frameForCRC1.length);
+            int calculatedCRC1 = calculateCRC16Modbus(frameForCRC1);
+            
+            // Variante 2: Sin incluir LEN (solo desde ADDRESS)
+            byte[] frameForCRC2 = new byte[payloadLength - 3]; // payload_length - LEN(1) - CRC(2)
+            System.arraycopy(validFrame, 2, frameForCRC2, 0, frameForCRC2.length);
+            int calculatedCRC2 = calculateCRC16Modbus(frameForCRC2);
+            
+            // Variante 3: Todo el frame menos CRC y EOI (incluyendo SOI)
+            byte[] frameForCRC3 = new byte[validFrame.length - 3]; // todo menos CRC(2) y EOI(1)
+            System.arraycopy(validFrame, 0, frameForCRC3, 0, frameForCRC3.length);
+            int calculatedCRC3 = calculateCRC16Modbus(frameForCRC3);
+
+            // Debug: mostrar todas las variantes
+            StringBuilder crc1Hex = new StringBuilder();
+            for (byte b : frameForCRC1) { crc1Hex.append(String.format("%02X ", b & 0xFF)); }
+            
+            StringBuilder crc2Hex = new StringBuilder();
+            for (byte b : frameForCRC2) { crc2Hex.append(String.format("%02X ", b & 0xFF)); }
+            
+            StringBuilder crc3Hex = new StringBuilder();
+            for (byte b : frameForCRC3) { crc3Hex.append(String.format("%02X ", b & 0xFF)); }
+            
+            Log.d(TAG, String.format("🔍 CRC V1 (LEN+): %s = 0x%04X", crc1Hex.toString().trim(), calculatedCRC1));
+            Log.d(TAG, String.format("🔍 CRC V2 (ADDR+): %s = 0x%04X", crc2Hex.toString().trim(), calculatedCRC2));
+            Log.d(TAG, String.format("🔍 CRC V3 (SOI+): %s = 0x%04X", crc3Hex.toString().trim(), calculatedCRC3));
+            Log.d(TAG, String.format("🔍 CRC Debug - CRC bytes: 0x%02X 0x%02X at positions %d,%d", 
+                validFrame[crcPos] & 0xFF, validFrame[crcPos + 1] & 0xFF, crcPos, crcPos + 1));
+            
+            // También probar interpretando el CRC como byte único
+            int receivedCRC_Single = validFrame[crcPos] & 0xFF; // Solo el primer byte del "CRC"
+            
+            // Verificar todas las variantes contra todos los formatos posibles
+            boolean crcValid = false;
+            String validVariant = "";
+            
+            // Probar V1 (LEN+)
+            if (receivedCRC_BE == calculatedCRC1) {
+                Log.d(TAG, "✅ CRC verification passed (V1-LEN+, Big-Endian)!");
+                crcValid = true; validVariant = "V1-BE";
+            } else if (receivedCRC_LE == calculatedCRC1) {
+                Log.d(TAG, "✅ CRC verification passed (V1-LEN+, Little-Endian)!");
+                crcValid = true; validVariant = "V1-LE";
+            }
+            
+            // Probar V2 (ADDR+)
+            if (!crcValid && receivedCRC_BE == calculatedCRC2) {
+                Log.d(TAG, "✅ CRC verification passed (V2-ADDR+, Big-Endian)!");
+                crcValid = true; validVariant = "V2-BE";
+            } else if (!crcValid && receivedCRC_LE == calculatedCRC2) {
+                Log.d(TAG, "✅ CRC verification passed (V2-ADDR+, Little-Endian)!");
+                crcValid = true; validVariant = "V2-LE";
+            }
+            
+            // Probar V3 (SOI+)
+            if (!crcValid && receivedCRC_BE == calculatedCRC3) {
+                Log.d(TAG, "✅ CRC verification passed (V3-SOI+, Big-Endian)!");
+                crcValid = true; validVariant = "V3-BE";
+            } else if (!crcValid && receivedCRC_LE == calculatedCRC3) {
+                Log.d(TAG, "✅ CRC verification passed (V3-SOI+, Little-Endian)!");
+                crcValid = true; validVariant = "V3-LE";
+            }
+            
+            // Probar como checksum de 8 bits
+            if (!crcValid) {
+                int checksum1 = calculateSimpleChecksum(frameForCRC1);
+                int checksum2 = calculateSimpleChecksum(frameForCRC2);
+                int checksum3 = calculateSimpleChecksum(frameForCRC3);
+                
+                Log.d(TAG, String.format("🔍 Simple checksums - V1: 0x%02X, V2: 0x%02X, V3: 0x%02X vs received: 0x%02X", 
+                    checksum1 & 0xFF, checksum2 & 0xFF, checksum3 & 0xFF, receivedCRC_Single));
+                
+                if (receivedCRC_Single == (checksum1 & 0xFF)) {
+                    Log.d(TAG, "✅ Checksum verification passed (V1-8bit)!");
+                    crcValid = true; validVariant = "V1-8bit";
+                } else if (receivedCRC_Single == (checksum2 & 0xFF)) {
+                    Log.d(TAG, "✅ Checksum verification passed (V2-8bit)!");
+                    crcValid = true; validVariant = "V2-8bit";
+                } else if (receivedCRC_Single == (checksum3 & 0xFF)) {
+                    Log.d(TAG, "✅ Checksum verification passed (V3-8bit)!");
+                    crcValid = true; validVariant = "V3-8bit";
+                }
+            }
+            
+            if (!crcValid) {
+                Log.w(TAG, "❌ CRC/Checksum mismatch in all variants and formats!");
+                Log.i(TAG, "ℹ️ IOBoard may use proprietary checksum algorithm - data parsing will continue");
+            } else {
+                Log.i(TAG, String.format("🎯 IOBoard CRC/Checksum format identified: %s", validVariant));
+            }
+        } else {
+            Log.w(TAG, "⚠️ No CRC found in response");
+        }
+        
+        // Parse específico según el tipo de respuesta
+        if (result.type == 0x00) { // Status Response
+            parseStatusResponse(result);
+        }
+        
+        result.isValid = true;
+        Log.d(TAG, String.format("✅ Valid IOBoard response parsed: %s", result.toString()));
+        
+        return result;
+    }
+    
+    private static void parseStatusResponse(IOBoardResponse response) {
+        if (response.data.length >= 6) {
+            // Byte 0: Door status
+            response.doorStatus = response.data[0] & 0xFF;
+            
+            // Bytes 1-3: Firmware version (ejemplo: 01 00 63 = v1.0.99)
+            int major = response.data[1] & 0xFF;
+            int minor = response.data[2] & 0xFF;
+            int patch = response.data[3] & 0xFF;
+            response.firmware = String.format("v%d.%d.%d", major, minor, patch);
+            
+            Log.d(TAG, String.format("📊 Status - Door: 0x%02X, Firmware: %s", 
+                response.doorStatus, response.firmware));
+            
+            // Bytes 4-5: Información adicional del sistema
+            if (response.data.length >= 6) {
+                int systemInfo1 = response.data[4] & 0xFF;
+                int systemInfo2 = response.data[5] & 0xFF;
+                Log.d(TAG, String.format("🔧 System Info: 0x%02X 0x%02X", systemInfo1, systemInfo2));
+            }
+        }
+    }
+
+    // Create MTC3P08L protocol frame for unlock pallet command
+    private byte[] createUnlockPalletFrame(int address, int palletNumber, String ledColor) {
+        // MTC3P08L Protocol Frame Structure (según documentación):
+        // [SOI][LEN][ADDR][TYPE][DATA][CRC][EOI]
+        // TYPE 01 = Single pallet parameter setting
+        // DATA = [NUM][LOCK][LED] = [1][1][6] = 8 bytes
+        
+        byte soi = 0x0D;      // Start of frame (según documentación)
+        byte eoi = 0x0A;      // End of frame (según documentación)
+        byte dataLen = 8;     // NUM(1) + LOCK(1) + LED(6) = 8 bytes
+        byte len = (byte) (dataLen + 7);  // N+7 según documentación = 8+7 = 15 (0x0F)
+        byte addr = (byte) address;
+        byte type = 0x01;     // Single pallet parameter setting
+        
+        // DATA section:
+        byte palletNum = (byte) palletNumber;  // NUM: 00-07 para pallets 1-8
+        byte doorLock = 0x01;                  // LOCK: 1=unlock, 0=no action
+        
+        // LED section (6 bytes): [RGB_R][RGB_G][RGB_B][Intensity][BlinkTimes][BlinkSpeed]
+        byte red = 0, green = 0, blue = 0;
+        switch (ledColor.toLowerCase()) {
+            case "red":
+                red = (byte) 255;
+                break;
+            case "green":
+                green = (byte) 255;
+                break;
+            case "blue":
+                blue = (byte) 255;
+                break;
+            case "white":
+                red = green = blue = (byte) 255;
+                break;
+            case "yellow":
+                red = green = (byte) 255;
+                break;
+            case "cyan":
+                green = blue = (byte) 255;
+                break;
+            case "magenta":
+                red = blue = (byte) 255;
+                break;
+            default:
+                green = (byte) 255; // Default to green
+                break;
+        }
+        
+        byte intensity = (byte) 255;      // Max intensity
+        byte blinkTimes = 16;             // 16 veces como en el ejemplo
+        byte blinkSpeed = 1;              // 1 segundo
+        
+        // Calculate CRC16-Modbus (x16+x15+x2+1) según documentación
+        byte[] dataForCrc = new byte[] {
+            soi, len, addr, type, palletNum, doorLock, red, green, blue, intensity, blinkTimes, blinkSpeed
+        };
+        int crc16 = calculateCRC16Modbus(dataForCrc);
+        
+        // CRC16 en formato little-endian (low byte first, high byte second)
+        byte crcLow = (byte) (crc16 & 0xFF);
+        byte crcHigh = (byte) ((crc16 >> 8) & 0xFF);
+        
+        return new byte[] {
+            soi, len, addr, type,                           // Header
+            palletNum, doorLock,                           // NUM, LOCK
+            red, green, blue, intensity, blinkTimes, blinkSpeed,  // LED (6 bytes)
+            crcLow, crcHigh,                               // CRC (2 bytes)
+            eoi                                            // End of frame
+        };
+    }
+
+    // Create Full Pallet Control frame (TYPE 02) - controls all 8 pallets
+    private byte[] createMultiplePalletsFrame(int address, String color, int intensity, 
+                                             int blinkTimes, int blinkSpeed, List<Integer> pallets) {
+        // MTC3P08L Full Pallet Control Frame Structure (TYPE 02):
+        // [SOI][LEN][ADDR][TYPE][LOCK][EXT][LED1(6bytes)][LED2(6bytes)]...[LED8(6bytes)][CRC][EOI]
+        // Total: 1+1+1+1+1+1+(8*6)+2+1 = 57 bytes (0x39)
+        
+        Log.d(TAG, "🎨 Creating Full Pallet Control frame: address=" + address + 
+              ", color=" + color + ", intensity=" + intensity + 
+              ", blinkTimes=" + blinkTimes + ", blinkSpeed=" + blinkSpeed +
+              ", pallets=" + pallets.toString());
+        
+        byte soi = 0x0D;      // Start of frame
+        byte eoi = 0x0A;      // End of frame
+        byte len = 0x39;      // Fixed length: 57 bytes for full pallet control
+        byte addr = (byte) address;
+        byte type = 0x02;     // Full Pallet Control command
+        
+        // Door lock control - following the documentation example:
+        // Example shows LOCK=0x01 for "Unlock: 01" (seems to be action code, not bit mask)
+        // For now, use 0x01 to match the documentation example exactly
+        byte lockControl = 0x01; // Unlock action (as per documentation example)
+        
+        byte extControl = (byte) 0x80; // Extended output control (fixed as per example)
+        
+        // Convert color to RGB
+        byte red = 0x00, green = 0x00, blue = 0x00;
+        switch (color.toUpperCase()) {
+            case "RED":
+                red = (byte) 0xFF;
+                break;
+            case "GREEN":
+                green = (byte) 0xFF;
+                break;
+            case "BLUE":
+                blue = (byte) 0xFF;
+                break;
+            case "YELLOW":
+                red = (byte) 0xFF;
+                green = (byte) 0xFF;
+                break;
+            case "PURPLE":
+                red = (byte) 0xFF;
+                blue = (byte) 0xFF;
+                break;
+            case "CYAN":
+                green = (byte) 0xFF;
+                blue = (byte) 0xFF;
+                break;
+            case "WHITE":
+                red = (byte) 0xFF;
+                green = (byte) 0xFF;
+                blue = (byte) 0xFF;
+                break;
+            default:
+                Log.w(TAG, "⚠️ Unknown color: " + color + ", using RED as default");
+                red = (byte) 0xFF;
+                break;
+        }
+        
+        // Build data array for CRC calculation
+        // CRC includes SOI + all data up to (but not including) the CRC field itself
+        List<Byte> dataForCrc = new ArrayList<>();
+        dataForCrc.add(soi);    // Include SOI in CRC calculation
+        dataForCrc.add(len);
+        dataForCrc.add(addr);
+        dataForCrc.add(type);
+        dataForCrc.add(lockControl);
+        dataForCrc.add(extControl);
+        
+        // Add 8 LED groups (6 bytes each) - one for each pallet
+        for (int i = 1; i <= 8; i++) {
+            if (pallets.contains(i)) {
+                // This pallet should have the specified color and effects
+                dataForCrc.add(red);
+                dataForCrc.add(green);
+                dataForCrc.add(blue);
+                dataForCrc.add((byte) intensity);
+                dataForCrc.add((byte) blinkTimes);
+                dataForCrc.add((byte) blinkSpeed);
+            } else {
+                // This pallet should be off (all zeros)
+                dataForCrc.add((byte) 0x00); // R
+                dataForCrc.add((byte) 0x00); // G
+                dataForCrc.add((byte) 0x00); // B
+                dataForCrc.add((byte) 0x00); // Intensity (off)
+                dataForCrc.add((byte) 0x00); // BlinkTimes
+                dataForCrc.add((byte) 0x01); // BlinkSpeed (minimum value)
+            }
+        }
+        
+        // Convert to byte array for CRC calculation
+        byte[] crcData = new byte[dataForCrc.size()];
+        for (int i = 0; i < dataForCrc.size(); i++) {
+            crcData[i] = dataForCrc.get(i);
+        }
+        
+        // Calculate CRC16-Modbus (TYPE 02 uses CRC16, not simple checksum like TYPE 01)
+        int crc16 = calculateCRC16Modbus(crcData);
+        
+        // CRC16 en formato little-endian (low byte first) - documentation shows 0C F1
+        byte crcLow = (byte) (crc16 & 0xFF);
+        byte crcHigh = (byte) ((crc16 >> 8) & 0xFF);
+        
+        // Build final frame - DON'T add SOI again since it's already in dataForCrc
+        List<Byte> frame = new ArrayList<>();
+        frame.addAll(dataForCrc); // This already includes SOI + all data
+        frame.add(crcLow);   // CRC low byte first (little-endian)
+        frame.add(crcHigh);  // CRC high byte second
+        frame.add(eoi);
+        
+        // Convert to byte array
+        byte[] frameArray = new byte[frame.size()];
+        for (int i = 0; i < frame.size(); i++) {
+            frameArray[i] = frame.get(i);
+        }
+        
+        // Log the frame for debugging
+        StringBuilder hexFrame = new StringBuilder();
+        for (byte b : frameArray) {
+            hexFrame.append(String.format("%02X ", b & 0xFF));
+        }
+        Log.d(TAG, "🎯 Full Pallet Control frame created: " + hexFrame.toString().trim());
+        Log.d(TAG, "📊 Frame details - LockControl: 0x" + String.format("%02X", lockControl & 0xFF) + 
+              ", ExtControl: 0x" + String.format("%02X", extControl & 0xFF) + 
+              ", Color: " + color + " (" + String.format("%02X%02X%02X", red & 0xFF, green & 0xFF, blue & 0xFF) + ")" +
+              ", CRC16: 0x" + String.format("%02X%02X", crcLow & 0xFF, crcHigh & 0xFF) + " (little-endian)");
+        
+        return frameArray;
+    }
+
+    // Implementación CRC16-Modbus (x16+x15+x2+1) según documentación MTC3P08L
+    private static int calculateCRC16Modbus(byte[] data) {
+        int crc = 0xFFFF;  // Initial value
+        
+        for (byte b : data) {
+            crc ^= (b & 0xFF);  // XOR with byte
+            
+            for (int i = 0; i < 8; i++) {
+                if ((crc & 0x0001) != 0) {
+                    crc >>= 1;
+                    crc ^= 0xA001;  // Polynomial for Modbus (reversed)
+                } else {
+                    crc >>= 1;
+                }
+            }
+        }
+        
+        return crc;
+    }
+
+    // Create Status Query frame (Type 00) - matches documentation exactly
+    private byte[] createStatusQueryFrame(int address) {
+        // MTC3P08L Status Query Frame Structure (from documentation):
+        // 0D 07 01 00 B2 D9 0A
+        // [SOI][LEN][ADDR][TYPE][CRC][EOI]
+        // TYPE 00 = Status query (no data needed) - uses CRC16-Modbus like TYPE 02
+        
+        byte soi = 0x0D;      // Start of frame
+        byte eoi = 0x0A;      // End of frame  
+        byte len = 0x07;      // Length: 7 (as per documentation)
+        byte addr = (byte) address;
+        byte type = 0x00;     // Status query
+        
+        // Calculate CRC16-Modbus for TYPE 00 (same as TYPE 02)
+        // CRC includes: SOI + LEN + ADDR + TYPE (no data for status query)
+        byte[] dataForCrc = new byte[] { soi, len, addr, type };
+        int crc16 = calculateCRC16Modbus(dataForCrc);
+        
+        // CRC16 en formato little-endian (low byte first, high byte second)
+        byte crcLow = (byte) (crc16 & 0xFF);
+        byte crcHigh = (byte) ((crc16 >> 8) & 0xFF);
+        
+        return new byte[] {
+            soi, len, addr, type,     // Header (no data for status query)
+            crcLow, crcHigh,          // CRC16-Modbus (2 bytes)
+            eoi                       // End of frame
+        };
+    }
+
+    // Test function to verify CRC calculation against documentation example
+    private void testCRCAgainstDocumentation() {
+        // Documentation example: 0D 0F 01 01 00 01 FF 00 00 FF 10 01 1D 6F 0A
+        // Expected CRC: 0x6F1D (little-endian: 1D 6F)
+        byte[] testData = new byte[] {
+            0x0D, 0x0F, 0x01, 0x01, 0x00, 0x01, (byte)0xFF, 0x00, 0x00, (byte)0xFF, 0x10, 0x01
+        };
+        
+        int calculatedCRC = calculateCRC16Modbus(testData);
+        int expectedCRC = 0x6F1D;
+        
+        Log.d(TAG, "🧪 CRC TEST:");
+        Log.d(TAG, "Expected CRC: 0x" + Integer.toHexString(expectedCRC).toUpperCase() + " (bytes: 1D 6F)");
+        Log.d(TAG, "Calculated CRC: 0x" + Integer.toHexString(calculatedCRC).toUpperCase() + 
+               " (bytes: " + String.format("%02X %02X", calculatedCRC & 0xFF, (calculatedCRC >> 8) & 0xFF) + ")");
+        
+        if (calculatedCRC == expectedCRC) {
+            Log.i(TAG, "✅ CRC16-Modbus calculation is CORRECT!");
+        } else {
+            Log.w(TAG, "❌ CRC16-Modbus calculation mismatch - needs adjustment");
+        }
+    }
+    
+    // Método para calcular checksum simple (suma de bytes)
+    private static int calculateSimpleChecksum(byte[] data) {
+        int sum = 0;
+        for (byte b : data) {
+            sum += (b & 0xFF);
+        }
+        return sum & 0xFF; // Retorna solo el byte menos significativo
+    }
+
+    @Override
+    protected void handleOnDestroy() {
+        Log.d(TAG, "Plugin destroyed");
+        if (serialManager != null) {
+            serialManager.closePort();
+        }
+        super.handleOnDestroy();
+    }
+}