smartx-rfid 0.4.0__py3-none-any.whl

smartx_rfid/__init__.py

@@ -0,0 +1,9 @@
+"""publish_lib_ghp - A simple Python library demonstrating how to publish packages to PyPI."""
+
+from importlib.metadata import version
+
+try:
+    __version__ = version("publish-lib-example")
+except Exception:
+    # Fallback for development environments
+    __version__ = "0.0.0-dev"

smartx_rfid/devices/RFID/R700_IOT/_main.py

@@ -0,0 +1,167 @@
+import asyncio
+import logging
+
+import httpx
+
+from smartx_rfid.schemas.tag import WriteTagValidator
+from smartx_rfid.utils.event import on_event
+
+from .on_event import OnEvent
+from .reader_helpers import ReaderHelpers
+from .write_commands import WriteCommands
+from .reader_config_example import R700_IOT_config_example
+
+
+class R700_IOT(OnEvent, ReaderHelpers, WriteCommands):
+    def __init__(
+        self,
+        # READER CONFIG
+        reading_config: dict,
+        name: str = "R700",
+        # CONNECTION
+        ip: str = "192.168.1.101",  # Example hotsname: impinj-14-46-36
+        username: str = "root",
+        password: str = "impinj",
+        start_reading: bool = False,
+        # Firmware Version
+        firmware_version: str = "8.4.1",
+    ):
+        self.name = name
+        self.device_type = "rfid"
+
+        self.ip = ip
+        self.username = username
+        self.password = password
+
+        self.start_reading = start_reading
+
+        # URL AND ENDPOINTS
+        self.urlBase = f"https://{self.ip}/api/v1"
+        self.endpoint_interface = f"{self.urlBase}/system/rfid/interface"
+        self.check_version_endpoint = f"{self.urlBase}/system/image"
+        self.endpoint_start = f"{self.urlBase}/profiles/inventory/start"
+        self.endpoint_stop = f"{self.urlBase}/profiles/stop"
+        self.endpointDataStream = f"{self.urlBase}/data/stream"
+        self.endpoint_gpo = f"{self.urlBase}/device/gpos"
+        self.endpoint_write = f"{self.urlBase}/profiles/inventory/tag-access"
+
+        self.interface_config = {"rfidInterface": "rest"}
+        self.auth = httpx.BasicAuth(self.username, self.password)
+
+        self.tags_to_write = {}
+
+        self.is_connected = False
+        self.is_reading = False
+        self._stop_connection = False
+
+        self.firmware_version = firmware_version
+
+        self.reading_config = reading_config
+        self.config_example = R700_IOT_config_example
+
+        self.on_event = on_event
+
+    async def disconnect(self):
+        """Desconecta o reader de forma segura."""
+        logging.info(f"{self.name} 🔌 Disconnecting reader")
+        self._stop_connection = True
+
+        if self.is_reading:
+            try:
+                async with httpx.AsyncClient(auth=self.auth, verify=False, timeout=5.0) as session:
+                    await self.stop_inventory(session)
+            except Exception as e:
+                logging.warning(f"{self.name} ⚠️ Error stopping inventory during disconnect: {e}")
+
+        self.is_connected = False
+        self.is_reading = False
+        self.on_event(self.name, "reading", False)
+        self.on_event(self.name, "connection", False)
+
+    async def connect(self):
+        self._stop_connection = False
+        while not self._stop_connection:
+            async with httpx.AsyncClient(auth=self.auth, verify=False, timeout=10.0) as session:
+                if self.is_connected:
+                    self.on_event(self.name, "connection", False)
+
+                self.is_connected = False
+                self.is_reading = False
+
+                # Configure interface
+                success = await self.configure_interface(session)
+                if not success:
+                    logging.warning(f"{self.name} - Failed to configure interface")
+                    await asyncio.sleep(1)
+                    continue
+
+                # Check firmware version
+                success = await self.check_firmware_version(session)
+                if not success:
+                    logging.warning(
+                        f"{self.name} - Incompatible firmware version. Update R700 firmware to {self.firmware_version}."
+                    )
+                    await asyncio.sleep(5)
+                    continue
+
+                # Stop any ongoing profiles
+                success = await self.stop_inventory(session)
+                if not success:
+                    logging.warning(f"{self.name} - Failed to stop profiles")
+                    await asyncio.sleep(1)
+                    continue
+
+                if self.start_reading or self.reading_config.get("startTriggers"):
+                    success = await self.start_inventory(session)
+                    if not success:
+                        logging.warning(f"{self.name} - Failed to start inventory")
+                        await asyncio.sleep(1)
+                        continue
+                if self.start_reading:
+                    self.is_reading = True
+                    self.on_event(self.name, "reading", True)
+
+                # Clear GPO states
+                for i in range(1, 4):
+                    asyncio.create_task(self.write_gpo(pin=i, state=False))
+
+                self.is_connected = True
+                self.on_event(self.name, "connection", True)
+                await self.get_tag_list(session)
+
+    async def clear_tags(self):
+        self.tags = {}
+
+    async def write_gpo(
+        self,
+        pin: int = 1,
+        state: bool | str = True,
+        control: str = "static",
+        time: int = 1000,
+        *args,
+        **kwargs,
+    ):
+        gpo_command = await self.get_gpo_command(pin=pin, state=state, control=control, time=time)
+        try:
+            async with httpx.AsyncClient(auth=self.auth, verify=False, timeout=10.0) as session:
+                await self.post_to_reader(session, self.endpoint_gpo, payload=gpo_command, method="put")
+        except Exception as e:
+            logging.warning(f"{self.name} - Failed to set GPO: {e}")
+
+    def write_epc(self, target_identifier: str | None, target_value: str | None, new_epc: str, password: str):
+        """
+        Writes a new EPC (Electronic Product Code) to RFID tags.
+        """
+        try:
+            validated_tag = WriteTagValidator(
+                target_identifier=target_identifier,
+                target_value=target_value,
+                new_epc=new_epc,
+                password=password,
+            )
+            logging.info(
+                f"{self.name} - Writing EPC: {validated_tag.new_epc} (Current: {validated_tag.target_identifier}={validated_tag.target_value})"
+            )
+            asyncio.create_task(self.send_write_command(validated_tag.model_dump()))
+        except Exception as e:
+            logging.warning(f"{self.name} - Write validation error: {e}")

