UR3 Roboter spielt Schach

→ zurück zur Übersicht: Praktikum Produktionstechnik

Abbildung 1: Roboter am Schachbrett

Einleitung

Das Projekt "UR3 spielt Schach" wurde entwickelt, um die Fähigkeiten eines UR3-Roboters in der präzisen Handhabung und Steuerung zu demonstrieren. Ziel war es, den Roboter so zu programmieren, dass er eigenständig Schachzüge ausführt, basierend auf vorgegebenen Befehlen. Obwohl das Projekt nicht vollständig abgeschlossen wurde, bietet es wertvolle Erkenntnisse und eine solide Basis für zukünftige Arbeiten. Erkenntnisse aus dem Projekt Schachspiel mittels kollaborierendem UR-Roboter unter ROS wurden dabei genutzt.

Ziel des Projekts

• Primäres Ziel: Programmierung eines UR3-Roboters, der Schachfiguren greift und bewegt.
• Sekundäre Ziele:
  • Verstehen und Implementieren der RoboDK-Software in Kombination mit Python.
  • Entwicklung von Algorithmen zur Steuerung des "RG2 Gripper" Greifers.
  • Simulation und Optimierung der Roboterbewegungen.

V-Modell

Zur systematischen Umsetzung des Projekts wurde das V-Modell als Vorgehensweise herangezogen (Abb.1). Dieses Modell stellt sicher, dass sämtliche erforderlichen Schritte konsequent umgesetzt werden.

Abbildung 2: V-Modell

Die Organisation und Verwaltung der erstellten Dokumente erfolgte mithilfe der Software TortoiseSVN.

Anforderungsdefinition

Die Anforderungsdefinition wurde in funktionale und nicht-funktionale Anforderungen unterteilt..

Funktionale Anforderungen

1. Präzision: Der Roboter muss die Schachfiguren sicher und ohne Kollisionen greifen und bewegen können.
2. Reaktionszeit: Der Roboter muss innerhalb von 5 Sekunden auf einen neuen Schachzug reagieren.
3. Kollisionen vermeiden: Der Roboter muss Bewegungen so planen, dass er keine Hindernisse berührt.
4. Benutzerfreundlichkeit: Die Interaktion mit dem System soll intuitiv und ohne umfangreiche Programmierkenntnisse möglich sein.

Nicht-Funktionale Anforderungen

1. Zuverlässigkeit: Das System soll stabil und ohne Unterbrechungen über längere Schachpartien hinweg funktionieren.

1. Wartbarkeit: Code und Hardware sollten leicht aktualisierbar und erweiterbar sein.

Fuktionaler Systementwurf

Der Funktionale Systementwurf wurde in Powerpoint mit Piktogrammen und einem Foto erstellt (siehe Abbildung 3.) und ist unter Funktionaler Systementwurf im SVN verfügbar.

Abbildung 3: funktionaler Systementwurf

Technischer Systementwurf

Der Technische Systementwurf wurde über den „PAP Designer“ erstellt (siehe Abbildung 4.) und ist unter Technischer Systementwurf im SVN verfügbar.

Abbildung 4: technischer Systementwurf

Komponentenspezifikation

Die verwendeten Komponenten wurden in Hard- und Software unterteilt. Dabei wurde sich am Projekt Schachspiel mittels kollaborierendem UR-Roboter unter ROS orientiert.

Hardware

