smartx-rfid 0.4.0__py3-none-any.whl

smartx_rfid/devices/RFID/X714/ble_protocol.py

@@ -0,0 +1,159 @@
+import asyncio
+import logging
+import sys
+import threading
+from typing import Optional
+
+from bleak import BleakClient, BleakScanner
+
+if sys.platform == "win32":
+    from bleak.backends.winrt.util import allow_sta
+else:
+    allow_sta = None
+from bleak.exc import BleakError
+
+if allow_sta:
+    allow_sta()
+
+# ---------------- Settings ----------------
+SERVICE_UUID = "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
+CHARACTERISTIC_RX = "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"  # Write (ESP32 receives)
+CHARACTERISTIC_TX = "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"  # Notify (ESP32 sends)
+
+
+class BLEProtocol:
+    def init_ble_vars(self):
+        self.client_ble: Optional[BleakClient] = None
+        self.client_ble_lock = asyncio.Lock()
+        self.connected_ble_event = asyncio.Event()
+        self.ble_stop = False
+        self.notify_enabled = False
+
+    # ---------------- Utilities ----------------
+    async def write_ble(self, data: bytes, verbose: bool = False) -> bool:
+        """Send data via BLE with connection check and lock."""
+        if not self.client_ble or not self.client_ble.is_connected:
+            logging.warning(f"{self.name} - ⚠️ BLE client not connected")
+            return False
+        async with self.client_ble_lock:
+            try:
+                await self.client_ble.write_gatt_char(CHARACTERISTIC_RX, data)
+                if verbose:
+                    logging.info(f"{self.name} - [BLE TX] {data}")
+                return True
+            except Exception as e:
+                logging.warning(f"{self.name} - [BLE Write Error] {e}")
+                return False
+
+    async def scan_for_device(self) -> Optional[str]:
+        """Scan for devices whose name starts with the defined prefix."""
+        while not self.ble_stop:
+            logging.info(f"{self.name} - 🔍 Scanning BLE devices...")
+            try:
+                devices = await BleakScanner.discover(timeout=5.0)
+                for d in devices:
+                    if d.name and d.name.startswith(self.ble_name):
+                        logging.info(f"{self.name} - ✅ Device found: {d.address} ({d.name})")
+                        return d.address
+                logging.warning(f"{self.name} - ❌ Device not found, retrying in 3s...")
+            except Exception as e:
+                logging.warning(f"{self.name} - [Scan Error] {e}")
+            await asyncio.sleep(self.reconnection_time)
+        return None
+
+    # ---------------- Main Connection ----------------
+    async def connect_and_run(self):
+        """Main BLE connection and operation loop."""
+        while not self.ble_stop:
+            try:
+                # Se já estava conectado antes, emite o evento de desconexão
+                if self.is_connected:
+                    self.is_connected = False
+                    self.on_event(self.name, "connection", False)
+
+                # Escolhe o endereço conforme o modo
+                if self.is_auto:
+                    address = await self.scan_for_device()
+                    if not address:
+                        continue
+                else:
+                    address = self.connection  # Usa o MAC address fixo
+                    logging.info(f"{self.name} - 🔗 Using fixed BLE address: {address}")
+
+                logging.info(f"{self.name} - Attempting to connect to {address}...")
+                client = BleakClient(address)
+
+                try:
+                    await asyncio.wait_for(client.connect(), timeout=5.0)
+                except asyncio.TimeoutError:
+                    logging.warning(f"{self.name} - ⏰ Connection attempt timed out")
+                    await asyncio.sleep(self.reconnection_time)
+                    continue
+
+                if not client.is_connected:
+                    logging.warning(f"{self.name} - ❌ Failed to connect.")
+                    await asyncio.sleep(self.reconnection_time)
+                    continue
+
+                async with client:
+                    logging.info(f"{self.name} - 🔗 Connected to device")
+                    self.client_ble = client
+                    self.connected_ble_event.set()
+
+                    # Notification callback
+                    def handle_notification(sender, data: bytearray):
+                        decoded = data.decode(errors="ignore")
+                        self.on_receive(decoded)
+
+                    # Habilita notificações automaticamente
+                    self.notify_enabled = False
+                    for service in client.services:
+                        for char in service.characteristics:
+                            if "notify" in char.properties:
+                                try:
+                                    await client.start_notify(char.uuid, handle_notification)
+                                    self.is_connected = True
+                                    self.on_event(self.name, "connection", True)
+                                    logging.info(f"{self.name} - ✅ BLE connection successfully established.")
+                                    self.config_reader()
+                                    self.notify_enabled = True
+                                except Exception as e:
+                                    logging.warning(f"{self.name} - [Notify Error] {char.uuid}: {e}")
+                    if not self.notify_enabled:
+                        logging.warning(f"{self.name} - ⚠️ No characteristics with notify property found!")
+                    # Loop principal de manutenção da conexão
+                    last_ping = 0
+                    while client.is_connected and not self.ble_stop:
+                        now = asyncio.get_event_loop().time()
+                        if now - last_ping >= 5:
+                            await self.write_ble(b"#ping")
+                            last_ping = now
+                        await asyncio.sleep(1)
+
+                    logging.info(f"{self.name} - 🔌 Disconnected from device.")
+
+            except BleakError as e:
+                logging.warning(f"{self.name} - [BLE Error] {e}")
+                await asyncio.sleep(self.reconnection_time)
+            except Exception as e:
+                logging.warning(f"{self.name} - [Unexpected BLE Error] {e}")
+                await asyncio.sleep(self.reconnection_time)
+            finally:
+                self.connected_ble_event.clear()
+                self.client_ble = None
+
+    # ---------------- Thread Wrapper ----------------
+    def connect_ble(self):
+        """Run BLE loop in a separate thread (ideal for FastAPI)."""
+
+        def run_loop():
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            loop.run_until_complete(self.connect_and_run())
+
+        threading.Thread(target=run_loop, daemon=True).start()
+
+    def stop(self):
+        """Request BLE loop stop."""
+        logging.info(f"{self.name} - 🛑 Stopping BLE loop...")
+        self.ble_stop = True

