SpaceMouse Teleoperations-Leitfaden: Einrichtung, Kalibrierung und Datenerhebung für Roboternutzung

[← Führer]

Wie man eine 3Dconnexion SpaceMouse für 6-DOF-Roboter-Teleoperation verwendet Fahrerinstallation, Achsenkartierung, Kalibrierung von Dead-Zones und Aufnahme von Demonstrationen im HDF5-Format für das Nachahmen des Lernens.

Warum SpaceMouse für Teleoperation?

Die 3Dconnexion SpaceMouse ist ein 6-DOF-Eingabegerät, das die Handbewegung in gleichzeitige Übersetzung (X, Y, Z) und Drehbefehle (Roll, Pitch, yaw) übersetzt.

• 6-DOF in einer Hand: Eine einzige SpaceMouse steuert alle sechs Freiheitsgraden eines Roboters-End-Effektors gleichzeitig. Keine Moduswechsel, keine Tastenkombinationen. Dies macht es zur intuitivsten Ein-Gerät-Telebetriebsoberfläche für die meisten Betreiber.
• ** Niedrige Eintrittskosten:** Der SpaceMouse Compact ($129) bietet den gleichen 6-DOF-Eingang wie Systeme, die 10-100x mehr kosten. Vergleichen Sie mit: Führer-Follower-Arme ($2.000-5.000), VR-Headsets ($500+ plus Controller), haptischen Geräten ($3.000+).
• Weit verbreitet in der Forschung: SpaceMouse Teleoperation wird in der Robomimic, MimicGen und Robosuite-Codebases verwendet und ist die Standardteleoperationsmethode für den DROID-Datensatz (500K+-Episoden). Wenn Sie Daten für [VLA-Feinabstimmung](T14] sammeln, sind SpaceMouse-Daten am besten mit bestehenden vor-Training-Datensätzen kompatibel.
• Kein Kalibrierungsdrift: Im Gegensatz zu VR-Controllern, die Raumskala-Tracking erfordern, ist ein SpaceMouse ein USB-Gerät, das nach der Freisetzung in das Zentrum zurückkehrt.
• ** Niedrige Betriebsermüdigkeit:** Das Gerät sitzt auf einem Schreibtisch. Die Hand des Betriebsnehmers ruht natürlich auf dem Knopf. Im Vergleich zum halten eines VR-Controllers in Armhöhe oder physisch bewegen eines Führers Arm, ist SpaceMouse Teleoperation deutlich weniger anstrengend für lange Datenerhebung Sitzungen.

Austrieb: SpaceMouse bietet kein Kraftfeedback (der Betreiber kann nicht spüren, was der Roboter berührt) und fehlt der positionale Intuitivität der Führer-Follower-Arme (wo der Führer-Arm die Position des Robots spiegelt). Für die allgemeine Pick-and-Place, die Umordnung von Objekten und die meisten Aufgaben der Manipulation von Tischplatten ist SpaceMouse der beste Preis-Leistungs-Kompromiss.

2. Hardware-Einstellung

SpaceMouse-Modelle

Model	Price	DOF	Buttons	Connection	Recommendation
SpaceMouse Compact	$129	6	2	USB	Best value. Use left button for gripper toggle, right for episode save.
SpaceMouse Pro	$299	6	15	USB	Extra buttons useful for multi-function teleop (speed presets, mode switching).
SpaceMouse Pro Wireless	$399	6	15	USB/BT	Wireless adds 2-5ms latency. USB mode recommended for data collection.
SpaceMouse Enterprise	$529	6	31	USB	Overkill for teleoperation. The extra buttons go unused.

** Unsere Empfehlung:** SpaceMouse Compact ($129) für die Einarm-Telebetrieb. Zwei SpaceMouse Compacts ($258 insgesamt) für die zweimanuelle Einrichtung. Das Pro bietet Komfort für 4 + Stunden Sitzungen, ist aber nicht zweimal so hoch wie für die meisten Teams. RCSV verwendet SpaceMouse Compact-Einheiten auf allen Sammelstationen.

Körperliche Einrichtung

