yostlabs 2025.10.24__tar.gz → 2025.10.29__tar.gz

{yostlabs-2025.10.24 → yostlabs-2025.10.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yostlabs
-Version: 2025.10.24
+Version: 2025.10.29
 Summary: Python resources and API for 3Space sensors from Yost Labs Inc.
 Project-URL: Homepage, https://yostlabs.com/
 Project-URL: Repository, https://github.com/YostLabs/3SpacePythonPackage/tree/main
@@ -16,6 +16,7 @@ Requires-Python: >=3.10
 Requires-Dist: async-timeout
 Requires-Dist: bleak
 Requires-Dist: numpy
+Requires-Dist: pybluez2
 Requires-Dist: pyserial
 Description-Content-Type: text/markdown
 

{yostlabs-2025.10.24 → yostlabs-2025.10.29}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 [project]
 name = "yostlabs"
 #If uploading again on the same day, add a fourth number
-version = "2025.10.24"
+version = "2025.10.29"
 authors = [
   { name="Yost Labs Inc.", email="techsupport@yostlabs.com" },
   { name="Andy Riedlinger", email="techsupport@yostlabs.com" },
@@ -24,7 +24,8 @@ dependencies = [
   "pyserial",
   "numpy",
   "bleak",
-  "async-timeout"
+  "async-timeout",
+  "pybluez2"
 ]
 
 [project.urls]

{yostlabs-2025.10.24 → yostlabs-2025.10.29}/src/yostlabs/communication/ble.py

@@ -53,7 +53,7 @@ class ThreespaceBLEComClass(ThreespaceComClass):
             cls.EVENT_LOOP_THREAD = threading.Thread(target=ylBleEventLoopThread, args=(cls.EVENT_LOOP,), daemon=True)
             cls.EVENT_LOOP_THREAD.start()
 
-    def __init__(self, ble: BleakClient | BLEDevice | str, discover_name: bool = True, discovery_timeout=5, error_on_disconnect=True, adv: AdvertisementData = None):
+    def __init__(self, ble: BleakClient | BLEDevice | str, discover_name: bool = True, discovery_timeout=5, error_on_disconnect=True, adv: AdvertisementData = None, profile: ThreespaceBLENordicUartProfile=None):
         """
         Parameters
         ----------
@@ -88,17 +88,18 @@ class ThreespaceBLEComClass(ThreespaceComClass):
             raise TypeError("Invalid type for creating a ThreespaceBLEComClass:", type(ble), ble)
 
         #Select the profile
-        self.profile = None
-        if self.adv is not None and len(self.adv.service_uuids) > 0:
-            for service_uuid in self.adv.service_uuids:
-                self.profile = self.get_profile(service_uuid)
-                if self.profile is not None:
-                    break
-            if self.profile is None:
+        self.profile = profile
+        if self.profile is None:
+            if self.adv is not None and len(self.adv.service_uuids) > 0:
+                for service_uuid in self.adv.service_uuids:
+                    self.profile = self.get_profile(service_uuid)
+                    if self.profile is not None:
+                        break
+                if self.profile is None:
+                    self.profile = ThreespaceBLEComClass.DEFAULT_PROFILE
+                    raise Exception(f"Unknown Service UUIDS: {self.adv.service_uuids}")
+            else:
                 self.profile = ThreespaceBLEComClass.DEFAULT_PROFILE
-                raise Exception(f"Unknown Service UUIDS: {self.adv.service_uuids}")
-        else:
-            self.profile = ThreespaceBLEComClass.DEFAULT_PROFILE
 
         self.__timeout = self.DEFAULT_TIMEOUT
 

yostlabs-2025.10.29/src/yostlabs/communication/bluetooth.py

@@ -0,0 +1,203 @@
+from yostlabs.communication.socket import ThreespaceSocketComClass
+import bluetooth
+import time
+import threading
+
+from dataclasses import dataclass
+from typing import Callable, Generator
+
+@dataclass
+class COD:
+    raw: int
+    services: list[str]
+    major_class: str
+    minor_class: str
+
+def decode_class_of_device(cod: int) -> dict:
+    """Decode a Bluetooth Class of Device (CoD) integer into its components."""
+
+    # Service Class bit masks (11 bits total)
+    services = {
+        0x002000: "Limited Discoverable Mode",
+        0x004000: "Positioning (Location Identification)",
+        0x008000: "Networking",
+        0x010000: "Rendering",
+        0x020000: "Capturing",
+        0x040000: "Object Transfer",
+        0x080000: "Audio",
+        0x100000: "Telephony",
+        0x200000: "Information",
+    }
+
+    # Major Device Classes (5 bits)
+    major_classes = {
+        0x00: "Miscellaneous",
+        0x01: "Computer",
+        0x02: "Phone",
+        0x03: "LAN/Network Access Point",
+        0x04: "Audio/Video",
+        0x05: "Peripheral",
+        0x06: "Imaging",
+        0x07: "Wearable",
+        0x08: "Toy",
+        0x09: "Health",
+        0x1F: "Uncategorized",
+    }
+
+    # Minor Class mappings for some major classes (for simplicity)
+    minor_classes = {
+        0x01: {
+            0x00: "Uncategorized",
+            0x01: "Desktop workstation",
+            0x02: "Server-class computer",
+            0x03: "Laptop",
+            0x04: "Handheld PC/PDA",
+            0x05: "Palm-size PC/PDA",
+        },
+        0x02: {
+            0x00: "Uncategorized",
+            0x01: "Cellular",
+            0x02: "Cordless",
+            0x03: "Smartphone",
+            0x04: "Wired modem or voice gateway",
+            0x05: "Common ISDN access",
+        },
+        0x05: {
+            0x00: "Uncategorized",
+            0x01: "Keyboard",
+            0x02: "Pointing device",
+            0x03: "Combo keyboard/pointing device",
+        },
+    }
+
+    # Extract fields
+    service_bits = cod & 0xFFE000  # top 11 bits
+    major_class = (cod >> 8) & 0x1F
+    minor_class = (cod >> 2) & 0x3F
+
+    # Decode services
+    decoded_services = [name for bit, name in services.items() if service_bits & bit]
+
+    # Decode major class
+    major_name = major_classes.get(major_class, "Unknown")
+
+    # Decode minor class (context-dependent)
+    minor_name = minor_classes.get(major_class, {}).get(minor_class, f"Minor code {minor_class}")
+
+    return COD(cod, decoded_services or ["None"], major_name, minor_name)
+
+@dataclass
+class ScannerResult:
+    address: str
+    name: str
+    class_of_device: COD
+
+class Scanner:
+
+    def __init__(self, interval=5):
+        self.enabled = False
+        self.done = True
+
+        self.nearby = None
+        self.thread = None
+        self.updated = False
+        self.duration = int(interval / 1.2)
+
+    def start(self):
+        if not self.done: return
+        self.thread = threading.Thread(target=self.process, daemon=True)
+        self.enabled = True
+        self.done = False
+        self.updated = False
+        self.thread.start()
+
+    def stop(self):
+        self.enabled = False
+
+    def get_most_recent(self):
+        if not self.updated: return None
+        self.updated = False
+        return self.nearby
+
+    @property
+    def is_running(self):
+        return self.done
+
+    def process(self):
+        while self.enabled:
+            nearby = bluetooth.discover_devices(duration=self.duration, lookup_names=True, lookup_class=True)
+            self.nearby = [ScannerResult(addr, name, decode_class_of_device(cod)) for addr, name, cod in nearby]
+            self.updated = True
+        self.done = True
+
+class ThreespaceBluetoothComClass(ThreespaceSocketComClass):
+
+    SCANNER = None
+
+    def __init__(self, addr: str, name: str = None, connection_timeout=None):
+        super().__init__(bluetooth.BluetoothSocket(bluetooth.Protocols.RFCOMM), (addr, 1), connection_timeout=connection_timeout)
+        self.address = addr
+        self.__name = name or addr
+    
+    @property
+    def name(self) -> str:
+        return self.__name
+
+    @classmethod
+    def __lazy_init_scanner(cls):
+        if cls.SCANNER is None:
+            cls.SCANNER = Scanner()
+            cls.SCANNER.start()
+
+    @staticmethod
+    def __default_filter(result: ScannerResult):
+        return result.class_of_device.major_class == "Wearable" and result.class_of_device.minor_class == "Minor code 0"
+
+    @staticmethod
+    def auto_detect(wait_for_update=True, filter: Callable[[ScannerResult],bool] = None) -> Generator["ThreespaceBluetoothComClass", None, None]:
+        """
+        Returns a list of com classes of the same type called on nearby
+        """
+        cls = ThreespaceBluetoothComClass
+        cls.__lazy_init_scanner()
+        if filter is None: 
+            filter = cls.__default_filter
+        if wait_for_update:
+            cls.SCANNER.updated = False
+            while not cls.SCANNER.updated: time.sleep(0.1)
+        if cls.SCANNER.nearby is None: return
+        for device_info in cls.SCANNER.nearby:
+            if not filter(device_info): continue
+            name = device_info.name or None
+            yield ThreespaceBluetoothComClass(device_info.address, name)
+
+
+if __name__ == "__main__":
+    from yostlabs.tss3.api import ThreespaceSensor
+
+    com = None
+    for device in ThreespaceBluetoothComClass.auto_detect():
+        com = device
+
+    if com is None:
+        print("Failed to detect a bluetooth sensor")
+        exit()
+    print("Connecting to:", com.name)
+
+    sensor = ThreespaceSensor(com, verbose=True)
+
+    sensor.set_settings(stream_slots=0)
+    print(sensor.get_settings("stream_slots", "stream_hz"))
+    print(sensor.getTaredOrientation())
+
+    sensor.startStreaming()
+
+    start_time = time.perf_counter()
+    while time.perf_counter() - start_time < 5:
+        sensor.updateStreaming()
+        packet = sensor.getOldestStreamingPacket()
+        while packet is not None:
+            print(packet)
+            packet = sensor.getOldestStreamingPacket()
+    sensor.stopStreaming()
+    sensor.cleanup()

{yostlabs-2025.10.24 → yostlabs-2025.10.29}/src/yostlabs/communication/serial.py

@@ -12,11 +12,13 @@ class ThreespaceSerialComClass(ThreespaceComClass):
     PID_BOOTLOADER = 0x1000
     PID_EMBED = 0x3040
     PID_DL = 0x3050
+    PID_LX = 0x3090
 
     PID_TO_STR_DICT = {
         PID_EMBED: "EM",
         PID_DL: "DL",
-        PID_BOOTLOADER: "BOOT"
+        PID_BOOTLOADER: "BOOT",
+        PID_LX: "LX"
     }
 
 

yostlabs-2025.10.29/src/yostlabs/communication/socket.py

@@ -0,0 +1,118 @@
+from yostlabs.communication.base import *
+import socket
+import time
+from typing import Callable
+
+class ThreespaceSocketComClass(ThreespaceComClass):
+
+    """
+    Inheriting classes must implement auto_detect() functionality.
+    Should also implement 'name' functionality
+    """
+
+    def __init__(self, sock: socket.socket, *connection_params, connection_timeout=None):
+        self.socket = sock
+        self._opened = False
+
+        self.buffer = bytearray()
+        self.__timeout = 2
+        self.__connection_timeout = connection_timeout
+        self.__connection_params = connection_params
+
+    @property
+    def timeout(self) -> float:
+        return self.__timeout
+    
+    @timeout.setter
+    def timeout(self, timeout: float):
+        self.__timeout = timeout
+
+    def open(self):
+        if self._opened: return True
+        try:
+            if self.__connection_timeout is None:
+                self.socket.setblocking(True)
+            else:
+                self.socket.settimeout(self.__connection_timeout)
+            self.socket.connect(*self.__connection_params)
+        except Exception as e:
+            try:
+                self.socket.close()
+            except: pass
+            print(e)
+            return False
+        self._opened = True
+        return True
+
+    def close(self):
+        if not self._opened: return
+        self.socket.close()
+        self._opened = False
+
+    def check_open(self):
+        return self._opened
+
+    def write(self, bytes: bytes):
+        self.socket.send(bytes)
+
+    def read(self, num_bytes: int):
+        self.__update_while(lambda: len(self.buffer) < num_bytes)
+        amount = min(len(self.buffer), num_bytes)
+        result = self.buffer[:amount]
+        del self.buffer[:amount]
+        return result
+    
+    def peek(self, num_bytes: int):
+        self.__update_while(lambda: len(self.buffer) < num_bytes)
+        amount = min(len(self.buffer), num_bytes)
+        return self.buffer[:amount]
+        
+    def read_until(self, expected: bytes):
+        self.__update_while(lambda: expected not in self.buffer)
+        if expected in self.buffer:
+            length = self.buffer.index(expected) + len(expected)
+            result = self.buffer[:length]
+            del self.buffer[:length]
+        else:
+            result = self.buffer.copy()
+            self.buffer.clear()
+        return result
+    
+    def peek_until(self, expected: bytes, max_length: int = None):
+        self.__update_while(lambda: expected not in self.buffer and (max_length is None or len(self.buffer) < max_length))
+        if expected in self.buffer:
+            length = self.buffer.index(expected) + len(expected)
+            if max_length is not None:
+                length = min(length, max_length)
+            result = self.buffer[:length]
+        else:
+            length = len(self.buffer)
+            if max_length is not None:
+                length = min(length, max_length)
+            result = self.buffer[length]
+        return result
+
+    def __update_while(self, condition: Callable):
+        start_time = time.perf_counter()
+        while condition():
+            self.__update_buffer()
+            if time.perf_counter() - start_time >= self.timeout:
+                return
+
+    def __update_buffer(self, max_bytes: int = 1000):
+        self.socket.setblocking(False)
+        try:
+            self.buffer += self.socket.recv(max_bytes)
+        except BlockingIOError:
+            return False
+        self.socket.settimeout(self.timeout)
+        return True
+
+    @property
+    def length(self):
+        while self.__update_buffer(): pass
+        return len(self.buffer)
+
+    @property
+    def reenumerates(self) -> bool:
+        return False