sr-robot3 2024.0.0rc2__py3-none-any.whl → 2025.0.0__py3-none-any.whl

sr/robot3/simulator/camera.py

@@ -0,0 +1,75 @@
+import struct
+
+import cv2
+import numpy as np
+from april_vision import FrameSource
+from numpy.typing import NDArray
+from serial import serial_for_url
+
+from ..utils import BoardInfo
+
+HEADER_SIZE = 5  # 1 byte for the type, 4 bytes for the length
+IMAGE_TAG_ID = 0
+
+
+class WebotsRemoteCameraSource(FrameSource):
+    # Webots cameras include an alpha channel, this informs april_vision of how to handle it
+    COLOURSPACE = cv2.COLOR_BGRA2GRAY
+
+    def __init__(self, camera_info: BoardInfo) -> None:
+        self.calibration = (0.0, 0.0, 0.0, 0.0)
+        # Use pyserial to give a nicer interface for connecting to the camera socket
+        self._serial = serial_for_url(camera_info.url, baudrate=115200, timeout=None)
+
+        # Check the camera is connected
+        response = self._make_request("*IDN?")
+        if not response.split(b":")[1].lower().startswith(b"cam"):
+            raise RuntimeError(f"Camera not connected to a camera, returned: {response!r}")
+
+        # Get the calibration data for this camera
+        response = self._make_request("CAM:CALIBRATION?")
+
+        # The calibration data is returned as a string of floats separated by colons
+        new_calibration = tuple(map(float, response.split(b":")))
+        assert len(new_calibration) == 4, f"Invalid calibration data: {new_calibration}"
+        self.calibration = new_calibration
+
+        # Get the image size for this camera
+        response = self._make_request("CAM:RESOLUTION?")
+        self.image_size = tuple(map(int, response.split(b":")))
+        assert len(self.image_size) == 2, f"Invalid image dimensions: {self.image_size}"
+
+    def read(self, fresh: bool = True) -> NDArray:
+        """
+        The method for getting a new frame.
+
+        :param fresh: Whether to flush the device's buffer before capturing
+        the frame, unused.
+        """
+        self._serial.write(b"CAM:FRAME!\n")
+        # The image is encoded as a TLV (Type, Length, Value) packet
+        # so we need to read the header to get the type and length of the image
+        header = self._serial.read(HEADER_SIZE)
+        assert len(header) == HEADER_SIZE, f"Invalid header length: {len(header)}"
+        img_tag, img_len = struct.unpack('>BI', header)
+        assert img_tag == IMAGE_TAG_ID, f"Invalid image tag: {img_tag}"
+
+        # Get the image data now we know the length
+        img_data = self._serial.read(img_len)
+        assert len(img_data) == img_len, f"Invalid image data length: {len(img_data)}"
+
+        rgb_frame_raw: NDArray[np.uint8] = np.frombuffer(img_data, np.uint8)
+
+        # Height is first, then width, then channels
+        return rgb_frame_raw.reshape((self.image_size[1], self.image_size[0], 4))
+
+    def close(self) -> None:
+        """Close the underlying socket on exit."""
+        self._serial.close()
+
+    def _make_request(self, command: str) -> bytes:
+        self._serial.write(command.encode() + b"\n")
+        response = self._serial.readline()
+        if not response.endswith(b"\n") or response.startswith(b"NACK:"):
+            raise RuntimeError(f"Failed to communicate with camera, returned: {response!r}")
+        return response

