Vertrieb kontaktieren
Zurück zu Wiki

Software <unk> Einrichtung, SocketCAN, ROS2 & Steuerungen

OpenArm-Software-Dokumentation: Einrichtungsanleitung, Ubuntu-Installation, Roboterbeschreibung (URDF/xacro), SocketCAN CAN-Bibliothek, ROS2-Installation für Humble/Jazzy und erweiterte Steuerungsübersicht.

Siehe auch OpenArm Hardware Hub.

Auf dieser Seite

  • [Softwareübersicht]
  • [Installieren Sie Ubuntu]
  • [Setup Guide] T54)
  • [Motor ID Setup]
  • [CAN-Schnittstelle]
  • [CAN FD vs CAN 2.0]
  • [Motor-Steuerungskommando]
  • [Motor LED Status]
  • Roboterbeschreibung (URDF)
  • [Installation]
  • Ich habe es nicht gesehen.
    • Ich bin nicht sicher.
  • [Architektur]
  • [Schlüsselklassen]
  • [ROS2-Integration]
  • [Schwache Installation]
  • [Jazzy Install]
  • [Vorgeschrittene Kontrollen]

OpenArm Dokumente

  • [Übersicht]
  • [Startend] T71)
    • Ich habe es nicht gesehen.
  • [Software] T73)
  • [Teleoperation] T74)
  • [Simulation] T75)
  • [FRA und Kauf]

Siehe auch

  • [OpenArm 1 Quickstart]
  • [← Alle Wiki-Artikel]
  • Die Kommission hat die Kommission mit der Kommission übermittelt.

Komplette Software-Dokumentation: Ubuntu-Einstellung, Roboterbeschreibungsdateien (URDF/xacro), die SocketCAN CAN-Bibliothek, die Installation und Konfiguration von ROS2 und fortschrittliche Steuerungsalgorithmen.

Ubuntu 22.04 ROS2 Humble SocketCAN URDF MoveIt2 C++ Python

Quelle: docs.openarm.dev/software/ ** Letztes Update:** 11. April 2026

1. Softwareübersicht

Willkommen im OpenArm-Software-Ökosystem! Das Werkzeugpaket wird zur Überbrückung des bi-manüellen Robots entwickelt, und Beiträge sind willkommen.

Das Software-Ökosystem bietet:

  • Modularisierte XACRO-Dateien für URDF-Robotermodelle
  • Low-Level-Control-API für Hochfrequenzmotorinteraktion über SocketCAN
  • ROS2-Integration (in aktiver Entwicklung) mit Steuerungsoberflächen und MoveIt2-Konfigurationen
  • Kontrollalgorithmen zur Systemidentifizierung, Schwerkraftkompensation und Cartesianischen Raumkontrolle

Neue Benutzer sollten mit dem Setup-Guide beginnen.

Software-Repositorien

Repository Description
openarm_description URDF/XACRO files for single-arm and bimanual configurations
openarm_can C++ CAN library for Linux-based motor control with Python bindings
openarm_ros2 ROS2 middleware integration packages

2. Installation von Ubuntu

Die OpenArm-Software benötigt Ubuntu Linux mit SocketCAN-Unterstützung. Ubuntu 22.04 LTS (Jammy Jellyfish) ist die empfohlene Version.

  1. Download Ubuntu 22.04 LTS. Besuchen Sie die offizielle Ubuntu-Downloadseite: ubuntu.com/download/desktop.

  2. Erstellen Sie einen bootable USB-Laufwerk.

  • Windows: Download Rufus, wählen Sie Ihr USB-Gerät und das Ubuntu ISO aus, dann schreiben.
  • ** macOS:** Verwenden Sie [Balena Etcher]
  • Linux: Verwenden Sie den Befehl T0 mit Ihrem ISO-Pfad und USB-Gerät-Identifikator.
  1. Boot von USB und installieren. Fügen Sie den bootable USB ein, starten Sie Ihr System neu, nehmen Sie auf die BIOS/UEFI-Einstellungen zuzugreifen und setzen Sie USB als primäres Bootgerät ein. Folgen Sie dem grafischen Installationsgerät, um Zeitzone, Benutzername und Passwort auszuwählen.