• Stellen Sie die SpaceMouse auf eine stabile Oberfläche in Schreibtischhöhe direkt vor dem Betreiber
• Position des Roboterarms, der dem Betreiber sichtbar ist (direkte Sichtlinie bevorzugt gegenüber nur Kameraansicht)
• USB-Hobs vermeiden für geringste Latenz direkt mit dem Arbeitsplatz-Motherboard USB-Ports verbinden
• Überprüfen Sie, ob das Gerät auf Linux als T10 angezeigt wird: T11 sollte ein oder mehrere Geräte anzeigen

3. ROS2 Fahrerinstallation

Die T12-Bibliothek bietet eine reine Python-Schnittstelle für alle 3D-Verbindungsgeräte. Wir wickeln sie in einen ROS2-Knoten für die Integration mit Roboter-Steuerungsstacks.

Schritt 1: Installieren Sie die Pyspacemouse

# Install the library and its hidapi dependency
pip install pyspacemouse hidapi

# On Ubuntu, you also need the udev rules for non-root access
sudo tee /etc/udev/rules.d/99-spacemouse.rules <<'EOF'
SUBSYSTEM=="usb", ATTR{idVendor}=="256f", MODE="0666"
SUBSYSTEM=="hidraw", ATTRS{idVendor}=="256f", MODE="0666"
EOF
sudo udevadm control --reload-rules && sudo udevadm trigger

# Verify the device is detected
python3 -c "import pyspacemouse; print(pyspacemouse.list_devices())"

Schritt 2: Erstellen Sie den ROS2-Teleoperationsknoten

#!/usr/bin/env python3
"""spacemouse_teleop_node.py - ROS2 node for SpaceMouse teleoperation."""
import rclpy
from rclpy.node import Node
from geometry_msgs.msg import Twist
import pyspacemouse
import numpy as np

class SpaceMouseTeleop(Node):
    def __init__(self):
        super().__init__('spacemouse_teleop')

        # Parameters (tune these per-robot)
        self.declare_parameter('linear_scale', 0.15)   # m/s per unit
        self.declare_parameter('angular_scale', 0.3)    # rad/s per unit
        self.declare_parameter('dead_zone', 0.08)       # ignore below this
        self.declare_parameter('publish_rate', 50.0)     # Hz

        self.linear_scale = self.get_parameter('linear_scale').value
        self.angular_scale = self.get_parameter('angular_scale').value
        self.dead_zone = self.get_parameter('dead_zone').value
        rate = self.get_parameter('publish_rate').value

        # Publisher
        self.pub = self.create_publisher(Twist, 'spacemouse/twist', 10)
        self.timer = self.create_timer(1.0 / rate, self.timer_callback)

        # Open device
        success = pyspacemouse.open()
        if not success:
            self.get_logger().error('Failed to open SpaceMouse device')
            raise RuntimeError('SpaceMouse not found')
        self.get_logger().info('SpaceMouse connected successfully')

    def apply_dead_zone(self, value):
        """Apply dead zone and normalize."""
        if abs(value) < self.dead_zone:
            return 0.0
        sign = 1.0 if value > 0 else -1.0
        return sign * (abs(value) - self.dead_zone) / (1.0 - self.dead_zone)

    def timer_callback(self):
        state = pyspacemouse.read()

        msg = Twist()
        # SpaceMouse axes -> robot EEF frame
        # NOTE: axis mapping depends on your robot's base frame convention.
        # These defaults work for OpenArm 1 and ViperX with Z-up, X-forward.
        msg.linear.x = self.apply_dead_zone(state.y) * self.linear_scale
        msg.linear.y = self.apply_dead_zone(state.x) * -self.linear_scale
        msg.linear.z = self.apply_dead_zone(state.z) * self.linear_scale
        msg.angular.x = self.apply_dead_zone(state.roll) * self.angular_scale
        msg.angular.y = self.apply_dead_zone(state.pitch) * self.angular_scale
        msg.angular.z = self.apply_dead_zone(state.yaw) * self.angular_scale

        self.pub.publish(msg)

def main():
    rclpy.init()
    node = SpaceMouseTeleop()
    rclpy.spin(node)
    node.destroy_node()
    rclpy.shutdown()

if __name__ == '__main__':
    main()

Schritt 3: Start

# Terminal 1: Start the SpaceMouse node
ros2 run your_package spacemouse_teleop_node \
  --ros-args -p linear_scale:=0.15 -p angular_scale:=0.3 -p dead_zone:=0.08

# Terminal 2: Verify output
ros2 topic echo /spacemouse/twist

