smartx-rfid 0.4.0__py3-none-any.whl

smartx_rfid/devices/generic/SERIAL/_main.py

@@ -0,0 +1,237 @@
+import asyncio
+import logging
+import time
+
+import serial.tools.list_ports
+import serial_asyncio
+from typing import Callable
+from smartx_rfid.utils.event import on_event
+
+
+class SERIAL(asyncio.Protocol):
+    """
+    Asynchronous Serial Communication Protocol Handler
+
+    This class implements an asyncio-based serial communication protocol
+    that supports automatic port detection, connection management, and
+    data handling with timeout mechanisms.
+
+    Features:
+    - Automatic port detection by VID/PID
+    - Automatic reconnection on connection loss
+    - Message buffering with timeout handling
+    - CRC16 checksum calculation
+    - Event-driven architecture
+    """
+
+    def __init__(
+        self,
+        name: str = "GENERIC_SERIAL",
+        port: str = "AUTO",
+        baudrate: int = 115200,
+        vid: int = 1,
+        pid: int = 1,
+        reconnection_time: int = 3,
+    ):
+        """
+        Initialize the SERIAL protocol handler.
+
+        Args:
+                name: Device name identifier
+                port: Serial port ('AUTO' for automatic detection)
+                baudrate: Communication baudrate
+                vid: USB Vendor ID for auto-detection
+                pid: USB Product ID for auto-detection
+                reconnection_time: Delay between reconnection attempts
+        """
+        self.name = name
+        self.device_type = "generic"
+
+        self.port = port
+        self.baudrate = baudrate
+        self.vid = vid
+        self.pid = pid
+        self.reconnection_time = reconnection_time
+
+        self.transport = None
+        self.on_con_lost = None
+        self.rx_buffer = bytearray()
+        self.last_byte_time = None
+        self.is_auto = self.port == "AUTO"
+
+        self.is_connected = False
+        self.is_reading = False
+
+        self.on_event: Callable = on_event
+
+    def connection_made(self, transport):
+        """
+        Callback invoked when a connection is established.
+
+        Args:
+                transport: The transport object for communication
+        """
+        self.transport = transport
+        self.is_connected = True
+        self.on_event(self.name, "connection", True)
+
+    def data_received(self, data):
+        """
+        Callback invoked when data is received from the serial port.
+
+        Handles incoming data with automatic message parsing and timeout management.
+        Messages are delimited by '\n' or '\r' characters.
+
+        Args:
+                data: Raw bytes received from the serial port
+        """
+        now = time.time()
+        self.rx_buffer += data
+        self.last_byte_time = now
+
+        # Cancela tarefa anterior de timeout
+        if hasattr(self, "_timeout_task") and self._timeout_task and not self._timeout_task.done():
+            self._timeout_task.cancel()
+
+        # Cria nova tarefa de timeout
+        async def timeout_clear():
+            await asyncio.sleep(0.3)  # 300 ms
+            if self.last_byte_time and (time.time() - self.last_byte_time) >= 0.3:
+                if self.rx_buffer:
+                    self.rx_buffer.clear()
+                    logging.warning("⚠️ Buffer cleared due to 300ms timeout without receiving data.")
+
+        self._timeout_task = asyncio.create_task(timeout_clear())
+
+        # Processa mensagens completas
+        while b"\n" in self.rx_buffer or b"\r" in self.rx_buffer:
+            # Encontra posição do primeiro delimitador
+            positions = [p for p in [self.rx_buffer.find(b"\n"), self.rx_buffer.find(b"\r")] if p != -1]
+            pos = min(positions)
+
+            # Extrai mensagem em bytes e converte para string
+            message_bytes = self.rx_buffer[:pos]
+            message = message_bytes.decode(errors="ignore").strip("\r\n")
+
+            # Remove mensagem do buffer
+            self.rx_buffer = self.rx_buffer[pos + 1 :]
+
+            if message:
+                self.on_event(self.name, "receive", message)
+
+    def connection_lost(self, exc):
+        """
+        Callback invoked when the connection is lost.
+
+        Args:
+                exc: Exception that caused the disconnection (if any)
+        """
+        logging.warning("⚠️ Serial connection lost.")
+        self.transport = None
+        self.is_connected = False
+        self.step = 0
+
+        if self.on_con_lost:
+            self.on_con_lost.set()
+        self.on_event(self.name, "connection", False)
+
+    def write(self, to_send, verbose=True):
+        """
+        Send data through the serial connection.
+
+        Automatically adds newline to strings and calculates CRC16 for bytes.
+
+        Args:
+                to_send: Data to send (str or bytes)
+                verbose: Enable logging of sent data
+        """
+        if self.transport:
+            if isinstance(to_send, str):
+                to_send += "\n"
+                to_send = to_send.encode()
+
+            # If it's bytes, calculate CRC and replace last two bytes
+            if isinstance(to_send, bytes) and len(to_send) >= 2:
+                crc = self.crc16(to_send)
+                to_send = to_send[:-2] + bytes([crc & 0xFF, crc >> 8])
+
+            if verbose:
+                if isinstance(to_send, bytes):
+                    hex_list = [f"0x{b:02X}" for b in to_send]
+                    logging.info(f"📤 Sending: {hex_list}")
+                else:
+                    logging.info(f"📤 Sending: {to_send}")
+
+            self.transport.write(to_send)
+        else:
+            logging.warning("❌ Send attempt failed: connection not established.")
+
+    async def connect(self):
+        """
+        Establish and maintain serial connection with automatic reconnection.
+
+        This method runs continuously, attempting to connect to the specified
+        serial port or auto-detecting it by VID/PID. When connection is lost,
+        it automatically attempts to reconnect.
+        """
+        loop = asyncio.get_running_loop()
+
+        while True:
+            self.on_con_lost = asyncio.Event()
+
+            # If AUTO mode, try to detect port by VID/PID
+            if self.is_auto:
+                logging.info("🔍 Auto-detecting port")
+                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"✅ Detected port: {found_port}")
+                        break
+
+                if found_port is None:
+                    logging.warning(f"⚠️ No port with VID={self.vid} and PID={self.pid} found.")
+                    logging.info(f"⏳ Retrying in {self.reconnection_time} seconds...")
+                    await asyncio.sleep(self.reconnection_time)
+                    continue  # try to detect again in next loop
+                else:
+                    self.port = found_port
+
+            try:
+                logging.info(f"🔌 Trying to connect to {self.port} at {self.baudrate} bps...")
+                await serial_asyncio.create_serial_connection(loop, lambda: self, self.port, baudrate=self.baudrate)
+                logging.info("🟢 Successfully connected.")
+                await self.on_con_lost.wait()
+                logging.info("🔄 Connection lost. Attempting to reconnect...")
+            except Exception as e:
+                logging.warning(f"❌ Connection error: {e}")
+
+            # If in AUTO mode, reset port to "AUTO" to force detection next loop
+            if self.is_auto:
+                self.port = "AUTO"
+
+            logging.info("⏳ Waiting 3 seconds before retrying...")
+            await asyncio.sleep(3)
+
+    def crc16(self, data: bytes, poly=0x8408):
+        """
+        Calculate CRC-16/CCITT-FALSE checksum.
+
+        Args:
+                data: Input bytes (last 2 bytes are excluded from calculation)
+                poly: CRC polynomial (default: 0x8408 for CCITT-FALSE)
+
+        Returns:
+                int: 16-bit CRC checksum
+        """
+        crc = 0xFFFF
+        for byte in data[:-2]:  # exclude last two bytes (CRC placeholder)
+            crc ^= byte
+            for _ in range(8):
+                if crc & 0x0001:
+                    crc = (crc >> 1) ^ poly
+                else:
+                    crc >>= 1
+        return crc & 0xFFFF