Warnung Die Standardinstallation löscht alle Daten auf dem ausgewählten Laufwerk.

  1. Nach der Installation: Systemupdates ausführen und Entwicklungswerkzeuge installieren.

sudo apt update && sudo apt upgrade -y sudo apt installieren -y curl git bauen-essentielle gnome-tweaks

Docker Alternative Für Entwicklungs-Szenarien ohne dedizierte Ubuntu-Maschine kann ein Docker-Setup verwendet werden. Für die Hardware-Steuerung mit SocketCAN ist jedoch eine native Ubuntu-Installation erforderlich.

3. OpenArm Setup-Leitfaden

Dieser Leitfaden führt Sie durch die Einrichtung Ihres OpenArm von Hardware-Verbindungen bis hin zu Software-Tests.

Voraussetzungen

Hardwareanforderungen

  • OpenArm Roboterarm mit DAMIAO-Motoren
  • 24 V Stromversorgung mit geeigneter Stromkapazität
  • Kabel (die mit dem Motorpaket enthaltenen Kabel reichen aus)

Anforderungen an die Kommunikationsgeräte

Purpose Required Device OS
Motor ID setup DAMIAO USB CAN Debugger Windows
Motor control & further setup SocketCAN-compatible interface Ubuntu 22.04 / 24.04 or other Linux with SocketCAN support

Schritt 1: Konfiguration der Motor-ID

Sie müssen jeden DAMIAO-Motor vor dem Montage mit der richtigen CAN-ID konfigurieren.

Verwenden Sie die folgende Tabelle als kurze Referenz für das für jeden Gelenk zugewiesene CAN-ID-Paar:

Joint Transmitter ID Receiver ID
J1 0x01 0x11
J2 0x02 0x12
J3 0x03 0x13
J4 0x04 0x14
J5 0x05 0x15
J6 0x06 0x16
J7 0x07 0x17
J8 0x08 0x18

**Damiao Debugging Tool (Windows) ** Laden Sie das Damiao Motor Debugging Tool herunter, um Motor-IDs über USB-CAN einzurichten und zu überprüfen: Debugging_Tools_v.1.6.8.8.exe. Testen Sie immer einen Motor nach dem anderen, bevor Sie ihn im Bus kombinieren.

Schritt 2: Einrichtung von CAN-Interface

Nach der Hardware-Ansammlung konfigurieren Sie die SocketCAN-Schnittstelle auf Ihrem Ubuntu-Gerät.

# Aktivieren Sie den OpenArm PPA und installieren Sie alle erforderlichen Pakete sudo apt-installation -y Software-Eigenschaften-Gemeinsam -y ppa:openarm/main sudo apt update sudo apt installieren -y \ kann-Nutzen \ Ich habe keine Ahnung. libeigen3-dev \

  • Ich kann nicht . Liborocos-kdl-dev \ Liburdfdom-dev \ Liburdfdom-Headers-dev \ Libiaml-cpp-dev \ mit offenem Arm

Dann bringen Sie die CAN-Schnittstelle mit dem OpenArm Helper (empfohlen) oder manuell auf:

# empfohlen CAN FD 1M Nominal / 5M Daten-Boud -Für die Klasse 1 -Für die Klasse 2 -Für die Klasse 2 -Für die Klasse 3 -Für die Klasse 3 -Für die Klasse 3 -Für die Klasse 4 -Für die Klasse 4 -Für die Klasse 4 -Für die Klasse 4 -Für die Klasse 4 -Für die Klasse 4 -Für die Klasse 4 -Für die Klasse 4 -Für die Klasse 4 -Für die Klasse 4 -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -F -