smartx_rfid/devices/RFID/X714/on_receive.py

@@ -0,0 +1,54 @@
+from smartx_rfid.schemas.tag import TagSchema
+import logging
+
+
+class OnReceive:
+    def on_receive(self, data, verbose: bool = False):
+        if not isinstance(data, str):
+            data = data.decode(errors="ignore")
+        data = data.replace("\r", "").replace("\n", "")
+        data = data.lower()
+        if verbose:
+            self.on_event(self.name, "receive", data)
+
+        if data.startswith("#read:"):
+            self.is_reading = data.endswith("on")
+            if self.is_reading:
+                self.on_start()
+            else:
+                self.on_stop()
+
+        elif data.startswith("#t+@"):
+            tag = data[4:]
+            epc, tid, ant, rssi = tag.split("|")
+            current_tag = {
+                "epc": epc,
+                "tid": tid,
+                "ant": int(ant),
+                "rssi": int(rssi) * (-1),
+            }
+            self.on_tag(current_tag)
+
+        elif len(data) == 24:
+            self.on_tag(data)
+
+        elif data.startswith("#set_cmd:"):
+            logging.info(f"{self.name} - CONFIG -> {data[data.index(':') + 1 :]}")
+
+        elif data == "#tags_cleared":
+            self.on_event(self.name, "tags_cleared", True)
+
+    def on_start(self):
+        self.clear_tags()
+        self.on_event(self.name, "reading", True)
+
+    def on_stop(self):
+        self.on_event(self.name, "reading", False)
+
+    def on_tag(self, tag: dict):
+        try:
+            tag_data = TagSchema(**tag)
+            tag = tag_data.model_dump()
+            self.on_event(self.name, "tag", tag)
+        except Exception as e:
+            logging.error(f"{self.name} - Invalid tag data: {e}")

smartx_rfid/devices/RFID/X714/rfid.py