smartx_rfid/devices/RFID/R700_IOT/on_event.py

@@ -0,0 +1,17 @@
+class OnEvent:
+    async def on_start(self):
+        self.is_reading = True
+        self.on_event(self.name, "reading", True)
+
+    async def on_stop(self):
+        self.is_reading = False
+        self.on_event(self.name, "reading", False)
+
+    async def on_tag(self, tag):
+        current_tag = {
+            "epc": tag.get("epcHex"),
+            "tid": tag.get("tidHex"),
+            "ant": tag.get("antennaPort"),
+            "rssi": int(tag.get("peakRssiCdbm", 0) / 100),
+        }
+        self.on_event(self.name, "tag", current_tag)

smartx_rfid/devices/RFID/R700_IOT/reader_config_example.py

@@ -0,0 +1,69 @@
+R700_IOT_config_example = {
+    "antennaConfigs": [
+        {
+            "antennaPort": 1,
+            "estimatedTagPopulation": 16,
+            "fastId": "enabled",
+            "inventorySearchMode": "dual-target",
+            "inventorySession": 1,
+            "receiveSensitivityDbm": -80,
+            "rfMode": 4,
+            "transmitPowerCdbm": 3300,
+        },
+        {
+            "antennaPort": 2,
+            "estimatedTagPopulation": 16,
+            "fastId": "enabled",
+            "inventorySearchMode": "dual-target",
+            "inventorySession": 1,
+            "receiveSensitivityDbm": -80,
+            "rfMode": 4,
+            "transmitPowerCdbm": 3300,
+        },
+        {
+            "antennaPort": 3,
+            "estimatedTagPopulation": 16,
+            "fastId": "enabled",
+            "inventorySearchMode": "dual-target",
+            "inventorySession": 1,
+            "receiveSensitivityDbm": -80,
+            "rfMode": 4,
+            "transmitPowerCdbm": 3300,
+        },
+        {
+            "antennaPort": 4,
+            "estimatedTagPopulation": 16,
+            "fastId": "enabled",
+            "inventorySearchMode": "dual-target",
+            "inventorySession": 1,
+            "receiveSensitivityDbm": -80,
+            "rfMode": 4,
+            "transmitPowerCdbm": 3300,
+        },
+    ],
+    "startTriggers": [{"gpiTransitionEvent": {"gpi": 1, "transition": "high-to-low"}}],
+    "stopTriggers": [{"gpiTransitionEvent": {"gpi": 1, "transition": "low-to-high"}}],
+    "eventConfig": {
+        "common": {"hostname": "disabled"},
+        "tagInventory": {
+            "epc": "disabled",
+            "epcHex": "enabled",
+            "xpcHex": "disabled",
+            "tid": "disabled",
+            "tidHex": "enabled",
+            "antennaPort": "enabled",
+            "transmitPowerCdbm": "disabled",
+            "peakRssiCdbm": "enabled",
+            "frequency": "disabled",
+            "pc": "disabled",
+            "lastSeenTime": "disabled",
+            "phaseAngle": "disabled",
+            "tagReporting": {
+                "reportingIntervalSeconds": 1,
+                "tagCacheSize": 2048,
+                "antennaIdentifier": "antennaPort",
+                "tagIdentifier": "epc",
+            },
+        },
+    },
+}