# CAN 2.0 (1M baud, keine FD)

  • kann ein Schaltfläche-Socket-Kann

# Für eine 4-arm-Setup (kan0 bis kan3)

  • offenarm- kann konfigurieren- socket kann-4-arms - fd

# Überprüfen Sie , ob die Schnittstelle UP ist IP-Link-Show kann0

Ein CAN Port pro Arm Jeder Arm benötigt eine dedizierte CAN-Schnittstelle. Ein Einarmsetzung verwendet T17. Ein zweibänderliches Setup verwendet T18 (rechtsführer) + T19 (linksführer) + T20 (rechtsführer) + T21 (linksführer).

CAN FD vs CAN 2.0

OpenArm-Motoren unterstützen sowohl CAN 2.0 (klassische CAN, 8-Byte-Nutzlast) als auch CAN FD (Flexible Data-Rate, bis zu 64-Byte-Nutzlast bei höheren Datenraten). CAN FD wird für die vollständige 5 Mbit/s-Datenbandbreite empfohlen, die von Damiao-Motoren verwendet wird.

Mode Nominal Baud Data Baud Nutzlast
CAN 2.0 1 Mbit/s — 8 bytes
CAN FD 1 Mbit/s 5 Mbit/s up to 64 bytes

Manuelle IP-Verbindungsbefehle (CAN 2.0):

sudo ip-link-set kann0 nach unten sudo ip-link-set kann0-typ kann bitrate 1000000 sudo ip-link-set kann auf

Manuelle IP-Verbindungsbefehle (CAN FD 1M / 5M):

sudo ip-link-set kann0 nach unten sudo ip-Link-Set kann0-Typ kann 1000000 dbitrate 5000000 fd auf bitrate sudo ip-link-set kann auf

Manuelle Motorsteuerungskommandos

Verwenden Sie diese Befehle für die Ablenkung von Fehlern auf niedrigem Niveau und zur Überprüfung der motorischen Kommunikation, bevor Sie Code auf höherem Niveau ausführen.

Überwachen Sie alle CAN-Rahmen im Bus Schneller - x kann0

# Motor-Badrate ändern ( --canid durch Zielmotor-ID ersetzen) -Bau-Bau-Bau-Bau-Bau-Bau-Bau-Bau-Bau 5000000 -Canid 1 -Socket-Bau-Bau # Fügen Sie --flash hinzu, um über Leistungzyklen hinweg zu bestehen (maximal ~ 10.000 flash schreibt pro Motor)

  • Openarm kann - Baudrate - Baudrate 5000000 - Canid 1 - Socket kann 0 - Flash

CAN 2.0 Motorsteuerung (ersetzen Sie T22 mit der Sender-ID des Zielmotors):

# Motorfehler klar kann 001#FFFFFFFFFFFFFB # Motor aktivieren Kann 0 001#FFFFFFFFFFFFFFFF Motor ausschalten kann 001#FFFFFFFFFFFFFD

CAN FD Motorsteuerung (siehe die zusätzliche T23 nach T24, die BRS-Flagge anzeigt):

# Motorfehler klar Kann nicht mehr ausgeschaltet werden # Motor aktivieren Kann die Fläche von Flächen ausführen Motor ausschalten Kann nicht mehr ausgeschaltet werden

Test One Motor at a Time Beim ersten Einsatz von Motoren schließen und testen Sie jeden Motor individuell, bevor Sie mehrere Motoren auf demselben CAN-Bus mit einer Kette schließen.

Motor LED-Status

Jeder Damiao-Motor hat eine LED an Bord, die seinen aktuellen Zustand anzeigt:

LED Pattern Meaning
Green (steady) Motor enabled and ready
Red (steady) Motor disabled
Red (flashing) Motor error state — send Clear Error command before re-enabling