Komponenten	Beschreibung	Preis	Bild
UR3	Das zentrale Element des Projekts ist der Roboterarm UR3 der Firma Universal Robots (UR). Der UR3 ist das kleinste Modell der kollaborativen Roboterreihe von UR. Mit einem Eigengewicht von 11 kg kann er Lasten von bis zu 3 kg heben. Die maximale Reichweite des Arms beträgt 500 mm, wenn dieser vollständig ausgefahren ist. Jedes Gelenk des UR3 kann sich um +/- 360° drehen. Für den Betrieb benötigt der Roboter eine Spannung von 24 V im Schaltschrank sowie 12 V an der Werkzeugschnittstelle. Die Kommunikation zwischen dem Roboter und einem PC erfolgt über eine Ethernet-Schnittstelle. Weitere technische Details können dem entsprechenden Datenblatt entnommen werden.	Kostenlos, da bereits vorhanden.	UR3Roboter
DGT Smart Board und Schachfiguren	Das freundlicherweise vom Hersteller Digital Game Technology (DGT) bereitgestellte "DGT Smart Board" wird üblicherweise zur Übertragung von Turnierspielen ins Internet verwendet. Das bedeutet, dass dieses Smart Board die Möglichkeit zum Auslesen der einzelnen Figuren auf den bestimmten Feldern bietet. Die Datenübertragung wird durch ein USB-Kabel sichergestellt. Gleichzeitig kann eine von DGT hergestellte Schachuhr an das Schachbrett angeschlossen werden. Weitere Informationen sind unter der Quelle zu finden.	0 €, Gesponsort vom Hersteller Digital Game Technology (DGT). Bei Chessware: 260€	DGT Smartboard
RG2 Gripper	Der RG2 Greifer von OnRobot ist ein vielseitiger und anpassungsfähiger Endeffektor, der für den Einsatz mit kollaborativen Robotern konzipiert wurde. Er wiegt 0,78 kg und kann Objekte mit einem maximalen Gewicht von 5 kg handhaben. Der Greifer verfügt über einen verstellbaren Hub von bis zu 110 mm und bietet eine hohe Präzision mit einer Wiederholgenauigkeit von ±0,1 mm . Die Greifkraft ist zwischen 3 und 40 N einstellbar, wobei die Greifgeschwindigkeit zwischen 38 und 127 mm/s variiert. Der Greifer benötigt eine Betriebsspannung von 24 V und hat einen Stromverbrauch, der je nach Einsatz zwischen 70 mA und 600 mA liegt. Für den Betrieb ist eine Umgebungstemperatur zwischen 5 °C und 50 °C erforderlich, und der Greifer kann einer relativen Luftfeuchtigkeit von 0–95 % (nicht kondensierend) standhalten. Die Lebensdauer des Greifers wird auf etwa 30.000 Betriebsstunden geschätzt. Der RG2 Greifer ist mit einer IP54-Schutzart ausgestattet, die ihn vor Staub und Spritzwasser schützt. Der Greifer wird durch einen integrierten elektrischen BLDC-Motor betrieben und bietet zahlreiche Anpassungsmöglichkeiten, wie etwa die Verwendung von Standard-, X-förmigen oder verlängerten Fingertippen, um unterschiedlichste Arbeitsstücke zu greifen. Die standardmäßigen Fingertipps bestehen aus EPDM-Gummi, der den Grip erhöht und gleichzeitig die Wahrscheinlichkeit verringert, dass Abdrücke auf den Objekten hinterlassen werden. Weitere technische Details und Informationen zu den verfügbaren Zubehörteilen, wie Fingertip-Erweiterungen, können im offiziellen Datenblatt eingesehen werden..	Kostenlos, da bereits vorhanden.	RG2 Gripper

Software - Robodk & Python Integration

RoboDK ist eine vielseitige Software zur Programmierung und Simulation von Industrierobotern. Sie ermöglicht die Entwicklung von Roboteranwendungen mit einer grafischen Benutzeroberfläche und ist vollständig kompatibel mit Python, um flexible, automatisierte Lösungen zu erstellen. Robodk bietet eine Vielzahl von Funktionen, die für die Programmierung und Simulation von Roboterbewegungen und -aufgaben genutzt werden können. Installation und Einrichtung Robodk Installation:

• Robodk steht für verschiedene Betriebssysteme zur Verfügung, darunter Windows, macOS und Linux. Auf den jeweiligen Plattformen kann Robodk durch gängige Installationsmethoden eingerichtet werden. Die genaue Vorgehensweise für die Installation ist auf der offiziellen Robodk-Website. verfügbar.

Python Installation: Python kann über die offizielle Webseite heruntergeladen und installiert werden. Für das Projekt wurde ursprünglich die Version 3.10 verwendet. Die funktionalität kann nur für diese Version gewährleistet werden.