@@ -0,0 +1,73 @@
+import asyncio
+
+
+class RfidCommands:
+    def start_inventory(self):
+        self.write("#READ:ON")
+
+    def stop_inventory(self):
+        self.write("#READ:OFF")
+
+    def clear_tags(self):
+        self.write("#CLEAR")
+
+    def config_reader(self):
+        set_cmd = "#set_cmd:"
+
+        # ANTENNAS
+        antennas = self.ant_dict
+        for antenna in antennas:
+            ant = antennas.get(antenna)
+            ant_cmd = f"|set_ant:{antenna},{ant.get('active')},{ant.get('power')},{abs(ant.get('rssi'))}"
+            set_cmd += ant_cmd
+
+        # SESSION
+        set_cmd += f"|SESSION:{self.session}"
+
+        # START_READING
+        set_cmd += f"|START_READING:{self.start_reading}"
+
+        # GPI_START
+        set_cmd += f"|GPI_START:{self.gpi_start}"
+
+        # IGNORE_READ
+        set_cmd += f"|IGNORE_READ:{self.ignore_read}"
+
+        # ALWAYS_SEND
+        set_cmd += f"|ALWAYS_SEND:{self.always_send}"
+
+        # SIMPLE_SEND
+        set_cmd += f"|SIMPLE_SEND:{self.simple_send}"
+
+        # KEYBOARD
+        set_cmd += f"|KEYBOARD:{self.keyboard}"
+
+        # BUZZER
+        set_cmd += f"|BUZZER:{self.buzzer}"
+
+        # DECODE_GTIN
+        set_cmd += f"|DECODE_GTIN:{self.decode_gtin}"
+
+        set_cmd = set_cmd.lower()
+        set_cmd = set_cmd.replace("true", "on").replace("false", "off")
+        self.write(set_cmd)
+
+        # OTHER CONFIG
+        self.write(f"#hotspot:{'on' if self.hotspot else 'off'}")
+        self.write(f"#prefix:{self.prefix}")
+        if self.protected_inventory_password is not None:
+            self.write(f"#protected_inventory:on;{self.protected_inventory_password}")
+        else:
+            self.write("#protected_inventory:off")
+
+        # Start Reading
+        if self.start_reading:
+            self.start_inventory()
+        else:
+            self.stop_inventory()
+
+    async def auto_clear(self):
+        while True:
+            await asyncio.sleep(30)
+            if self.is_connected:
+                self.clear_tags()

smartx_rfid/devices/RFID/X714/serial_protocol.py