smartx_rfid/devices/RFID/R700_IOT/reader_helpers.py

@@ -0,0 +1,136 @@
+import asyncio
+import json
+import logging
+
+import httpx
+
+
+class ReaderHelpers:
+    async def check_firmware_version(self, session: httpx.AsyncClient | None = None):
+        endpoint = self.check_version_endpoint
+
+        try:
+            if session is None:
+                async with httpx.AsyncClient(auth=self.auth, verify=False, timeout=5.0) as client:
+                    response = await client.get(endpoint)
+            else:
+                response = await session.get(endpoint)
+
+            if response.status_code != 200:
+                logging.warning(f"{self.name} - Failed to get firmware version: {response.status_code}")
+                return False
+
+            version_info = response.json()
+            firmware_version = version_info.get("primaryFirmware", "Unknown")
+            return firmware_version.startswith(self.firmware_version)
+
+        except Exception as e:
+            logging.warning(f"{self.name} - Error GET {endpoint}: {e}")
+            return False
+
+    async def configure_interface(self, session):
+        return await self.post_to_reader(
+            session,
+            self.endpoint_interface,
+            payload=self.interface_config,
+            method="put",
+        )
+
+    async def stop_inventory(self, session=None):
+        return await self.post_to_reader(session, self.endpoint_stop)
+
+    async def start_inventory(self, session=None):
+        return await self.post_to_reader(session, self.endpoint_start, payload=self.reading_config)
+
+    async def post_to_reader(self, session, endpoint, payload=None, method="post", timeout=3):
+        try:
+            if session is None:
+                async with httpx.AsyncClient(auth=self.auth, verify=False, timeout=timeout) as client:
+                    return await self.post_to_reader(client, endpoint, payload, method, timeout)
+
+            if method == "post":
+                response = await session.post(endpoint, json=payload, timeout=timeout)
+                if response.status_code != 204:
+                    logging.warning(f"{self.name} - POST {endpoint} failed: {response.status_code}")
+
+            elif method == "put":
+                response = await session.put(endpoint, json=payload, timeout=timeout)
+                if response.status_code != 204:
+                    logging.warning(f"{self.name} - PUT {endpoint} failed: {response.status_code}")
+
+            return response.status_code == 204
+
+        except Exception as e:
+            logging.warning(f"{self.name} - Error posting to {endpoint}: {e}")
+            return False
+
+    async def get_tag_list(self, session):
+        try:
+            async with session.stream("GET", self.endpointDataStream, timeout=None) as response:
+                if response.status_code != 200:
+                    logging.warning(f"{self.name} - Failed to connect to data stream: {response.status_code}")
+                    return
+
+                logging.info(f"{self.name} - Connected to data stream.")
+
+                async for line in response.aiter_lines():
+                    try:
+                        string = line.strip()
+                        if not string:
+                            continue
+                        jsonEvent = json.loads(string)
+
+                        if "inventoryStatusEvent" in jsonEvent:
+                            status = jsonEvent["inventoryStatusEvent"]["inventoryStatus"]
+                            if status == "running":
+                                asyncio.create_task(self.on_start())
+                            else:
+                                asyncio.create_task(self.on_stop())
+                        elif "tagInventoryEvent" in jsonEvent:
+                            tagEvent = jsonEvent["tagInventoryEvent"]
+                            asyncio.create_task(self.on_tag(tagEvent))
+
+                    except (json.JSONDecodeError, UnicodeDecodeError) as parse_error:
+                        logging.warning(f"{self.name} - Failed to parse event: {parse_error}")
+        except Exception as e:
+            logging.warning(f"{self.name} - Unexpected error: {e}")
+
+    async def get_gpo_command(
+        self, pin: int = 1, state: bool | str = True, control: str = "static", time: int = 1000
+    ) -> dict:
+        """
+        Gera o payload de configuração de GPO para o leitor RFID.
+
+        Args:
+            pin (int): Número do pino GPO a ser configurado. Default é 1.
+            state (bool | str): Estado do pino. Pode ser:
+                - True ou "high" → alto
+                - False ou "low" → baixo
+            control ("static" | "pulsed"): Tipo de controle do pino.
+                - "static": mantém o estado
+                - "pulsed": envia pulso por tempo definido
+            time (int): Duração do pulso em milissegundos. Apenas usado se control="pulsed". Default 1000ms.
+
+        Returns:
+            dict: Payload compatível com a API do leitor RFID para configurar GPO.
+
+        Example:
+            gpo_cmd = await self.get_gpo_command(pin=2, state=True, control="pulsed", time=500)
+        """
+        # Normaliza o estado
+        state = "high" if state is True else "low" if state is False else str(state)
+
+        if control == "static":
+            gpo_command = {"gpoConfigurations": [{"gpo": pin, "state": state, "control": control}]}
+        elif control == "pulsed":
+            gpo_command = {
+                "gpoConfigurations": [
+                    {
+                        "gpo": pin,
+                        "state": state,
+                        "pulseDurationMilliseconds": time,
+                        "control": control,
+                    }
+                ]
+            }
+        return gpo_command

