Software-Setup

SDK-Installation

Die Steuerung des VLAI L1 erfolgt über roboticscenter Python SDK, das sowohl High-Level-Task-APIs als auch Low-Level-Joint-Control bereitstellt. Installieren Sie es auf Ihrem Host-PC.

Erstellen Sie eine virtuelle Umgebung

python -m venv ~/.venvs/vlai
source ~/.venvs/vlai/bin/activate

Installieren Sie das SDK

pip install roboticscenter[l1]

Überprüfen Sie die Installation

python -c "from roboticscenter import L1; print('SDK OK')"
rc --version   # command-line tool

Verbindung zum L1

Der L1 führt seinen eigenen integrierten ROS2-Stack aus und stellt eine gRPC-Steuerungs-API über Ihr lokales Netzwerk bereit. Ihr Host-PC kommuniziert mit ihm über WLAN oder Ethernet.

Erstmalige Netzwerkeinrichtung

# Power on the L1 — it will connect to the configured WiFi automatically
# Then discover it on your network:
rc discover
# Output: L1-XXXX found at 192.168.1.45 (port 8888)

Verbinden und überprüfen

rc connect --device l1 --host 192.168.1.45
# Output: Connected to VLAI L1 (firmware v2.1.4, battery: 87%)

# Or use the Python SDK:
from roboticscenter import L1

robot = L1(host="192.168.1.45")
robot.connect()
print(robot.get_status())
# {'battery': 87, 'arm_left': 'ready', 'arm_right': 'ready', 'base': 'ready'}
robot.disconnect()

Legen Sie eine statische IP fest (empfohlen für den Laborgebrauch)

rc config set network.static_ip 192.168.1.100
rc config set network.gateway 192.168.1.1
rc config apply   # reboots the L1 network stack

ROS2 mit MoveIt2 Dual-Arm-Steuerung

Der L1 wird mit integriertem ROS2 Humble ausgeliefert. Ihr Host-PC verbindet sich als ROS2-Knoten über dasselbe Netzwerk. Sie benötigen ROS2 Humble auf Ihrem Host.

ROS2 Humble auf dem Host installieren (Ubuntu 22.04)

sudo apt update && sudo apt install ros-humble-desktop \
  ros-humble-moveit ros-humble-ros2-control \
  ros-humble-ros2-controllers -y

Starten Sie die L1 ROS2-Brücke

# On the L1 (via SSH or the onboard terminal):
ros2 launch vlai_l1_ros2 l1_bringup.launch.py

# On your host PC:
source /opt/ros/humble/setup.bash
export ROS_DOMAIN_ID=42   # must match the L1's domain ID
ros2 topic list   # should show /l1/left_arm/joint_states, etc.

Zweiarmige MoveIt2-Planung

source /opt/ros/humble/setup.bash
ros2 launch vlai_l1_moveit l1_moveit.launch.py

# In another terminal — plan and execute a bimanual task:
ros2 run vlai_l1_moveit bimanual_demo
# Executes: left arm picks object, right arm receives and places

Individuelle Armsteuerung über Python

from roboticscenter import L1
import numpy as np

robot = L1(host="192.168.1.45")
robot.connect()

# Move left arm to Cartesian pose (position + quaternion)
pose = {
    "position": [0.4, 0.1, 0.35],    # x, y, z in meters from base
    "orientation": [0, 0, 0, 1]      # quaternion xyzw
}
robot.left_arm.move_to_pose(pose, speed=0.3)

# Read current joint state
state = robot.left_arm.get_joint_state()
print("Left arm joints:", state.positions)  # 8 values in radians

robot.disconnect()

Mobile Basissteuerung

aus roboticscenter import L1 robot = L1(host="192.168.1.45") robot.connect() # Fahren Sie 1 Meter mit 0,5 m/s vorwärts robot.base.move(x=1.0, y=0.0, speed=0.5) # Um 90 Grad im Uhrzeigersinn drehen robot.base.rotate(angle=-90, speed=0.3) # Grad # Hubhöhe einstellen (106 bis 162 cm) robot.base.set_lift_height(130) # cm # Stopp robot.base.stop() robot.disconnect()

Browser-Teleoperationspanel

Der L1 verfügt über ein integriertes Browser-Teleop-Panel – keine Softwareinstallation erforderlich. Navigieren Sie zur IP des L1 auf Port 8888.

Greifen Sie auf das Panel zu

# Open in browser:
http://192.168.1.45:8888

# Or launch via CLI:
rc teleop --device l1

Das Gremium bietet:

• WASD-Tastatursteuerung für mobile Basis
• Kartesischer Joystick für den linken/rechten Arm (Klicken und Ziehen im 3D-Ansichtsfenster)
• Tasten zum Öffnen/Schließen des Greifers
• Kamerafeed von allen montierten Kameras
• Episodenaufzeichnung mit einem Klick starten/stoppen
• Batterie- und gemeinsame Statusanzeige

VR-Teleop (Developer Pro und Max)

rc teleop --device l1 --mode vr
# Opens a WebXR session — put on Meta Quest and visit the displayed URL

Integration von Vision-Sprache-Aktionsmodellen

Die L1 Developer Pro- und Max-Stufen umfassen integrierte Rechenleistung, mit der VLA-Inferenz lokal ausgeführt werden kann. Für alle Ebenen können Sie VLA-Inferenz auf einem Host-PC ausführen und Aktionen an den Roboter streamen.

Führen Sie OpenVLA auf dem Host-PC aus (beliebige Stufe)

pip install roboticscenter[vla] aus roboticscenter import L1 aus roboticscenter.vla OpenVLAClient importieren robot = L1(host="192.168.1.45") robot.connect() vla = OpenVLAClient( model="openvla/openvla-7b", device="cuda" # oder "cpu" für langsamere Inferenz ) # Beobachtung erfassen obs = robot.capture_observation() # gibt RGB-Bild + Gelenkstatus zurück # Aktion von VLA abrufen (textbedingt) action = vla.predict( image=obs["image"], Anweisung = „Nimm den blauen Block und lege ihn auf den roten Teller“ ) # Aktion: Diktat der Armgelenkdeltas + Greiferbefehl # Aktion am Roboter ausführen robot.execute_action(Aktion) robot.disconnect()

VLA-Inferenz auf dem Gerät (Developer Pro/Max)

rc deploy vla \
  --model openvla/openvla-7b \
  --quantize int4   # fits in 6GB VRAM on V3 compute (70 TOPS)

# Now VLA runs on the L1's onboard compute — no host PC needed:
rc run policy \
  --task "Pick up the blue block and place it on the red plate" \
  --max_steps 50

Häufige Probleme

# Try direct connection by IP if you know it:
rc connect --device l1 --host 192.168.1.45

# Or connect the L1 via Ethernet directly to your laptop:
# Set your laptop to 192.168.2.1/24, L1 will appear at 192.168.2.100

# Check reachability first:
from roboticscenter import L1
robot = L1(host="192.168.1.45")
robot.connect()
reachable = robot.left_arm.check_pose_reachable(
    position=[0.4, 0.1, 0.35])
print("Reachable:", reachable)  # if False, adjust target pose
robot.disconnect()