@@ -0,0 +1,89 @@
+import asyncio
+import logging
+
+import serial.tools.list_ports
+import serial_asyncio
+
+
+class SerialProtocol(asyncio.Protocol):
+    def connection_made(self, transport):
+        self.transport = transport
+        self.is_connected = True
+        logging.info(f"{self.name} - ✅ Serial connection successfully established.")
+        self.on_connected()
+
+    def data_received(self, data):
+        self.rx_buffer += data
+
+        while b"\n" in self.rx_buffer:
+            idx = self.rx_buffer.index(b"\n")
+            packet = self.rx_buffer[:idx]
+            self.rx_buffer = self.rx_buffer[idx + 1 :]
+            self.on_receive(packet)
+
+    def connection_lost(self, exc):
+        logging.warning(f"{self.name} - ⚠️ Serial connection lost.")
+        self.transport = None
+        self.is_connected = False
+        self.on_event(self.name, "connection", False)
+
+        if self.on_con_lost:
+            self.on_con_lost.set()
+
+    def write_serial(self, to_send, verbose=True):
+        if self.transport:
+            if verbose:
+                logging.info(f"{self.name} - 📤 Sending: {to_send}")
+            if isinstance(to_send, str):
+                to_send += "\n"
+                to_send = to_send.encode()  # convert string to bytes
+            self.transport.write(to_send)
+        else:
+            logging.warning(f"{self.name} - ❌ Send attempt failed: connection not established.")
+
+    async def connect_serial(self):
+        """Serial connection/reconnection loop"""
+        loop = asyncio.get_running_loop()
+
+        asyncio.create_task(self.auto_clear())
+
+        while True:
+            self.on_con_lost = asyncio.Event()
+
+            # If AUTO mode, try to detect port by VID/PID
+            if self.is_auto:
+                logging.info(f"{self.name} - 🔍 Auto-detecting port by VID={self.vid:04x} and PID={self.pid:04x}...")
+                ports = serial.tools.list_ports.comports()
+                found_port = None
+                for p in ports:
+                    # p.vid and p.pid are integers (e.g. 0x0001 == 1 decimal)
+                    if p.vid == self.vid and p.pid == self.pid:
+                        found_port = p.device
+                        logging.info(f"{self.name} - ✅ Detected port: {found_port}")
+                        break
+
+                if found_port is None:
+                    logging.info(f"{self.name} - ⚠️ No port with VID={self.vid} and PID={self.pid} found.")
+                    logging.info(f"{self.name} - ⏳ Retrying in {self.reconnection_time} seconds...")
+                    await asyncio.sleep(self.reconnection_time)
+                    continue  # try to detect again in next loop
+                else:
+                    self.connection = found_port
+
+            try:
+                logging.info(f"{self.name} - 🔌 Trying to connect to {self.connection} at {self.baudrate} bps...")
+                await serial_asyncio.create_serial_connection(
+                    loop, lambda: self, self.connection, baudrate=self.baudrate
+                )
+                logging.info(f"{self.name} - 🟢 Successfully connected.")
+                await self.on_con_lost.wait()
+                logging.info(f"{self.name} - 🔄 Connection lost. Attempting to reconnect...")
+            except Exception as e:
+                logging.warning(f"{self.name} - ❌ Connection error: {e}")
+
+            # If in AUTO mode, reset port to "AUTO" to force detection next loop
+            if self.is_auto:
+                self.connection = "AUTO"
+
+            logging.info(f"{self.name} - ⏳ Waiting {self.reconnection_time} seconds before retrying...")
+            await asyncio.sleep(self.reconnection_time)

smartx_rfid/devices/RFID/X714/tcp_protocol.py

