@leonardojc/capacitor-ioboard 1.2.8 → 2.0.0

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

@@ -1,262 +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 {
-
-    private static final String TAG = "CapacitorIoboard";
-
-    @Override
-    public void load() {
-        super.load();
-        Log.d(TAG, "IOBoard Protocol Plugin loaded - working at protocol level");
-    }
-
-    // Protocol-level methods - these return frames to be sent and parse responses
-
-    @PluginMethod
-    public void buildCommand(PluginCall call) {
-        String command = call.getString("command");
-        Integer address = call.getInt("address");
-        
-        if (command == null || address == null) {
-            call.reject("Command and address are required");
-            return;
-        }
-
-        try {
-            byte[] frame = null;
-            
-            switch (command.toUpperCase()) {
-                case "GET_STATUS":
-                    frame = IOBoardProtocolUtils.createStatusQuery((byte) address.intValue());
-                    break;
-                    
-                case "UNLOCK_PALLET":
-                    Integer palletNumber = call.getInt("palletNumber");
-                    String ledColor = call.getString("ledColor", "green");
-                    if (palletNumber == null) {
-                        call.reject("palletNumber is required for UNLOCK_PALLET command");
-                        return;
-                    }
-                    
-                    // Create data payload for single pallet unlock
-                    byte[] singlePalletData = new byte[2];
-                    singlePalletData[0] = (byte) palletNumber.intValue(); // Pallet number
-                    singlePalletData[1] = (byte) (ledColor.equals("red") ? 1 : 0); // LED color: 0=green, 1=red
-                    
-                    frame = IOBoardProtocolUtils.createFrame((byte) address.intValue(), IOBoardProtocolUtils.FRAME_TYPE_SINGLE_PALLET, singlePalletData);
-                    break;
-                    
-                case "CONTROL_MULTIPLE":
-                    Integer doorLockMask = call.getInt("doorLockMask", 0);
-                    String ledColorMultiple = call.getString("ledColor", "green");
-                    
-                    // Create data payload for multiple pallet control
-                    byte[] multiplePalletData = new byte[2];
-                    multiplePalletData[0] = (byte) doorLockMask.intValue(); // Door lock mask
-                    multiplePalletData[1] = (byte) (ledColorMultiple.equals("red") ? 1 : 0); // LED color
-                    
-                    frame = IOBoardProtocolUtils.createFrame((byte) address.intValue(), IOBoardProtocolUtils.FRAME_TYPE_FULL_PALLET, multiplePalletData);
-                    break;
-                    
-                case "OTA_NOTIFICATION":
-                    Integer majorVersion = call.getInt("majorVersion");
-                    Integer minorVersion = call.getInt("minorVersion");
-                    Integer patchVersion = call.getInt("patchVersion");
-                    Integer firmwareSize = call.getInt("firmwareSize");
-                    
-                    if (majorVersion == null || minorVersion == null || patchVersion == null || firmwareSize == null) {
-                        call.reject("All version parameters and firmware size are required for OTA_NOTIFICATION");
-                        return;
-                    }
-                    
-                    // Create OTA notification data payload (example structure)
-                    byte[] otaData = new byte[7];
-                    otaData[0] = (byte) majorVersion.intValue();
-                    otaData[1] = (byte) minorVersion.intValue();
-                    otaData[2] = (byte) patchVersion.intValue();
-                    // Firmware size as 4 bytes (little endian)
-                    otaData[3] = (byte) (firmwareSize & 0xFF);
-                    otaData[4] = (byte) ((firmwareSize >> 8) & 0xFF);
-                    otaData[5] = (byte) ((firmwareSize >> 16) & 0xFF);
-                    otaData[6] = (byte) ((firmwareSize >> 24) & 0xFF);
-                    
-                    frame = IOBoardProtocolUtils.createFrame((byte) address.intValue(), IOBoardProtocolUtils.FRAME_TYPE_OTA_REQUEST, otaData);
-                    break;
-                    
-                default:
-                    call.reject("Unknown command: " + command);
-                    return;
-            }
-            
-            JSObject result = new JSObject();
-            result.put("frame", IOBoardProtocolUtils.frameToHex(frame));
-            result.put("command", command);
-            result.put("address", address);
-            
-            call.resolve(result);
-            
-        } catch (Exception e) {
-            Log.e(TAG, "Error building command", e);
-            call.reject("Failed to build command: " + e.getMessage());
-        }
-    }
-
-    @PluginMethod
-    public void parseResponse(PluginCall call) {
-        String hexData = call.getString("data");
-        
-        if (hexData == null || hexData.trim().isEmpty()) {
-            call.reject("Data is required");
-            return;
-        }
-
-        try {
-            Log.d(TAG, "Parsing response: " + hexData);
-            
-            IOBoardProtocolUtils.ParsedResponse parsedResponse = IOBoardProtocolUtils.parseResponse(hexData);
-            
-            JSObject result = new JSObject();
-            result.put("valid", parsedResponse.success);
-            result.put("rawData", hexData);
-            result.put("message", parsedResponse.message);
-            
-            if (parsedResponse.success) {
-                result.put("address", parsedResponse.address);
-                result.put("frameType", parsedResponse.frameType);
-                
-                if (parsedResponse.data != null && parsedResponse.data.length > 0) {
-                    result.put("payload", IOBoardProtocolUtils.frameToHex(parsedResponse.data));
-                    
-                    // If it's a status response, parse the data
-                    if (parsedResponse.frameType == IOBoardProtocolUtils.FRAME_TYPE_STATUS_QUERY && parsedResponse.data.length >= 4) {
-                        result.put("doorLockStatus", parsedResponse.data[0]);
-                        
-                        // Software version (assuming bytes 1-3 are major, minor, patch)
-                        if (parsedResponse.data.length >= 4) {
-                            JSObject version = new JSObject();
-                            version.put("major", parsedResponse.data[1]);
-                            version.put("minor", parsedResponse.data[2]);
-                            version.put("patch", parsedResponse.data[3]);
-                            result.put("softwareVersion", version);
-                        }
-                    }
-                }
-            }
-            
-            call.resolve(result);
-            
-        } catch (Exception e) {
-            Log.e(TAG, "Error parsing response", e);
-            call.reject("Failed to parse response: " + e.getMessage());
-        }
-    }
-
-    @PluginMethod
-    public void validateFrame(PluginCall call) {
-        String hexData = call.getString("data");
-        
-        if (hexData == null || hexData.trim().isEmpty()) {
-            call.reject("Data is required");
-            return;
-        }
-
-        try {
-            // Use parseResponse to validate the frame
-            IOBoardProtocolUtils.ParsedResponse parsed = IOBoardProtocolUtils.parseResponse(hexData);
-            
-            JSObject result = new JSObject();
-            result.put("valid", parsed.success);
-            result.put("data", hexData);
-            result.put("message", parsed.message);
-            
-            if (parsed.success) {
-                byte[] frameData = IOBoardProtocolUtils.hexStringToBytes(hexData);
-                result.put("length", frameData.length);
-            }
-            
-            call.resolve(result);
-            
-        } catch (Exception e) {
-            Log.e(TAG, "Error validating frame", e);
-            call.reject("Failed to validate frame: " + e.getMessage());
-        }
-    }
-
-    @PluginMethod
-    public void hexToBytes(PluginCall call) {
-        String hexData = call.getString("data");
-        
-        if (hexData == null || hexData.trim().isEmpty()) {
-            call.reject("Data is required");
-            return;
-        }
-
-        try {
-            byte[] bytes = IOBoardProtocolUtils.hexStringToBytes(hexData);
-            
-            // Convert byte array to JSArray of integers
-            JSArray bytesArray = new JSArray();
-            for (byte b : bytes) {
-                bytesArray.put((int) b & 0xFF); // Convert to unsigned int
-            }
-            
-            JSObject result = new JSObject();
-            result.put("bytes", bytesArray);
-            result.put("length", bytes.length);
-            result.put("hex", hexData);
-            
-            call.resolve(result);
-            
-        } catch (Exception e) {
-            Log.e(TAG, "Error converting hex to bytes", e);
-            call.reject("Failed to convert hex to bytes: " + e.getMessage());
-        }
-    }
-
-    @PluginMethod
-    public void bytesToHex(PluginCall call) {
-        JSArray bytesArray = call.getArray("bytes");
-        
-        if (bytesArray == null) {
-            call.reject("Bytes array is required");
-            return;
-        }
-
-        try {
-            byte[] bytes = new byte[bytesArray.length()];
-            for (int i = 0; i < bytesArray.length(); i++) {
-                bytes[i] = (byte) bytesArray.getInt(i);
-            }
-            
-            String hexString = IOBoardProtocolUtils.frameToHex(bytes);
-            
-            // Convert byte array back to JSArray for consistency
-            JSArray resultBytesArray = new JSArray();
-            for (byte b : bytes) {
-                resultBytesArray.put((int) b & 0xFF);
-            }
-            
-            JSObject result = new JSObject();
-            result.put("hex", hexString);
-            result.put("length", bytes.length);
-            result.put("bytes", resultBytesArray);
-            
-            call.resolve(result);
-            
-        } catch (Exception e) {
-            Log.e(TAG, "Error converting bytes to hex", e);
-            call.reject("Failed to convert bytes to hex: " + 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();
+    }
+}