Für die Nutzung von Python mit RoboDK wird die RoboDK Python-API benötigt. Diese lässt sich einfach über den Python Package Index (PyPI) mit folgendem Befehl Installieren:

pip install robodk

Verwendung von Python mit Robodk Verbindung zwischen Robodk und Python:

• Nach der Installation von Robodk und der Python-API können Python-Skripte genutzt werden, um Roboterbewegungen zu steuern, Berechnungen anzustellen und Simulationen durchzuführen. Robodk bietet hierfür ein einfach zu bedienendes API, das es ermöglicht, Roboter zu programmieren und Bewegungsabläufe zu simulieren. Dazu muss ein Modell des UR3 in RoboDK geladen werden. Dieses kann hier heruntergeladen werden.

Entwicklung

Hier wurde die meiste Zeit des Projektzeitraums genutzt. Zur Erstellung der Skripte wurde die Programmiersprache Python über gelernt und unter anderem mit KI-Unterstützung geschrieben.

Die Programmierung wurde in drei Teilprogramme unterteilt.

1. Ein Modul, das auf Schachzüge des Nutzers auf dem „DGT Smart-Board“ reagiert und auf Basis von „Stockfish“ Züge zurückgibt
2. Eine rtde (real time data exchange) bzw Echtzeit Logik, die das Öffnen und Schließen des Greifers an den UR3 übermittelt
3. Ein Programm, das den Roboter die einzelnen Felder auf dem Brett anfahren lässt

Interaktive Schachsteuerung Stockfish und DGT Smart-Board - Modul 1

Das Ziel dieses Moduls ist die Entwicklung eines interaktiven Schachsystems, das:

• Den Schachzug eines Spielers auf einem DGT Smart-Board erfasst.
• Den optimalen Zug für den Computergegner mithilfe der Stockfish-Schachengine berechnet.
• Den berechneten Zug auf der Konsole ausgibt.

Kommunikation mit dem DGT Smart-Board:

Verbindung

Das Schachbrett wird über die serielle Schnittstelle (z. B. COM9) verbunden. Die Kommunikation erfolgt mit einer festen Baudrate von 9600 sowie definierten Steuerbefehlen.

Datenverarbeitung

Die Rohdaten des Schachbretts werden in eine 8x8-Matrix umgewandelt, die die aktuelle Position der Schachfiguren beschreibt. Die Matrix wird in die FEN-Notation (Forsyth-Edwards-Notation) umgewandelt, ein Standardformat, das von Stockfish zur Analyse verwendet wird.

FEN-Notation

Die FEN-Notation (Forsyth-Edwards Notation) ist eine standardisierte Methode zur Darstellung eines Schachbretts zu einem bestimmten Zeitpunkt im Spiel. Sie besteht aus sechs durch Leerzeichen getrennten Teilen: die Stellung der Figuren, die Zugfarbe, die Rochade-Möglichkeiten, die en-passant-Spalte, die Halbzugzahl und die Zugnummer.

• 1.Stellung der Figuren

"rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"

Dies stellt die Anfangsstellung eines Schachspiels dar. Die Figuren werden reihenweise von oben nach unten notiert, wobei Kleinbuchstaben für schwarze Figuren und Großbuchstaben für weiße stehen. Die Buchstaben w oder b zeigen an, wer am Zug ist (hier Weiß).

Stockfish-Integration:

Die generierte FEN-Notation wird an die Stockfish-Engine übergeben. Stockfish berechnet innerhalb von zwei Sekunden den optimalen Zug. Das Ergebnis wird in algebraischer Notation (z. B. e2e4) ausgegeben.

Ablauf des Programms

Schritt 1: Initialisierung

• Aufbau einer seriellen Verbindung mit dem DGT Smart-Board über Port COM9.
• Starten der Stockfish-Engine durch Angabe des Dateipfads.

Schritt 2: Schleife für den Spielfluss

• Erkennung des Spielerzugs
  • Der aktuelle Zustand des Schachbretts wird mit dem zuletzt gespeicherten verglichen.
  • Der erkannte neue Zug wird in FEN-Notation umgewandelt.
• Stockfish-Berechnung:
  • Die FEN-Notation wird an Stockfish übermittelt.
  • Der berechnete Zug des Computers wird ausgegeben.
