yostlabs 2025.1.3.4__tar.gz → 2025.1.9__tar.gz

{yostlabs-2025.1.3.4 → yostlabs-2025.1.9}/Examples/example_commands.py

@@ -1,4 +1,5 @@
-from Threespace3 import ThreespaceSensor, ThreespaceSerialComClass
+from yostlabs.tss3.api import ThreespaceSensor
+from yostlabs.communication.serial import ThreespaceSerialComClass
 
 #Create a sensor by auto detecting a ThreespaceSerialComClass
 sensor = ThreespaceSensor(ThreespaceSerialComClass)

{yostlabs-2025.1.3.4 → yostlabs-2025.1.9}/Examples/example_component_specific_settings_and_commands.py

@@ -1,5 +1,6 @@
 
-from Threespace3 import ThreespaceSensor, ThreespaceSerialComClass
+from yostlabs.tss3.api import ThreespaceSensor
+from yostlabs.communication.serial import ThreespaceSerialComClass
 
 """
 It is possible for a board to have multiple types of the same component on it. For example there may be two accelerometers, such as a low-G and high-G component.

{yostlabs-2025.1.3.4 → yostlabs-2025.1.9}/Examples/example_firmware_upload.py

@@ -1,5 +1,6 @@
-from Threespace3 import ThreespaceSensor, ThreespaceSerialComClass
-from Threespace3_utils import ThreespaceFirmwareUploader
+from yostlabs.tss3.api import ThreespaceSensor
+from yostlabs.communication.serial import ThreespaceSerialComClass
+from yostlabs.tss3.utils.version import ThreespaceFirmwareUploader
 
 #Create a sensor by auto detecting a ThreespaceSerialComClass
 sensor = ThreespaceSensor(ThreespaceSerialComClass)

{yostlabs-2025.1.3.4 → yostlabs-2025.1.9}/Examples/example_parsing_stored_binary.py

@@ -1,5 +1,6 @@
-from Threespace3 import ThreespaceSensor, ThreespaceSerialComClass, StreamableCommands
-from ThreespaceParser import ThreespaceBinaryParser
+from yostlabs.tss3.api import ThreespaceSensor, StreamableCommands
+from yostlabs.communication.serial import ThreespaceSerialComClass
+from yostlabs.tss3.utils.parser import ThreespaceBinaryParser
 import time
 
 #Create a sensor by auto detecting a ThreespaceSerialComClass

{yostlabs-2025.1.3.4 → yostlabs-2025.1.9}/Examples/example_read_settings.py

@@ -1,4 +1,5 @@
-from Threespace3 import ThreespaceSensor, ThreespaceSerialComClass
+from yostlabs.tss3.api import ThreespaceSensor
+from yostlabs.communication.serial import ThreespaceSerialComClass
 
 #Create a sensor by auto detecting a ThreespaceSerialComClass
 sensor = ThreespaceSensor(ThreespaceSerialComClass)

{yostlabs-2025.1.3.4 → yostlabs-2025.1.9}/Examples/example_streaming.py

@@ -1,4 +1,5 @@
-from Threespace3 import ThreespaceSensor, ThreespaceSerialComClass, StreamableCommands
+from yostlabs.tss3.api import ThreespaceSensor, StreamableCommands
+from yostlabs.communication.serial import ThreespaceSerialComClass
 import time
 
 #Create a sensor by auto detecting a ThreespaceSerialComClass

{yostlabs-2025.1.3.4 → yostlabs-2025.1.9}/Examples/example_streaming_manager.py

@@ -1,5 +1,6 @@
-from Threespace3 import ThreespaceSensor, ThreespaceSerialComClass, StreamableCommands
-from Threespace3_utils import ThreespaceStreamingManager, ThreespaceStreamingStatus
+from yostlabs.tss3.api import ThreespaceSensor, StreamableCommands
+from yostlabs.communication.serial import ThreespaceSerialComClass
+from yostlabs.tss3.utils.streaming import ThreespaceStreamingManager, ThreespaceStreamingStatus
 import time
 
 """

{yostlabs-2025.1.3.4 → yostlabs-2025.1.9}/Examples/example_write_settings.py

@@ -1,4 +1,5 @@
-from Threespace3 import ThreespaceSensor, ThreespaceSerialComClass
+from yostlabs.tss3.api import ThreespaceSensor
+from yostlabs.communication.serial import ThreespaceSerialComClass
 import time
 
 #Create a sensor by auto detecting a ThreespaceSerialComClass