smartx_rfid/devices/RFID/R700_IOT/write_commands.py

@@ -0,0 +1,60 @@
+import logging
+
+import httpx
+
+
+class WriteCommands:
+    async def get_write_cmd(self, tag):
+        identifier = tag.target_identifier
+        target = tag.target_value
+        epc = tag.new_epc
+        password = tag.password
+
+        return {
+            "accessCommands": [
+                {
+                    "identifier": "1",
+                    "blockWrite": {
+                        "memoryBank": "epc",
+                        "wordOffset": 2,
+                        "dataHex": epc[0:8],
+                    },
+                },
+                {
+                    "identifier": "2",
+                    "blockWrite": {
+                        "memoryBank": "epc",
+                        "wordOffset": 4,
+                        "dataHex": epc[8:16],
+                    },
+                },
+                {
+                    "identifier": "3",
+                    "blockWrite": {
+                        "memoryBank": "epc",
+                        "wordOffset": 6,
+                        "dataHex": epc[16:24],
+                    },
+                },
+            ],
+            "tagAccessPasswordHex": password,
+            "tagSelectors": [
+                {
+                    "action": "include",
+                    "tagMemoryBank": identifier if identifier else "epc",
+                    "bitOffset": 0 if identifier == "tid" else 32,
+                    "mask": target if target else "0",
+                    "maskLength": 1 if identifier is None else 96,
+                }
+            ],
+        }
+
+    async def send_write_command(self, write_command):
+        if not isinstance(write_command, list):
+            write_command = [write_command]
+        payload = {"accessConfigurations": write_command}
+        try:
+            async with httpx.AsyncClient(auth=self.auth, verify=False, timeout=10.0) as session:
+                await self.post_to_reader(session, self.endpoint_write, payload=payload)
+        except Exception as e:
+            logging.warning(f"{self.name} - Failed to Write: {e}")

smartx_rfid/devices/RFID/X714/_main.py