KAN Fehlerbehebung

  • [CAN-Kommunikationsanomalie Diagnose]T88) Diagnose von intermittierenden und anhaltenden CAN-Busfehlern
  • [Gemeinsame Verkabelungsprobleme] T89) Polarität des Anschlusses, Endwiderstand und Kabelschutzspitzen

Schritt 3: Motorprüfung

Nach der Konfiguration der CAN-Schnittstelle testen Sie die Motorkommunikation, indem Sie die Test-Utilities aus dem T25-Repository ausführen. Überprüfen Sie, ob alle 8 Verbindungen auf Positionsbefehle reagieren und das Encoder-Feedback zurückgeben.

Zusammenfassung des Weges

Step Description
0 Prerequisites — hardware, cables, CAN adapter
1 Motor ID Configuration (Windows + Damiao Tools)
2 Setup CAN Interface (openarm-can-configure-socketcan)
3 Motor Test — verify joint communication
4 Motor Configuration — tune control parameters
5 Hands-On: Demo Run

4. Roboterbeschreibung (URDF/xacro)

Das T27-Paket enthält URDF/xacro-Dateien für einarmige und zweibrännige Roboterkonfigurationen, die in Simulationen und Bewegungsplanung verwendet werden.

Verzeichnisstruktur

  • T28 Hauptroboterdatei
  • T29 Version-spezifische URDF
  • Einzelne Verzeichnisse für Armkinematik, Körpermontage, Endefektor und ROS2-Steuerung
  • T30 Version-spezifische Parameterdateien

Installation

# Stellen Sie sicher, dass ROS2 installiert ist (siehe Abschnitt 6) # Umgebungsvariablen festlegen ROS_DISTRO=schwache Export COLCON_WS=~/ros2_ws

# Klonen des Repositoriums git clone T97 \ $COLCON_WS/src/openarm_description

  • Ich bin ein Schwein . cd $COLCON_WS Colcon-Build --Packs-Select openarm_description

# Quelle des Arbeitsraums Quelle $COLCON_WS/install/setup.bash

Beispiele für die URDF-Generation

Einarm mit Hand xacro-Roboter/offener Arm_robot.xacro-Arm_Type:=Rechtsend_effector:=Hand

Einarmschnitt ohne Endwirkung xacro-Roboter/Openarm_robot.xacro-Arm_type:=Rechtsend_effector:=nichts

# Bimanuelle Einrichtung mit ROS2-Steuerung xacro-Roboter/openarm_robot.xacro-Bimanual:=true ros2_control:=true

# Simulationsversion mit gefälschter Hardware xacro-Roboter/openarm_robot.xacro-Simulation:=true

Die V-Bild-Visualisierung

Das Paket enthält Startdateien für die RViz-Visualisierung sowohl für einarmige als auch für zweibrobote Konfigurationen:

# Einarm-Visualisierung starten ros2 start openarm_description display.launch.py

# Einführung der zweimanschließenden Visualisierung Ros2 Start-Openarm_Description Display_bimanual.launch.py

Argumente zur Konfiguration

Zu den anpassbaren Parametern gehören: Arm-/Körpertypen, End-Effektor-Auswahl, zweimanütiger Modus, CAN-Schnittstellen, Positionierungsausgleich und ROS2-Steuerungseinstellungen.

Multi-Roboter-Einstellung

Mehrere Instanzen können mit ROS-Namenpacing und T31 Umgebungsvariablen für die Netzwerkisolierung ausgeführt werden:

# Rechtsarm auf Domäne 0 Export ROS_DOMAIN_ID=0 ros2 start openarm_description display.launch.py Namenspace:=/right_arm

# Linker Arm auf Domäne 1 (separat Terminal) Export ROS_DOMAIN_ID=1 ros2 start openarm_description display.launch.py Namenspace:=/left_arm

5. CAN-Bibliothek (openarm_can)