{yostlabs-2025.1.3.4 → yostlabs-2025.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yostlabs
-Version: 2025.1.3.4
+Version: 2025.1.9
 Summary: Python resources and API for 3Space sensors from Yost Labs Inc.
 Project-URL: Homepage, https://yostlabs.com/
 Author-email: "Yost Labs Inc." <techsupport@yostlabs.com>, Andy Riedlinger <techsupport@yostlabs.com>

yostlabs-2025.1.9/install.bat

@@ -0,0 +1 @@
+python -m pip install --upgrade yostlabs

yostlabs-2025.1.9/install_test.bat

@@ -0,0 +1 @@
+python -m pip install --index-url https://test.pypi.org/simple/ --upgrade --pre --no-deps yostlabs

{yostlabs-2025.1.3.4 → yostlabs-2025.1.9}/pyproject.toml

@@ -4,14 +4,16 @@ build-backend = "hatchling.build"
 
 [tool.hatch.build.targets.sdist]
 exclude = [
-  "build.bat"
+  "build.bat",
+  "build_test.bat",
+  "env"
 ]
 
 
 [project]
 name = "yostlabs"
 #If uploading again on the same day, add a fourth number
-version = "2025.01.03.4"
+version = "2025.01.09"
 authors = [
   { name="Yost Labs Inc.", email="techsupport@yostlabs.com" },
   { name="Andy Riedlinger", email="techsupport@yostlabs.com" },

yostlabs-2025.1.9/src/yostlabs/communication/base.py

@@ -0,0 +1,90 @@
+from typing import Generator
+
+class ThreespaceInputStream:
+
+    """
+    Reads specified number of bytes. 
+    If that many bytes are not available after timeout, less data will be returned
+    """
+    def read(self, num_bytes) -> bytes:
+        raise NotImplementedError()
+    
+    def read_all(self):
+        return self.read(self.length)
+
+    def read_until(self, expected: bytes) -> bytes:
+        raise NotImplementedError()
+
+    """Allows reading without removing the data from the buffer"""
+    def peek(self, num_bytes) -> bytes:
+        raise NotImplementedError()
+    
+    def peek_until(self, expected: bytes, max_length=None) -> bytes:
+        raise NotImplementedError()
+    
+    def readline(self) -> bytes:
+        return self.read_until(b"\n")
+    
+    def peekline(self, max_length=None) -> bytes:
+        return self.peek_until(b"\n", max_length=max_length)    
+    
+    @property
+    def length(self) -> int:
+        raise NotImplementedError()
+    
+    @property
+    def timeout(self) -> float:
+        raise NotImplementedError()
+
+    @timeout.setter
+    def timeout(self, timeout: float):
+        raise NotImplementedError()    
+
+class ThreespaceOutputStream:
+
+    """Write the given bytes"""
+    def write(self, bytes):
+        raise NotImplementedError()
+
+class ThreespaceComClass(ThreespaceInputStream, ThreespaceOutputStream):
+    """
+    Base class for a com class to use with the sensor object.
+    Com classes should be initialized without connection and require
+    there open called before use
+    """
+    
+    def close(self):
+        raise NotImplementedError()
+    
+    def open(self) -> bool:
+        """
+        Should return True on success, False on failure
+        If already open, should stay open
+        """
+        raise NotImplementedError()
+    
+    def check_open(self) -> bool:
+        """
+        Should return True if the port is currently open, False otherwise.
+        Must give the current state, not a cached state
+        """
+        raise NotImplementedError()
+    
+    @staticmethod
+    def auto_detect() -> Generator["ThreespaceComClass", None, None]:
+        """
+        Returns a list of com classes of the same type called on nearby
+        """
+        raise NotImplementedError()
+    
+    @property
+    def reenumerates(self) -> bool:
+        """
+        If the device Re-Enumerates when going from bootloader to firmware or vice versa, this must return True.
+        This indicates to the API that it must search for the new com class representing the object when switching between bootloader and firmware
+        """
+        raise NotImplementedError
+    
+    @property
+    def name(self) -> str:
+        raise NotImplementedError()

yostlabs-2025.1.9/src/yostlabs/communication/serial.py

@@ -0,0 +1,141 @@
+from yostlabs.communication.base import *
+import serial
+import serial.tools.list_ports
+
+
+class ThreespaceSerialComClass(ThreespaceComClass):
+
+    PID_V3_MASK = 0x3000
+    PID_BOOTLOADER = 0x1000 #We should really change this to 0x3000
+
+    VID = 0x2476
+
+    DEFAULT_BAUDRATE = 115200
+    DEFAULT_TIMEOUT = 2
+
+    def __init__(self, ser: serial.Serial | str):
+        if isinstance(ser, serial.Serial):
+            self.ser = ser
+        elif isinstance(ser, str):
+            self.ser = serial.Serial(ser, baudrate=ThreespaceSerialComClass.DEFAULT_BAUDRATE, timeout=ThreespaceSerialComClass.DEFAULT_TIMEOUT)
+        else:
+            raise TypeError("Invalid type for creating a ThreespaceSerialComClass:", type(ser), ser)
+
+        self.ser = ser
+
+        self.peek_buffer = bytearray()
+        self.peek_length = 0
+
+    def write(self, bytes):
+        self.ser.write(bytes)
+    
+    def read(self, num_bytes):
+        if self.peek_length >= num_bytes:
+            result = self.peek_buffer[:num_bytes]
+            self.peek_length -= num_bytes
+            del self.peek_buffer[:num_bytes]
+        else:
+            result = self.peek_buffer + self.ser.read(num_bytes - self.peek_length) #Must supply the amount desired to read instead of just buffering so the timeout works
+            self.peek_buffer.clear()
+            self.peek_length = 0
+        return result
+    
+    def peek(self, num_bytes):
+        if self.peek_length >= num_bytes:
+            return self.peek_buffer[:num_bytes]
+        else:
+            self.peek_buffer += self.ser.read(num_bytes - self.peek_length) #Must supply the amount desired to read instead of just buffering so the timeout works
+            self.peek_length = len(self.peek_buffer) #The read may have timed out, so calculate new size
+            return self.peek_buffer.copy()
+        
+    def read_until(self, expected: bytes) -> bytes:
+        if expected in self.peek_buffer:
+            length = self.peek_buffer.index(expected) + len(expected)
+            result = self.peek_buffer[:length]
+            self.peek_length -= length
+            del self.peek_buffer[:length]
+            return result
+        #Have to actually read from serial port until the data is available
+        result = self.peek_buffer + self.ser.read_until(expected)
+        self.peek_buffer.clear()
+        self.peek_length = 0
+        return result
+
+    def peek_until(self, expected: bytes, max_length=None) -> bytes:
+        if expected in self.peek_buffer:
+            length = self.peek_buffer.index(expected) + len(expected)
+            if max_length is not None and length > max_length: 
+                length = max_length
+            result = self.peek_buffer[:length]
+            return result
+        if max_length is not None and self.peek_length >= max_length:
+            return self.peek_buffer[:max_length]
+        
+        #Have to actually read from serial port until the data is available
+        if max_length is not None:
+            max_length = max(0, max_length - self.peek_length)
+        self.peek_buffer += self.ser.read_until(expected, size=max_length)
+        self.peek_length = len(self.peek_buffer)
+        return self.peek_buffer.copy()
+
+    def close(self):
+        self.ser.close()
+        self.peek_buffer.clear()
+        self.peek_length = 0
+    
+    def open(self):
+        try:
+            self.ser.open()
+        except:
+            return False
+        return True
+
+    def check_open(self):
+        try:
+            self.ser.in_waiting
+        except:
+            return False
+        return True
+
+    @property
+    def length(self):
+        return self.peek_length + self.ser.in_waiting    
+
+    @property
+    def timeout(self) -> float:
+        return self.ser.timeout
+    
+    @timeout.setter
+    def timeout(self, timeout: float):
+        self.ser.timeout = timeout    
+
+    @property
+    def reenumerates(self) -> bool:
+        return True
+    
+    @property
+    def name(self) -> str:
+        return self.ser.port
+
+    #This is not part of the ThreespaceComClass interface, but is useful as a utility for those directly using the ThreespaceSerialComClass
+    @staticmethod 
+    def enumerate_ports():
+        cls = ThreespaceSerialComClass
+        ports = serial.tools.list_ports.comports()
+        for port in ports:
+            if port.vid == cls.VID and (port.pid & cls.PID_V3_MASK == cls.PID_V3_MASK or port.pid == cls.PID_BOOTLOADER): 
+                yield port
+
+    @staticmethod
+    def auto_detect(default_timeout=2, default_baudrate=115200) -> Generator["ThreespaceSerialComClass", None, None]:
+        """
+        Returns a list of com classes of the same type called on nearby.
+        These ports will start unopened. This allows the caller to get a list of ports without having to connect.
+        """
+        cls = ThreespaceSerialComClass
+        ports = serial.tools.list_ports.comports()
+        for port in ports:
+            if port.vid == cls.VID and (port.pid & cls.PID_V3_MASK == cls.PID_V3_MASK or port.pid == cls.PID_BOOTLOADER): 
+                ser = serial.Serial(None, baudrate=default_baudrate, timeout=default_timeout) #By setting port as None, can create an object without immediately opening the port
+                ser.port = port.device #Now assign the port, allowing the serial object to exist without being opened yet
+                yield ThreespaceSerialComClass(ser)

yostlabs-2025.1.9/src/yostlabs/math/__init__.py

@@ -0,0 +1 @@
+__all__ = ["quaternion", "vector"]

{yostlabs-2025.1.3.4/src/yostlabs/tss3 → yostlabs-2025.1.9/src/yostlabs/math}/quaternion.py

@@ -1,23 +1,5 @@
 import math
-
-def vec_len(vector: list[float|int]):
-    return sum(v ** 2 for v in vector) ** 0.5
-
-def vec_dot(a: list[float], b: list[float]):
-    return sum(a[i] * b[i] for i in range(len(a)))
-
-def vec_cross(a: list[float], b: list[float]):
-    cross = [0, 0, 0]
-    cross[0] = a[1] * b[2] - a[2] * b[1]
-    cross[1] = a[2] * b[0] - a[0] * b[2]
-    cross[2] = a[0] * b[1] - a[1] * b[0]
-    return cross
-
-def vec_normalize(vec: list[float]):
-    l = vec_len(vec)
-    if l == 0:
-        return vec
-    return [v / l for v in vec]
+import yostlabs.math.vector as _vec
 
 def quat_mul(a: list[float], b: list[float]):
     out = [0, 0, 0, 0]
@@ -49,19 +31,6 @@ def quat_rotate_vec(quat: list[float], vec: list[float]):
     final = quat_mul(halfway, inv)
     return [final[0], final[1], final[2]]
 
-def is_right_handed(order: str, negations: list[bool]):
-    right_handed = order.lower() in ("xzy", "yxz", "zyx")
-    for i in range(3):
-        if negations[i]:
-            right_handed = not right_handed
-    return right_handed
-
-def axis_to_unit_vector(axis: str):
-    axis = axis.lower()
-    if axis == 'x' or axis == 0: return [1, 0, 0]
-    if axis == 'y' or axis == 1: return [0, 1, 0]
-    if axis == 'z' or axis == 2: return [0, 0, 1]
-
 def angles_to_quaternion(angles: list[float], order: str, degrees=True):
     quat = [0, 0, 0, 1]
     for i in range(len(angles)):
@@ -69,7 +38,7 @@ def angles_to_quaternion(angles: list[float], order: str, degrees=True):
         angle = angles[i]
         if degrees:
             angle = math.radians(angle)
-        unit_vec = axis_to_unit_vector(axis)
+        unit_vec = _vec.axis_to_unit_vector(axis)
         w = math.cos(angle / 2)
         imaginary = math.sin(angle / 2)
         unit_vec = [v * imaginary for v in unit_vec]
@@ -91,15 +60,15 @@ def quat_from_two_vectors(forward: list[float], down: list[float]):
     forward_reference = [0, 0, 1]
     down_reference = [0, -1, 0]
 
-    forward = vec_normalize(forward)
-    down = vec_normalize(down)
+    forward = _vec.vec_normalize(forward)
+    down = _vec.vec_normalize(down)
 
     #Create the first rotation to align the forward axis
-    axis_of_rotation = vec_cross(forward_reference, forward)
-    axis_of_rotation = vec_normalize(axis_of_rotation)
+    axis_of_rotation = _vec.vec_cross(forward_reference, forward)
+    axis_of_rotation = _vec.vec_normalize(axis_of_rotation)
     if not any(abs(v) > 0 for v in axis_of_rotation):
         axis_of_rotation = down_reference #This is just a direct 180 degree rotation around any orthogonal axis, so just use the down_ref
-    dot = min(1, max(-1, vec_dot(forward_reference, forward)))
+    dot = min(1, max(-1, _vec.vec_dot(forward_reference, forward)))
     angle1 = math.acos(dot)
     imaginary = math.sin(angle1/2)
     quat = [v * imaginary for v in axis_of_rotation] #XYZ
@@ -109,11 +78,11 @@ def quat_from_two_vectors(forward: list[float], down: list[float]):
     down_reference = quat_rotate_vec(quat, down_reference)
 
     #find the rotation to make the remaining reference align with its given value
-    axis_of_rotation = vec_cross(down_reference, down)
-    axis_of_rotation = vec_normalize(axis_of_rotation)
+    axis_of_rotation = _vec.vec_cross(down_reference, down)
+    axis_of_rotation = _vec.vec_normalize(axis_of_rotation)
     if not any(abs(v) > 0 for v in axis_of_rotation):
         axis_of_rotation = forward #Rotate along the final forward vector until up is aligned
-    dot = min(1, max(-1, vec_dot(down_reference, down)))
+    dot = min(1, max(-1, _vec.vec_dot(down_reference, down)))
     angle2 = math.acos(dot)
     imaginary = math.sin(angle2/2)
     rotation = [v * imaginary for v in axis_of_rotation] #XYZ
@@ -163,4 +132,18 @@ def quaternion_global_to_local(quat, vec):
     return quat_rotate_vec(inverse, vec)
 
 def quaternion_local_to_global(quat, vec):
-    return quat_rotate_vec(quat, vec)
+    return quat_rotate_vec(quat, vec)
+
+#https://splines.readthedocs.io/en/latest/rotation/slerp.html
+def slerp(a, b, t):
+    dot = _vec.vec_dot(a, b)
+    if dot < 0: #To force it to be the shortest route
+        b = [-v for v in b]
+
+    theta = math.acos(dot)
+    sin_theta = math.sin(theta)
+    r1 = math.sin(1 - t) * theta / sin_theta
+    r2 = math.sin(t * theta) / sin_theta
+    a = [r1 * v for v in a]
+    b = [r2 * v for v in b]
+    return _vec.vec_normalize([v + w for v, w in zip(a, b)])

yostlabs-2025.1.9/src/yostlabs/math/vector.py

@@ -0,0 +1,31 @@
+def vec_len(vector: list[float|int]):
+    return sum(v ** 2 for v in vector) ** 0.5
+
+def vec_dot(a: list[float], b: list[float]):
+    return sum(a[i] * b[i] for i in range(len(a)))
+
+def vec_cross(a: list[float], b: list[float]):
+    cross = [0, 0, 0]
+    cross[0] = a[1] * b[2] - a[2] * b[1]
+    cross[1] = a[2] * b[0] - a[0] * b[2]
+    cross[2] = a[0] * b[1] - a[1] * b[0]
+    return cross
+
+def vec_normalize(vec: list[float]):
+    l = vec_len(vec)
+    if l == 0:
+        return vec
+    return [v / l for v in vec]
+
+def vec_is_right_handed(order: str, negations: list[bool]):
+    right_handed = order.lower() in ("xzy", "yxz", "zyx")
+    for i in range(3):
+        if negations[i]:
+            right_handed = not right_handed
+    return right_handed
+
+def axis_to_unit_vector(axis: str):
+    axis = axis.lower()
+    if axis == 'x' or axis == 0: return [1, 0, 0]
+    if axis == 'y' or axis == 1: return [0, 1, 0]
+    if axis == 'z' or axis == 2: return [0, 0, 1]

{yostlabs-2025.1.3.4 → yostlabs-2025.1.9}/src/yostlabs/tss3/api.py

@@ -1,233 +1,15 @@
 from yostlabs.tss3.consts import *
+from yostlabs.communication.base import ThreespaceInputStream, ThreespaceOutputStream, ThreespaceComClass
+from yostlabs.communication.serial import ThreespaceSerialComClass
 
-import serial
-import serial.tools.list_ports
 from enum import Enum
 from dataclasses import dataclass, field
-from typing import Any, TypeVar, Generic, Generator
+from typing import TypeVar, Generic
 import struct
 import types
 import inspect
 import time
 
-class ThreespaceInputStream:
-
-    """
-    Reads specified number of bytes. 
-    If that many bytes are not available after timeout, less data will be returned
-    """
-    def read(self, num_bytes) -> bytes:
-        raise NotImplementedError()
-    
-    def read_all(self):
-        return self.read(self.length)
-
-    def read_until(self, expected: bytes) -> bytes:
-        raise NotImplementedError()
-
-    """Allows reading without removing the data from the buffer"""
-    def peek(self, num_bytes) -> bytes:
-        raise NotImplementedError()
-    
-    def peek_until(self, expected: bytes, max_length=None) -> bytes:
-        raise NotImplementedError()
-    
-    def readline(self) -> bytes:
-        return self.read_until(b"\n")
-    
-    def peekline(self, max_length=None) -> bytes:
-        return self.peek_until(b"\n", max_length=max_length)    
-    
-    @property
-    def length(self) -> int:
-        raise NotImplementedError()
-    
-    @property
-    def timeout(self) -> float:
-        raise NotImplementedError()
-
-    @timeout.setter
-    def timeout(self, timeout: float):
-        raise NotImplementedError()    
-
-class ThreespaceOutputStream:
-
-    """Write the given bytes"""
-    def write(self, bytes):
-        raise NotImplementedError()
-
-class ThreespaceComClass(ThreespaceInputStream, ThreespaceOutputStream):
-    """
-    Base class for a com class to use with the sensor object.
-    Com classes should be initialized without connection and require
-    there open called before use
-    """
-    
-    def close(self):
-        raise NotImplementedError()
-    
-    def open(self) -> bool:
-        """
-        Should return True on success, False on failure
-        If already open, should stay open
-        """
-        raise NotImplementedError()
-    
-    def check_open(self) -> bool:
-        """
-        Should return True if the port is currently open, False otherwise.
-        Must give the current state, not a cached state
-        """
-        raise NotImplementedError()
-    
-    @staticmethod
-    def auto_detect() -> Generator["ThreespaceComClass", None, None]:
-        """
-        Returns a list of com classes of the same type called on nearby
-        """
-        raise NotImplementedError()
-    
-    @property
-    def reenumerates(self) -> bool:
-        """
-        If the device Re-Enumerates when going from bootloader to firmware or vice versa, this must return True.
-        This indicates to the API that it must search for the new com class representing the object when switching between bootloader and firmware
-        """
-        raise NotImplementedError
-    
-    @property
-    def name(self) -> str:
-        raise NotImplementedError()
-
-class ThreespaceSerialComClass(ThreespaceComClass):
-
-    PID_V3_MASK = 0x3000
-    PID_BOOTLOADER = 0x1000 #We should really change this to 0x3000
-
-    VID = 0x2476
-
-    def __init__(self, ser: serial.Serial):
-        self.ser = ser
-
-        self.peek_buffer = bytearray()
-        self.peek_length = 0
-
-    def write(self, bytes):
-        self.ser.write(bytes)
-    
-    def read(self, num_bytes):
-        if self.peek_length >= num_bytes:
-            result = self.peek_buffer[:num_bytes]
-            self.peek_length -= num_bytes
-            del self.peek_buffer[:num_bytes]
-            #self.peek_buffer = self.peek_buffer[num_bytes:]
-        else:
-            result = self.peek_buffer + self.ser.read(num_bytes - self.peek_length) #Must supply the amount desired to read instead of just buffering so the timeout works
-            self.peek_buffer.clear()
-            self.peek_length = 0
-        return result
-    
-    def peek(self, num_bytes):
-        if self.peek_length >= num_bytes:
-            return self.peek_buffer[:num_bytes]
-        else:
-            self.peek_buffer += self.ser.read(num_bytes - self.peek_length) #Must supply the amount desired to read instead of just buffering so the timeout works
-            self.peek_length = len(self.peek_buffer) #The read may have timed out, so calculate new size
-            return self.peek_buffer.copy()
-        
-    def read_until(self, expected: bytes) -> bytes:
-        if expected in self.peek_buffer:
-            length = self.peek_buffer.index(expected) + len(expected)
-            result = self.peek_buffer[:length]
-            self.peek_length -= length
-            del self.peek_buffer[:length]
-            #self.peek_buffer = self.peek_buffer[length:]
-            return result
-        #Have to actually read from serial port until the data is available
-        result = self.peek_buffer + self.ser.read_until(expected)
-        self.peek_buffer.clear()
-        self.peek_length = 0
-        return result
-
-    def peek_until(self, expected: bytes, max_length=None) -> bytes:
-        if expected in self.peek_buffer:
-            length = self.peek_buffer.index(expected) + len(expected)
-            if max_length is not None and length > max_length: 
-                length = max_length
-            result = self.peek_buffer[:length]
-            return result
-        if max_length is not None and self.peek_length >= max_length:
-            return self.peek_buffer[:max_length]
-        
-        #Have to actually read from serial port until the data is available
-        if max_length is not None:
-            max_length = max(0, max_length - self.peek_length)
-        self.peek_buffer += self.ser.read_until(expected, size=max_length)
-        self.peek_length = len(self.peek_buffer)
-        return self.peek_buffer.copy()
-
-    def close(self):
-        self.ser.close()
-        self.peek_buffer.clear()
-        self.peek_length = 0
-    
-    def open(self):
-        try:
-            self.ser.open()
-        except:
-            return False
-        return True
-
-    def check_open(self):
-        try:
-            self.ser.in_waiting
-        except:
-            return False
-        return True
-
-    @property
-    def length(self):
-        return self.peek_length + self.ser.in_waiting    
-
-    @property
-    def timeout(self) -> float:
-        return self.ser.timeout
-    
-    @timeout.setter
-    def timeout(self, timeout: float):
-        self.ser.timeout = timeout    
-
-    @property
-    def reenumerates(self) -> bool:
-        return True
-    
-    @property
-    def name(self) -> str:
-        return self.ser.port
-
-    #This is not part of the ThreespaceComClass interface, but is useful as a utility for those directly using the ThreespaceSerialComClass
-    @staticmethod 
-    def enumerate_ports():
-        cls = ThreespaceSerialComClass
-        ports = serial.tools.list_ports.comports()
-        for port in ports:
-            if port.vid == cls.VID and (port.pid & cls.PID_V3_MASK == cls.PID_V3_MASK or port.pid == cls.PID_BOOTLOADER): 
-                yield port
-
-    @staticmethod
-    def auto_detect(default_timeout=2, default_baudrate=115200) -> Generator["ThreespaceSerialComClass", None, None]:
-        """
-        Returns a list of com classes of the same type called on nearby.
-        These ports will start unopened. This allows the caller to get a list of ports without having to connect.
-        """
-        cls = ThreespaceSerialComClass
-        ports = serial.tools.list_ports.comports()
-        for port in ports:
-            if port.vid == cls.VID and (port.pid & cls.PID_V3_MASK == cls.PID_V3_MASK or port.pid == cls.PID_BOOTLOADER): 
-                ser = serial.Serial(None, baudrate=default_baudrate, timeout=default_timeout) #By setting port as None, can create an object without immediately opening the port
-                ser.port = port.device #Now assign the port, allowing the serial object to exist without being opened yet
-                yield ThreespaceSerialComClass(ser)
-
 
 #For converting from internal format specifiers to struct module specifiers
 __3space_format_conversion_dictionary = {
@@ -620,10 +402,6 @@ class StreamableCommands(Enum):
 
     GetButtonState = 250
 
-THREESPACE_STREAMING_STATUS_NORMAL = 0
-THREESPACE_STREAMING_STATUS_INTERCEPT = 1
-THREESPACE_STREAMING_STATUS_UNKNOWN_ECHO = 2
-
 THREESPACE_AWAIT_COMMAND_FOUND = 0
 THREESPACE_AWAIT_COMMAND_TIMEOUT = 1
 
@@ -673,10 +451,11 @@ THREESPACE_REQUIRED_HEADER = THREESPACE_HEADER_ECHO_BIT | THREESPACE_HEADER_CHEC
 class ThreespaceSensor:
     
     def __init__(self, com = None, timeout=2):
-        if com is None: #Default to attempting to use the serial com class
+        if com is None: #Default to attempting to use the serial com class if none is provided
             com = ThreespaceSerialComClass
-
-        if inspect.isclass(com) and issubclass(com, ThreespaceComClass): #Auto discover
+        
+        #Auto discover using the supplied com class type
+        if inspect.isclass(com) and issubclass(com, ThreespaceComClass):
             new_com = None
             for serial_com in com.auto_detect():
                 new_com = serial_com
@@ -685,14 +464,14 @@ class ThreespaceSensor:
                 raise RuntimeError("Failed to auto discover com port")
             self.com = new_com
             self.com.open()
-        elif inspect.isclass(type(com)) and issubclass(type(com), ThreespaceComClass): #Already a com class
+        #The supplied com already was a com class, nothing to do
+        elif inspect.isclass(type(com)) and issubclass(type(com), ThreespaceComClass):
             self.com = com
-        elif isinstance(com, str):  #Use string to open a serial port
-            self.com = ThreespaceSerialComClass(serial.Serial(com, baudrate=115200, timeout=timeout))
-        elif isinstance(com, serial.Serial):
-            self.com = ThreespaceSerialComClass(com)
-        else:
-            raise ValueError("Unknown type", type(com))
+        else: #Unknown type, try making a ThreespaceSerialComClass out of this
+            try:
+                self.com = ThreespaceSerialComClass(com)
+            except:
+                raise ValueError("Failed to create default ThreespaceSerialComClass from parameter:", type(com), com)
 
         self.com.read_all() #Clear anything that may be there
 

yostlabs-2025.1.9/src/yostlabs/tss3/utils/calibration.py

@@ -0,0 +1,153 @@
+import yostlabs.math.quaternion as quat
+import yostlabs.math.vector as vec
+
+import numpy as np
+from dataclasses import dataclass
+import copy
+
+class ThreespaceGradientDescentCalibration:
+
+    @dataclass
+    class StageInfo:
+        start_vector: int
+        end_vector: int
+        stage: int
+        scale: float
+
+        count: int = 0
+
+    MAX_SCALE = 1000000000
+    MIN_SCALE = 1
+    STAGES = [
+        StageInfo(0, 6, 0, MAX_SCALE),
+        StageInfo(0, 12, 1, MAX_SCALE),
+        StageInfo(0, 24, 2, MAX_SCALE)
+    ]
+
+    #Note that each entry has a positive and negative vector included in this list
+    CHANGE_VECTORS = [
+        np.array([0,0,0,0,0,0,0,0,0,.0001,0,0], dtype=np.float64),
+        np.array([0,0,0,0,0,0,0,0,0,-.0001,0,0], dtype=np.float64),
+        np.array([0,0,0,0,0,0,0,0,0,0,.0001,0], dtype=np.float64),
+        np.array([0,0,0,0,0,0,0,0,0,0,-.0001,0], dtype=np.float64),
+        np.array([0,0,0,0,0,0,0,0,0,0,0,.0001], dtype=np.float64),
+        np.array([0,0,0,0,0,0,0,0,0,0,0,-.0001], dtype=np.float64), #First 6 only try to change the bias
+        np.array([.001,0,0,0,0,0,0,0,0,0,0,0], dtype=np.float64),
+        np.array([-.001,0,0,0,0,0,0,0,0,0,0,0], dtype=np.float64),
+        np.array([0,0,0,0,.001,0,0,0,0,0,0,0], dtype=np.float64),
+        np.array([0,0,0,0,-.001,0,0,0,0,0,0,0], dtype=np.float64),
+        np.array([0,0,0,0,0,0,0,0,.001,0,0,0], dtype=np.float64),
+        np.array([0,0,0,0,0,0,0,0,-.001,0,0,0], dtype=np.float64), #Next 6 only try to change the scale
+        np.array([0,.0001,0,0,0,0,0,0,0,0,0,0], dtype=np.float64),
+        np.array([0,-.0001,0,0,0,0,0,0,0,0,0,0], dtype=np.float64),
+        np.array([0,0,.0001,0,0,0,0,0,0,0,0,0], dtype=np.float64),
+        np.array([0,0,-.0001,0,0,0,0,0,0,0,0,0], dtype=np.float64),
+        np.array([0,0,0,.0001,0,0,0,0,0,0,0,0], dtype=np.float64),
+        np.array([0,0,0,-.0001,0,0,0,0,0,0,0,0], dtype=np.float64),
+        np.array([0,0,0,0,0,.0001,0,0,0,0,0,0], dtype=np.float64),
+        np.array([0,0,0,0,0,-.0001,0,0,0,0,0,0], dtype=np.float64),
+        np.array([0,0,0,0,0,0,.0001,0,0,0,0,0], dtype=np.float64),
+        np.array([0,0,0,0,0,0,-.0001,0,0,0,0,0], dtype=np.float64),
+        np.array([0,0,0,0,0,0,0,.0001,0,0,0,0], dtype=np.float64),
+        np.array([0,0,0,0,0,0,0,-.0001,0,0,0,0], dtype=np.float64), #Next 12 only try to change the shear
+    ]
+
+    def __init__(self, relative_sensor_orients: list[np.ndarray[float]], no_inverse=False):
+        """
+        Params
+        ------
+        relative_sensor_orients : The orientation of the sensor during which each sample is taken if it was tared as if pointing into the screen. 
+        The inverse of these will be used to calculate where the axes should be located relative to the sensor
+        no_inverse : The relative_sensor_orients will be treated as the sample_rotations
+        """
+        if no_inverse:
+            self.rotation_quats = relative_sensor_orients
+        else:
+            self.rotation_quats = [np.array(quat.quat_inverse(orient)) for orient in relative_sensor_orients]
+
+    def apply_parameters(self, sample: np.ndarray[float], params: np.ndarray[float]):
+        bias = params[9:]
+        scale = params[:9]
+        scale = scale.reshape((3, 3))
+        return scale @ (sample + bias)
+
+    def rate_parameters(self, params: np.ndarray[float], samples: list[np.ndarray[float]], targets: list[np.ndarray[float]]):
+        total_error = 0
+        for i in range(len(samples)):
+            sample = samples[i]
+            target = targets[i]
+
+            sample = self.apply_parameters(sample, params)
+            
+            error = target - sample
+            total_error += vec.vec_len(error)
+        return total_error
+
+    def generate_target_list(self, origin: np.ndarray):
+        targets = []
+        for orient in self.rotation_quats:
+            new_vec = np.array(quat.quat_rotate_vec(orient, origin), dtype=np.float64)
+            targets.append(new_vec)
+        return targets
+
+    def __get_stage(self, stage_number: int):
+        if stage_number >= len(self.STAGES):
+            return None
+        #Always get a shallow copy of the stage so can modify without removing the initial values
+        return copy.copy(self.STAGES[stage_number])
+
+    def calculate(self, samples: list[np.ndarray[float]], origin: np.ndarray[float], verbose=False, max_cycles_per_stage=1000):
+        targets = self.generate_target_list(origin)
+        initial_params = np.array([1,0,0,0,1,0,0,0,1,0,0,0], dtype=np.float64)
+        stage = self.__get_stage(0)
+
+        best_params = initial_params
+        best_rating = self.rate_parameters(best_params, samples, targets)
+        count = 0
+        while True:
+            last_best_rating = best_rating
+            params = best_params
+
+            #Apply all the changes to see if any improve the result
+            for change_index in range(stage.start_vector, stage.end_vector):
+                change_vector = self.CHANGE_VECTORS[change_index]
+                new_params = params + (change_vector * stage.scale)
+                rating = self.rate_parameters(new_params, samples, targets)
+
+                #A better rating, store it
+                if rating < best_rating:
+                    best_params = new_params
+                    best_rating = rating
+            
+            if verbose and count % 100 == 0:
+                print(f"Round {count}: {best_rating=} {stage=}")
+            
+            #Decide if need to go to the next stage or not
+            count += 1
+            stage.count += 1
+            if stage.count >= max_cycles_per_stage:
+                stage = self.__get_stage(stage.stage + 1)
+                if stage is None:
+                    if verbose: print("Done from reaching count limit")
+                    break
+                if verbose: print("Going to next stage from count limit")
+                
+            if best_rating == last_best_rating: #The rating did not improve
+                if stage.scale == self.MIN_SCALE: #Go to the next stage since can't get any better in this stage!
+                    stage = self.__get_stage(stage.stage + 1)
+                    if stage is None:
+                        if verbose: print("Done from exhaustion")
+                        break
+                    if verbose: print("Going to next stage from exhaustion")
+                else:   #Reduce the size of the changes to hopefully get more accurate tuning
+                    stage.scale *= 0.1  
+                    if stage.scale < self.MIN_SCALE:
+                        stage.scale = self.MIN_SCALE
+            else: #Rating got better! To help avoid falling in a local minimum, increase the size of the change to see if that could make it better
+                stage.scale *= 1.1
+        
+        if verbose:
+            print(f"Final Rating: {best_rating}")
+            print(f"Final Params: {best_params}")
+
+        return best_params

{yostlabs-2025.1.3.4/src/yostlabs/tss3 → yostlabs-2025.1.9/src/yostlabs/tss3/utils}/parser.py

@@ -15,7 +15,6 @@ class ThreespaceBufferInputStream(ThreespaceInputStream):
         num_bytes = min(len(self.buffer), num_bytes)
         result = self.buffer[:num_bytes]
         del self.buffer[:num_bytes]
-        #self.buffer = self.buffer[num_bytes:]
         return result
     
     def read_all(self):
@@ -28,7 +27,6 @@ class ThreespaceBufferInputStream(ThreespaceInputStream):
         length = self.buffer.index(expected) + len(expected)
         result = self.buffer[:length]
         del self.buffer[:length]
-        #self.buffer = self.buffer[length:]
         raise result
 
     """Allows reading without removing the data from the buffer"""

yostlabs-2025.1.3.4/src/yostlabs/tss3/utils.py → yostlabs-2025.1.9/src/yostlabs/tss3/utils/streaming.py

@@ -1,11 +1,8 @@
-from .api import ThreespaceSensor, ThreespaceCommand, StreamableCommands, ThreespaceCmdResult, threespaceGetHeaderLabels
-from dataclasses import dataclass, field
-import copy
-from typing import Any, Callable
-from enum import Enum
+from yostlabs.tss3.api import ThreespaceSensor, StreamableCommands, ThreespaceCmdResult, threespaceGetHeaderLabels
 
-import numpy as np
-import yostlabs.tss3.quaternion as yl_math
+from enum import Enum
+from typing import Any, Callable
+from dataclasses import dataclass, field
 
 class ThreespaceStreamingStatus(Enum):
     Data = 0        #Normal data update
@@ -435,237 +432,4 @@ class ThreespaceStreamingManager:
             else:
                 slot_info.append(None)
         
-        return slot_info
-
-class ThreespaceGradientDescentCalibration:
-
-    @dataclass
-    class StageInfo:
-        start_vector: int
-        end_vector: int
-        stage: int
-        scale: float
-
-        count: int = 0
-
-    MAX_SCALE = 1000000000
-    MIN_SCALE = 1
-    STAGES = [
-        StageInfo(0, 6, 0, MAX_SCALE),
-        StageInfo(0, 12, 1, MAX_SCALE),
-        StageInfo(0, 24, 2, MAX_SCALE)
-    ]
-
-    #Note that each entry has a positive and negative vector included in this list
-    CHANGE_VECTORS = [
-        np.array([0,0,0,0,0,0,0,0,0,.0001,0,0], dtype=np.float64),
-        np.array([0,0,0,0,0,0,0,0,0,-.0001,0,0], dtype=np.float64),
-        np.array([0,0,0,0,0,0,0,0,0,0,.0001,0], dtype=np.float64),
-        np.array([0,0,0,0,0,0,0,0,0,0,-.0001,0], dtype=np.float64),
-        np.array([0,0,0,0,0,0,0,0,0,0,0,.0001], dtype=np.float64),
-        np.array([0,0,0,0,0,0,0,0,0,0,0,-.0001], dtype=np.float64), #First 6 only try to change the bias
-        np.array([.001,0,0,0,0,0,0,0,0,0,0,0], dtype=np.float64),
-        np.array([-.001,0,0,0,0,0,0,0,0,0,0,0], dtype=np.float64),
-        np.array([0,0,0,0,.001,0,0,0,0,0,0,0], dtype=np.float64),
-        np.array([0,0,0,0,-.001,0,0,0,0,0,0,0], dtype=np.float64),
-        np.array([0,0,0,0,0,0,0,0,.001,0,0,0], dtype=np.float64),
-        np.array([0,0,0,0,0,0,0,0,-.001,0,0,0], dtype=np.float64), #Next 6 only try to change the scale
-        np.array([0,.0001,0,0,0,0,0,0,0,0,0,0], dtype=np.float64),
-        np.array([0,-.0001,0,0,0,0,0,0,0,0,0,0], dtype=np.float64),
-        np.array([0,0,.0001,0,0,0,0,0,0,0,0,0], dtype=np.float64),
-        np.array([0,0,-.0001,0,0,0,0,0,0,0,0,0], dtype=np.float64),
-        np.array([0,0,0,.0001,0,0,0,0,0,0,0,0], dtype=np.float64),
-        np.array([0,0,0,-.0001,0,0,0,0,0,0,0,0], dtype=np.float64),
-        np.array([0,0,0,0,0,.0001,0,0,0,0,0,0], dtype=np.float64),
-        np.array([0,0,0,0,0,-.0001,0,0,0,0,0,0], dtype=np.float64),
-        np.array([0,0,0,0,0,0,.0001,0,0,0,0,0], dtype=np.float64),
-        np.array([0,0,0,0,0,0,-.0001,0,0,0,0,0], dtype=np.float64),
-        np.array([0,0,0,0,0,0,0,.0001,0,0,0,0], dtype=np.float64),
-        np.array([0,0,0,0,0,0,0,-.0001,0,0,0,0], dtype=np.float64), #Next 12 only try to change the shear
-    ]
-
-    def __init__(self, relative_sensor_orients: list[np.ndarray[float]], no_inverse=False):
-        """
-        Params
-        ------
-        relative_sensor_orients : The orientation of the sensor during which each sample is taken if it was tared as if pointing into the screen. 
-        The inverse of these will be used to calculate where the axes should be located relative to the sensor
-        no_inverse : The relative_sensor_orients will be treated as the sample_rotations
-        """
-        if no_inverse:
-            self.rotation_quats = relative_sensor_orients
-        else:
-            self.rotation_quats = [np.array(yl_math.quat_inverse(orient)) for orient in relative_sensor_orients]
-
-    def apply_parameters(self, sample: np.ndarray[float], params: np.ndarray[float]):
-        bias = params[9:]
-        scale = params[:9]
-        scale = scale.reshape((3, 3))
-        return scale @ (sample + bias)
-
-    def rate_parameters(self, params: np.ndarray[float], samples: list[np.ndarray[float]], targets: list[np.ndarray[float]]):
-        total_error = 0
-        for i in range(len(samples)):
-            sample = samples[i]
-            target = targets[i]
-
-            sample = self.apply_parameters(sample, params)
-            
-            error = target - sample
-            total_error += yl_math.vec_len(error)
-        return total_error
-
-    def generate_target_list(self, origin: np.ndarray):
-        targets = []
-        for orient in self.rotation_quats:
-            new_vec = np.array(yl_math.quat_rotate_vec(orient, origin), dtype=np.float64)
-            targets.append(new_vec)
-        return targets
-
-    def __get_stage(self, stage_number: int):
-        if stage_number >= len(self.STAGES):
-            return None
-        #Always get a shallow copy of the stage so can modify without removing the initial values
-        return copy.copy(self.STAGES[stage_number])
-
-    def calculate(self, samples: list[np.ndarray[float]], origin: np.ndarray[float], verbose=False, max_cycles_per_stage=1000):
-        targets = self.generate_target_list(origin)
-        initial_params = np.array([1,0,0,0,1,0,0,0,1,0,0,0], dtype=np.float64)
-        stage = self.__get_stage(0)
-
-        best_params = initial_params
-        best_rating = self.rate_parameters(best_params, samples, targets)
-        count = 0
-        while True:
-            last_best_rating = best_rating
-            params = best_params
-
-            #Apply all the changes to see if any improve the result
-            for change_index in range(stage.start_vector, stage.end_vector):
-                change_vector = self.CHANGE_VECTORS[change_index]
-                new_params = params + (change_vector * stage.scale)
-                rating = self.rate_parameters(new_params, samples, targets)
-
-                #A better rating, store it
-                if rating < best_rating:
-                    best_params = new_params
-                    best_rating = rating
-            
-            if verbose and count % 100 == 0:
-                print(f"Round {count}: {best_rating=} {stage=}")
-            
-            #Decide if need to go to the next stage or not
-            count += 1
-            stage.count += 1
-            if stage.count >= max_cycles_per_stage:
-                stage = self.__get_stage(stage.stage + 1)
-                if stage is None:
-                    if verbose: print("Done from reaching count limit")
-                    break
-                if verbose: print("Going to next stage from count limit")
-                
-            if best_rating == last_best_rating: #The rating did not improve
-                if stage.scale == self.MIN_SCALE: #Go to the next stage since can't get any better in this stage!
-                    stage = self.__get_stage(stage.stage + 1)
-                    if stage is None:
-                        if verbose: print("Done from exhaustion")
-                        break
-                    if verbose: print("Going to next stage from exhaustion")
-                else:   #Reduce the size of the changes to hopefully get more accurate tuning
-                    stage.scale *= 0.1  
-                    if stage.scale < self.MIN_SCALE:
-                        stage.scale = self.MIN_SCALE
-            else: #Rating got better! To help avoid falling in a local minimum, increase the size of the change to see if that could make it better
-                stage.scale *= 1.1
-        
-        if verbose:
-            print(f"Final Rating: {best_rating}")
-            print(f"Final Params: {best_params}")
-
-        return best_params
-
-from xml.dom import minidom, Node
-class ThreespaceFirmwareUploader:
-
-    def __init__(self, sensor: ThreespaceSensor, file_path: str = None, percentage_callback: Callable[[int],None] = None, verbose: bool = False):
-        self.sensor = sensor
-        self.set_firmware_path(file_path)
-        self.verbose = verbose
-
-        self.percent_complete = 0
-        self.callback = percentage_callback
-
-    def set_firmware_path(self, file_path: str):
-        if file_path is None: 
-            self.firmware = None
-            return
-        self.firmware = minidom.parse(file_path)
-
-    def set_percent_callback(self, callback: Callable[[float],None]):
-        self.callback = callback
-
-    def set_verbose(self, verbose: bool):
-        self.verbose = verbose
-
-    def get_percent_done(self):
-        return self.percent_complete
-    
-    def __set_percent_complete(self, percent: float):
-        self.percent_complete = percent
-        if self.callback:
-            self.callback(percent)
-
-    def log(self, *args):
-        if not self.verbose: return
-        print(*args)
-
-    def upload_firmware(self):
-        self.percent_complete = 0
-        if not self.sensor.in_bootloader:
-            self.sensor.enterBootloader()
-        self.__set_percent_complete(5)
-        
-        boot_info = self.sensor.bootloader_get_info()
-
-        root = self.firmware.firstChild
-        for c in root.childNodes:
-            if c.nodeType == Node.ELEMENT_NODE:
-                name = c.nodeName
-                if name == "SetAddr":
-                    self.log("Write S")
-                    error = self.sensor.bootloader_erase_firmware()
-                    if error:
-                        self.log("Failed to erase firmware:", error)
-                    else:
-                        self.log("Successfully erased firmware")
-                    self.__set_percent_complete(20)
-                elif name == "MemProgC":
-                    mem = bytes.fromhex(c.firstChild.nodeValue)
-                    self.log("Attempting to program", len(mem), "bytes to the chip")
-                    cpos = 0
-                    while cpos < len(mem):
-                        memchunk = mem[cpos : min(len(mem), cpos + boot_info.pagesize)]
-                        error = self.sensor.bootloader_prog_mem(memchunk)
-                        if error:
-                            self.log("Failed upload:", error)
-                        else:
-                            self.log("Wrote", len(memchunk), "bytes successfully to offset", cpos)
-                        cpos += len(memchunk)
-                        self.__set_percent_complete(20 + cpos / len(mem) * 79)
-                elif name == "Run":
-                    self.log("Resetting with new firmware.")
-                    self.sensor.bootloader_boot_firmware()
-                    self.__set_percent_complete(100)
-
-if __name__ == "__main__":
-    firmware_file = "D:\\svn\\trunk\\3Space\\TSS_3.0_Firmware\\Nuvoton_BASE_Project\\build\\Application.xml"
-    sensor = ThreespaceSensor()
-    sensor.set_settings(debug_level=0)
-    sensor.set_settings(cpu_speed=192000000, power_initial_hold_state=0)
-    sensor.commitSettings()
-
-    firmware_uploader = ThreespaceFirmwareUploader(firmware_file, verbose=True)
-    firmware_uploader.upload_firmware(sensor)
-
-    print(sensor.get_settings("version_firmware"))
-
+        return slot_info

yostlabs-2025.1.9/src/yostlabs/tss3/utils/version.py

@@ -0,0 +1,76 @@
+from yostlabs.tss3.api import ThreespaceSensor
+from xml.dom import minidom, Node
+
+from typing import Callable
+
+class ThreespaceFirmwareUploader:
+
+    def __init__(self, sensor: ThreespaceSensor, file_path: str = None, percentage_callback: Callable[[int],None] = None, verbose: bool = False):
+        self.sensor = sensor
+        self.set_firmware_path(file_path)
+        self.verbose = verbose
+
+        self.percent_complete = 0
+        self.callback = percentage_callback
+
+    def set_firmware_path(self, file_path: str):
+        if file_path is None: 
+            self.firmware = None
+            return
+        self.firmware = minidom.parse(file_path)
+
+    def set_percent_callback(self, callback: Callable[[float],None]):
+        self.callback = callback
+
+    def set_verbose(self, verbose: bool):
+        self.verbose = verbose
+
+    def get_percent_done(self):
+        return self.percent_complete
+    
+    def __set_percent_complete(self, percent: float):
+        self.percent_complete = percent
+        if self.callback:
+            self.callback(percent)
+
+    def log(self, *args):
+        if not self.verbose: return
+        print(*args)
+
+    def upload_firmware(self):
+        self.percent_complete = 0
+        if not self.sensor.in_bootloader:
+            self.sensor.enterBootloader()
+        self.__set_percent_complete(5)
+        
+        boot_info = self.sensor.bootloader_get_info()
+
+        root = self.firmware.firstChild
+        for c in root.childNodes:
+            if c.nodeType == Node.ELEMENT_NODE:
+                name = c.nodeName
+                if name == "SetAddr":
+                    self.log("Write S")
+                    error = self.sensor.bootloader_erase_firmware()
+                    if error:
+                        self.log("Failed to erase firmware:", error)
+                    else:
+                        self.log("Successfully erased firmware")
+                    self.__set_percent_complete(20)
+                elif name == "MemProgC":
+                    mem = bytes.fromhex(c.firstChild.nodeValue)
+                    self.log("Attempting to program", len(mem), "bytes to the chip")
+                    cpos = 0
+                    while cpos < len(mem):
+                        memchunk = mem[cpos : min(len(mem), cpos + boot_info.pagesize)]
+                        error = self.sensor.bootloader_prog_mem(memchunk)
+                        if error:
+                            self.log("Failed upload:", error)
+                        else:
+                            self.log("Wrote", len(memchunk), "bytes successfully to offset", cpos)
+                        cpos += len(memchunk)
+                        self.__set_percent_complete(20 + cpos / len(mem) * 79)
+                elif name == "Run":
+                    self.log("Resetting with new firmware.")
+                    self.sensor.bootloader_boot_firmware()
+                    self.__set_percent_complete(100)