sr/robot3/simulator/time_server.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import logging
+from datetime import datetime
+
+from ..exceptions import BoardDisconnectionError, IncorrectBoardError
+from ..serial_wrapper import SerialWrapper
+from ..utils import BoardIdentity, get_simulator_boards
+
+logger = logging.getLogger(__name__)
+
+BAUDRATE = 115200
+
+
+class TimeServer:
+    @staticmethod
+    def get_board_type() -> str:
+        """
+        Return the type of the board.
+
+        :return: The literal string 'TimeServer'.
+        """
+        return 'TimeServer'
+
+    def __init__(
+        self,
+        serial_port: str,
+        initial_identity: BoardIdentity | None = None,
+    ) -> None:
+        if initial_identity is None:
+            initial_identity = BoardIdentity()
+        self._serial = SerialWrapper(
+            serial_port,
+            BAUDRATE,
+            identity=initial_identity,
+            # Disable the timeout so sleep works properly
+            timeout=None,
+        )
+
+        self._identity = self.identify()
+        if self._identity.board_type != self.get_board_type():
+            raise IncorrectBoardError(self._identity.board_type, self.get_board_type())
+        self._serial.set_identity(self._identity)
+
+    @classmethod
+    def initialise(cls) -> 'TimeServer' | None:
+        # The filter here is the name of the emulated board in the simulator
+        boards = get_simulator_boards('TimeServer')
+
+        if not boards:
+            return None
+
+        board_info = boards[0]
+
+        # Create board identity from the info given
+        initial_identity = BoardIdentity(
+            manufacturer='sbot_simulator',
+            board_type=board_info.type_str,
+            asset_tag=board_info.serial_number,
+        )
+
+        try:
+            board = cls(board_info.url, initial_identity)
+        except BoardDisconnectionError:
+            logger.warning(
+                f"Simulator specified time server at port {board_info.url!r}, "
+                "could not be identified. Ignoring this device")
+            return None
+        except IncorrectBoardError as err:
+            logger.warning(
+                f"Board returned type {err.returned_type!r}, "
+                f"expected {err.expected_type!r}. Ignoring this device")
+            return None
+
+        return board
+
+    def identify(self) -> BoardIdentity:
+        """
+        Get the identity of the board.
+
+        :return: The identity of the board.
+        """
+        response = self._serial.query('*IDN?')
+        return BoardIdentity(*response.split(':'))
+
+    def get_time(self) -> float:
+        time_str = self._serial.query('TIME?')
+        return datetime.fromisoformat(time_str).timestamp()
+
+    def sleep(self, duration: float) -> None:
+        if duration < 0:
+            raise ValueError("sleep length must be non-negative")
+
+        self._serial.query(f'SLEEP:{int(duration * 1000)}')

sr/robot3/timeout.py

@@ -1,4 +1,5 @@
 """Functions for killing the robot after a certain amount of time."""
+import atexit
 import logging
 import os
 import signal
@@ -9,6 +10,9 @@ from typing import Optional
 
 logger = logging.getLogger(__name__)
 
+TIMEOUT_MESSAGE = "Timeout expired: Game Over!"
+EXIT_ATTEMPTS = 0
+
 
 def timeout_handler(signal_type: int, stack_frame: Optional[FrameType]) -> None:
     """
@@ -17,13 +21,34 @@ def timeout_handler(signal_type: int, stack_frame: Optional[FrameType]) -> None:
     This function is called when the timeout expires and will stop the robot's main process.
     In order for this to work, any threads that are created must be daemons.
 
+    If the process doesn't terminate clearly (perhaps because the exception was caught),
+    exit less cleanly.
+
     NOTE: This function is not called on Windows.
 
-    :param signal_type: The sginal that triggered this handler
+    :param signal_type: The signal that triggered this handler
     :param stack_frame: The stack frame at the time of the signal
     """
-    logger.info("Timeout expired: Game Over!")
-    exit(0)
+    global EXIT_ATTEMPTS
+    EXIT_ATTEMPTS += 1
+
+    if sys.platform == "win32":
+        raise AssertionError("This function should not be called on Windows")
+
+    if EXIT_ATTEMPTS == 1:
+        # Allow 2 seconds for the process to exit cleanly before killing it
+        signal.alarm(2)
+        logger.info(TIMEOUT_MESSAGE)
+        # Exit cleanly
+        exit(0)
+    else:
+        # The process didn't exit cleanly, so first call the cleanup handlers
+        # and use an unhanded alarm to force python to exit with a core dump
+        signal.signal(signal.SIGALRM, signal.SIG_DFL)
+        signal.alarm(2)  # Allow 2 seconds for cleanup
+
+        atexit._run_exitfuncs()
+        exit(0)
 
 
 def win_timeout_handler() -> None:
@@ -35,7 +60,7 @@ def win_timeout_handler() -> None:
 
     NOTE: This function is only called on Windows.
     """
-    logger.info("Timeout expired: Game Over!")
+    logger.info(TIMEOUT_MESSAGE)
     os.kill(os.getpid(), signal.SIGTERM)
 
 
@@ -52,6 +77,7 @@ def kill_after_delay(timeout_seconds: int) -> None:
         # Windows doesn't have SIGALRM,
         # so we approximate its functionality using a delayed SIGTERM
         timer = Timer(timeout_seconds, win_timeout_handler)
+        timer.daemon = True
         timer.start()
     else:
         signal.signal(signal.SIGALRM, timeout_handler)

sr/robot3/utils.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import logging
+import os
 import signal
 import socket
 from abc import ABC, abstractmethod
@@ -14,6 +15,8 @@ from serial.tools.list_ports_common import ListPortInfo
 T = TypeVar('T')
 logger = logging.getLogger(__name__)
 
+IN_SIMULATOR = os.environ.get('WEBOTS_SIMULATOR', '') == '1'
+
 
 class BoardIdentity(NamedTuple):
     """