smartx_rfid/devices/generic/TCP/_main.py

@@ -0,0 +1,72 @@
+import asyncio
+import logging
+
+from .helpers import Helpers
+from smartx_rfid.utils.event import on_event
+from typing import Callable
+
+
+class TCP(Helpers):
+    def __init__(
+        self,
+        name: str = "GENERIC_TCP",
+        ip: str = "192.168.1.101",
+        port: int = 23,
+    ):
+        self.name = name
+        self.device_type = "generic"
+
+        self.ip = ip
+        self.port = port
+
+        self.reader = None
+        self.writer = None
+
+        self.is_connected = False
+        self.on_event: Callable = on_event
+
+    async def connect(self):
+        while True:
+            try:
+                logging.info(f"Connecting: {self.name} - {self.ip}:{self.port}")
+                self.reader, self.writer = await asyncio.wait_for(
+                    asyncio.open_connection(self.ip, self.port), timeout=3
+                )
+                self.is_connected = True
+                self.on_event(self.name, "connection", True)
+
+                # Start the receive and monitor tasks
+                tasks = [
+                    asyncio.create_task(self.receive_data()),
+                    asyncio.create_task(self.monitor_connection()),
+                ]
+
+                # Wait until one of the tasks completes (e.g. disconnection)
+                done, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
+
+                # Cancel any remaining tasks
+                for task in pending:
+                    task.cancel()
+
+                self.is_connected = False
+                self.on_event(self.name, "connection", False)
+
+            except Exception as e:
+                self.is_connected = False
+                self.on_event(self.name, "connection", False)
+                logging.error(f"[CONNECTION ERROR] {e}")
+
+            await asyncio.sleep(3)
+
+    async def write(self, data: str, verbose=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"[SENT] {data.strip()}")
+            except Exception as e:
+                logging.warning(f"[SEND ERROR] {e}")
+                self.is_connected = False
+                self.on_event(self.name, "connection", False)