• Warten auf Computerzug:
  • Die Ausgabe des berechneten Computerzugs erfolgt nach dessen Berechnung.

Schritt 3: Aktualisierung

• Das Schachbrett wird erneut ausgelesen und der Zustand für den nächsten Zug gespeichert.
• Der Prozess wiederholt sich, bis das Spiel abgeschlossen ist.

Fehlerbehandlung und Optimierung

Ein bekannter Fehler tritt auf, wenn Stockfish einen Zug zurückgibt, obwohl der Computer nicht am Zug ist. Dies erfordert eine Optimierung der Steuerlogik. Eine mögliche Übergangslösung besteht darin, die fehlerhaften Ausgaben zu ignorieren, wenn der Computer nicht an der Reihe ist.

Erforderliche Bibliotheken

Für die Nutzung des Programms müssen folgende Python-Bibliotheken installiert sein:

pip install serial
pip install time
pip install chess
pip install chess.engine

Inbetriebnahme

• Python installieren
• Das Python Programm aus dem SVN herunterladen.
• Das USB-C Kabel an das Schachbrett anschließen.
• Die Schachfiguren auf dem Brett standardmäßig aufbauen.
• Das Python Skript per IDE oder CMD Konsole starten.
• Weitere Instruktionen sind in der Konsole.
• Eine Partie spielen. Dabei muss der Spieler die eigenen, sowie die in der Konsole ausgegebenen Züge von Stockfish manuell ziehen.

RTDE-Schnittstelle für UR3 - Modul 2

Die RTDE (Real-Time Data Exchange) Schnittstelle konnte nicht vollständig integriert werden. Dennoch wurden wertvolle Lernerfahrungen gesammelt.

• Ziele der RTDE-Integration
  • Herstellung einer Echtzeitkommunikation zwischen dem Python-Programm und dem UR3-Roboterarm.
  • Steuerung des Greifers zur Bewegung und Platzierung von Schachfiguren.
  • Synchronisation von Roboterbewegungen und Greiferaktionen basierend auf Schachzügen.

Verwendeter Ansatz:

• RTDE-Setup
  • Installation und Grundkonfiguration des RTDE-Python-SDKs von Universal Robots.
  • Verbindung zum Roboter über die IP-Adresse 192.168.3.1 und den Port COM9.
• Erste Implementierung:
  • Tests zur Übermittlung von Befehlen wie:

set input register
set output register

• Entwicklung eines Prototyps zur Steuerung von Bewegungen und Greiferbefehlen.

Die erstellten Dokumente sind nicht zur direkten Weiterverwendung geeignet, da die RTDE-Schnittstelle aufgrund technischer Herausforderungen nicht vollständig implementiert werden konnte. Aufgrund der unzureichenden Stabilität der aktuellen Implementierung wäre die Entwicklung eines neuen Programms zielführender, um Missverständnisse und Fehlfunktionen zu vermeiden.

Robotersteuerung zur Ansteuerung von Schachfeldern - Modul 3

• Ziel:
  • Präzise Bewegung eines UR3-Roboters zu definierten Schachfeldern.
  • Steuerung über RoboDK mithilfe von Python.
• Ergebnisse:

Der Roboter kann erfolgreich zu einzelnen Feldern bewegt werden. Die Ansteuerung erfolgt über die Angabe von Gelenkwinkeln im Python-Skript.

• Ansatz:
  • Verbindung über RoboDK API:
    • Der Roboter wird durch den Namen „UR3“ in der RoboDK-Szene referenziert.
    • Befehle werden in Echtzeit über die RunMode-Schnittstelle übertragen.
  • Direkte Definition der Gelenkwinkel:
    • Zielgelenkwinkel werden im Gradmaß spezifiziert.
    • Beispiel für das Feld A8: [-6, -157, -39, -49, 95, 83].
• Synchronisierung der Bewegung:
  • Der Roboter stoppt an der definierten Position und wartet auf den Abschluss der Bewegung.

Quellcode zur Umsetzung:

from robolink import *  # API zur RoboDK-Steuerung importieren