@@ -0,0 +1,146 @@
+import asyncio
+import logging
+
+from typing import Callable
+
+from .ble_protocol import BLEProtocol
+from .on_receive import OnReceive
+from .rfid import RfidCommands
+from .serial_protocol import SerialProtocol
+from .tcp_protocol import TCPProtocol
+from .write_commands import WriteCommands
+
+from smartx_rfid.utils.event import on_event
+
+ant_default_config = {
+    "1": {"active": True, "power": 22, "rssi": -120},
+    "2": {"active": False, "power": 22, "rssi": -120},
+    "3": {"active": False, "power": 22, "rssi": -120},
+    "4": {"active": False, "power": 22, "rssi": -120},
+}
+
+
+class X714(SerialProtocol, OnReceive, RfidCommands, BLEProtocol, WriteCommands, TCPProtocol):
+    def __init__(
+        self,
+        name: str = "X714",
+        connection_type: str = "SERIAL",  # SERIAL, BLE or TCP
+        # SERIAL
+        port: str = "AUTO",  # AUTO or COMx / /dev/ttyX
+        baudrate: int = 115200,
+        vid: int = 1,
+        pid: int = 1,
+        # TCP
+        ip: str | None = "192.168.1.100",
+        tcp_port: int = 23,
+        # BLE
+        ble_name: str = "SMTX",
+        # GENERIC
+        buzzer: bool = False,
+        session: int = 1,  # 0, 1, 2, 3
+        start_reading: bool = False,
+        gpi_start: bool = False,
+        ignore_read: bool = False,
+        always_send: bool = True,
+        simple_send: bool = False,
+        keyboard: bool = False,
+        decode_gtin: bool = False,
+        hotspot: bool = True,
+        reconnection_time: int = 3,
+        prefix: str = "",
+        protected_inventory_password: str | None = None,
+        # Antenna config
+        # If ant_dict is provided use it else use the other vars
+        ant_dict: dict | None = None,
+        active_ant: list[int] | None = [1],
+        read_power: int = 22,
+        read_rssi: int = -120,
+    ):
+        # Name
+        self.name = name
+        self.device_type = "rfid"
+
+        # CONNECTION TYPE
+        if connection_type in ["SERIAL", "BLE", "TCP"]:
+            self.connection_type = connection_type
+        else:
+            self.connection_type = "SERIAL"
+            logging.warning(f"[{self.name}] Invalid connection_type '{connection_type}' set to 'SERIAL'")
+
+        # SERIAL CONFIG
+        self.port = port
+        self.baudrate = baudrate
+        self.vid = vid
+        self.pid = pid
+        self.is_auto = self.port == "AUTO"
+
+        # TCP CONFIG
+        self.ip = ip
+        self.tcp_port = tcp_port
+
+        # BLE CONFIG
+        self.ble_name = ble_name
+        self.init_ble_vars()
+
+        # GENERIC CONFIG
+        self.buzzer = buzzer
+        if session not in [0, 1, 2, 3]:
+            session = 1
+            logging.warning(f"[{self.name}] Invalid session '{session}' set to '1'")
+        self.session = session
+        self.start_reading = start_reading
+        self.gpi_start = gpi_start
+        self.ignore_read = ignore_read
+        self.always_send = always_send
+        self.simple_send = simple_send
+        self.keyboard = keyboard
+        self.decode_gtin = decode_gtin
+        self.hotspot = hotspot
+        self.reconnection_time = reconnection_time
+        self.prefix = prefix
+        self.protected_inventory_password = protected_inventory_password
+
+        # ANTENNA CONFIG
+        if ant_dict is not None:
+            self.ant_dict = ant_dict
+        else:
+            self.ant_dict = ant_default_config
+            for ant in self.ant_dict.keys():
+                ant_num = int(ant)
+                if active_ant and ant_num in active_ant:
+                    self.ant_dict[ant]["active"] = True
+                else:
+                    self.ant_dict[ant]["active"] = False
+                self.ant_dict[ant]["power"] = read_power
+                self.ant_dict[ant]["rssi"] = read_rssi
+
+        self.transport = None
+        self.on_con_lost = None
+        self.rx_buffer = bytearray()
+        self.last_byte_time = None
+
+        self.is_connected = False
+        self.is_reading = False
+
+        self.on_event: Callable = on_event
+
+    def write(self, to_send, verbose=True):
+        if self.connection_type == "SERIAL":
+            self.write_serial(to_send, verbose)
+        elif self.connection_type == "BLE":
+            asyncio.create_task(self.write_ble(to_send.encode(), verbose))
+        else:
+            asyncio.create_task(self.write_tcp(to_send, verbose))
+
+    async def connect(self):
+        if self.connection_type == "SERIAL":
+            await self.connect_serial()
+        elif self.connection_type == "BLE":
+            await self.connect_ble()
+        else:
+            await self.connect_tcp(self.ip, self.tcp_port)
+
+    def on_connected(self):
+        """Callback chamado quando a conexão é estabelecida."""
+        self.config_reader()
+        self.on_event(self.name, "connected", True)