4. Achsenkartierung und Konfiguration

Die SpaceMouse liefert sechs Achsenwerte in ihrem eigenen Koordinatenrahmen. Ihr Roboter verwendet einen anderen Rahmen.

Gemeinsame Achsenkarten

SpaceMouse Axis	OpenArm 1	ViperX-300 / ALOHA	Franka Research 3
X (push/pull)	+Y (forward)	+X (forward)	+X (forward)
Y (left/right)	-X (right)	-Y (right)	+Y (left)
Z (up/down)	+Z (up)	+Z (up)	+Z (up)
Roll (tilt left/right)	+Roll	+Roll	+Roll
Pitch (tilt fwd/back)	+Pitch	+Pitch	-Pitch
Yaw (twist)	+Yaw	+Yaw	+Yaw

** Wie man seine Kartierung bestimmen kann:** Bewegen Sie die SpaceMouse-Knopf in jede Richtung einzeln, während Sie den Roboter beobachten. Bewegt sich der Roboter in die falsche Richtung, dann verweigern Sie diese Achse. Bewegt sich er auf der falschen Achse, tauschen Sie die Achse aus. Der Prozess dauert 5-10 Minuten und muss nur einmal pro Roboterkonfiguration durchgeführt werden.

5. Dead-Zone-Ausrichtung und Empfindlichkeit

Die SpaceMouse ist sehr empfindlich. Ohne das Filtern von Dead-Zone wird der Roboter abweichen, wenn die Hand des Betreibers auf der Knopf ruht.

# spacemouse_config.yaml - Per-axis configuration
spacemouse_teleop:
  ros__parameters:
    # Dead zone: ignore input below this threshold (0.0-1.0)
    # Higher = less drift, but less responsive to small movements
    dead_zone_translation: 0.08   # Good default for most operators
    dead_zone_rotation: 0.12      # Rotation is more sensitive; higher DZ needed

    # Scaling: how fast the robot moves per unit of SpaceMouse input
    # Start conservative (0.1), increase as operator gains confidence
    linear_scale_x: 0.15    # m/s - forward/backward
    linear_scale_y: 0.15    # m/s - left/right
    linear_scale_z: 0.10    # m/s - up/down (slower to prevent table crashes)
    angular_scale_roll: 0.25   # rad/s
    angular_scale_pitch: 0.25  # rad/s
    angular_scale_yaw: 0.30    # rad/s - wrist yaw is the most-used rotation

    # Smoothing: exponential moving average (0.0 = no smoothing, 0.95 = very smooth)
    # Smoothing reduces jitter but adds latency. 0.3-0.5 is a good range.
    smoothing_factor: 0.4

Ausgleichsverfahren:

1. Setzen Sie die Tode Zone auf 0,15 (konservativ). Lassen Sie die Knopfplatte los. Wenn der Roboter noch abläuft, erhöhen Sie die Tode Zone. Wenn nicht, verringern Sie um 0,02 Schritte, bis Sie den Mindestwert finden, der abläuft.
2. Setzen Sie die lineare Skala auf 0,10. Versuchen Sie, den Roboter 10 cm zu bewegen. Wenn es mehr als eine Sekunde dauert, erhöhen Sie. Wenn der Roboter zu schnell bewegt, um ihn zu steuern, reduzieren Sie. Ziel: 0,5-1.0 Sekunden für eine 10 cm Bewegung.
3. Setzen Sie die Winkel-Skala auf 0,20 und versuchen Sie, den End-Effektor 45 Grad zu drehen.
4. Setzen Sie die Glässlichkeit auf 0,4. Wenn die Bewegungen sich drückend anfühlen, erhöhen Sie sie.

6. Integration mit OpenArm 1

Die [OpenArm 1]T15) verwendet Damiao-Aktuatoren mit einem CAN-Bus-Schnittstelle. Die SpaceMouse-Twist-Befehle werden in End-Effektor-Geschwindigkeitsziele umgewandelt, die ein inverser Kinematik (IK) -Lösser in gemeinsame Geschwindigkeitsbefehle umgewandelt.

# openarm_spacemouse_teleop.py - Tested configuration for OpenArm 1
# Requires: openarm_sdk, pyspacemouse, numpy

import numpy as np
from openarm_sdk import OpenArm
from openarm_sdk.ik import DampedLeastSquaresIK
import pyspacemouse

