RC G1 Tactile Glove <unk> Linux Setup
Verwenden Sie die RC G1 Tactile Glove auf Ubuntu, Debian oder einem modernen Linux. Die GUI des Anbieters ist nur Windows/macOS.
Die GUI-Verbindung ist nur für Windows und macOS verfügbar. Auf Linux spricht man direkt über USB-Serie mit dem Handschuh, indem man ein dokumentiertes binäres Protokoll
Berührungsempfindung Gesamtzeit: ca. 45 Minuten Schwierigkeiten: Zwischenzeit aktualisiert Mai 2026
** getestet auf:** Ubuntu 22.04, Ubuntu 24.04, Debian 12, Fedora 40. Kernel 5.4 oder neuer hat den
Was Sie erreichen werden
Am Ende dieses Leitfaden haben Sie eine funktionierende Linux-Pipeline: Die Handschuh strömt über USB-Serie oder Bluetooth in ein stabiles
Voraussetzungen
- Hardware: RC G1 Touch Glove, Datenübernahmemodul (geladen), USB-A Bluetooth-Dongle or USB-A zu USB-C-Kabel.
- OS: jede Linux-Distribution auf Kernel 5.4 oder neuerer. Dieser Leitfaden ist gegen Ubuntu 22.04 / 24.04, Debian 12 und Fedora 40 geschrieben.
- Fähigkeiten: Komfortabel mit der Schale,
T20 , und kurzes Python lesen.
Die Schritte
- Bestätigen Sie, dass der Kernel-Treiber vorhanden ist
Moderne Linux-Kernel (5.4+) bundeln
```bash
dmesg | tail -20
```
Sie sollten eine Zeile sehen wie:
```bash
[ 1234.567890] usb 1-2: ch341-uart converter now attached to ttyUSB0
```
Wenn Sie es nicht sehen, installieren Sie das zusätzliche Modulpaket:
```bash
# Ubuntu / Debian
sudo apt install -y linux-modules-extra-$(uname -r)
# Fedora
sudo dnf install kernel-modules-extra
```
Dann trennen Sie das USB-Chip ab, wieder anlegen und überprüfen Sie
- Fügen Sie sich zur Dialoggruppe hinzu
Auf Debian und Ubuntu gehört das Seriengerät
```bash
sudo usermod -aG dialout $USER
```
Dann log out und log back in, oder laufen
```bash
serial.serialutil.SerialException: [Errno 13] Permission denied: '/dev/ttyUSB0'
```
Auf Fedora ist die gleichwertige Gruppe
- Installieren Sie eine deterministische Udev-Regel (optional, aber empfohlen)
Ohne eine udev-Regel zugeordnet der Kernel
```bash
sudo tee /etc/udev/rules.d/99-rc-g1-glove.rules >/dev/null <<'EOF'
# RC G1 Tactile Glove — CH340 serial (WCH 1a86:7523)
SUBSYSTEM=="tty", ATTRS{idVendor}=="1a86", ATTRS{idProduct}=="7523", MODE="0660", GROUP="dialout", SYMLINK+="rc-g1-glove-%n"
EOF
```
Umladen Sie die Regeln:
```bash
sudo udevadm control --reload-rules && sudo udevadm trigger
```
Jetzt erscheint Ihr Gerät als
Paare über Bluetooth mit BlueZ (optional Path)
Wenn Sie lieber den drahtlosen Dongle als ein USB-Kabel verwenden möchten, schließen Sie den Dongle in
```bash
sudo apt install -y screen
screen /dev/rc-g1-glove-0 921600
```
Innerhalb der
```bash
AT+SCAN=1
# → +SCAN=2,3C8A1F2E9A36,-1,23,JQ-RH_3C:8A:1F:2E:9A:36 ← copy this MAC
AT+CONN=3C8A1F2E9A36
# → OK (and then binary sensor data starts streaming — exit screen with Ctrl-A k)
```
Die Firmware gibt eine von
** BlueZ Hinweis:** Sie brauchen nicht
- Installieren Sie Python-Abhängigkeiten
Die Installation funktioniert im ganzen System, aber ein virtueller V hält die Dinge ordentlich:
```bash
python3 -m venv ~/.venv/rc-g1
source ~/.venv/rc-g1/bin/activate
pip install pyserial numpy
```
Wenn Sie eine Systeminstallation bevorzugen:
```bash
python3 -m pip install --user pyserial numpy
```
Python 3.9 oder neuer ist erforderlich.
- Schreiben Sie dem Leser
Erstellen Sie
```python
#!/usr/bin/env python3
"""Minimal serial reader for the RC G1 Tactile Glove.
Frame format (per vendor protocol spec, v1.2):
[Header 4B: 0xAA 0x55 0x03 0x99]
[Packet seq 1B: 0x01 or 0x02]
[Sensor type 1B: 0x01=LH, 0x02=RH, 0x03=LF, 0x04=RF, 0x05=WB]
[Payload]
seq 0x01: 128 bytes — first 128 of 256 raw pressure values (8-bit ADC each)
seq 0x02: 144 bytes — last 128 pressure values + 16 bytes IMU (4 floats: w, x, y, z quaternion)
Two packets together = one full frame (256 pressure points, of which 162 are physically wired
to fabric sensors; the remaining slots read ~0 and can be masked). Wired streaming = 100 Hz,
Bluetooth = 30 Hz.
"""
import argparse, struct, sys, time
import serial
import numpy as np
HEADER = b"\xAA\x55\x03\x99"
SENSOR_NAMES = {0x01: "LH", 0x02: "RH", 0x03: "LF", 0x04: "RF", 0x05: "WB"}
def read_frame(port: serial.Serial):
# Sync to header
buf = b""
while True:
buf += port.read(1)
if buf.endswith(HEADER):
break
if len(buf) > 4096:
raise IOError("lost sync — no header in 4 KB")
seq, sensor = port.read(1), port.read(1)
if not seq or not sensor:
raise IOError("short read on header trailer")
seq, sensor = seq[0], sensor[0]
payload_len = 128 if seq == 0x01 else 144
payload = port.read(payload_len)
if len(payload) != payload_len:
raise IOError(f"short payload: got {len(payload)}/{payload_len}")
return seq, sensor, payload
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--port", default="/dev/rc-g1-glove-0")
ap.add_argument("--baud", type=int, default=921600)
args = ap.parse_args()
with serial.Serial(args.port, args.baud, timeout=1) as port:
print(f"Reading from {args.port} @ {args.baud}…", file=sys.stderr)
half = None
t0, n = time.time(), 0
while True:
seq, sensor, payload = read_frame(port)
if seq == 0x01:
half = payload # stash first half
continue
if seq != 0x02 or half is None:
continue
# Combine the two halves
raw = np.frombuffer(half + payload[:128], dtype=np.uint8) # 256 pressure pts
imu = struct.unpack("<ffff", payload[128:144]) # quaternion w,x,y,z
n += 1
if n % 100 == 0:
hz = n / (time.time() - t0)
side = SENSOR_NAMES.get(sensor, hex(sensor))
peak = int(raw.max())
print(f"[{side}] frames={n} rate={hz:5.1f} Hz peak={peak:3d}/255 quat={imu}",
file=sys.stderr)
if __name__ == "__main__":
main()
```
Lassen Sie es laufen .
python3 reader.py --port /dev/rc-g1-glove-0
Sie sollten alle 100 Bilder eine Statuslinie sehen, die die Probenrate zeigt. Drücken Sie einen Fingerspitz und beobachten Sie, wie
(optional) Laufen Sie als Systemd-Dienst
Für kopflose Einsätze
```bash
[Unit]
Description=RC G1 Tactile Glove reader (%i)
After=local-fs.target
[Service]
Type=simple
User=robotics
ExecStart=/home/robotics/.venv/rc-g1/bin/python /home/robotics/rc-g1-glove/reader.py --port /dev/%i
Restart=on-failure
RestartSec=2
[Install]
WantedBy=multi-user.target
```
Aktivieren und starten:
```bash
sudo systemctl daemon-reload
sudo systemctl enable --now rc-g1-reader@rc-g1-glove-0.service
```
Folgen Sie den Logs:
```bash
journalctl -u rc-g1-reader@rc-g1-glove-0.service -f
```
Die Vorlage
- Streamen Sie in die RC-Datenplattform
Der Leser druckt den Status auf stderr und schreibt (in der Produktion) die Frames auf stdout in jedem Format, das Ihnen gefällt.
```bash
pip install centeros-cli
centeros auth login
python reader.py --port /dev/rc-g1-glove-0 | centeros stream --hardware rc-g1-tactile-glove --operator-id <you>
```
Die CLI verwaltet die Authentifizierung, erneute Versuche und den gefüllten Upload auf das WebSocket der Plattform. Siehe den [SDK quickstart]
Rammlayout und ROS-2-Beispiele
Der obige Leser erzeugt pro vollen Rahmen ein flaches 256-Element
Für die ROS 2-Integration wickeln Sie
** Durchput-Sensity-Check:** 100 Hz x (256 Byte Druck + 16 Byte IMU + 12 Byte Rahmen) = ~28 KB/s pro Hand. Die CH340 bei 921600 Baud hat ~115 KB/s nutzbare Bandbreite, so dass kabelgebundene Ein-Hand-Streaming verwendet etwa ein Viertel der Verbindung.
Fehlerbehebung
Kein
Reader läuft bei 50 Hz anstelle von 100 Hz: Sie sind auf Bluetooth (30 Hz nominell; einige Hosts messen ~50 Hz einschließlich erneuter Versuche).
Frames decode garbage / IMU quaternion ist NaN: überprüfen Sie, dass der baud
Zwei Handschuhe verbunden, nur ein Stream: Prüfen Sie, ob die udev-Regel aus Schritt 3 zwei Symlinks (
Was soll ich jetzt tun?
Wenn eine Hand zuverlässig strömt, sind die nächsten hochwertigen Schritte: (1) Kalibrieren Sie die Druckbasis pro Kanal, indem Sie 5 Sekunden einer leeren Hand aufzeichnen und das Mittel subtrahieren, (2) bringen Sie die zweite Hand auf und überprüfen Sie beide gleichzeitig in die Plattform strömt und (3) erfassen Sie einen markierten Datensatz mit dem Episodenmodus des CLI des Centeros