# Initialisiere die Verbindung zu RoboDK
RDK = Robolink()

# Roboterobjekt finden (Name aus der RoboDK GUI übernehmen)
robot = RDK.Item('UR3')

# Verbindung prüfen
if robot is None:
    print("Kein Roboter gefunden")
else:
    # Setze RoboDK in einen Modus, der Echtzeit-Bewegungen ausführt (RUNMODE)
    RDK.setRunMode(RUNMODE_RUN_ROBOT)  # RUNMODE_RUN_ROBOT: Echtzeit-Modus
    
    # Zielgelenkwinkel (Anpassen an deinen Roboter)
    joints = [-6, -157, -39, -49, 95, 83]  # Werte in Grad

    # Bewege den Roboter (echte Bewegung zum realen Roboter ausführen)
    robot.MoveJ(joints)  

    # Warten, bis der Roboter die Bewegung abgeschlossen hat
    robot.WaitMove()  

    print("Roboterbewegung abgeschlossen und synchronisiert!")

Testdurchführung & Anleitung

1. Voraussetzungen:

• RoboDK und Python sind installiert.
• Das Schachbrett ist korrekt ausgerichtet (Feld A8 in der Tisch-Ecke).

2. Inbetriebnahme:

• Das Python Skript aus dem SVN herunterladen.
• pip installieren.
• den nachfolgenden Befehl über eine beliebige Python IDE oder cmd ausführen.

pip install robodk

• Das LAN-Kabel des UR3 Roboters an den Computer anschließen
• Den Roboter über den großen Ein-/Ausschalt Knopf starten
• Im Initialisierungsbildschirm auf „Roboter an“ drücken. Das anschließen einer Maus an den USB-Port des Steuergeräts ist hier zu empfehlen, es kann aber auch über den Touchscreen bedient werden.
• RoboDK öffnen und das Modell des UR3 Roboters über Datei->Öffnen…->UR3.robot laden. Es ist unter
• Das Python Skript über Datei->Öffnen...->A8.py in RoboDK laden. Es sollte im Projekt erscheinen.
• In RoboDK in der oberen leiste auf „verbinden->Roboter verbinden“ klicken.
• In der neuen Sidebar bei der IP 192.168.3.1 eingeben und „Ping“ drücken.
• Wenn der Roboter reagiert, auf „Verbinden“ drücken.
• Das Python-Skript durch einen Doppelklick starten.

Inverse Kinematik

Die Berechnung der Inversen Kinematik (IK) für alle Schachfeldkoordinaten wurde bisher nicht vollständig umgesetzt. Ebenso blieb die Entwicklung sicherer, kollisionsfreier Bewegungen unvollständig. Statt die Gelenkwinkel automatisch über RoboDK zu berechnen, wurden die Werte für jedes Schachfeld manuell eingegeben. Die manuelle Eingabe diente der Überprüfung der grundlegenden Funktionalität der Roboterbewegung.

In Zukunft sollten folgende Optimierungen vorgenommen werden:

• Automatische Berechnung der Gelenkwinkel über RoboDK.
• Dynamische Anpassung des Schachbretts für flexiblere Platzierung.
• Kollisionsvermeidung durch geplante Bewegungsbahnen.

Fazit

Das entwickelte Programm erlaubt die präzise Steuerung eines UR3-Roboters zu einem definierten Schachfeld. Die grundlegende Funktionalität wurde erfolgreich validiert, jedoch sind weitere Optimierungen erforderlich, um eine flexible und dynamische Anwendung zu ermöglichen. Die Anleitung zur Inbetriebnahme findet sich im SVN

Fazit

Das Projekt „UR3 spielt Schach“ hat einen interessanten Einblick in die Nutzung von kollaborativen Robotern, insbesondere des UR3 von Universal Robots, in der Automatisierung und Robotik zur Durchführung von Schachzügen gegeben. Trotz der unvollständigen Realisierung aller geplanten Ziele konnten wesentliche Fortschritte erzielt werden, insbesondere in der Integration von RoboDK mit Python und der Entwicklung von Steuerungsskripten für die Roboterbewegungen. Das Projekt hat das Potenzial, ein gutes Fundament für die weitere Forschung und Entwicklung im Bereich der Robotik und Automatisierung von Spielemechaniken zu bieten.