# OpenArm-specific settings (tested at RCSV San Francisco lab)
OPENARM_CONFIG = {
    'axis_map': {
        'x': ('y', 1.0),      # SpaceMouse Y -> OpenArm +X (forward)
        'y': ('x', -1.0),     # SpaceMouse X -> OpenArm -Y (right)
        'z': ('z', 1.0),      # SpaceMouse Z -> OpenArm +Z (up)
        'roll': ('roll', 1.0),
        'pitch': ('pitch', 1.0),
        'yaw': ('yaw', 1.0),
    },
    'linear_scale': 0.12,     # m/s - OpenArm is precise; keep speed moderate
    'angular_scale': 0.25,    # rad/s
    'dead_zone': 0.08,
    'ik_damping': 0.05,       # Damped least-squares regularization
    'control_rate': 50,       # Hz - matches OpenArm servo rate
}

arm = OpenArm(port='/dev/ttyUSB0')
ik = DampedLeastSquaresIK(arm.urdf_path, damping=OPENARM_CONFIG['ik_damping'])
pyspacemouse.open()

print("SpaceMouse teleop active. Left button = toggle gripper. Right button = e-stop.")

try:
    while True:
        state = pyspacemouse.read()

        # Apply dead zone and scaling
        twist = np.zeros(6)
        for i, axis in enumerate(['x', 'y', 'z', 'roll', 'pitch', 'yaw']):
            raw = getattr(state, OPENARM_CONFIG['axis_map'][axis][0])
            raw *= OPENARM_CONFIG['axis_map'][axis][1]
            if abs(raw) < OPENARM_CONFIG['dead_zone']:
                raw = 0.0
            scale = OPENARM_CONFIG['linear_scale'] if i < 3 else OPENARM_CONFIG['angular_scale']
            twist[i] = raw * scale

        # IK solve: twist -> joint velocities
        current_joints = arm.get_joint_positions()
        joint_velocities = ik.solve(current_joints, twist)
        arm.set_joint_velocities(joint_velocities)

        # Button handling
        if state.buttons[0]:  # Left button -> toggle gripper
            arm.toggle_gripper()
        if state.buttons[1]:  # Right button -> emergency stop
            arm.stop()
            break

except KeyboardInterrupt:
    arm.stop()

7. Integration mit ViperX / ALOHA Setup

Für ViperX-300 und ALOHA integriert sich die SpaceMouse über den Interbotix SDK oder den ALOHA-Teleoperationsstack.

# Using the ALOHA codebase with SpaceMouse
cd ~/aloha
python3 scripts/teleop_spacemouse.py \
  --robot_config configs/viperx300s.yaml \
  --spacemouse_config configs/spacemouse_compact.yaml \
  --linear_scale 0.15 \
  --angular_scale 0.30 \
  --dead_zone 0.08

# For bimanual ALOHA with two SpaceMouse devices:
python3 scripts/teleop_spacemouse_bimanual.py \
  --left_device_id 0 \
  --right_device_id 1

Wenn Sie zwei SpaceMouse-Geräte für die zweimanuelle Teleoperation verwenden, markieren Sie sie physisch (Band, Aufkleber) und geben Sie ihnen konsistente Gerät-IDs zu.

# List connected SpaceMouse devices with serial numbers
python3 -c "
import pyspacemouse
devices = pyspacemouse.list_devices()
for d in devices:
    print(f'Name: {d.name}, Serial: {d.serial}, ID: {d.id}')
"

8. Aufnahme von Demonstrationen auf HDF5

Die Aufnahmeloute erfasst synchronisierte Kamera-Räume, gemeinsame Zustände, Aktionen und Sprachanmerkungen in HDF5-Dateien das Standardformat für Roboter-Lerndaten-Sets.

#!/usr/bin/env python3
"""record_episode.py - Record a teleoperation episode to HDF5."""
import h5py
import numpy as np
import time
from datetime import datetime