smartx_rfid/devices/generic/TCP/helpers.py

@@ -0,0 +1,41 @@
+import asyncio
+import logging
+
+
+class Helpers:
+    async def monitor_connection(self):
+        while self.is_connected:
+            await asyncio.sleep(3)
+            if (self.writer and self.writer.is_closing()) or (self.reader and self.reader.at_eof()):
+                self.is_connected = False
+                logging.info("[DISCONNECTED] Socket closed.")
+                break
+
+            await self.write("ping", verbose=False)
+
+    async def receive_data(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:
+                        await self.on_received_cmd(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)
+                    # event received
+                    self.on_event(self.name, "receive", line.strip())
+
+        except Exception as e:
+            self.is_connected = False
+            logging.error(f"[RECEIVE ERROR] {e}")

smartx_rfid/schemas/tag.py

@@ -0,0 +1,55 @@
+import re
+from typing import Optional
+from pydantic import BaseModel, Field, field_validator
+
+
+class TagSchema(BaseModel):
+    epc: str = Field("000000000000000000000001")
+    tid: Optional[str | None] = Field("E28000000000000000000001")
+    ant: Optional[int | None] = 0
+    rssi: Optional[int | None] = 0
+
+    @field_validator("epc", "tid")
+    def validate_epc_length_and_hex(cls, v, field):
+        if v is None:
+            return v
+        if len(v) != 24:
+            raise ValueError(f"{field} must have exactly 24 characters")
+        if not re.fullmatch(r"[0-9a-fA-F]{24}", v):
+            raise ValueError(f"{field} must contain only hexadecimal characters (0-9, a-f)")
+        return v.lower()
+
+
+class WriteTagValidator(BaseModel):
+    target_identifier: Optional[str] = Field(None, description='Identifier type: "epc", "tid", or None')
+    target_value: Optional[str] = Field(None, description="Current value of the identifier (24 hexadecimal characters)")
+    new_epc: str = Field(..., description="New EPC value to write (24 hexadecimal characters)")
+    password: str = Field(..., description="Password to access the tag (8 hexadecimal characters)")
+
+    @field_validator("target_identifier")
+    def validate_identifier(cls, v):
+        if v == "None" or v is None:
+            return None
+        allowed_values = ("epc", "tid", None)
+        if v not in allowed_values:
+            raise ValueError(f"target_identifier must be one of {allowed_values}")
+        return v.lower()
+
+    @field_validator("target_value", "new_epc")
+    def validate_epc_length_and_hex(cls, v, field):
+        if v is None or v == "None":
+            v = "0" * 24
+
+        if len(v) != 24:
+            raise ValueError(f"{field} must have exactly 24 characters")
+        if not re.fullmatch(r"[0-9a-fA-F]{24}", v):
+            raise ValueError(f"{field} must contain only hexadecimal characters (0-9, a-f)")
+        return v.lower()
+
+    @field_validator("password")
+    def validate_password_length_and_hex(cls, v, field):
+        if len(v) != 8:
+            raise ValueError(f"{field} must have exactly 8 characters")
+        if not re.fullmatch(r"[0-9a-fA-F]{8}", v):
+            raise ValueError(f"{field} must contain only hexadecimal characters (0-9, a-f)")
+        return v.lower()

smartx_rfid/utils/event.py

@@ -0,0 +1,15 @@
+import logging
+
+
+def on_event(name: str, event_type: str, event_data=None):
+    """
+    Default event handler for protocol events.
+
+    This method can be overridden to handle specific events like
+    connection status changes or received messages.
+
+    Args:
+            event_type: Type of event ('connection', 'receive', etc.)
+            event_data: Associated data with the event
+    """
+    logging.info(f"{name} -> 🔔 Event: {event_type}, Data: {event_data}")

smartx_rfid-0.4.0.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: smartx-rfid
+Version: 0.4.0
+Summary: SmartX RFID library
+License: MIT
+License-File: LICENSE
+Keywords: python,library,RFID,smartx,packaging
+Author: Gabriel Henrique Pascon
+Author-email: gh.pascon@gmail.com
+Requires-Python: >=3.11,<4.0
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: bleak (>=1.1.1,<2.0.0)
+Requires-Dist: httpx (==0.28.1)
+Requires-Dist: pydantic (>=2.12.5,<3.0.0)
+Requires-Dist: pyepc (==0.5.0)
+Requires-Dist: pyserial (==3.5)
+Requires-Dist: pyserial-asyncio (==0.6)
+Requires-Dist: ruff (>=0.14.11,<0.15.0)
+Project-URL: Documentation, https://github.com/ghpascon/smartx_rfid#readme
+Project-URL: Homepage, https://github.com/ghpascon/smartx_rfid
+Project-URL: Repository, https://github.com/ghpascon/smartx_rfid
+Description-Content-Type: text/markdown
+
+# SmartX RFID
+
+The official SmartX RFID Python library for seamless integration with RFID systems and devices.
+
+## Overview
+
+SmartX RFID is a comprehensive Python package designed to provide easy-to-use interfaces for RFID operations and device management. This library serves as the foundation for building robust RFID applications.
+
+## Features (Current & Planned)
+
+- **Device Communication**: Asynchronous serial communication with RFID devices
+- **Auto-Detection**: Automatic port detection for USB devices by VID/PID
+- **Connection Management**: Automatic reconnection and error handling
+- **External Device Support**: Interface with various RFID readers and writers *(coming soon)*
+- **Tag Operations**: Read, write, and manage RFID tags *(coming soon)*
+- **Protocol Support**: Multiple RFID protocols and standards *(coming soon)*
+
+## Installation
+
+```bash
+pip install smartx-rfid
+```
+
+## Quick Start
+
+```python
+from smartx_rfid.devices import SERIAL
+import asyncio
+
+async def main():
+    device = SERIAL(name="MyRFIDDevice")
+    await device.connect()
+
+asyncio.run(main())
+```
+
+## Development Status
+
+This library is actively under development. Current focus areas include:
+
+- Core device communication protocols
+- External device integration
+- Enhanced error handling
+- Comprehensive documentation
+
+## License
+
+MIT License
+
+## Support
+
+For issues and support, please visit our [GitHub repository](https://github.com/ghpascon/smartx_rfid).
+

smartx_rfid-0.4.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+smartx_rfid/__init__.py,sha256=XCdKdP8o5LT3VjJtWOuFHJzztc0FXt3Ms89qsx0p6sM,282
+smartx_rfid/devices/RFID/R700_IOT/_main.py,sha256=xd9roD7ovnJAXLp6r7PtxYz98CgKO1t6gz3t4V0KIMU,6293
+smartx_rfid/devices/RFID/R700_IOT/on_event.py,sha256=JmJ6RcGgX34b2gkuqyZ4G1LSDliRRALg_DdvenHOZVk,538
+smartx_rfid/devices/RFID/R700_IOT/reader_config_example.py,sha256=oi4vg3_zjYFDUeq1Y_d5InUx_Rq5M2CB5RDVkK3WCgU,2264
+smartx_rfid/devices/RFID/R700_IOT/reader_helpers.py,sha256=UC4ozq9FmuQtCK5Nv8Mjg4tZyuFetjx1eMWiw5yb0XY,5692
+smartx_rfid/devices/RFID/R700_IOT/write_commands.py,sha256=d1GXBaBVaNqvPWitYNZ94uZJOy2wwbj-2uzCxWOflPo,2037
+smartx_rfid/devices/RFID/X714/_main.py,sha256=ERMeQnbLevGXtZ-8Roykb67jbt53yacawibPkCs4eGo,4753
+smartx_rfid/devices/RFID/X714/ble_protocol.py,sha256=M3Cs66WX6oa_EPdMTLEjD-IRxAjpfrKzGj4hn1vxlxQ,6951
+smartx_rfid/devices/RFID/X714/on_receive.py,sha256=yjkxWL1ZGzcZKZXKwQ85cvl33fsjhXATOwg9QQBk-GQ,1641
+smartx_rfid/devices/RFID/X714/rfid.py,sha256=W-8-ADYv9oYE9PHDEynQhHCXyVecDRfplWRIxb3cqts,1974
+smartx_rfid/devices/RFID/X714/serial_protocol.py,sha256=eOGM5sK35SxXfS9KjB8JQzYhR1qs4H3vw3-n3oPOjQQ,3681
+smartx_rfid/devices/RFID/X714/tcp_protocol.py,sha256=GthynyN6YMl6R16nrAnlrDK61QnuZAOhYhPqycBCwJA,4804
+smartx_rfid/devices/RFID/X714/write_commands.py,sha256=gkfsQ--bijZWw0e1FP8Wb0qtFtexM4hP6HJz6y5hvOM,987
+smartx_rfid/devices/__init__.py,sha256=EVhtb-IBLpits8dr-I1ZYYuWHw9ddqiu-98myg-iyFg,251
+smartx_rfid/devices/generic/SERIAL/_main.py,sha256=BB4b6t6NI7tQDZH1ZAl-ZqSG8WH_HmGJIrIs5hIxpS8,8356
+smartx_rfid/devices/generic/TCP/_main.py,sha256=BzpIiCxamtauQCa7GCldNlG_fhSLJoSxDs2lhGEc31M,2318
+smartx_rfid/devices/generic/TCP/helpers.py,sha256=5ySy0Wv6D3q9AEV8kVLw1aMbe3kMDm4lFxP3KLIMMWM,1386
+smartx_rfid/schemas/tag.py,sha256=gq38yKPqPBPaF-wx_0_lnhttz0neM_bob94puv-5Z7Y,2285
+smartx_rfid/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+smartx_rfid/utils/event.py,sha256=7QOdiSfiMscoAaTq4U3E3asYGSVnolr9OD3FSYGh6bg,469
+smartx_rfid-0.4.0.dist-info/METADATA,sha256=OPKyl9QnD1r2um-C9pwMXuKsMxEji8qv7xItz5T8MsQ,2676
+smartx_rfid-0.4.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+smartx_rfid-0.4.0.dist-info/licenses/LICENSE,sha256=npGJO3HuHM3JdFNEXv1jRmP_wRYq9-ujkqJPmLxrtEw,1080
+smartx_rfid-0.4.0.dist-info/RECORD,,

smartx_rfid-0.4.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any

smartx_rfid-0.4.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gabriel Henrique Pascon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.