@@ -34,6 +37,13 @@ class BoardIdentity(NamedTuple):
     sw_version: str = ""
 
 
+class BoardInfo(NamedTuple):
+    """A container for the information about a board connection."""
+    url: str
+    serial_number: str
+    type_str: str
+
+
 class Board(ABC):
     """
     This is the base class for all boards.
@@ -123,7 +133,7 @@ def singular(container: Mapping[str, T]) -> T:
 
     :param container: A mapping of connected boards of a type
     :raises RuntimeError: If there is not exactly one of this type of board connected
-    :return: _description_
+    :return: The connected board of the type
     """
     length = len(container)
 
@@ -228,6 +238,36 @@ def ensure_atexit_on_term() -> None:
     signal.signal(signal.SIGTERM, handle_signal)
 
 
+def get_simulator_boards(board_filter: str = '') -> list[BoardInfo]:
+    """
+    Get a list of all boards configured in the simulator.
+
+    This is used to support discovery of boards in the simulator environment.
+
+    :param board_filter: A filter to only return boards of a certain type
+    :return: A list of board connection information
+    """
+    if 'WEBOTS_ROBOT' not in os.environ:
+        return []
+
+    simulator_data = os.environ['WEBOTS_ROBOT'].splitlines()
+    simulator_boards = []
+
+    for board_data in simulator_data:
+        board_data = board_data.rstrip('/')
+        board_fragment, serial_number = board_data.rsplit('/', 1)
+        board_url, board_type = board_fragment.rsplit('/', 1)
+
+        board_info = BoardInfo(url=board_url, serial_number=serial_number, type_str=board_type)
+
+        if board_filter and board_info.type_str != board_filter:
+            continue
+
+        simulator_boards.append(board_info)
+
+    return simulator_boards
+
+
 def list_ports() -> None:
     """
     Print a list of all connected USB serial ports.

{sr_robot3-2024.0.0rc2.dist-info → sr_robot3-2025.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sr-robot3
-Version: 2024.0.0rc2
+Version: 2025.0.0
 Summary: Student Robotics API for Python 3
 Author-email: Student Robotics <kit-team@studentrobotics.org>
 License: MIT License
@@ -37,22 +37,24 @@ Classifier: Topic :: Education
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pyserial <4,>=3
-Requires-Dist: april-vision <3,>=2.1
-Requires-Dist: paho-mqtt <2,>=1.6
-Requires-Dist: pydantic <2,>=1.9.1
-Requires-Dist: typing-extensions ; python_version < "3.10"
+Requires-Dist: pyserial<4,>=3
+Requires-Dist: april-vision==2.2.0
+Requires-Dist: paho-mqtt<3,>=2
+Requires-Dist: pydantic<2,>=1.9.1
+Requires-Dist: typing-extensions; python_version < "3.10"
+Requires-Dist: tomli<3,>=2.0.1; python_version < "3.11"
 Provides-Extra: dev
-Requires-Dist: flake8 ; extra == 'dev'
-Requires-Dist: isort ; extra == 'dev'
-Requires-Dist: mypy ; extra == 'dev'
-Requires-Dist: build ; extra == 'dev'
-Requires-Dist: types-pyserial ; extra == 'dev'
-Requires-Dist: pytest ; extra == 'dev'
-Requires-Dist: pytest-cov ; extra == 'dev'
-Requires-Dist: types-paho-mqtt ; extra == 'dev'
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: types-pyserial; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: paho-mqtt<3,>=2; extra == "dev"
+Requires-Dist: mypy==1.10.0; python_version < "3.9" and extra == "dev"
+Requires-Dist: mypy<2,>=1.7; python_version >= "3.9" and extra == "dev"
 Provides-Extra: vision
-Requires-Dist: opencv-python-headless <5,>=4 ; extra == 'vision'
+Requires-Dist: opencv-python-headless<5,>=4; extra == "vision"
 
 # sr-robot3
 

sr_robot3-2025.0.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+sr/robot3/__init__.py,sha256=lW7j65ruMEkRNJjZzp8929TefPMaMhqXzpsGPJqMkRs,1476
+sr/robot3/_version.py,sha256=-X88o2Nur4PzeUeRdAC4dP3gTVlb9JWw08awOdH4TYg,417
+sr/robot3/arduino.py,sha256=9rGsvGDb1JoHB4c7W61R16Y3eb0-UZ9TE49Qu7BJIZE,16934
+sr/robot3/astoria.py,sha256=0EIXoxvs1glkGuzLDYG7HptKucc8q7sdWAQiu96NG24,8547
+sr/robot3/camera.py,sha256=b2r8-ttQgLqbMv9BI6qWb5sHjeg4Zb5VrGo2uWMYGd8,8686
+sr/robot3/exceptions.py,sha256=A8cpuvFaIFazWSrp9QNts9ikINWymgoGALv4JAL-SU8,1381
+sr/robot3/game_specific.py,sha256=X8vLUbTRdNPZEggC6LxZzaNb9oqMly8-3PyQoD3B1ho,282
+sr/robot3/kch.py,sha256=CxMbRztCNz75Uikv3KaViV6zYlXsJuBbI6qg2AsQW4Q,12500
+sr/robot3/logging.py,sha256=1KO1yW2RP9qSUHr-i1NOMM68szxML5qJyDKtdt34uyg,3464
+sr/robot3/marker.py,sha256=6LzT59xjEFroljcDsejfcUeU-5dlDAEWbPepp-25fOY,5403
+sr/robot3/motor_board.py,sha256=6yYhz0WSLzPvAzREIYUmCLeCtc6Qwkm7hdTOPFgRZ70,11356
+sr/robot3/mqtt.py,sha256=1xKQ0uwkupURWFXrvsD75TE-GlltfbrpVNqoabgmsrc,6679
+sr/robot3/power_board.py,sha256=3Skbc7kmG1pr2K6n94POkMOXT4jzbOiYCz2cb60CWv8,17734
+sr/robot3/py.typed,sha256=dXL7b_5DnfZ_09rOcxu7D-0rT56DRm26uGUohPJOPQc,94
+sr/robot3/raw_serial.py,sha256=rdh0lyS9tJDyHbAZKyJSO8lKvdJ3-_iZzvmUSOdbo08,7368
+sr/robot3/robot.py,sha256=cqUrPFver_yAjdTPBLqPjsoliSuNdiHn7RGrpXLsuMA,15888
+sr/robot3/serial_wrapper.py,sha256=CDRVFbIILf4ahiToIHrVf02hz_GXpFeazDHdw3rGgX0,9327
+sr/robot3/servo_board.py,sha256=1GppUoqdx9wUA551bO95dEbtCGdzS10twv8OZ3S6t8U,12505
+sr/robot3/timeout.py,sha256=qBPCOwnOW9h0fLnL-peraO9RsaKWc92TcTYNgyTzo_g,2678
+sr/robot3/utils.py,sha256=dA2WyB73hnw41jLkOpk6ail7mfrW3oxKU0KrpQuHv1Y,9146
+sr/robot3/calibrations/__init__.py,sha256=TTL-lkU5tj3EszSEInRTftNvX5rsMyRUSHf12RlJ4QY,130
+sr/robot3/simulator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sr/robot3/simulator/camera.py,sha256=thenTnlyHzHrosUg9juUSfYCs2U4dfkS7vFoto1b3_k,3138
+sr/robot3/simulator/time_server.py,sha256=MwFJM7p3vqf4balmGwIMXcCLBVJQgnq2X4gY_agalwc,2859
+sr_robot3-2025.0.0.dist-info/LICENSE,sha256=d9EjkBp2jG1JOJ3zKfKRwBtPe1nhh1VByrw4iH3A9WA,1101
+sr_robot3-2025.0.0.dist-info/METADATA,sha256=iQFR8uEwpNe7S497QqT56Pash4wDEbw2Ud0V7K6ZjJY,5322
+sr_robot3-2025.0.0.dist-info/WHEEL,sha256=UvcQYKBHoFqaQd6LKyqHw9fxEolWLQnlzP0h_LgJAfI,91
+sr_robot3-2025.0.0.dist-info/top_level.txt,sha256=XFzWuC7umCVdV-O6IuC9Rl0qehvEC-U34M9WJ2-2h3E,3
+sr_robot3-2025.0.0.dist-info/RECORD,,

{sr_robot3-2024.0.0rc2.dist-info → sr_robot3-2025.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: setuptools (74.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

sr_robot3-2024.0.0rc2.dist-info/RECORD

@@ -1,26 +0,0 @@
-sr/robot3/__init__.py,sha256=lW7j65ruMEkRNJjZzp8929TefPMaMhqXzpsGPJqMkRs,1476
-sr/robot3/_version.py,sha256=SXjMGAhD6YctTnTcwOWelhbWC-EouEhUcdYCxGBqZ-s,169
-sr/robot3/arduino.py,sha256=sz-9AAg649Spp70sit3GwrwvDhsMfAM7yv94Dgg3gfM,14362
-sr/robot3/astoria.py,sha256=dyrK_vMFHl9F-E9sXgDGNbuW3SLcTCQzNgu_-d7uB0Q,8435
-sr/robot3/camera.py,sha256=UKvJFLGVptZLquNpGne34AaEnqw07CpH8C-gaxPdUrQ,6621
-sr/robot3/exceptions.py,sha256=A8cpuvFaIFazWSrp9QNts9ikINWymgoGALv4JAL-SU8,1381
-sr/robot3/game_specific.py,sha256=X8vLUbTRdNPZEggC6LxZzaNb9oqMly8-3PyQoD3B1ho,282
-sr/robot3/kch.py,sha256=uPdzxdbFxCS0F7UdkUsIuh7xXyKs8Jw4QpHBeVw_k-U,5413
-sr/robot3/logging.py,sha256=QHvdxWieSyQcu2pKpjG6ur3A8BWGwDia4h3lOjBKDZ4,3447
-sr/robot3/marker.py,sha256=FDRWl-tNN7xeRnlQLRitjumuligJmVxa2Mr49n1YurE,4886
-sr/robot3/motor_board.py,sha256=qfwbchUdfdZoSfeTwNuG24GR2cCmo_5vdFSkQtPIQxk,10109
-sr/robot3/mqtt.py,sha256=6JQdPlx1LpVE1g_n2hbQ2vAOUKwWrtNcZlH-F_q-0Lc,6300
-sr/robot3/power_board.py,sha256=tKBwuqDqqc_N0jdOxBstHe_eoZ1glOTv1eEuV_1287k,16213
-sr/robot3/py.typed,sha256=dXL7b_5DnfZ_09rOcxu7D-0rT56DRm26uGUohPJOPQc,94
-sr/robot3/raw_serial.py,sha256=nXNdaPfPL7l9dznkuaniRjb8EYnE4_wsQPi7dESxUXE,4876
-sr/robot3/robot.py,sha256=iPvbvFFamZe1x0ebgUqsTHmlKUEr3MZoGHuzAD4Pqdo,13239
-sr/robot3/serial_wrapper.py,sha256=iBN9GvOQdxPSz3LO3Mqxoskm7wltN7YeiORg_yIV0jQ,8832
-sr/robot3/servo_board.py,sha256=EUTxCXq79wGWK2CAmc3nzviGBeJpNq1F_wz-CX2FKmY,11234
-sr/robot3/timeout.py,sha256=QA-Rer05wl1wnt4hKVXwlMnMAsyaqTvcLTU7dmrr6IE,1843
-sr/robot3/utils.py,sha256=tpLVRVEC_6nBdiBxecSDgLmExy6_bLhrJKkMPrN2vew,7936
-sr/robot3/calibrations/__init__.py,sha256=TTL-lkU5tj3EszSEInRTftNvX5rsMyRUSHf12RlJ4QY,130
-sr_robot3-2024.0.0rc2.dist-info/LICENSE,sha256=d9EjkBp2jG1JOJ3zKfKRwBtPe1nhh1VByrw4iH3A9WA,1101
-sr_robot3-2024.0.0rc2.dist-info/METADATA,sha256=GhMKUBWNH2otMOa7laLSTndBVeX3J9OITfv2QWkJJxY,5180
-sr_robot3-2024.0.0rc2.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-sr_robot3-2024.0.0rc2.dist-info/top_level.txt,sha256=XFzWuC7umCVdV-O6IuC9Rl0qehvEC-U34M9WJ2-2h3E,3
-sr_robot3-2024.0.0rc2.dist-info/RECORD,,