Die OpenArm CAN-Bibliothek ist die primäre Kommunikationsbrücke zwischen OpenArm-Steuerungsanwendungen auf hoher Ebene und Motorenprotokollen auf niedriger Ebene.

Architektur

Die Bibliothek hat eine dreischichtige Struktur:

  • Kan/Socket Hochwertige Komponenten: T32, T33, T34
  • Damiao_motor Motorprotokollschicht (Damiao MIT-Modus)
  • canbus CAN-Kommunikation auf niedrigem Niveau (Linux SocketCAN)

Schlüsselklassen

Class Description
OpenArm Manages the CAN socket and all motor components globally
ArmComponent Coordinates multiple arm motors as an integrated system
GripperComponent Manages single motor operations with gripper-specific functions: open(), close(), set_position()
DMDeviceCollection Provides shared motor operations including bulk control and parameter queries

Motorsteuerungsmethode

Die Motoren verwenden das Damiao Motor-Protokoll mit MIT-Steuerungsmodus mit T42-Parameter:

  • Die Struktur des MIT-Param: {kp, kd, q, dq, tau} // kp - Positionsgewinn // kd - Geschwindigkeitsgewinn // q - gewünschte Position (rad) // dq - gewünschte Geschwindigkeit (rad/s) // tau - Drehmoment (Nm)

MITParam-Params; params.kp = 10,0; Params.kd = 0,5; Params.q = Ziel_Position; Params.dq = 0,0; Params.tau = 0,0;

arm.send_mit_control(joint_id, Params);

Implementierung von Arbeitsflüssen

  1. Initialisieren Sie OpenArm mit CAN-Schnittstelle. Erstellen Sie eine T43-Instanz, die auf Ihre CAN-Schnittstelle (z.B. T44) zeigt.

  2. Registrieren Sie Motorgeräte mit Typ- und CAN-IDs. Geben Sie für jeden Gelenk Sender-ID, Empfänger-ID und Motormodell an.

  3. Motoren aktivieren und den Rückrufmodus konfigurieren. Für die Steuerungsantworten verwenden Sie den Rückrufmodus T45; für die Parameteranfragen T46.

  4. **Führung der Steuerung über MIT-Parameter.**Senden Sie Position/Geschwindigkeit/Torque-Befehle bis zu 1000 Hz.

  5. Bewältigungs- und Rückkopplungsrahmen. Lesen Sie die Gelenkzustände bei gewünschter Frequenz wieder.

Konfigurationsnoten

  • Die Vektorlängen für Motortypen, Senden- und Empfangs-IDs müssen genau übereinstimmen
  • Zeitunterbrechungswerte: 10002000 Mikrosekunden für langsame Betriebsläufe; 300500 für schnelle Steuerungsschleifen
  • Die Frequenz des Steuerzyklus darf bei Einrichtungen mit 8 Motoren nicht über 1000 Hz liegen
  • Verwenden Sie T47 Rückrufmodus für die Steuerung; T48 für Parameteranfragen

6. Integration von ROS2

OpenArm verfügt über native ROS2-Unterstützung, einschließlich URDF/XACRO-Modelle, T49-Integration, Gravitationskompensation, Impedanzkontrolle und einer kompletten MoveIt2-Planungsgruppekonfiguration.

Installation von ROS2 Humble (empfohlen)

# Installieren Sie ROS2 Humble Desktop-Paket sudo apt installieren -y ros-humble-desktop

# Installieren von OpenArm-spezifischen Controllerpaketen sudo apt installieren -y \ Ros-humble-ros2-kontrolle \ Ros-humble-ros2-Steuerungen \ "Ros-Humble-Controller-Manager" Schleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschleppschle Schnittstelle mit Schnittstellen

# MoveIt2-Benutzer Installieren zusätzlicher Pakete sudo apt installieren -y \

  • Rost-Humble-bewegt \ Schnellsteuerungsschalter