class EpisodeRecorder:
    def __init__(self, arm, cameras, save_dir='./episodes'):
        self.arm = arm
        self.cameras = cameras  # dict of {name: camera_object}
        self.save_dir = save_dir
        self.recording = False
        self.episode_data = None

    def start_episode(self, task_description=""):
        """Begin recording a new episode."""
        self.recording = True
        self.episode_data = {
            'joint_positions': [],
            'joint_velocities': [],
            'eef_pos': [],
            'eef_quat': [],
            'gripper_state': [],
            'actions': [],          # The twist commands sent to the robot
            'timestamps': [],
            'task_description': task_description,
        }
        # Add camera frame lists
        for cam_name in self.cameras:
            self.episode_data[f'camera_{cam_name}'] = []
        print(f"Recording started: '{task_description}'")

    def record_step(self, action_twist):
        """Record one timestep of data."""
        if not self.recording:
            return
        t = time.time()
        self.episode_data['joint_positions'].append(self.arm.get_joint_positions())
        self.episode_data['joint_velocities'].append(self.arm.get_joint_velocities())
        self.episode_data['eef_pos'].append(self.arm.get_eef_position())
        self.episode_data['eef_quat'].append(self.arm.get_eef_quaternion())
        self.episode_data['gripper_state'].append(self.arm.get_gripper_state())
        self.episode_data['actions'].append(action_twist)
        self.episode_data['timestamps'].append(t)
        for cam_name, cam in self.cameras.items():
            self.episode_data[f'camera_{cam_name}'].append(cam.get_frame())

    def save_episode(self):
        """Save the recorded episode to HDF5."""
        if not self.recording:
            return None
        self.recording = False
        n_steps = len(self.episode_data['timestamps'])
        if n_steps < 10:
            print(f"Episode too short ({n_steps} steps). Discarding.")
            return None

        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
        filepath = f"{self.save_dir}/episode_{timestamp}.hdf5"

        with h5py.File(filepath, 'w') as f:
            # Metadata
            f.attrs['task_description'] = self.episode_data['task_description']
            f.attrs['n_steps'] = n_steps
            f.attrs['timestamp'] = timestamp
            f.attrs['control_freq_hz'] = 50

            # State data
            f.create_dataset('joint_positions',
                data=np.array(self.episode_data['joint_positions'], dtype=np.float32))
            f.create_dataset('joint_velocities',
                data=np.array(self.episode_data['joint_velocities'], dtype=np.float32))
            f.create_dataset('eef_pos',
                data=np.array(self.episode_data['eef_pos'], dtype=np.float32))
            f.create_dataset('eef_quat',
                data=np.array(self.episode_data['eef_quat'], dtype=np.float32))
            f.create_dataset('gripper_state',
                data=np.array(self.episode_data['gripper_state'], dtype=np.float32))
            f.create_dataset('actions',
                data=np.array(self.episode_data['actions'], dtype=np.float32))
            f.create_dataset('timestamps',
                data=np.array(self.episode_data['timestamps'], dtype=np.float64))

            # Camera data (compressed)
            for cam_name in self.cameras:
                frames = np.array(self.episode_data[f'camera_{cam_name}'],
                                  dtype=np.uint8)
                f.create_dataset(f'camera_{cam_name}', data=frames,
                    compression='gzip', compression_opts=4)

        print(f"Saved episode: {filepath} ({n_steps} steps, "
              f"{n_steps/50:.1f}s)")
        return filepath

9. Tipps zur Datenqualität

Die hochwertigen Demonstrationen von SpaceMouse erzeugen reibungslose Politiken, die besser verallgemeinert werden.

• Die ersten Demonstrationen einer Sitzung sind immer schlimmer als die späteren.
• ** Bewegung langsam und reibungslos.** Geräuschreiche Bewegungen erzeugen lautere Aktionsetiketten. Wenn Sie eine schnelle Bewegung machen müssen, lassen Sie zuerst die Knopf (Nullgeschwindigkeit) los, dann reibungslos wieder ein. Zielen Sie 15-30 Sekunden Episoden für Pick-and-Place-Aufgaben.
• Variante Anfangsbedingungen. Zwischen Episoden, Randomize Objektposition (im Arbeitsraum), Objektorientierung und Robotern Startkonfiguration. Diese Variation ist wichtiger als Episodezahl für die Verallgemeinerung.
• Reset consistent. Verwenden Sie einen scripted reset, der den Roboter zwischen den Episoden zu einer festen Startposition zurückbringt.
• Anmerken Sie sofort. Schreiben Sie die Aufgabenbeschreibung vor oder während der Aufnahme, nicht nach.
• Sitzungsdauer: Begrenzen Sie die Sammelstunden auf 2 Stunden ohne Pause. Nach 2 Stunden verschlechtert die Ermüdung des Betreibers die Demonstrationsqualität messbar (Action jerk erhöht sich auf Basis interner RCSV-Benchmarks um 20-40%).

