nextwheel 0.2.1a1__py3-none-any.whl

nextwheel/__init__.py

@@ -0,0 +1,1169 @@
+# Copyright 2023 NextWheel Developers
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Provides the NextWheel class that fetches data from an intrumented wheel."""
+
+import json
+import os
+import socket
+import struct
+import threading
+from enum import IntEnum
+from time import time as get_current_time
+from typing import Any
+
+import numpy as np
+import requests
+from requests.exceptions import ConnectTimeout
+
+try:
+    from kineticstoolkit import TimeSeries  # type: ignore
+except ModuleNotFoundError:
+
+    class TimeSeries:  # type: ignore
+        """Object similar to the Kinetics Toolkit TimeSeries class."""
+
+        def __init__(
+            self,
+            time: list[float] | np.ndarray | None = None,
+            data: dict[str, np.ndarray] | None = None,
+            info: dict[str, dict[str, Any]] | None = None,
+        ):
+            self.time = time if time is not None else []
+            self.data = data if data is not None else {}
+            self.info = info if info is not None else {}
+
+        def __str__(self):
+            return "Object with attributes time and data"
+
+        def __repr__(self):
+            return "Object with attributes time and data"
+
+
+# Constants
+
+GRAVITY = 9.80665
+STANDARD_MAG_RANGE = 2500
+HTTP_RESPONSE_CODE_OK = 200
+HTTP_RESPONSE_CODE_BAD_REQUEST = 400
+DEFAULT_UDP_PORT = 12345
+UDP_RECEIVE_BUFFER_SIZE = 65535
+UDP_SOCKET_TIMEOUT = 0.2  # s, delay to notice that streaming was stopped
+ENCODER_RESOLUTION = 0.087890625 / 180 * np.pi  # rad per tick
+
+
+class FrameType(IntEnum):
+    """Identify frame type from a UDP datagram or a dat file."""
+
+    CONFIG = 1
+    ADC = 2
+    IMU = 3
+    POWER = 4
+    ENCODER = 7
+    SUPERFRAME = 255
+
+
+class GlobalConfig:
+    """
+    Global configuration of the instrumented wheel.
+
+    This is be used to store the current configuration and calculate
+    conversions from raw data.
+    """
+
+    def __init__(self):
+        # IMU CONFIG
+        self.accel_range = 16
+        self.gyro_range = 2000
+        self.mag_range = STANDARD_MAG_RANGE
+        self.imu_sampling_rate = 240
+        self.adc_sampling_rate = 240
+        self.encoder_sampling_rate = 240
+
+        # ADC CONFIG
+        self.adc_rate = 240
+
+        # ENCODER CONFIG
+        self.encoder_rate = 240
+
+        # ACCORDING TO ADS8688 DATASHEET
+        self._adc_v_ref = 4.096
+        # ADC RANGING from [-5,5] V according to PCB design
+        self._adc_in_max = 1.25 * self._adc_v_ref
+        self._adc_in_min = -1.25 * self._adc_v_ref
+
+        # ACCORDING TO BMX160 DATASHEET
+        self._accel_mg_lsb_2g = 0.000061035
+        self._accel_mg_lsb_4g = 0.000122070
+        self._accel_mg_lsb_8g = 0.000244141
+        self._accel_mg_lsb_16g = 0.000488281
+        self._gyro_sensitivity_125dps = 0.0038110
+        self._gyro_sensitivity_250dps = 0.0076220
+        self._gyro_sensitivity_500dps = 0.0152439
+        self._gyro_sensitivity_1000dps = 0.0304878
+        self._gyro_sensitivity_2000dps = 0.0609756
+        self._mag_ut_lsb = 0.3
+
+    def convert_adc_int_to_volts(self, values: np.ndarray) -> np.ndarray:
+        """
+        Convert ADC values from ADC integers to volts.
+
+        Parameters
+        ----------
+        values
+            ADC outputs (integer).
+
+        Returns
+        -------
+        np.ndarray
+            ADC inputs in volts.
+
+        """
+        # This is according to the 86888 datasheet
+        return (
+            values * (self._adc_in_max - self._adc_in_min) / 65535
+            + self._adc_in_min
+        )
+
+    def convert_accel_int_to_m_s2(self, values: np.ndarray) -> np.ndarray:
+        """
+        Convert acceleration values from integers to m/s2.
+
+        Parameters
+        ----------
+        values
+            Integers as reported by the sensor.
+
+        Returns
+        -------
+        np.ndarray
+            Acceleration in m/s2.
+
+        """
+        factor = {
+            2: self._accel_mg_lsb_2g * GRAVITY,
+            4: self._accel_mg_lsb_4g * GRAVITY,
+            8: self._accel_mg_lsb_8g * GRAVITY,
+            16: self._accel_mg_lsb_16g * GRAVITY,
+        }
+
+        try:
+            return values * factor[self.accel_range]
+        except KeyError as exc:
+            raise ValueError("Invalid accel range") from exc
+
+    def convert_gyro_int_to_deg_s(self, values: np.ndarray) -> np.ndarray:
+        """
+        Convert gyro values from integers to deg/s.
+
+        Parameters
+        ----------
+        values
+            Integers as reported by the sensor.
+
+        Returns
+        -------
+        np.ndarray
+            Angular velocity in m/s2.
+
+        """
+        factor = {
+            125: self._gyro_sensitivity_125dps,
+            250: self._gyro_sensitivity_250dps,
+            500: self._gyro_sensitivity_500dps,
+            1000: self._gyro_sensitivity_1000dps,
+            2000: self._gyro_sensitivity_2000dps,
+        }
+
+        try:
+            return values * factor[self.gyro_range]
+        except KeyError as exc:
+            raise ValueError("Invalid gyro range") from exc
+
+    def convert_mag_values(self, values: np.ndarray) -> np.ndarray:
+        """
+        Convert magnetometer integers to uT.
+
+        Parameters
+        ----------
+        values
+            Integers as reported by the sensor.
+
+        Returns
+        -------
+        np.ndarray
+            Magnetic field in uT.
+
+        """
+        if self.mag_range == STANDARD_MAG_RANGE:
+            return values * self._mag_ut_lsb
+
+        raise ValueError("Invalid mag range")
+
+    def convert_encoder_values(self, values: np.ndarray) -> np.ndarray:
+        """
+        Convert encoder ticks to radians.
+
+        Parameters
+        ----------
+        values
+            Integers as reported by the sensor.
+
+        Returns
+        -------
+        np.ndarray
+            Angle in radians.
+
+        """
+        return values * ENCODER_RESOLUTION
+
+
+class NextWheel:
+    """
+    Communicate with the instrumented wheel.
+
+    The class permit to communicate with the instrumented wheel with 3 methods:
+        - NextWheel.start_streaming() asks the wheel to stream its data over
+        UDP and starts receiving it in a background thread.
+        - NextWheel.fetch() return the streamed data in a nested dictionary
+        with all the usefull informations.
+        - NextWheel.stop_streaming() stops the stream.
+    It needs an IP address like in the example below.
+
+    The wheel sends its data to the UDP address and port given to
+    NextWheel.start_streaming() (by default, broadcast 255.255.255.255 on
+    port 12345). Use a different port for each wheel to reduce network load
+    on each receiver. The local firewall must accept incoming UDP datagrams
+    on this port.
+
+    Raises
+    ------
+    TimeoutError
+        When ip.setter cannot connect to the wheel.
+
+
+    Exemple
+    -------
+    >>> from nextwheel import NextWheel
+    >>> nw = NextWheel("196.168.1.254")
+    >>> nw.start_streaming()
+
+    >>> print(nw.fetch())
+
+    >>> nw.stop_streaming()
+
+    """
+
+    def __init__(
+        self,
+        ip: str = "",
+        *,
+        port: int = 80,
+        debug: bool = False,
+    ):
+        # General configuration
+        self.max_imu_samples = 0
+        self.max_analog_samples = 0
+        self.max_encoder_samples = 0
+        self.max_power_samples = 0
+        self._config = GlobalConfig()
+        self._debug = debug
+        self.has_calibration_matrix = False
+        self.calibration_matrix: np.ndarray = np.eye(6)
+        self.calibration_offset: np.ndarray = np.zeros(6)
+
+        # Communication stuff (port must be set before ip, which connects)
+        self.port = port
+        self.ip = ip
+        self._udp_socket: None | socket.socket = None
+        self._udp_thread: None | threading.Thread = None
+        self._stop_event = threading.Event()
+        self._mutex = threading.Lock()
+        self._thread_is_running = False
+
+        # Data buffers. In these arrays, column 0 is the time
+        self._adc_values = []  # type: list[np.ndarray]
+        self._imu_values = []  # type: list[np.ndarray]
+        self._power_values = []  # type: list[np.ndarray]
+        self._encoder_values = []  # type: list[np.ndarray]
+
+    @property
+    def ip(self):
+        """Getter for ip property."""
+        return self._ip
+
+    @ip.setter
+    def ip(self, value):
+        """Setter for ip property."""
+        self._ip = value
+        if value == "":
+            return
+
+        try:
+            self.set_time(get_current_time())
+        except ConnectTimeout as e:
+            raise TimeoutError from e
+
+        # Calibration constants
+        self.file_download("calibration.json")
+        self._load_calibration("calibration.json")
+
+    def _load_calibration(self, filename="calibration.json"):
+        """Load calibration file if the file is found."""
+        try:
+            with open(filename, encoding="utf8") as json_file:
+                calibration = json.load(json_file)
+            self.calibration_matrix = np.array(calibration["Matrix"])
+            self.calibration_offset = np.array(calibration["Offset"])
+            self.has_calibration_matrix = True
+        except FileNotFoundError:
+            self.calibration_matrix = np.identity(6)
+            self.calibration_offset = np.zeros((6,))
+            self.has_calibration_matrix = False
+            print("No Calibration File Detected")
+
+    def _parse_message(self, stream: bytes, offset: int = 0) -> int:  # noqa PLR0911 Too many return statements (7 > 6)
+        """
+        Parse a series of bytes corresponding to a messages.
+
+        It only parses the first message from the stream, then returns the
+        position of the next message in the stream. If the received message
+        is a superframe, all messages from the superframe are parsed and
+        processed.
+
+        Parameters
+        ----------
+        stream
+            The received message or the data stored in the dat file.
+        offset
+            Start processing at this position in the stream.
+
+        Returns
+        -------
+        offset
+            The position of the next message in the stream.
+
+        """
+        if not isinstance(stream, bytes):
+            raise ValueError("stream must be bytes.")
+
+        if offset >= len(stream):
+            return offset
+
+        # Extract the type of message
+        frame_type, timestamp, data_size = struct.unpack(
+            "<BQB", stream[offset : offset + 10]
+        )
+        offset += 10
+        time = timestamp / 1e6
+
+        # Process the frame
+        if frame_type == FrameType.CONFIG:
+            # Config frame (should always be first)
+            data = stream[offset : offset + data_size]
+            offset += data_size
+
+            (
+                accel_range,
+                gyro_range,
+                mag_range,
+                imu_sampling_rate,
+                adc_sampling_rate,
+                encoder_sampling_rate,
+            ) = struct.unpack("<6I", data)
+
+            # Update configuration
+            self._config.accel_range = accel_range
+            self._config.gyro_range = gyro_range
+            self._config.mag_range = mag_range
+            self._config.imu_sampling_rate = imu_sampling_rate
+            self._config.adc_sampling_rate = adc_sampling_rate
+            self._config.encoder_sampling_rate = encoder_sampling_rate
+            return offset
+
+        if frame_type == FrameType.ADC:  # frame type of the ADC values
+            data = stream[offset : offset + data_size]
+            offset += data_size
+
+            self._adc_values.append(
+                np.hstack([[time], struct.unpack("<8H", data)])
+            )
+
+            if len(self._adc_values) > self.max_analog_samples:
+                self._adc_values.pop(0)
+            return offset
+
+        if frame_type == FrameType.IMU:  # frame type of the IMU
+            data = stream[offset : offset + data_size]
+            offset += data_size
+
+            self._imu_values.append(
+                np.hstack(
+                    [
+                        [time],
+                        self._config.convert_accel_int_to_m_s2(
+                            np.array(struct.unpack_from("<3h", data[:6]))
+                        ),
+                        self._config.convert_gyro_int_to_deg_s(
+                            np.array(struct.unpack_from("<3h", data[6:12]))
+                        ),
+                        self._config.convert_mag_values(
+                            np.array(struct.unpack_from("<3h", data[12:18]))
+                        ),
+                    ]
+                )
+            )
+
+            if len(self._imu_values) > self.max_imu_samples:
+                self._imu_values.pop(0)
+            return offset
+
+        if frame_type == FrameType.POWER:  # frame type of the POWER
+            data = stream[offset : offset + data_size]
+            offset += data_size
+
+            self._power_values.append(
+                np.hstack([[time], struct.unpack_from("<3fB", data)])
+            )
+
+            if len(self._power_values) > self.max_power_samples:
+                self._power_values.pop(0)
+            return offset
+
+        if frame_type == FrameType.ENCODER:  # frame type of the ENCODER
+            data = stream[offset : offset + data_size]
+            offset += data_size
+
+            self._encoder_values.append(
+                np.hstack(
+                    [
+                        [time],
+                        self._config.convert_encoder_values(
+                            np.array(struct.unpack_from("<q", data))
+                        ),
+                    ]
+                )
+            )
+
+            if len(self._encoder_values) > self.max_encoder_samples:
+                self._encoder_values.pop(0)
+            return offset
+
+        if frame_type == FrameType.SUPERFRAME:
+            for _ in range(data_size):  # data_size = number of frames
+                offset = self._parse_message(stream, offset)
+            return offset
+
+        raise ValueError(f"Received an unknown frame type: {frame_type}")
+
+    def _parse_datagram(self, datagram: bytes) -> None:
+        """
+        Parse all messages contained in a received UDP datagram.
+
+        Parameters
+        ----------
+        datagram
+            Information containing data in bytes.
+
+        """
+        offset = 0
+        with self._mutex:
+            while (
+                new_offset := self._parse_message(datagram, offset)
+            ) > offset:
+                offset = new_offset
+
+    def _receive_loop(self, udp_socket: socket.socket, wheel_ip: str) -> None:
+        """
+        Receive UDP datagrams from the wheel until streaming is stopped.
+
+        Parameters
+        ----------
+        udp_socket
+            Bound UDP socket with a timeout.
+        wheel_ip
+            Datagrams not coming from this address (e.g., from another wheel
+            broadcasting on the same port) are ignored.
+
+        """
+        while not self._stop_event.is_set():
+            try:
+                datagram, (sender_ip, _) = udp_socket.recvfrom(
+                    UDP_RECEIVE_BUFFER_SIZE
+                )
+            except TimeoutError:
+                continue
+            except OSError:
+                # Socket closed by stop_streaming
+                break
+
+            if sender_ip != wheel_ip:
+                continue
+
+            if self._debug:
+                print(f"Received {len(datagram)} bytes from {sender_ip}")
+
+            try:
+                self._parse_datagram(datagram)
+            except (ValueError, struct.error) as e:
+                # A corrupted datagram should not stop the stream
+                print("Invalid datagram received: ", e)
+
+    def _update_config_from_params(self, params: dict) -> None:
+        """Update the conversion configuration from get_sensors_params()."""
+        with self._mutex:
+            self._config.accel_range = params["accelerometer_precision"]
+            self._config.gyro_range = params["gyrometer_precision"]
+            self._config.imu_sampling_rate = params["imu_sampling_rate"]
+            self._config.adc_sampling_rate = params["adc_sampling_rate"]
+            self._config.encoder_sampling_rate = params[
+                "encoder_sampling_rate"
+            ]
+
+    def start_streaming(  # noqa: PLR0913
+        self,
+        address: str = "255.255.255.255",
+        port: int = DEFAULT_UDP_PORT,
+        *,
+        max_imu_samples: int = 1000,
+        max_analog_samples: int = 1000,
+        max_encoder_samples: int = 100,
+        max_power_samples: int = 10,
+    ):
+        """
+        Start streaming.
+
+        Parameters
+        ----------
+        address : str, optional
+            IP address (x.x.x.x) where the wheel sends the streamed data. The
+            default 255.255.255.255 broadcasts to the whole local network.
+            Using the IP address of this computer avoids broadcasting.
+        port : int, optional
+            UDP port where the wheel sends the streamed data, and where this
+            computer listens. The default is 12345.
+        max_imu_samples : int, optional
+            Maximum IMU data to keep in memory. The default is 1000.
+        max_analog_samples : int, optional
+            Maximum ADC data to keep in memory. The default is 1000.
+        max_encoder_samples : int, optional
+            Maximum encoder data to keep in memory. The default is 100.
+        max_power_samples : int, optional
+            Maximum Power data to keep in memory. The default is 10.
+
+        Returns
+        -------
+        None.
+
+        """
+        if self._thread_is_running:
+            return
+
+        self.max_imu_samples = max_imu_samples
+        self.max_analog_samples = max_analog_samples
+        self.max_encoder_samples = max_encoder_samples
+        self.max_power_samples = max_power_samples
+
+        # The config frame is only sent when streaming starts, which may have
+        # been done by another client. Get the current config from the REST
+        # API so that the data can be converted in any case.
+        params = self.get_sensors_params()
+        self._update_config_from_params(params)
+
+        udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        udp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        if hasattr(socket, "SO_REUSEPORT"):
+            # Allows several NextWheel instances to receive broadcasts on the
+            # same port.
+            udp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+        udp_socket.bind(("", port))
+        udp_socket.settimeout(UDP_SOCKET_TIMEOUT)
+        self._udp_socket = udp_socket
+
+        self._stop_event.clear()
+        self._udp_thread = threading.Thread(
+            target=self._receive_loop,
+            args=(udp_socket, socket.gethostbyname(self.ip)),
+            daemon=True,
+        )
+        self._udp_thread.start()
+        self._thread_is_running = True
+
+        if self._debug:
+            print(
+                "Listening on UDP port",
+                port,
+                "for data sent to",
+                address,
+            )
+
+        # Ask the wheel to start streaming. "Already streaming" means that
+        # another client started it (possibly to another destination), which
+        # is fine.
+        response = requests.get(
+            f"http://{self.ip}:{self.port}/start_streaming",
+            params={"address": address, "port": str(port)},
+        )
+        already_streaming = (
+            response.status_code == HTTP_RESPONSE_CODE_BAD_REQUEST
+            and "Already streaming" in response.text
+        )
+        if (
+            response.status_code != HTTP_RESPONSE_CODE_OK
+            and not already_streaming
+        ):
+            self.stop_streaming()
+            raise RuntimeError(
+                f"Could not start streaming: {response.status_code} "
+                f"{response.text}"
+            )
+
+    def stop_streaming(self):
+        """
+        Stop streaming.
+
+        Returns
+        -------
+        None.
+
+        """
+        if not self._thread_is_running:
+            return
+
+        try:
+            requests.get(f"http://{self.ip}:{self.port}/stop_streaming")
+        finally:
+            self._stop_event.set()
+            if self._udp_thread is not None:
+                self._udp_thread.join()
+                self._udp_thread = None
+            if self._udp_socket is not None:
+                self._udp_socket.close()
+                self._udp_socket = None
+            self._thread_is_running = False
+
+    def monitor(
+        self, address: str = "255.255.255.255", port: int = DEFAULT_UDP_PORT
+    ) -> None:
+        """
+        Blocking function that monitors the sensors measurements.
+
+        This function shows the current sensor states in a simple GUI
+        for testing and monitoring. To log data, use NextWheel.fetch()
+        instead. See start_streaming() for address and port.
+        """
+        # Don't import until needed.
+        import nextwheel.monitor as nwm  # noqa
+
+        self.start_streaming(address, port)
+        nwm.monitor(self)
+        self.stop_streaming()
+
+    def graphical_monitor(self) -> None:  # noqa because under development
+        """
+        Blocking function that monitors using Matplotlib.
+
+        Under development.
+        """
+        import matplotlib as mpl  # noqa
+        from cycler import cycler  # noqa
+        import matplotlib.pyplot as plt  # noqa
+        from matplotlib import animation  # noqa
+
+        is_running = [True]
+
+        def on_close(_):
+            is_running[0] = False
+
+        self.start_streaming()
+        plt.pause(0.5)
+
+        # Matplotlib defaults
+        mpl.rcParams["axes.prop_cycle"] = cycler(
+            color=["r", "g", "b", "c", "m", "y", "k", "tab:orange"]
+        )
+        mpl.rcParams["figure.figsize"] = [10, 5]
+        mpl.rcParams["figure.dpi"] = 75
+        mpl.rcParams["lines.linewidth"] = 1
+
+        # Create figure and plots
+        fig = plt.figure(figsize=(12, 8))
+        fig.canvas.mpl_connect("close_event", on_close)
+
+        adc_plot = plt.subplot(4, 1, 1)
+        adc_plot.set_title("Analogs")
+        adc_lines = []
+        for i in range(6):
+            adc_lines.append(adc_plot.plot([])[0])
+        adc_plot.set_xlim(0, self.max_analog_samples)
+        adc_plot.set_ylim(0, 65536)
+        adc_plot.set_ylabel("Raw channels")
+
+        accel_plot = plt.subplot(4, 1, 2)
+        accel_plot.set_title("Accelerometers")
+        accel_lines = []
+        for i in range(3):
+            accel_lines.append(accel_plot.plot([])[0])
+        accel_plot.set_xlim(0, self.max_imu_samples)
+        accel_plot.set_ylim(-20, 20)
+        accel_plot.set_ylabel("m/s2")
+
+        gyro_plot = plt.subplot(4, 1, 3)
+        gyro_plot.set_title("Gyrometers")
+        gyro_lines = []
+        for i in range(3):
+            gyro_lines.append(gyro_plot.plot([])[0])
+        gyro_plot.set_xlim(0, self.max_imu_samples)
+        gyro_plot.set_ylim(-1000, 1000)
+        gyro_plot.set_ylabel("deg/s")
+
+        encoder_plot = plt.subplot(4, 1, 4)
+        encoder_plot.set_title("Encoder")
+        encoder_line = encoder_plot.plot([])[0]
+        encoder_plot.set_xlim(0, self.max_encoder_samples)
+        encoder_plot.set_ylim(0, 4000)
+        encoder_plot.set_ylabel("radians")
+
+        plt.tight_layout()
+
+        def on_timer(_):
+            self._mutex.acquire()
+            adc_values = np.zeros((self.max_analog_samples, 9))
+            adc_values[-len(self._adc_values) :] = np.array(self._adc_values)
+
+            imu_values = np.zeros((self.max_imu_samples, 10))
+            imu_values[-len(self._imu_values) :] = np.array(self._imu_values)
+
+            encoder_values = np.zeros((self.max_encoder_samples, 2))
+            encoder_values[-len(self._encoder_values) :] = (
+                np.array(self._encoder_values) % 4000
+            )
+            self._mutex.release()
+
+            try:
+                for i in range(6):
+                    adc_lines[i].set_data(
+                        range(self.max_analog_samples), adc_values[:, i + 1]
+                    )
+            except ValueError:
+                pass
+
+            try:
+                for i in range(3):
+                    accel_lines[i].set_data(
+                        range(self.max_imu_samples), imu_values[:, i + 1]
+                    )
+
+                for i in range(3):
+                    gyro_lines[i].set_data(
+                        range(self.max_imu_samples), imu_values[:, i + 4]
+                    )
+            except ValueError:
+                pass
+
+            try:
+                encoder_line.set_data(
+                    range(self.max_encoder_samples), encoder_values[:, 1]
+                )
+            except ValueError:
+                pass
+
+        animation.FuncAnimation(
+            fig,
+            on_timer,  # type: ignore
+            interval=33,
+            cache_frame_data=False,
+        )  # 30 ips
+
+        while is_running[0]:
+            plt.pause(0.5)
+
+        self.stop_streaming()
+
+    def fetch(self, clear=False) -> dict[str, TimeSeries]:
+        """
+        Fetch data and return a nested dictionary. Clear the buffer.
+
+        Returns a dictionary of multiple TimeSeries, the dictionary having
+        these keys:
+        - Analog:
+            TimeSeries that corresponds to the ADC values, and that contains
+            these data:
+                "Channels": Nx6 raw uncalibrated voltage values as integers.
+                "Forces": Nx4 forces in newtons in the form [Fx, Fy, Fz, 0.0].
+                "Moments": Nx4 moments in Nm in the form [Mx, My, Mz, 0.0].
+            Forces and Moments are present only if a calibration matrix was
+            found.
+        - IMU:
+            TimeSeries that corresponds to the Inertial Measurement Unit, and
+            that contains these data:
+                "Acc": Nx4 acceleration in m/s2, in the form
+                    [acc_x, acc_y, acc_z, 0.0]
+                "Gyro": Nx4 angular speed in rad/s, in the form
+                    [w_x, w_y, w_z, 0.0]
+                "Mag": Nx4 magnetometer values, uncalibrated, in the form
+                    [mag_x, mag_y, mag_z, 0.0]
+        - Encoder:
+            TimeSeries that corresponds to the angular encoder, and that
+            contains this data:
+                "Angle": series of N angles in radians.
+        - Power:
+            TimeSeries that corresponds to the electric power meter, and that
+            contains these data:
+                "Voltage": series of N battery voltages in Volts.
+                "Current": series of N battery currents in Amperes.
+                "Power": series of N battery powers in Watts.
+
+        Parameters
+        ----------
+        clear
+            True to clear the buffer so that every call to fetch returns new
+            data. False to return the whole buffer, which size is set by the
+            arguments of NextWheel.start_streaming().
+
+        Returns
+        -------
+        data : dict[str, TimeSeries]
+            A dictionary of multiple TimeSeries described above.
+
+        """
+        self._mutex.acquire()
+
+        # Concatenate all samples in big numpy arrays
+        adc_values = np.array(self._adc_values)
+        imu_values = np.array(self._imu_values)
+        encoder_values = np.array(self._encoder_values)
+        power_values = np.array(self._power_values)
+
+        if len(adc_values) == 0:
+            adc_values = np.zeros((0, 7))
+        if len(imu_values) == 0:
+            imu_values = np.zeros((0, 10))
+        if len(encoder_values) == 0:
+            encoder_values = np.zeros((0, 2))
+        if len(power_values) == 0:
+            power_values = np.zeros((0, 4))
+
+        if clear:
+            # Reset the buffers
+            self._adc_values = []
+            self._imu_values = []
+            self._encoder_values = []
+            self._power_values = []
+
+        self._mutex.release()
+
+        if len(adc_values) > 0 and self.has_calibration_matrix:
+            calibrated_adc_values = (
+                np.dot(self.calibration_matrix, adc_values[:, 1:7].T).T
+                - self.calibration_offset
+            )
+        else:
+            calibrated_adc_values = adc_values
+
+        data = {}
+        data["Analog"] = TimeSeries(time=adc_values[:, 0])
+        data["Analog"].data["Channels"] = adc_values[:, 1:8]
+        data["Analog"].info["Channels"] = {"Unit": "raw"}
+        if self.has_calibration_matrix:
+            data["Analog"].data["Forces"] = np.zeros(
+                (calibrated_adc_values.shape[0], 4)
+            )
+            data["Analog"].data["Forces"][:, 0:3] = calibrated_adc_values[
+                :, 0:3
+            ]
+            data["Analog"].info["Forces"] = {"Unit": "N"}
+            data["Analog"].data["Moments"] = np.zeros(
+                (calibrated_adc_values.shape[0], 4)
+            )
+            data["Analog"].data["Moments"][:, 0:3] = calibrated_adc_values[
+                :, 3:6
+            ]
+            data["Analog"].info["Moments"] = {"Unit": "Nm"}
+
+        data["IMU"] = TimeSeries(
+            time=imu_values[:, 0],
+            data={
+                "Acc": imu_values[:, 1:4],
+                "Gyro": imu_values[:, 4:7],
+                "Mag": imu_values[:, 7:],
+            },
+            info={
+                "Acc": {"Unit": "m/s2"},
+                "Gyro": {"Unit": "rad/s"},
+                "Mag": {"Unit": "uncalibrated"},
+            },
+        )
+        data["Encoder"] = TimeSeries(
+            time=encoder_values[:, 0],
+            data={"Angle": encoder_values[:, 1]},
+            info={"Angle": {"Unit": "radians"}},
+        )
+        data["Power"] = TimeSeries(
+            time=power_values[:, 0],
+            data={
+                "Voltage": power_values[:, 1],
+                "Current": power_values[:, 2],
+                "Power": power_values[:, 3],
+            },
+            info={
+                "Voltage": {"Unit": "V"},
+                "Current": {"Unit": "A"},
+                "Power": {"Unit": "W"},
+            },
+        )
+        return data
+
+    def set_time(self, unix_time: int) -> None:
+        """
+        Set the time of the instrumented wheel.
+
+        Parameters
+        ----------
+        unix_time : int
+            Unix time in seconds.
+
+        Returns
+        -------
+        requests.Response
+
+        """
+        requests.post(
+            f"http://{self.ip}:{self.port}/config_set_time",
+            params={"time": unix_time},
+        )
+
+    def set_sensors_params(  # noqa: PLR0913
+        self,
+        adc_sampling_rate: int,
+        imu_sampling_rate: int,
+        encoder_sampling_rate: int,
+        accelerometer_precision: int,
+        gyrometer_precision: int,
+    ) -> requests.Response:
+        """
+        Set the parameters of the instrumented wheel.
+
+        Parameters
+        ----------
+        adc_sampling_rate
+            Sampling rate for the forces in Hz. Valid values are 120, 240,
+            480, 960, 1000, 2000
+        imu_sampling_rate
+            Sampling rate for the IMU, in Hz. Valid values are 60, 120, 240.
+        encoder_sampling_rate
+            Sampling rate for the encoder, in Hz. Valid values are 60, 120,
+            240.
+        accelerometer_precision
+            Accelerometer range, in g. Value values are 2, 4, 8, 16.
+        gyrometer_precision
+            Gyrometer range, in degrees per second. Valid values are 250, 500,
+            1000, 2000.
+
+        Returns
+        -------
+        requests.Response
+
+        """
+        params = {
+            "adc_sampling_rate": adc_sampling_rate,
+            "imu_sampling_rate": imu_sampling_rate,
+            "encoder_sampling_rate": encoder_sampling_rate,
+            "accelerometer_precision": accelerometer_precision,
+            "gyrometer_precision": gyrometer_precision,
+        }
+
+        response = requests.post(
+            f"http://{self.ip}:{self.port}/config_update", params=params
+        )
+        return response
+
+    def get_sensors_params(self) -> dict:
+        """
+        Get the parameters of the instrumented wheel sensors.
+
+        Returns
+        -------
+        dict
+            A dictionary in the form parameter:value.
+
+        """
+        response = requests.get(f"http://{self.ip}:{self.port}/config")
+        return json.loads(response.content)
+
+    def get_system_state(self) -> dict:
+        """
+        Get the system state of the instrumented wheel.
+
+        Returns
+        -------
+        dict
+            A dictionary in the form parameter:value
+
+        """
+        response = requests.get(f"http://{self.ip}:{self.port}/system_state")
+        return json.loads(response.content)
+
+    def get_ntp_time(self) -> dict:
+        """
+        Get the NTP time status of the instrumented wheel.
+
+        Returns
+        -------
+        dict
+            A dictionary with keys synced, server, time (epoch seconds),
+            local_time (ISO 8601), last_sync (epoch seconds) and
+            adjusting (remaining gradual correction in seconds).
+
+        """
+        response = requests.get(f"http://{self.ip}:{self.port}/ntp_time")
+        return json.loads(response.content)
+
+    def resync_ntp(self) -> None:
+        """
+        Request a new NTP synchronization on the instrumented wheel.
+
+        NTP is stopped after the next synchronization. Use get_ntp_time()
+        to check when last_sync is updated.
+
+        Returns
+        -------
+        None
+
+        """
+        requests.get(f"http://{self.ip}:{self.port}/ntp_resync")
+
+    def start_recording(self) -> None:
+        """
+        Start recording data on the instrumented wheel.
+
+        Returns
+        -------
+        None
+
+        """
+        requests.get(f"http://{self.ip}:{self.port}/start_recording")
+
+    def stop_recording(self) -> None:
+        """
+        Stop recording data on the instrumented wheel.
+
+        Returns
+        -------
+        None
+
+        """
+        requests.get(f"http://{self.ip}:{self.port}/stop_recording")
+
+    def file_list(self) -> dict:
+        """
+        Get the list of files on the instrumented wheel.
+
+        Returns
+        -------
+        dict
+
+        """
+        response = requests.get(f"http://{self.ip}:{self.port}/file_list")
+        return json.loads(response.content)
+
+    def file_download(self, filename: str, save_path: str = ".") -> int:
+        """
+        Download a file from the instrumented wheel.
+
+        Parameters
+        ----------
+        filename
+            The name of the file to download
+        save_path
+            Optional. Where to save the file. The default is the current
+            folder.
+
+        Returns
+        -------
+        int
+            The size of the file
+
+        """
+        param = {"file": filename}
+        response = requests.get(
+            f"http://{self.ip}:{self.port}/file_download",
+            params=param,
+            stream=True,
+        )
+        if response.status_code == HTTP_RESPONSE_CODE_OK:
+            with open(os.path.join(save_path, filename), "wb") as f:
+                f.write(response.content)
+                # Return size...
+                return f.tell()
+
+        # filed download
+        return 0
+
+    def file_delete(self, filename: str) -> None:
+        """
+        Delete a file from the instrumented wheel.
+
+        Parameters
+        ----------
+        filename
+            The name of the file to delete
+
+        Returns
+        -------
+        None
+
+        """
+        requests.get(
+            f"http://{self.ip}:{self.port}/file_delete",
+            params={"file": filename},
+        )
+
+
+def read_dat(filename: str, calibration_file: str | None = None) -> dict:
+    """
+    Read a dat file downloaded from the instrumented wheel.
+
+    Parameters
+    ----------
+    filename
+        The name of the local file to read.
+    calibration_file
+        Optional. The calibration.json file, as found on the wheel and
+        downloaded using NextWheel.file_download("calibration.json"). If not
+        provided, forces and moments are not reconstructed from channel values.
+
+    Returns
+    -------
+    dict
+        A dictionary with the same structure as given by NextWheel.fetch.
+
+    """
+    # Create a dummy wheel to parse the data
+    nw = NextWheel()
+    if calibration_file is not None:
+        nw._load_calibration(calibration_file)
+    nw.max_analog_samples = int(1e15)
+    nw.max_encoder_samples = int(1e15)
+    nw.max_imu_samples = int(1e15)
+    nw.max_power_samples = int(1e15)
+
+    offset = 0
+    with open(filename, "rb") as fid:
+        stream = fid.read()
+
+    while (new_offset := nw._parse_message(stream, offset)) > offset:
+        offset = new_offset
+
+    return nw.fetch()