# Quelle der ROS2-Umgebung (zufügen ~/.bashrc für die Persistenz) echo "Quelle /opt/ros/humble/setup.bash" >> ~/.bashrc Quelle ~/.bashrc

# Überprüfen Sie die Installation -h ros2 Themenliste

Installation von ROS2 Jazzy (alternativ)

# Für Ubuntu 24.04 oder Jazzy-Benutzer sudo apt installieren -y ros-jazzy-desktop

# Installieren von Controller-Paketen (jazzy-spezifische Namen) sudo apt installieren -y \ Ros-Jazzy-ros2-Kontrolle \ Ros-Jazzy-ros2-Steuerungen \ Ros-Jazzy-Controller-Manager

Quelle echo "Quelle /opt/ros/jazzy/setup.bash" >> ~/.bashrc Quelle ~/.bashrc

Jazzy Status Die Jazzy-Distribution wird derzeit entwickelt und kann mit OpenArm-Paketen Probleme mit der Stabilität haben.

Openarm_ros2 Aufstellung des Repositoriums

# Erstellen Sie Arbeitsplatz und klonen Sie mkdir -p ~/ros2_ws/src cd ~/ros2_ws/src git clone T98

# Installieren von Abhängigkeiten cd ~/ros2_ws rosdep installieren --from-paths src --ignore-src - r - y

  • Ich bin ein Schwein . Colcon-Build --Symlink-Installation

# Source-Arbeitsraum Quelle Installation/Setup.bash

ROS2-Funktionen

  • Steuerungsoberflächen für die gemeinsame Position, Geschwindigkeit und Anstrengung
  • MoveIt2 Planungsgruppenkonfiguration für Einarmband- und Zweirandsetzungen
  • Schwerkraftkompensation aus der Box
  • Impedanzgesteuung
  • Hardware-Schnittstellen-Plugin für T50

7. Fortgeschrittene Steuerungen

Der Abschnitt "Vorgeschrittene Kontrollen" ist ein aktiv entwickeltes Gebiet für Kontrollleitungen und Algorithmen.

**Bei jeder Kontrollmodus wird eine detaillierte Dokumentation vorbereitet. Beiträge sind willkommen siehe [Beitragsleitfaden] T90.

Systemidentifizierung

Verfahren zur Charakterisierung der Dynamik des OpenArm, einschließlich Gelenksprengung, Trägheit und Dämpfungsparameter.

Schwerkraftkompensation

Die Schwerkraftkompensation hält den Arm gewichtsfrei (konform) durch Berechnung und Abschaffung von Schwerkraftmomenten an jedem Gelenk in Echtzeit.

Cartesian Space Control

Steuern Sie den End-Effektor des Arms in kartesischem Raum (XYZ-Position + Orientierung) anstatt in gemeinsamer Raum.

Das Ausgleichsmodell für Spannungen

Der Teleoperationsstack verwendet ein auf Tanh basierendes Reibungskompensationsmodell, das pro Gelenk angewendet wird:

# Formel zur Entschädigung von Reibungen # tau_f = Fc * tanh(k * dq) + Fv * dq + Fo Ich bin nicht hier . # Fc - statische Reibungsstufe # k - Reibungsübergangsschärfe # Fv - viskoser Reibungskoeffizient # Fo - Reibungsverschiebung # dq - Gelenksgeschwindigkeit

tau_f = Fc * tanh(k * dq) + Fv * dq + Fo

Die Parameter pro Gelenk (Kp, Kd, Fc, k, Fv, Fo) sind in den Steuerungskonfigurationsdateien konfigurierbar.

Attribution Die Inhalte auf dieser Seite basieren auf der offiziellen OpenArm-Dokumentation unter [docs.openarm.dev] (T91), Urheberrecht © 20252026 Enactic, Inc.

← Hardware Teleoperation →

Brauchen Sie eine OpenArm-Einheit, Ersatzteile oder eine zweite für Ihr Labor?