Quelltext der Seite UR3 Roboter spielt Schach

[[UR3 Roboter spielt Schach | ]]
'''Autor:''' [[Benutzer:Joern-hendrik.beleke@stud.hshl.de | Jörn-Hendrik Beleke]] <br/>
'''Betreuer:''' [[Benutzer:Mirekgoebel|Prof. Dr. Mirek Göbel]] & [[Benutzer:Marc Ebmeyer|Marc Ebmeyer]]

→ zurück zur Übersicht: [https://wiki.hshl.de/wiki/index.php/Praktikum_Produktionstechnik ''Praktikum Produktionstechnik'']<br/><br/>

= 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 zu programmieren, um eigenständig Schachzüge auszuführen, 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.
Es wurden unter anderem Erkenntnisse des Projekts [https://wiki.hshl.de/wiki/index.php/Schachspiel_mittels_kollaborierendem_UR-Roboter_unter_ROS  Schachspiel mittels kollaborierendem UR-Roboter unter ROS] 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 wird das V-Modell als Vorgehensweise herangezogen (Abb. 1). Dieses Modell stellt sicher, dass sämtliche erforderlichen Schritte, die für die erfolgreiche Durchführung eines Projekts notwendig sind, konsequent umgesetzt werden.
[[Datei:V-Modell2020.png|Abbildung 1: V-Modell|links|500px|mini]]<br><br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>

Die Organisation und Verwaltung der erstellten Dokumente erfolgt mithilfe der Software [https://tortoisesvn.net/index.de.html TortoiseSVN]. Im Folgenden werden die jeweiligen Dokumente, passend zu den einzelnen Phasen des V-Modells, als Download-Links bereitgestellt.

= Anforderungsdefinition =
Die '''Anforderungsdefinition''' wurde in zwei Teile getrennt.

'''Funktionale Anforderungen'''
# '''Präzision:''' Der Roboter muss die Schachfiguren sicher, ohne Kollisionen greifen und bewegen können. 
# '''Reaktionszeit:''' Der Roboter muss innerhalb von 5 Sekunden auf einen neuen Schachzug reagieren.
# '''Sicherheit:''' Der Roboter muss sicher betrieben werden und darf keine gefährlichen Bewegungen durchführen, die Benutzer gefährden könnten.
# '''Benutzerfreundlichkeit:''' Die Interaktion mit dem System muss einfach und intuitiv sein, ohne dass umfangreiche Programmierkenntnisse erforderlich sind.

'''Nicht-Funktionale Anforderungen'''
# '''Zuverlässigkeit:''' Der Roboter und die Software müssen stabil arbeiten und auch bei längeren Schachpartien ohne Unterbrechungen funktionieren.

# '''Wartbarkeit:''' Der Code und die Hardware sollten so gestaltet sein, dass sie leicht aktualisiert, erweitert oder repariert werden können.

= Fuktionaler Systementwurf =
Der Funktionale Systementwurf wurde in Powerpoint mit Piktogrammen und einem Foto erstellt (siehe Abbildung 2.).
[[Datei:Schachspiel_Systementwurf.jpg|Abbildung 2: funktionaler Systementwurf|links|350px|mini]]<br><br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>

= Technischer Systementwurf =
Der Technische Systementwurf wurde über den „PAP Designer“ erstellt (siehe Abbildung 3.).

[[Datei:Schachspiel_Technischer_Systementwurf.jpg|Abbildung 3: technischer Systementwurf|links|350px|mini]]<br><br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
=Komponentenspezifikation=

Die '''Komponentenspezifikation''' definiert, welche einzelnen Komponenten für die Umsetzung der Aufgaben genutzt werden. Dabei werden die Komponenten klar in die Bereiche Hardware und Software gegliedert.
=Hardware=

{| class="mw-datatable"
! style="font-weight: bold;" | Komponenten
! style="font-weight: bold;" | Beschreibung
! style="font-weight: bold;" | Preis
! style="font-weight: bold;" | 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<ref name='Datenblatt UR3'> UR3: ''UniversalRobots- UR3Roboter''. 2025. Online: https://www.i-botics.de/wp-content/uploads/2016/08/ur3_de.pdf; Abruf: 27.01.2025</ref>.
|Kostenlos, da bereits vorhanden.
|[[Datei:UR3Roboter.jpg|126px|mini|zentriert|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 <ref name = 'DGT Smart Board' > DGT: ''DGT - DGT Smart Board''. 2025. Online: https://digitalgametechnology.com/products/home-use-e-boards/smart-board-with-indices; Abruf: 27.01.2025</ref> zu finden.
|0 €, Gesponsort vom Hersteller Digital Game Technology (DGT). Bei Chessware: 260€ 
|[[Datei:DGT Smartboard.png|126px|mini|zentriert|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.<ref name='Datenblatt RG2'> RG2Gripper: ''UniversalRobots- RG2 Gripper''. 2025. Online:https://onrobot.com/sites/default/files/documents/Datasheet_RG2_EN_0.pdf; Abruf: 27.01.2025</ref>.
|Kostenlos, da bereits vorhanden. 
|[[Datei: RG2 Gripper.png|126px|mini|zentriert|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<ref name='RoboDK'>  RoboDK 2025. Online: https://robodk.com/de/; Abruf: 27.01.2025</ref>. verfügbar.
'''Python Installation:'''
Python kann über die offizielle Webseite<ref name='Python'> Python 2025. Online: https://www.python.org/downloads/; Abruf: 27.01.2025</ref> 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:
<div style="width:1200px; height:50px; solid #088">
<pre>
pip install robodk
</pre>
</div>
<br clear = all>
'''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 <ref name='RoboDK_UR3'> Universal Robots: ''UR3''. 2025. Online: https://robodk.com/robot/de/Universal-Robots/UR3#:~:text=Der%20Roboter%20UR3%20ist%20ein,Collaborative%2C%20Auftragen%2C%20Remote%20TCP.; Abruf: 27.01.2025</ref> heruntergeladen werden.

=Entwicklung=
Hier wurde die meiste Zeit des Projektzeitraums genutzt.
Zur Erstellung der Skripte wurde die Programmiersprache Python über <ref name='learnpython'>Learnpython Online https://www.learnpython.org/; Abruf 27.01.2025</ref> gelernt und unter anderem mit KI-Unterstützung <ref name='ChatGPT'>Chat GPT Online https://chat.openai.com; Abruf: 27.01.2025</ref> geschrieben.

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

= Interaktive Schachsteuerung Stockfish und DGT Smart-Board - Modul 1 =
Ziel dieses Moduls ist es, ein interaktives Schachsystem, das
* Den Schachzug eines Spielers auf einem DGT Smart-Board liest.
* Den besten Zug für den Computergegner mithilfe der Stockfish-Schachengine berechnet.
* Den neuen Zug auf der Konsole präsentiert.


'''  Kommunikation mit dem DGT Smart-Board:'''

'''Verbindung:'''
Das Schachbrett wird über die serielle Schnittstelle (z. B. COM9) verbunden.
Kommunikation erfolgt mit der festen Baudrate 9600 und Steuerbefehlen.
Datenverarbeitung:
Rohdaten des Bretts werden in eine 8x8-Matrix umgewandelt, die den Zustand des Bretts beschreibt (z. B. Figurenpositionen).
Wandlung der Matrix in die FEN-Notation (Forsyth-Edwards-Notation)<ref name'fen'> FEN Notation Online https://www.chess.com/de/terms/forsyth-edwards-notation-fen; Abruf: 27.01.2025</ref>, ein Standardformat, das von Stockfish genutzt wird.

''' Stockfish-Integration:'''

Die FEN-Notation wird an Stockfish übergeben.
Stockfish berechnet innerhalb von 2 Sekunden den besten Zug für den Computergegner.
Ergebnis:
Der Zug wird in '''algebraischer Schachnotation''' (z. B. e2e4) an den Nutzer zurückgegeben.

'''Schritt 1: Initialisierung'''
* Setzen einer seriellen Verbindung zum DGT-Brett (Port COM9).
* Starten der Stockfish-Engine (Dateipfad wird angegeben).

'''Schritt 2: Schleife für den Spielfluss'''
*Spielerzug erkennen:
**Vergleich des aktuellen Schachbretts mit dem zuletzt bekannten Zustand.
**Neuer Zug wird als FEN-String erkannt und verarbeitet.
*Stockfish-Berechnung:
**FEN-String wird an Stockfish übergeben, der den besten Zug des Computers berechnet.
*Warten auf Computerzug:
**Der Computerzug wird erwartet, basierend auf dem zuletzt berechneten Zug.

'''Schritt 3: Aktualisierung'''
*Die neue Stellung wird vom Brett gelesen und für die nächste Berechnung verwendet.
*Der Prozess wiederholt sich, bis das Spiel abgeschlossen ist.

Das Programm ist unter <ref name 'Schachspiel manuell' > Interaktive Schachsteuerung Stockfish und DGT Smart-Board  https://svn.hshl.de/svn/MTR_GPE_Praktikum/trunk/Fachthemen/UR3_Schach/Projekt/Projekte_und_Dateien/Stockfish.py</ref> verfügbar und kann genutzt werden. Leider kann ein Fehler entstehen, dass Züge zurückgegeben werden, wenn Stockfish nicht an der Reihe ist und muss ausgebessert werden. Falls der Nutzer die Ausgaben des Programmes, falls der Computer nicht am Zug ist ignoriert funktioniert es jedoch einwandfrei.
Zur Nutzung des Programms müssen die Bibliotheken "serial, time, chess chess.engine" installiert werden. Dafür müssen in Python die folgenden Befehle ausgeführt werden:
<div style="width:1200px; height:50px; solid #088">
<pre>
pip install serial
pip install time
pip install chess
pip install chess.engine
</pre>
</div>
<br clear = all>

=RTDE-Schnittstelle für UR3 - Modul 2=
Leider konnte die RTDE (Real Time Data Exchange) Schnittstelle nicht ausreichend integriert werden. Dennoch wurden Lernerfolge erzielt.

* '''Ziele der RTDE-Integration'''
**Echtzeitkommunikation zwischen Python-Programm und UR3-Roboterarm.
**Steuerung des Greifers zur Bewegung und Platzierung von Schachfiguren.
**Synchronisierung von Roboterbewegungen und Greiferaktionen, basierend auf Schachzügen.

'''Verwendeter Ansatz:'''
*''' RTDE-Setup'''
**Installation und Grundkonfiguration des RTDE-Python-SDK von Universal Robots.
**Verbindung zum Roboter durch spezifizierte IP-Adresse 192.168.3.1 und Port COM9.
*'''Erste Implementierung:'''
**Tests zur Kommunikation von Befehlen wie
<div style="width:1200px; height:50px; solid #088">
<pre>
set input register
set output register
</pre>
</div>
<br clear = all>
*Entwicklung eines Prototyps zur Steuerung von Bewegungen und Greiferbefehlen.

Leider sind die erstellten Dokumente nicht zur Weiterverwendung geeignet, da die RTDE-Schnittstelle aufgrund technischer Schwierigkeiten nicht vollständig implementiert werden konnte und die Erstellung eines neuen Programmes vermutlich weniger Verwirrung stiften würde.

= Robotersteuerung zur Ansteuerung von Schachfeldern - Modul 3 =
* '''Ziel:'''
**Präzise Bewegung eines UR3-Roboters zu definierten Schachfeldern.
**Steuerung über RoboDK mithilfe von Python.
*'''Erreicht:'''
Der Roboter kann erfolgreich zu einzelnen Feldern gefahren werden.
Ansteuerung ü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:'''
**Roboter stoppt an der Position und wartet auf den Abschluss der Bewegung

Die Berechnung der Inversen Kinematik (IK) für alle Schachfeldkoordinaten konnte leider nicht rechtzeitig umgesetzt werden. Ebenso blieb die komplexe Bewegungsplanung, wie die Entwicklung sicherer und kollisionsfreier Wege, unvollständig. Statt die Gelenkwinkel automatisch über RoboDK zu berechnen, wurden die Werte für jedes Schachfeld manuell eingegeben. Diese manuelle Vorgehensweise sollte dazu dienen, die grundsätzliche Funktionalität der Roboterarmbewegung anschaulich darzustellen.

Das Programm kann genutzt werden, indem das UR3 Modell in RoboDK geladen- und der Roboter verbunden wird. Genaueres ist in der Anleitung: <ref name 'Anleitung' > Anleitung https://svn.hshl.de/svn/MTR_GPE_Praktikum/trunk/Fachthemen/UR3_Schach/Projekt/Projekte_und_Dateien/Inbetriebnahme_UR3_spielt_schach.docx</ref> erklärt. Dann wird und dann das Python Skript <ref name 'A8' > A8.py skript https://svn.hshl.de/svn/MTR_GPE_Praktikum/trunk/Fachthemen/UR3_Schach/Projekt/Projekte_und_Dateien/A8_anfahren.py></ref> ausgeführt, um den Roboter auf das Feld A8 fahren zu lassen. Das Programm funktioniert nur, wenn das Schachbrett mit den x- und y-Koordinaten mit den Kanten des Tisches auf dem der Roboter platziert ist übereinstimmt. Die Ausrichtung des Schachbrettes ist so, dass das Feld A8 in der Ecke des Tisches platziert ist. Das ist nicht optimal und braucht Ausbesserung zur dynamischeren Verwendung in der Zukunft. Das Programm funktioniert unter Beachtung der angegebenen Umstände jedoch einwandfrei.

=Abnahmetest =
noch nicht erfolgt.

= 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 nicht vollständigen Umsetzung aller geplanten Ziele konnten bedeutende 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 Implementierung 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 Berechnung der Inversen Kinematik, die momentan manuell erfolgt. 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 voll funktionsfähigen, autonomen Roboter, der in der Lage ist, Schach auf hohem Niveau zu spielen und auch in anderen Anwendungen eingesetzt zu werden.