Die realisierten Module zur Schachsteuerung und zur Ansteuerung der Schachfelder mit dem UR3 sind funktional, aber es gibt noch Herausforderungen, wie die vollständige Integration der RTDE-Schnittstelle und die Berechnung der Inversen Kinematik, die noch nicht rechtzeitig abgeschlossen werden konnten. Die manuelle Eingabe von Gelenkwinkeln konnte zwar eine erste Grundlage schaffen, jedoch ist die vollständige Automatisierung und Optimierung dieser Prozesse für eine zuverlässige und flexible Nutzung notwendig.

Die Integration von Stockfish zur Berechnung von Schachzügen und die Nutzung des DGT Smart-Boards zur Erkennung von Spielzügen haben gut funktioniert und bieten eine solide Grundlage für eine interaktive Schachsteuerung. Für zukünftige Arbeiten sind jedoch Verbesserungen in der Bewegungsplanung, der Robotersteuerung sowie der vollständigen RTDE-Integration erforderlich, um das Projekt weiter zu optimieren und die geplante Automatisierung zu erreichen.

Insgesamt stellt das Projekt eine wertvolle Lernerfahrung dar, und die gewonnenen Erkenntnisse können als Grundlage für eine weiterführende Entwicklung in der Roboterprogrammierung und -steuerung dienen.

Ausblick

Das Projekt „UR3 spielt Schach“ hat die Basis für die Automatisierung und Robotik im Bereich von Brettspielen gelegt. Es zeigt, dass die Kombination von kollaborativen Robotern wie dem UR3, der Integration von RoboDK und Python sowie der Nutzung externer Software wie Stockfish und DGT Smart-Boards ein vielversprechendes Potenzial bietet, um Roboter für komplexe Aufgaben wie das Schachspielen zu nutzen.

In zukünftigen Arbeiten wird es wichtig sein, die noch offenen Herausforderungen zu adressieren. Ein wichtiger Schritt wird die vollständige Implementierung der RTDE-Schnittstelle sein, um eine zuverlässige Echtzeitkommunikation zwischen Python und dem Roboter zu gewährleisten. Damit könnte der Roboter nicht nur präzise gesteuert, sondern auch komplexe Aufgaben autonom und ohne manuelle Eingriffe erledigen.

Ein weiteres Ziel ist die Automatisierung der aktuell noch manuell durchgeführten Berechnung der Inversen Kinematik. Die Entwicklung eines robusten Algorithmus, der diese Berechnungen in Echtzeit durchführen kann, wäre entscheidend für eine effiziente und flexible Steuerung der Roboterbewegungen und für die Handhabung von Schachfiguren auf verschiedenen Positionen des Schachbretts.

Auch die Bewegungsplanung des Roboters muss weiter optimiert werden, um kollisionsfreie und sichere Bewegungen zu gewährleisten. Hier wäre die Entwicklung eines Systems zur dynamischen Kollisionsvermeidung und Wegplanung sinnvoll, das nicht nur statisch definierte Felder, sondern auch variable Spielpositionen und Hindernisse berücksichtigen kann.

Zudem könnte die Interaktivität des Systems weiter ausgebaut werden, beispielsweise durch die Einbindung von Benutzerschnittstellen, die es auch nicht-technischen Nutzern ermöglichen, den Roboter einfach zu steuern oder eigene Schachpartien gegen den Computer zu spielen.

Langfristig könnte das Projekt als Grundlage für den Einsatz kollaborativer Roboter in anderen Bereichen dienen, in denen Präzision und Automatisierung gefragt sind, wie etwa in der industriellen Fertigung oder in der medizinischen Rehabilitation.

Die gewonnenen Erfahrungen und die technische Grundlage bieten eine vielversprechende Basis für die Weiterentwicklung und die Erweiterung des Projekts zu einem vollständig autonomen und funktionsfähigen Roboter", der in der Lage ist, Schach auf hohem Niveau zu spielen und auch in anderen Anwendungen eingesetzt zu werden.