@@ -0,0 +1,127 @@
+import asyncio
+import logging
+import socket
+
+
+class TCPHelpers:
+    async def monitor_connection(self):
+        while self.is_connected:
+            await asyncio.sleep(self.reconnection_time)
+            if (self.writer and self.writer.is_closing()) or (self.reader and self.reader.at_eof()):
+                self.is_connected = False
+                logging.info(f"{self.name} - [DISCONNECTED] Socket closed.")
+                break
+
+            await self.write_tcp("ping", verbose=False)
+
+    async def receive_data_tcp(self):
+        buffer = ""
+        try:
+            while True:
+                try:
+                    data = await asyncio.wait_for(self.reader.read(1024), timeout=0.1)
+                except asyncio.TimeoutError:
+                    # Timeout: process what's in the buffer as a command
+                    if buffer:
+                        self.on_receive(buffer.strip())
+                        buffer = ""
+                    continue
+
+                if not data:
+                    raise ConnectionError("Connection lost")
+
+                buffer += data.decode(errors="ignore")
+
+                while "\n" in buffer:
+                    line, buffer = buffer.split("\n", 1)
+                    self.on_receive(line.strip())
+
+        except Exception as e:
+            if self.is_connected:
+                self.is_connected = False
+                logging.warning(f"[RECEIVE ERROR] {e}")
+
+
+class TCPProtocol(TCPHelpers):
+    async def connect_tcp(self, ip, port):
+        while True:
+            try:
+                logging.info(f"Connecting: {self.name} - {ip}:{port}")
+
+                # Verifica IP antes (evita travar no DNS)
+                try:
+                    resolved_ip = socket.gethostbyname(ip)
+                except OSError:
+                    raise ValueError(f"Invalid IP address: {ip}")
+
+                # Tenta abrir conexão com timeout real
+                connect_task = asyncio.open_connection(resolved_ip, port)
+                self.reader, self.writer = await asyncio.wait_for(connect_task, timeout=3)
+
+                self.is_connected = True
+                self.on_connected()
+                logging.info(f"✅ [CONNECTED] {self.name} - {ip}:{port}")
+
+                # Cria tasks de leitura e monitoramento
+                tasks = [
+                    asyncio.create_task(self.receive_data_tcp()),
+                    asyncio.create_task(self.monitor_connection()),
+                    asyncio.create_task(self.periodic_ping(10)),
+                ]
+
+                # Espera até que uma delas finalize
+                done, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
+
+                # Cancela o resto
+                for t in pending:
+                    t.cancel()
+
+                self.is_connected = False
+                self.on_event(self.name, "connection", False)
+                logging.info(f"🔌 [DISCONNECTED] {self.name} - Reconnecting...")
+
+            except asyncio.TimeoutError:
+                logging.warning(f"⏱️ [TIMEOUT] {self.name} - No response from {ip}:{port}")
+                continue
+            except ValueError as e:
+                logging.warning(f"❌ [INVALID IP] {self.name}: {e}")
+                continue
+            except OSError as e:
+                logging.warning(f"💥 [NETWORK ERROR] {self.name}: {e}")
+                continue
+            except Exception as e:
+                logging.warning(f"❌ [UNEXPECTED ERROR] {self.name}: {e}")
+                continue
+
+            # Garante desconexão limpa
+            if self.writer:
+                try:
+                    self.writer.close()
+                    await self.writer.wait_closed()
+                except Exception:
+                    pass
+                self.writer = None
+                self.reader = None
+                self.is_connected = False
+
+            logging.info(f"🔁 Retrying {self.name} in {self.reconnection_time}s...")
+            await asyncio.sleep(self.reconnection_time)
+
+    async def write_tcp(self, data: str, verbose: bool = True):
+        if self.is_connected and self.writer:
+            try:
+                data = data + "\n"
+                self.writer.write(data.encode())
+                await self.writer.drain()
+                if verbose:
+                    logging.info(f"{self.name} - [SENT] {data.strip()}")
+            except Exception as e:
+                logging.warning(f"{self.name} - [SEND ERROR] {e}")
+                if self.is_connected:
+                    self.is_connected = False
+                    self.on_event(self.name, "connection", False)
+
+    async def periodic_ping(self, interval: int):
+        while self.is_connected:
+            await asyncio.sleep(interval)
+            await self.write_tcp("ping", verbose=False)

smartx_rfid/devices/RFID/X714/write_commands.py

@@ -0,0 +1,25 @@
+import logging
+from smartx_rfid.schemas.tag import WriteTagValidator
+
+
+class WriteCommands:
+    def write_epc(self, target_identifier: str | None, target_value: str | None, new_epc: str, password: str):
+        try:
+            validated_tag = WriteTagValidator(
+                target_identifier=target_identifier,
+                target_value=target_value,
+                new_epc=new_epc,
+                password=password,
+            )
+        except Exception as e:
+            logging.warning(f"{self.name} - {e}")
+            return
+        identifier = validated_tag.target_identifier
+        value = validated_tag.target_value
+        epc = validated_tag.new_epc
+        password = validated_tag.password
+        logging.info(f"{self.name} - Writing EPC: {epc} (Current: {identifier}={value})")
+        if identifier is None:
+            self.write(f"#WRITE:{epc};{password}", False)
+        else:
+            self.write(f"#WRITE:{epc};{password};{identifier};{value}", False)

smartx_rfid/devices/__init__.py

@@ -0,0 +1,8 @@
+# GENERIC
+from .generic.SERIAL._main import SERIAL
+from .generic.TCP._main import TCP
+
+# RFID DEVICES
+from .RFID.X714._main import X714
+from .RFID.R700_IOT._main import R700_IOT
+from .RFID.R700_IOT.reader_config_example import R700_IOT_config_example