yostlabs 2025.4.30__tar.gz → 2025.9.17__tar.gz

{yostlabs-2025.4.30 → yostlabs-2025.9.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yostlabs
-Version: 2025.4.30
+Version: 2025.9.17
 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

{yostlabs-2025.4.30 → yostlabs-2025.9.17}/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.04.30"
+version = "2025.09.17"
 authors = [
   { name="Yost Labs Inc.", email="techsupport@yostlabs.com" },
   { name="Andy Riedlinger", email="techsupport@yostlabs.com" },

{yostlabs-2025.4.30 → yostlabs-2025.9.17}/src/yostlabs/communication/ble.py

@@ -1,5 +1,6 @@
 import asyncio
 import async_timeout
+import threading
 import time
 from bleak import BleakScanner, BleakClient
 from bleak.backends.device import BLEDevice
@@ -24,10 +25,23 @@ MANUFACTURER_NAME_STRING_UUID = "00002a29-0000-1000-8000-00805f9b34fb"
 
 class TssBLENoConnectionError(Exception): ...
 
+def ylBleEventLoopThread(loop: asyncio.AbstractEventLoop):
+    asyncio.set_event_loop(loop)
+    loop.run_forever()
+
 from yostlabs.communication.base import *
 class ThreespaceBLEComClass(ThreespaceComClass):
 
     DEFAULT_TIMEOUT = 2
+    EVENT_LOOP = None
+    EVENT_LOOP_THREAD = None
+
+    @classmethod
+    def __lazy_event_loop_init(cls):
+        if cls.EVENT_LOOP is None:
+            cls.EVENT_LOOP = asyncio.new_event_loop()
+            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):
         """
@@ -39,6 +53,7 @@ class ThreespaceBLEComClass(ThreespaceComClass):
         error_on_disconnect : If trying to read while the sensor is disconnected, an exception will be generated. This may be undesirable \
         if it is expected that the sensor will frequently go in and out of range and the user wishes to preserve data (such as streaming)
         """
+        self.__lazy_event_loop_init()
         bleak_options = { "timeout": discovery_timeout, "disconnected_callback": self.__on_disconnect }
         if isinstance(ble, BleakClient):    #Actual client
             self.client = ble
@@ -46,7 +61,8 @@ class ThreespaceBLEComClass(ThreespaceComClass):
         elif isinstance(ble, str): 
             if discover_name: #Local Name stirng
                 self.__lazy_init_scanner()
-                device = ThreespaceBLEComClass.SCANNER_EVENT_LOOP.run_until_complete(BleakScanner.find_device_by_name(ble, timeout=discovery_timeout))
+                future = asyncio.run_coroutine_threadsafe(BleakScanner.find_device_by_name(ble, timeout=discovery_timeout), self.EVENT_LOOP)
+                device = future.result()
                 if device is None:
                     raise BleakDeviceNotFoundError(ble)
                 self.client = BleakClient(device, **bleak_options)
@@ -63,26 +79,27 @@ class ThreespaceBLEComClass(ThreespaceComClass):
         self.__timeout = self.DEFAULT_TIMEOUT
 
         self.buffer = bytearray()
-        self.event_loop: asyncio.AbstractEventLoop = None
         self.data_read_event: asyncio.Event = None
 
         #Default to 20, will update on open
         self.max_packet_size = 20
         
         self.error_on_disconnect = error_on_disconnect
-        #is_connected is different from open.
-        #check_open() should return is_connected as that is what the user likely wants.
-        #open is whether or not the client will auto connect to the device when rediscovered.
-        #This file is set up to automatically close the connection if a method is called and is_connected is False
-        #This behavior might be specific to Windows.
+
+        #is_connected is different from open. Open is the cached idea of whether the BLE connection should be active,
+        #while is_connected is the actual state of the connection. Basically, opened means a connection is desired, while
+        #is_connected means it is actually connected.
         self.__opened = False
+
         #client.is_connected is really slow (noticeable when called in bulk, which happens do to the assert_connected)... 
         #So instead using the disconnected callback and this variable to manage tracking the state without the delay
         self.__connected = False
+
         #Writing functions will naturally throw an exception if disconnected. Reading ones don't because they use notifications rather
         #then direct reads. This means reading functions will need to assert the connection status but writing does not.
 
     async def __async_open(self):
+        self.data_read_event = asyncio.Event()
         await self.client.connect()
         await self.client.start_notify(NORDIC_UART_TX_UUID, self.__on_data_received)
 
@@ -92,9 +109,7 @@ class ThreespaceBLEComClass(ThreespaceComClass):
             if not self.__connected and self.error_on_disconnect:
                 self.close()
             return
-        self.event_loop = asyncio.new_event_loop()
-        self.data_read_event = asyncio.Event()
-        self.event_loop.run_until_complete(self.__async_open())
+        asyncio.run_coroutine_threadsafe(self.__async_open(), self.EVENT_LOOP).result()
         self.max_packet_size = self.client.mtu_size - 3 #-3 to account for the opcode and attribute handle stored in the data packet
         self.__opened = True
         self.__connected = True
@@ -104,14 +119,12 @@ class ThreespaceBLEComClass(ThreespaceComClass):
         #the disconnect call will hang on Windows. It seems similar to this issue: https://github.com/hbldh/bleak/issues/1359
         await asyncio.sleep(0.5)
         await self.client.disconnect()
+        self.data_read_event = None
+        self.buffer.clear()
 
     def close(self):
         if not self.__opened: return
-        self.event_loop.run_until_complete(self.__async_close())
-        self.buffer.clear()
-        self.event_loop.close()
-        self.event_loop = None
-        self.data_read_event = None
+        asyncio.run_coroutine_threadsafe(self.__async_close(), self.EVENT_LOOP).result()
         self.__opened = False
 
     def __on_disconnect(self, client: BleakClient):
@@ -125,28 +138,10 @@ class ThreespaceBLEComClass(ThreespaceComClass):
             raise TssBLENoConnectionError(f"{self.name} is not connected")
 
     def check_open(self):
-        #Checking this, while slow, isn't much difference in speed as allowing the disconnect callback to update via
-        #running the empty async function. So just going to use this here. Repeated calls to check_open are not a good
-        #idea from a speed perspective until a fix is found. We will probably make a version of this BLEComClass that uses
-        #a background thread for asyncio to allow for speed increases.
-        self.__connected = self.client.is_connected
         if not self.__connected and self.__opened and self.error_on_disconnect:
             self.close()
         return self.__connected
 
-    #Bleak does run a thread to read data on notification after calling start_notify, however on notification
-    #it schedules a callback using loop.call_soon_threadsafe() so the actual notification can't happen unless we
-    #run the event loop. Therefore, this async function that does nothing is used just to trigger an event loop updated
-    #so the read callbacks __on_data_received can occur
-    @staticmethod
-    async def __wait_for_callbacks_async():
-        pass
-
-    def __read_all_data(self):
-        self.event_loop.run_until_complete(self.__wait_for_callbacks_async())
-        self.data_read_event.clear()
-        self.__assert_connected()
-
     def __on_data_received(self, sender: BleakGATTCharacteristic, data: bytearray):
         self.buffer += data
         self.data_read_event.set()
@@ -155,7 +150,9 @@ class ThreespaceBLEComClass(ThreespaceComClass):
         start_index = 0
         while start_index < len(bytes):
             end_index = min(len(bytes), start_index + self.max_packet_size) #Can only send max_packet_size data per call to write_gatt_char
-            self.event_loop.run_until_complete(self.client.write_gatt_char(NORDIC_UART_RX_UUID, bytes[start_index:end_index], response=False))
+            asyncio.run_coroutine_threadsafe(
+                self.client.write_gatt_char(NORDIC_UART_RX_UUID, bytes[start_index:end_index], response=False),
+                self.EVENT_LOOP).result()
             start_index = end_index
     
     async def __await_read(self, timeout_time: int):
@@ -169,19 +166,19 @@ class ThreespaceBLEComClass(ThreespaceComClass):
             return False
 
     async def __await_num_bytes(self, num_bytes: int):
-        start_time = self.event_loop.time()
-        while len(self.buffer) < num_bytes and self.event_loop.time() - start_time < self.timeout:
+        start_time = self.EVENT_LOOP.time()
+        while len(self.buffer) < num_bytes and self.EVENT_LOOP.time() - start_time < self.timeout:
             await self.__await_read(start_time + self.timeout)
 
     def read(self, num_bytes: int):
-        self.event_loop.run_until_complete(self.__await_num_bytes(num_bytes))
+        asyncio.run_coroutine_threadsafe(self.__await_num_bytes(num_bytes), self.EVENT_LOOP).result()
         num_bytes = min(num_bytes, len(self.buffer))
         data = self.buffer[:num_bytes]
         del self.buffer[:num_bytes]
         return data
 
     def peek(self, num_bytes: int):
-        self.event_loop.run_until_complete(self.__await_num_bytes(num_bytes))
+        asyncio.run_coroutine_threadsafe(self.__await_num_bytes(num_bytes), self.EVENT_LOOP).result()
         num_bytes = min(num_bytes, len(self.buffer))
         data = self.buffer[:num_bytes]
         return data        
@@ -189,13 +186,13 @@ class ThreespaceBLEComClass(ThreespaceComClass):
     #Reads until the pattern is received, max_length is exceeded, or timeout occurs
     async def __await_pattern(self, pattern: bytes, max_length: int = None):
         if max_length is None: max_length = float('inf')
-        start_time = self.event_loop.time()
-        while pattern not in self.buffer and self.event_loop.time() - start_time < self.timeout and len(self.buffer) < max_length:
+        start_time = self.EVENT_LOOP.time()
+        while pattern not in self.buffer and self.EVENT_LOOP.time() - start_time < self.timeout and len(self.buffer) < max_length:
             await self.__await_read(start_time + self.timeout)
         return pattern in self.buffer
 
     def read_until(self, expected: bytes) -> bytes:
-        self.event_loop.run_until_complete(self.__await_pattern(expected))
+        asyncio.run_coroutine_threadsafe(self.__await_pattern(expected), self.EVENT_LOOP).result()
         if expected in self.buffer: #Found the pattern
             length = self.buffer.index(expected) + len(expected)
             result = self.buffer[:length]
@@ -207,7 +204,7 @@ class ThreespaceBLEComClass(ThreespaceComClass):
         return result
 
     def peek_until(self, expected: bytes, max_length: int = None) -> bytes:
-        self.event_loop.run_until_complete(self.__await_pattern(expected, max_length=max_length))
+        asyncio.run_coroutine_threadsafe(self.__await_pattern(expected, max_length=max_length), self.EVENT_LOOP).result()
         if expected in self.buffer:
             length = self.buffer.index(expected) + len(expected)
         else:
@@ -220,7 +217,6 @@ class ThreespaceBLEComClass(ThreespaceComClass):
 
     @property
     def length(self):
-        self.__read_all_data() #Gotta update the data before knowing the length
         return len(self.buffer) 
 
     @property
@@ -236,7 +232,12 @@ class ThreespaceBLEComClass(ThreespaceComClass):
         return False
     
     @property
-    def name(self) -> str:
+    def name(self) -> str | None:
+        """
+        The name of the device. This may be the Address or the Local Name of the device
+        depending on how discovery was done.
+        May also be None
+        """
         return self.__name
     
     @property
@@ -244,7 +245,7 @@ class ThreespaceBLEComClass(ThreespaceComClass):
         return self.client.address    
 
     SCANNER = None
-    SCANNER_EVENT_LOOP = None
+    SCANNER_LOCK = None
 
     SCANNER_CONTINOUS = False   #Controls if scanning will continously run
     SCANNER_TIMEOUT = 5         #Controls the scanners timeout
@@ -256,13 +257,20 @@ class ThreespaceBLEComClass(ThreespaceComClass):
 
     @classmethod
     def __lazy_init_scanner(cls):
+        cls.__lazy_event_loop_init()
         if cls.SCANNER is None:
-            cls.SCANNER = BleakScanner(detection_callback=cls.__detection_callback, service_uuids=[NORDIC_UART_SERVICE_UUID])
-            cls.SCANNER_EVENT_LOOP = asyncio.new_event_loop()
+            cls.SCANNER_LOCK = threading.Lock()
+            #Scanner should be created inside of the Async Context that will use it
+            async def create_scanner():
+                cls.SCANNER = BleakScanner(detection_callback=cls.__detection_callback, service_uuids=[NORDIC_UART_SERVICE_UUID])
+            asyncio.run_coroutine_threadsafe(create_scanner(), cls.EVENT_LOOP).result()
+
+            
 
     @classmethod
     def __detection_callback(cls, device: BLEDevice, adv: AdvertisementData):
-        cls.discovered_devices[device.address] = {"device": device, "adv": adv, "last_found": time.time()}
+        with cls.SCANNER_LOCK:
+            cls.discovered_devices[device.address] = {"device": device, "adv": adv, "last_found": time.time()}
     
     @classmethod
     def set_scanner_continous(cls, continous: bool):
@@ -276,8 +284,10 @@ class ThreespaceBLEComClass(ThreespaceComClass):
         """
         cls.__lazy_init_scanner()
         cls.SCANNER_CONTINOUS = continous
-        if continous: cls.SCANNER_EVENT_LOOP.run_until_complete(cls.SCANNER.start())
-        else: cls.SCANNER_EVENT_LOOP.run_until_complete(cls.SCANNER.stop())
+        if continous: 
+            asyncio.run_coroutine_threadsafe(cls.SCANNER.start(), cls.EVENT_LOOP).result()
+        else: 
+            asyncio.run_coroutine_threadsafe(cls.SCANNER.stop(), cls.EVENT_LOOP).result()
 
     @classmethod
     def update_nearby_devices(cls):
@@ -286,36 +296,37 @@ class ThreespaceBLEComClass(ThreespaceComClass):
         """
         cls.__lazy_init_scanner()
         if cls.SCANNER_CONTINOUS:
-            #Allow the callbacks for nearby devices to trigger
-            cls.SCANNER_EVENT_LOOP.run_until_complete(cls.__wait_for_callbacks_async())
-            #Remove expired devices
-            cur_time = time.time()
-            to_remove = [] #Avoiding concurrent list modification
-            for device in cls.discovered_devices:
-                if cur_time - cls.discovered_devices[device]["last_found"] > cls.SCANNER_EXPIRATION_TIME:
-                    to_remove.append(device) 
-            for device in to_remove:
-                del cls.discovered_devices[device]
-
+            with cls.SCANNER_LOCK:
+                #Remove expired devices
+                cur_time = time.time()
+                to_remove = [] #Avoiding concurrent list modification
+                for device in cls.discovered_devices:
+                    if cur_time - cls.discovered_devices[device]["last_found"] > cls.SCANNER_EXPIRATION_TIME:
+                        to_remove.append(device) 
+                for device in to_remove:
+                    del cls.discovered_devices[device]
+                discovered = cls.discovered_devices.copy()
         else:
             #Mark all devices as invalid before searching for nearby devices
             cls.discovered_devices.clear()
             start_time = time.time()
             end_time = cls.SCANNER_TIMEOUT or float('inf')
             end_count = cls.SCANNER_FIND_COUNT or float('inf')
-            cls.SCANNER_EVENT_LOOP.run_until_complete(cls.SCANNER.start())
+            asyncio.run_coroutine_threadsafe(cls.SCANNER.start(), cls.EVENT_LOOP).result()
             while time.time() - start_time < end_time and len(cls.discovered_devices) < end_count:
-                cls.SCANNER_EVENT_LOOP.run_until_complete(cls.__wait_for_callbacks_async())
-            cls.SCANNER_EVENT_LOOP.run_until_complete(cls.SCANNER.stop())
-        
-        return cls.discovered_devices
+                time.sleep(0)
+            asyncio.run_coroutine_threadsafe(cls.SCANNER.stop(), cls.EVENT_LOOP).result()
+            discovered = cls.discovered_devices.copy()
+        return discovered
     
     @classmethod
     def get_discovered_nearby_devices(cls):
         """
         A helper to get a copy of the discovered devices
         """
-        return cls.discovered_devices.copy()
+        with cls.SCANNER_LOCK:
+            discovered = cls.discovered_devices.copy()
+        return discovered
 
     @staticmethod
     def auto_detect() -> Generator["ThreespaceBLEComClass", None, None]:
@@ -325,5 +336,6 @@ class ThreespaceBLEComClass(ThreespaceComClass):
         """
         cls = ThreespaceBLEComClass
         cls.update_nearby_devices()
-        for device_info in cls.discovered_devices.values():
-            yield(ThreespaceBLEComClass(device_info["device"]))
+        with cls.SCANNER_LOCK:
+            for device_info in cls.discovered_devices.values():
+                yield(ThreespaceBLEComClass(device_info["device"]))

{yostlabs-2025.4.30 → yostlabs-2025.9.17}/src/yostlabs/tss3/api.py

@@ -100,7 +100,7 @@ class ThreespaceCommand:
                     response = response[size:]
                 else: #Strings are special, find the null terminator
                     str_len = response.index(0)
-                    output.append(struct.unpack(f"<{str_len}s", response[str_len])[0])
+                    output.append(struct.unpack(f"<{str_len}s", response[:str_len])[0])
                     response = response[str_len + 1:] #+1 to skip past the null terminator character too
         else: #Fast parse because no strings
             output.extend(struct.unpack(f"<{self.out_format}", response[:self.info.out_size]))
@@ -115,37 +115,42 @@ class ThreespaceCommand:
         raw = bytearray([])
         if self.info.num_out_params == 0: return None, raw
         output = []
-        for c in self.out_format:
-            if c != 's':
-                format_str = f"<{c}"
-                size = struct.calcsize(format_str)
-                response = com.read(size)
-                raw += response
-                if len(response) != size:
-                    if verbose:
-                        print(f"Failed to read {c} type. Aborting...")
-                    return None
-                output.append(struct.unpack(format_str, response)[0])
-            else: #Strings are special, find the null terminator
-                response = com.read(1)
-                raw += response
-                if len(response) != 1:
-                    if verbose:
-                        print(f"Failed to read string. Aborting...")
-                    return None
-                byte = chr(response[0])
-                string = ""
-                while byte != '\0':
-                    string += byte
-                    #Get next byte
-                    response = com.read(1)
+
+        if not math.isnan(self.info.out_size):
+            #Fast read and parse
+            response = com.read(self.info.out_size)
+            raw += response
+            if len(response) != self.info.out_size:
+                if verbose:
+                    print(f"Failed to read {self.info.name} {len(response)} / {self.info.out_size}. Aborting...")
+            output.extend(struct.unpack(f"<{self.out_format}", response))
+        else:
+            #There is a string, so go element by element
+            i = 0
+            while i < len(self.out_format):
+                c = self.out_format[i]
+                if c != 's':
+                    end_index = self.out_format.find('s', i)
+                    if end_index == -1: end_index = len(self.out_format)
+                    format_str = f"<{self.out_format[i:end_index]}"
+                    size = struct.calcsize(format_str)
+                    response = com.read(size)
                     raw += response
-                    if len(response) != 1:
+                    if len(response) != size:
+                        if verbose:
+                            print(f"Failed to read {c} type. Aborting...")
+                        return None
+                    output.append(struct.unpack(format_str, response)[0])
+                    i = end_index
+                else:
+                    response = com.read_until(b'\0')
+                    raw += response
+                    if response[-1] != 0:
                         if verbose:
                             print(f"Failed to read string. Aborting...")
                         return None
-                    byte = chr(response[0])
-                output.append(string)
+                    output.append(response[:-1].decode())
+                    i += 1
         
         if self.info.num_out_params == 1:
             return output[0], raw
@@ -162,7 +167,7 @@ class ThreespaceGetStreamingBatchCommand(ThreespaceCommand):
     def set_stream_slots(self, streaming_slots: list[ThreespaceCommand]):
         self.commands = streaming_slots
         self.out_format = ''.join(slot.out_format for slot in streaming_slots if slot is not None)
-        self.info.out_size = struct.calcsize(f"<{self.out_format}")
+        self.info.out_size = sum(slot.info.out_size for slot in streaming_slots if slot is not None)
 
     def parse_response(self, response: bytes):
         data = []
@@ -180,9 +185,8 @@ class ThreespaceGetStreamingBatchCommand(ThreespaceCommand):
         raw_response = bytearray([])
         for command in self.commands:
             if command is None: continue
-            binary = com.read(command.info.out_size)
-            raw_response += binary
-            out = command.parse_response(binary)
+            out, raw = command.read_command(com, verbose=verbose)
+            raw_response += raw
             response.append(out)
         
         return response, raw_response
@@ -393,6 +397,8 @@ class StreamableCommands(Enum):
     GetCorrectedAccelVec = 55
     GetCorrectedMagVec = 56
 
+    GetDateTime = 63
+
     GetRawGyroRate = 65
     GetRawAccelVec = 66
     GetRawMagVec = 67
@@ -401,8 +407,10 @@ class StreamableCommands(Enum):
     GetEeptsNewestStep = 71
     GetEeptsNumStepsAvailable = 72
 
+    GetDateTimeString = 93
     GetTimestamp = 94
 
+    GetBatteryCurrent = 200
     GetBatteryVoltage = 201
     GetBatteryPercent = 202
     GetBatteryStatus = 203
@@ -609,14 +617,14 @@ class ThreespaceSensor:
         self.streaming_packet_size = 0
         self._force_stop_streaming()
 
-        #Now reinitialize the cached settings
-        self.__cache_header_settings()
-        self.__cache_streaming_settings()
-
         self.__cache_serial_number(int(self.get_settings("serial_number"), 16))
         self.__empty_debug_cache()
         self.immediate_debug = int(self.get_settings("debug_mode")) == 1 #Needed for some startup processes when restarting
 
+        #Now reinitialize the cached settings
+        self.__cache_header_settings()
+        self.__cache_streaming_settings()
+
     def __initialize_commands(self):
         self.commands: list[ThreespaceCommand] = [None] * 256
         self.getStreamingBatchCommand: ThreespaceGetStreamingBatchCommand = None
@@ -670,6 +678,9 @@ class ThreespaceSensor:
 
         setattr(self, command.info.name, method)
 
+    def has_command(self, command: ThreespaceCommand):
+        return self.commands[command.info.num] is not None 
+
     def __get_command(self, command_name: str):
         for command in self.commands:
             if command is None: continue
@@ -1007,6 +1018,7 @@ class ThreespaceSensor:
         header = ThreespaceHeader.from_bytes(header, self.header_info)
         return header
 
+    #TODO: max_data_length is not sufficient. Need MINIMUM length as well. Can have a situation where len = 0 and checksum = 0
     def __peek_checksum(self, header: ThreespaceHeader, max_data_length=4096):
         """
         Using a header that contains the checksum and data length, calculate the checksum of the expected
@@ -1100,7 +1112,7 @@ class ThreespaceSensor:
                     self.misaligned = False
                     return THREESPACE_UPDATE_COMMAND_PARSED
             elif self.is_log_streaming and header.echo == THREESPACE_FILE_READ_BYTES_COMMAND_NUM:
-                if not blocking: 
+                if not blocking:
                     expected_output_size = len(header.raw_binary) + min(header.length, THREESPACE_LIVE_LOG_STREAM_MAX_PACKET_SIZE)
                     if self.com.length < expected_output_size: return THREESPACE_UPDATE_COMMAND_NOT_ENOUGH_DATA
                 if checksum_match := self.__peek_checksum(header, max_data_length=THREESPACE_LIVE_LOG_STREAM_MAX_PACKET_SIZE):
@@ -1204,9 +1216,9 @@ class ThreespaceSensor:
 
     def startStreaming(self) -> ThreespaceCmdResult[None]: ...
     def __startStreaming(self) -> ThreespaceCmdResult[None]:
-        if self.is_data_streaming: return
-        self.streaming_packets.clear()
-        self.__cache_streaming_settings()
+        if not self.is_data_streaming:
+            self.streaming_packets.clear()
+            self.__cache_streaming_settings()
 
         result = self.execute_command(self.commands[THREESPACE_START_STREAMING_COMMAND_NUM])
         self.is_data_streaming = True
@@ -1632,6 +1644,7 @@ class ThreespaceSensor:
     def getCorrectedMagVec(self, id: int) -> ThreespaceCmdResult[list[float]]: ...    
     def enableMSC(self) -> ThreespaceCmdResult[None]: ...
     def disableMSC(self) -> ThreespaceCmdResult[None]: ...
+    def getDateTimeString(self) -> ThreespaceCmdResult[str]: ...
     def getTimestamp(self) -> ThreespaceCmdResult[int]: ...
     def getBatteryVoltage(self) -> ThreespaceCmdResult[float]: ...
     def getBatteryPercent(self) -> ThreespaceCmdResult[int]: ...
@@ -1760,6 +1773,7 @@ _threespace_commands: list[ThreespaceCommand] = [
     ThreespaceCommand("stopStreaming", THREESPACE_STOP_STREAMING_COMMAND_NUM, "", "", custom_func=ThreespaceSensor._ThreespaceSensor__stopStreaming),
     ThreespaceCommand("pauseLogStreaming", 87, "b", ""),
     
+    ThreespaceCommand("getDateTimeString", 93, "", "S"),
     ThreespaceCommand("getTimestamp", 94, "", "U"),
 
     ThreespaceCommand("tareWithCurrentOrientation", 96, "", ""),
@@ -1788,6 +1802,7 @@ _threespace_commands: list[ThreespaceCommand] = [
     ThreespaceCommand("fileStartStream", 180, "", "U", custom_func=ThreespaceSensor._ThreespaceSensor__fileStartStream),
     ThreespaceCommand("fileStopStream", 181, "", "", custom_func=ThreespaceSensor._ThreespaceSensor__fileStopStream),
 
+    ThreespaceCommand("getBatteryCurrent", 200, "", "I"),
     ThreespaceCommand("getBatteryVoltage", 201, "", "f"),
     ThreespaceCommand("getBatteryPercent", 202, "", "b"),
     ThreespaceCommand("getBatteryStatus", 203, "", "b"),

{yostlabs-2025.4.30 → yostlabs-2025.9.17}/src/yostlabs/tss3/utils/parser.py

@@ -137,7 +137,7 @@ class ThreespaceBinaryParser:
             if "read_size" not in kwargs:
                 raise ValueError("Missing arguement 'read_size' when registering the fileReadBytes command with the binary parser")
             raise NotImplementedError("The fileReadBytes command has yet to be implemented for the ThreespaceBinaryParser")
-        elif cmd.info.num == THREESPACE_GET_STREAMING_BATCH_COMMAND_NUM:
+        elif cmd.info.num == THREESPACE_GET_STREAMING_BATCH_COMMAND_NUM and not isinstance(cmd, ThreespaceGetStreamingBatchCommand):
             if "stream_slots" not in kwargs:
                 raise ValueError("Missing arguement 'stream_slots' when registering the getStreamingBatch command with the binary parser")
             cmd = ThreespaceGetStreamingBatchCommand(kwargs['stream_slots'])
@@ -221,7 +221,6 @@ class ThreespaceBinaryParser:
             return None
         
         if self.header_info.checksum_enabled and not math.isnan(self.__parsing_msg_length): #Can validate checksum before parsing
-            print("Pre validating checksum")
             if not self.__peek_checksum():
                 #Data corruption/Misalignment error
                 if self.verbose and not self.misaligned:

{yostlabs-2025.4.30 → yostlabs-2025.9.17}/src/yostlabs/tss3/utils/streaming.py

@@ -1,4 +1,5 @@
-from yostlabs.tss3.api import ThreespaceSensor, StreamableCommands, ThreespaceCmdResult, threespaceGetHeaderLabels
+from yostlabs.tss3.api import ThreespaceSensor, StreamableCommands, ThreespaceCmdResult, threespaceGetHeaderLabels, \
+    ThreespaceGetStreamingBatchCommand, threespaceCommandGet
 
 from enum import Enum
 from typing import Any, Callable
@@ -17,6 +18,17 @@ class ThreespaceStreamingStatus(Enum):
     #disable the streaming manager for some reason
     Reset = 4
 
+#Used for when the callback signature changed to allow user data, but maintain backwards compatability
+def _api_compatible_callback(func: Callable):
+    arg_count = func.__code__.co_argcount
+    if hasattr(func, "__self__"): arg_count -= 1 #Do NOT count self
+
+    if arg_count == 1:
+        def without_userdata(status: ThreespaceStreamingStatus, user_data: Any):
+            return func(status)
+        return without_userdata
+    return func
+
 from typing import NamedTuple
 ThreespaceStreamingOption = NamedTuple("ThreespaceStreamingOption", [("cmd", StreamableCommands), ("param", int|None)])
 class ThreespaceStreamingManager:
@@ -44,6 +56,7 @@ class ThreespaceStreamingManager:
         hz: int = None
 
         only_newest: bool = False
+        user_data: Any = None
 
         @property
         def interval(self):
@@ -73,9 +86,12 @@ class ThreespaceStreamingManager:
         self.is_streaming = False #Store this seperately to attempt to allow using both the regular streaming and streaming manager via pausing and such
 
         #Set the initial streaming speed
-        self.interval = int(self.sensor.get_settings("stream_interval"))    
+        self.interval = int(self.sensor.get_settings("stream_interval"))   
+        self.desired_interval = self.interval 
 
-        self.dirty = False
+        #Registrations and update rate dirt are handled separately for some situations.
+        #Primarily, we want registration to succeed even if the update can't update the rate.
+        self.dirty_registrations = False
         self.validated = False
 
         #Control variable to manually control when updating happens here
@@ -86,6 +102,14 @@ class ThreespaceStreamingManager:
         self.max_interval = 0xFFFFFFFF
         self.min_interval = 1000000 / 2000
 
+    @property
+    def dirty(self):
+        return self.dirty_registrations or self.dirty_rate
+    
+    @property
+    def dirty_rate(self):
+        return self.desired_interval != self.interval
+
     @property
     def paused(self):
         return len(self.pausers) > 0
@@ -100,8 +124,8 @@ class ThreespaceStreamingManager:
         self.pausers.add(locker)
         if len(self.pausers) == 1 and self.is_streaming:
             self.__stop_streaming()
-            for callback in self.callbacks:
-                callback(ThreespaceStreamingStatus.Paused)
+            for callback in self.callbacks.values():
+                callback.func(ThreespaceStreamingStatus.Paused, callback.user_data)
         return True
 
     def resume(self, locker: object):
@@ -112,8 +136,8 @@ class ThreespaceStreamingManager:
 
         #Attempt to start again
         if len(self.pausers) == 0:
-            for callback in self.callbacks:
-                callback(ThreespaceStreamingStatus.Resumed)
+            for callback in self.callbacks.values():
+                callback.func(ThreespaceStreamingStatus.Resumed, callback.user_data)
             self.__apply_streaming_settings_and_update_state()
 
     def lock_modifications(self, locker: object):
@@ -138,7 +162,7 @@ class ThreespaceStreamingManager:
         self.block_updates = True
         values = list(self.callbacks.values()) #To prevent concurrent dict modification, cache this
         for cb in values:
-            cb.func(ThreespaceStreamingStatus.Reset)
+            cb.func(ThreespaceStreamingStatus.Reset, cb.user_data)
         self.block_updates = False
         self.lockers.clear()
         self.pausers.clear()
@@ -170,18 +194,18 @@ class ThreespaceStreamingManager:
                 #Let all the callbacks know the data was updated
                 for cb in self.callbacks.values():
                     if cb.only_newest: continue
-                    cb.func(ThreespaceStreamingStatus.Data)
+                    cb.func(ThreespaceStreamingStatus.Data, cb.user_data)
 
                 result = self.sensor.getOldestStreamingPacket()
             
             for cb in self.callbacks.values():
                 if cb.only_newest:
-                    cb.func(ThreespaceStreamingStatus.Data)
-                cb.func(ThreespaceStreamingStatus.DataEnd)
+                    cb.func(ThreespaceStreamingStatus.Data, cb.user_data)
+                cb.func(ThreespaceStreamingStatus.DataEnd, cb.user_data)
 
-    def register_callback(self, callback: Callable[[ThreespaceStreamingStatus],None], hz=None, only_newest=False):
+    def register_callback(self, callback: Callable[[ThreespaceStreamingStatus,Any],None], hz=None, only_newest=False, user_data=None):
         if callback in self.callbacks: return
-        self.callbacks[callback] = ThreespaceStreamingManager.Callback(callback, hz, only_newest)
+        self.callbacks[callback] = ThreespaceStreamingManager.Callback(_api_compatible_callback(callback), hz, only_newest, user_data=user_data)
         self.__update_streaming_speed()
 
     def unregister_callback(self, callback: Callable[[ThreespaceStreamingStatus],None]):
@@ -217,7 +241,11 @@ class ThreespaceStreamingManager:
             
             cmd.registrations.add(owner)
             if immediate_update and self.dirty:
-                return self.__apply_streaming_settings_and_update_state()
+                updated = self.__apply_streaming_settings_and_update_state()
+                if self.dirty_registrations:
+                    return updated
+                else: #The rate was dirty, that does not affect the registration process
+                    return True
             return True
         
         if self.locked: #Wasn't already registered, so don't allow new registrations
@@ -232,7 +260,7 @@ class ThreespaceStreamingManager:
         self.registered_commands[info] = ThreespaceStreamingManager.Command(command, param=param, slot=num_commands_registered)
         self.registered_commands[info].labels = self.sensor.getStreamingLabel(command.value).data
         self.registered_commands[info].registrations.add(owner)
-        self.dirty = True
+        self.dirty_registrations = True
         if immediate_update:
             return self.__apply_streaming_settings_and_update_state()
         return True
@@ -266,7 +294,7 @@ class ThreespaceStreamingManager:
             return
         
         #Remove the command from streaming since nothing owns it anymore
-        self.dirty = True
+        self.dirty_registrations = True
         if immediate_update:
             self.__apply_streaming_settings_and_update_state()
 
@@ -284,7 +312,7 @@ class ThreespaceStreamingManager:
             if owner in registered_command.registrations:
                 registered_command.registrations.remove(owner)
                 if len(registered_command.registrations) == 0:
-                    self.dirty = True
+                    self.dirty_registrations = True
         
         if self.dirty and immediate_update:
             self.__apply_streaming_settings_and_update_state()
@@ -327,7 +355,7 @@ class ThreespaceStreamingManager:
             self.__stop_streaming()
         
         #Clean up any registrations that need removed and activate any that need activated
-        if self.dirty:
+        if self.dirty_registrations:
             to_remove = []
             for k, v in self.registered_commands.items():
                 if len(v.registrations) == 0:
@@ -338,21 +366,24 @@ class ThreespaceStreamingManager:
                 del self.registered_commands[key]
                 if key in self.results:
                     del self.results[key]
-        self.dirty = False
+        self.dirty_registrations = False
 
         if self.num_commands_registered > 0:
             slots_string = self.__build_stream_slots_string()
-            err, num_successes = self.sensor.set_settings(stream_slots=slots_string, stream_interval=self.interval)
+            err, num_successes = self.sensor.set_settings(stream_slots=slots_string, stream_interval=self.desired_interval)
             if err:
                 self.validated = False
                 return False
+            self.interval = self.desired_interval
             if not self.paused and self.enabled: 
                 self.__start_streaming() #Re-enable
         
         self.validated = True
         return True
 
-    def __update_streaming_speed(self):        
+    def __update_streaming_speed(self): 
+        if self.locked: return #Don't update the desired speed if modifications are locked
+
         required_interval = None
         for callback in self.callbacks.values():
             if callback.interval is None: continue
@@ -360,13 +391,12 @@ class ThreespaceStreamingManager:
                 required_interval = callback.interval
 
         if required_interval is None: #Treat required as current to make sure the current interval is still valid
-            required_interval = self.interval 
+            required_interval = self.desired_interval 
 
         required_interval = min(self.max_interval, max(self.min_interval, required_interval))
-        if required_interval != self.interval:
-            print(f"Updating streaming speed from {1000000 / self.interval}hz to {1000000 / required_interval}hz")
-            self.interval = int(required_interval)
-            self.dirty = True
+        if required_interval != self.desired_interval:
+            print(f"Updating desired speed from {1000000 / self.desired_interval}hz to {1000000 / required_interval}hz")
+            self.desired_interval = int(required_interval)
             self.__apply_streaming_settings_and_update_state()
 
     def __start_streaming(self):
@@ -450,4 +480,29 @@ class ThreespaceStreamingManager:
             else:
                 slot_info.append(None)
         
-        return slot_info
+        return slot_info
+
+#Utility functions
+def get_stream_options_from_str(string: str):
+    options = []
+    slots = string.split(',')
+    for slot in slots:
+        slot = slot.split(':')
+        cmd = int(slot[0])
+        if cmd == 255: continue #Ignore 255
+
+        #Get the param if any
+        param = None
+        if len(slot) > 2:
+            raise Exception()
+        if len(slot) == 2:
+            param = int(slot[1])
+        
+        stream_option = ThreespaceStreamingOption(StreamableCommands(cmd), param)
+        options.append(stream_option)
+    
+    return options
+
+def stream_options_to_command(options: list[ThreespaceStreamingOption]):
+    commands = [threespaceCommandGet(v.cmd.value) for v in options]
+    return ThreespaceGetStreamingBatchCommand(commands)