10. Umwandlung in RLDS / LeRobot Format

Nach der Aufnahme von HDF5-Episoden konvertieren Sie sie in RLDS- oder LeRobot-Format für VLA-Training:

# Convert HDF5 episodes to LeRobot format (for SmolVLA, ACT training)
# Requires: pip install lerobot

from lerobot.common.datasets.push_dataset_to_hub import hdf5_to_lerobot

hdf5_to_lerobot(
    raw_dir="./episodes/",           # Directory of HDF5 files
    repo_id="your-org/your-dataset", # Hugging Face Hub repo
    fps=50,
    video=True,                      # Encode camera frames as mp4
    push_to_hub=True,                # Upload to Hugging Face Hub
)

# Convert HDF5 to RLDS format (for OpenVLA fine-tuning)
# Requires: pip install tensorflow-datasets

python3 -m rlds_tools.hdf5_to_rlds \
  --input_dir ./episodes/ \
  --output_dir ./rlds_dataset/ \
  --dataset_name my_spacemouse_data \
  --action_key actions \
  --state_key joint_positions

11. Gemeinsame Probleme und Lösungen

SpaceMouse-Drift (Roboter bewegt sich, wenn Knopf freigesetzt wird)

Verursachen: Die tote Zone ist zu klein oder das Gerät hat eine leichte mechanische Verzerrung. Fix: Steigen Sie die tote Zone auf 0,10-0,15. Wenn der Drift anhält, kalibrieren Sie das Gerät: Entplücken, auf eine flache Oberfläche platzieren, wieder anlegen. Das Gerät kalibriert seine Zentrumposition automatisch bei der Aufschaltung.

Achsenumkehr (Roboter bewegt sich in entgegengesetzte Richtung)

** Ursache:** Axis Signal Mismatch zwischen SpaceMouse- und Roboterrahmen. Fix: Verweigern Sie die verletzende Achse in Ihrer Konfiguration. Bewegen Sie jede Achse einzeln und überprüfen Sie die Richtung.

USB-Anschluss während der Aufzeichnung

Ursache: Loser USB-Verbindung, USB-Hub-Strommanagement oder Betriebssystem, das das Gerät suspendiert. Fix:

# Disable USB autosuspend for 3Dconnexion devices
echo -1 | sudo tee /sys/bus/usb/devices/*/power/autosuspend_delay_ms

# Or permanently in /etc/udev/rules.d/99-spacemouse.rules:
ACTION=="add", SUBSYSTEM=="usb", ATTR{idVendor}=="256f", \
  TEST=="power/autosuspend_delay_ms", \
  ATTR{power/autosuspend_delay_ms}="-1"

Ein High Action-Dorp in den Aufnahmen

Ursache: Zu niedriger Glässungsfaktor oder unerfahrener Betriebsinhaber. Fix: Erhöhen Sie den Glässungsfaktor auf 0,5-0,6. Stellen Sie sicher, dass der Betriebsinhaber mindestens 30 Minuten Übung vor der Aufzeichnung der Produktionsdaten durchgeführt hat.

Zwei SpaceMouse-Geräte werden ausgetauscht

Ursache: Die Aufzählung der USB-Geräte ist nicht deterministisch. Fix: Verwenden Sie Seriennummern zur Identifizierung des Geräts (siehe Code in Abschnitt 7). Erstellen Sie eine udev-Regel, die konsistente Symlinks basierend auf der Seriennummer zugeordnet.

Verwandte Lesungen

• [Wie Roboter-Trainingdaten gesammelt werden (Full Guide) ]T17)
• [Start mit Teleoperation]
• [Bimanuelle Teleoperationshardware Einrichtung]
• [VLA Modelle Vergleich 2026] T20)
• [Physische KI im Jahr 2026]
• [OpenArm 1]
• [RCSV-Datendienstleistungen]

Sammeln von Teleoperationsdaten bei RCSV

SpaceMouse-Reichwerke sind bereits auf OpenArm, ViperX und DK1-Plattformen konfiguriert und kalibriert.

Erforschung der Datendienste Kontaktieren Sie uns