Projektlabor Robotik MINTgrün

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.

========= - PROJEKTDOKUMENTATION Schnappi-Roboterspiel - =========

 <figure schnappi_final>
{{:projektesose21:schnappi:2.jpg?700|}}
<caption>Schnappi - Schnappi - Roboterspiel</caption>
</figure>
====== Motivation ======

Schnappi ist ein Roboter gesteuertes Spiel, basierend auf dem in Abbildung {{ref>kroko_doc}} dargestellten
Kinderspiel "Korko Doc", bei dem die Teilnehmenden nach und nach die Zähne eines Krokodils herunterdrücken bis das Krokodil nach dem Zufallsprinzip zubeißt. Dies geschieht durch einen integrierten Mechanismus, welcher dafür sorgt, dass bei jedem Öffnen des Mauls ein anderer Zahn "aktiviert" wird. So wissen die Spielenden nie, bei welchem Zahn das Krokodil zubeißt.\\

<figure kroko_doc>
{{:projektesose21:schnappi:Kroko Doc.png?400 |}}
<caption>Kroko Doc ([[https://www.voelkner.de/products/512778/Hasbro-Geschicklichkeitsspiel-Kroko-Doc.html | Re-In Retail International GmbH]])</caption>
</figure>


Eine Variante des Spiels für Erwachse ist die Verwendung als Partyspiel:\\
Hierbei wird der/die Spielende nach dem Zuschnappen des Krokodils aufgefordert, sich ein Getränk einzuschenken, dieses zu trinken und anschließend das Krokodil mit geöffnetem Maul an den/die Nächste(n) weiterzugeben, damit das Spiel von Neuem beginnen kann.\\
\\
Der gesamte Spielablauf soll durch das Schnappi - Roboterspiel automatisiert werden. Abbildung {{ref>schnappi_final}} zeigt die finale Version des fertigen Projekts.\\
\\


===== Ansatz zur Umsetzung der Projektidee =====

<figure cad_schnappi>
{{:projektesose21:schnappi:cad_modell_schnappi_-_roboterspiel.png?500|}}
<caption>CAD Modell Schnappi - Roboterspiel</caption>
</figure>

Das Krokodil soll auf einem Roboter montiert werden, welcher in der Mitte eines Tisches platziert wird und durch Rotationsbewegungen die automatische Ausrichtung des Krokodils zu den Mitspielenden ermöglicht. Abbildung {{ref>cad_schnappi}} zeigt ein CAD Modell für eine mögliche Umsetzung.\\
\\
Die Spielenden werden dabei von einer Smartphonekamera erkannt und ihre Position registriert.\\
Anschließend entscheidet der Roboter eigenständig zu welchem/welcher Mitspielenden er fährt (entweder nach einem vorgegebenen Muster oder zufällig). Diese/r muss dann einen Zahn herunterdrücken. Der Roboter registriert mit Hilfe von Sensoren, wenn ein Zahn gedrückt wurde und rotiert anschließend weiter. Nach und nach werden so alle Spielenden angefahren.\\
\\
Wenn das Krokodil zubeißt, wird dies ebenfalls durch einen Sensor registriert. Der/die gerade Spielende bekommt dann automatisiert ein kleines Getränk ausgeschenkt. Der Roboter soll dazu das zugehörige Glas erkennen, den Ausgießer an das Glas heranfahren und das Glas selbstständig füllen. Nachdem der Ausgießer wieder eingefahren ist, soll das Maul des Krokodils wieder geöffnet werden und das Spiel geht weiter.\\
\\
Der gesamte Ablauf ist im Ablaufdiagramm in Abbildung {{ref>ablaufdiagramm}} dargestellt.\\
\\

<figure ablaufdiagramm>
{{:projektesose21:schnappi:ablaufdiagramm.png?1000|}}
<caption>Ablaufdiagramm Schnappi - Roboterspiel</caption>
</figure>

Der Fokus im Projekt Schnappi liegt auf der Entwicklung des Spiels und der Fähigkeit des Roboters, die Spielenden zu erkennen, anzufahren (muss-Funktionen) und die Interaktion mit dem Krokodil zu detektieren und auszuwerten (soll-Funktionen).//
//

Im Laufe des Projektfortschritts wurde beschlossen, auf eine automatische Öffnung des Krokodilmauls durch den Roboter zu verzichten und stattdessen nur zu detektieren, ob des Krokodilmaul durch die/den Spielenden wieder geöffnet wurde. Grund für diese Entscheidung war, dass kein geeigneter Kraftangriffspunkt im Inneren des Krokodils für einen Aktuator gefunden wurde.//
//

Für die Implementierung der automatischen Getränkeausgabe (nice-to-have-Funktion) kann teilweise auf die Ansätze der Projektarbeit [[https://www.mintgruen.tu-berlin.de/robotikWiki/doku.php?id=projektewise1617:remixpublic:start | ReMix]] aus dem Wintersemester 2016/17 zurückgegriffen werden.


====== Methoden und technische Umsetzung ======

Im Folgenden soll die Vorgehensweise bei der Entwicklung des Schnappi Roboterspiels erläutert werden. In diesem Zusammenhang werden sowohl die angewandten Methoden als auch die technische Umsetzung betrachtet. Die Beschreibung der technischen Umsetzung umfasst die Bereiche Mechanik, Sensorik, IT-Komponenten und Software.
Die Basis bildet hierbei der Projektstrukturplan.

===== Projektstrukturplan =====

Um die in Abbildung {{ref>ablaufdiagramm}} dargestellten Funktionen strukturiert und nach ihrer jeweiligen Priorität umzusetzen, wurde zunächst ein Projektstrukturplan in Form eines Flussdiagramms erstellt (vgl. Abbildung {{ref>projektstrukturplan}}). Hierzu wurde das Projekt Schnappi in die vier Teilsysteme Gesichtserkennung, Rotation, Krokodil und Getränkeausgabe unterteilt. Jedes dieser Teilsysteme ist wiederum unterteilt in eine Hardware- und einen Softwareteil. Eine Ausnahme bildet hier das Teilsystem Übrige IT-Komponenten. Dieses beinhaltet jene Komponenten, die übergeordnet für alle anderen Teilsysteme benötigt werden. Hierzu gehören beispielsweise der Arduino Mega zur Daten- und Signalverarbeitung und das Breadbord.//
//

Die Pfeile symbolisieren in diesem Schaubild Beziehungen und Interaktionen. Gestrichelte Linien zeigen an, dass es sich um einen Daten- bzw. Signalaustausch handelt, Volllinien repräsentieren physische Interaktion zwischen Mensch und Maschine.//
//

Der Mensch interagiert hier zunächst mit der Gesichtserkennung indem er in die Smartphone-Kamera schaut. Diese verarbeitet das Bild und gibt die gewonnenen Informationen in Form von digitalen Daten an den Arduino weiter. Dort werden die Daten weiterverarbeitet und das Signal zur Ansteuerung der Rotationseinheit gegeben, welche dann die mechanische Bewegung des Krokodils zur/zum nächsten Spielenden ausführt. Der Mensch interagiert dann physisch mit dem Krokodil, indem er einen Zahn drückt. Der neue Zustand des Krokodilgebisses wird anschließend als elektrisches Signal zurück an den Arduino gegeben, dort verarbeitet und beeinflusst die darauf folgende Signalausgabe des Arduinos. Entweder wird das Signal an die Getränkeausgabe gegeben, die Getränkeausgabe zu starten, oder an die Rotation, die/den nächsten Mitspielenden anzusteuern.//
//

<figure projektstrukturplan>
{{:projektesose21:schnappi:projektstrukturplan.png?1000|}}
<caption>Projektstrukturplan Schnappi - Roboterspiel</caption>
</figure>//
//

===== Aufbau und Funktionsweise der Teilsysteme=====

Zunächst sollen der Aufbau, die Hardware und die Funktionsweise der einzelnen Teilsysteme näher beschrieben werden. Die Beschreibung der Software und des Programmablaufs erfolgt anschließend in einem separaten Abschnitt.

==== Gesichtserkennung ====

(Hier wird zunächst auf die grundlegenden Wechselwirkungen zwischen den Kernelementen eingegangen. Detaillierte Funktionsweisen und Programmabläufe werden später im Punkt Software[Link dorthin] dargestellt.//
//Mit Hilfe der Gesichtserkennung sollen die Spielenden gezählt und deren jeweilige Position am Tisch erfasst und abgespeichert werden. Dabei wir die zugehörige Funktion einmalig ausgeführt. Auf die gewonnenen Daten kann dann im Verlauf des Spiels jederzeit zugegriffen werden.

Verwendete Kernelemente:
  * Smartphonehalterung
  * "HC05" Bluetooth Chip
  * Android-Processing App (auf dem Smartphone)
  * zugehöriger Arduino Code

Um das Smartphone als eine zuverlässige Gesichtserkennung zu benutzen mussten wir dieses zunächst statisch montieren. Dazu befindet sich an einem Holzbalken im Zentrum der Drehplattform eine Smartphonehalterung[link zu Foto mit Halterung]. Hier kann ein beliebiges bluetoothfähiges Smartphone (mit entsprechender App) jederzeit unkompliziert montiert werden.
Zu Beginn dieser Funktion dreht sich das Grundgestell um 360° um die eigene Achse. Dabei prüft die App auf dem Smartphone in jedem Motorschritt ob ein Gesicht erkannt wurde, oder nicht. Auf Basis dessen wird ein bestimmtes Signal über Bluetooth an den Arduino gesendet. Dieser wertet die empfangenen Daten aus. Abhängig von den Eingangsdaten steuert er anschließend den Motor an und speichert ggf. erkannte Spielerpositionen. Nach einer vollständigen Umdrehung liefert uns der Arduino ein Array (Tabelle) die alle erkannten Spielerpositionen -und Bereiche enthält[Link zu Bild mit Tabelle]. Damit ist die Gesichtserkennung abgeschlossen.
//
//


==== Rotation ====

Der **Antrieb** der Rotationsplattform erfolgt über einen **NEMA 17 Steppermotor** (vgl. Abbildung {{ref>nema_17}}), da dieser eine sehr genaue Positionierung ermöglicht. Er wird über einen Motortreiber angesteuert, welcher auf einem Breadboard steckt und mit dem Arduino Mega verbunden ist. Ein wesentlicher Nachteil von Steppermotoren besteht in ihrem im Vergleich zu Getriebemotoren geringen Drehmoment und der damit verbundenen Gefahr, einzelne Schritte zu überspringen, wenn das erforderliche Moment höher ist, als das Drehmoment des Motors. Um dies zu vermeiden wurde ein Getriebe in den Antrieb bzw. zwischen Motor und Anschlusskonstruktion integriert.//
//

<figure nema_17>
{{:projektesose21:schnappi:nema_17_neu.png?300|}}
<caption>Steppermotor NEMA 17([[https://www.amazon.de/STEPPERONLINE-Schrittmotor-Stepping-4-Draht-Stepper/dp/B07KZQ77VH/ref=asc_df_B07KZQ77VH/?tag=googshopde-21&linkCode=df0&hvadid=310714376572&hvpos=&hvnetw=g&hvrand=11909927742086535107&hvpone=&hvptwo=&hvqmt=&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=9061140&hvtargid=pla-751815974347&psc=1&th=1&psc=1&tag=&ref=&adgrpid=65515479087&hvpone=&hvptwo=&hvadid=310714376572&hvpos=&hvnetw=g&hvrand=11909927742086535107&hvqmt=&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=9061140&hvtargid=pla-751815974347 | amazon.de]])</caption>
</figure>//
//

Das Getriebe, welches in Abbildung {{ref>getriebe}} links zu sehen ist, besteht aus einem **Ritzel** mit 17 Zähnen, welches auf der Abtriebswelle des Motors montiert ist und einem **Zahnrad** mit 100 Zähnen, welches auf einem Drehteller montiert ist. Aus dieser Zahnradpaarung ergibt sich gemäß Formel (1) eine Übersetzung von ca. 5,88. Das Holzzahnrad stand aus einem anderen Projekt im Labor zur Verfügung und konnte wiederverwendet werden. Da kein passendes Ritzel mit dem gleichen Modul wie dem des Holzzahnrades (Modul 2,5) zur Verfügung stand, welches dauerhaft für die Konstruktion zur Verfügung gestellt werden konnte, wurde das Ritzel mit einem CAD Programm (Fusion 360) als Step-Datei erstellt und anschließend 3D-gedruckt (vgl. Abbildung {{ref>getriebe}} rechts).//
//


{{:projektesose21:schnappi:formel_uebersetzung_neu.png?900|}}//
//

<figure getriebe>
{{:projektesose21:schnappi:getriebe_neu_4.png?800|}}
<caption>Getriebe</caption>
</figure>//
//



Der **Drehteller** (vgl. Abbildung {{ref>drehteller}}) besteht aus einem Innen- und einem Außenring und bildet die Basis des **Drehgestells**. Der Außenring mit Gummifüßen, auf welchem das große Zahnrad fest montiert ist, steht auf dem Tisch und bewegt sich im Betrieb nicht. Der Innenring rotiert im Betrieb und ermöglicht so die Relativbewegung der Plattformaufbauten zur Unterkonstruktion.//
//

<figure drehteller>
{{:projektesose21:schnappi:drehteller_mit_zahnrad_unterseite_neu_2.png?800|}}
<caption>Drehteller mit Zahnrad (Unterseite)</caption>
</figure>//
//

Es ist wichtig, dass alle kabelgebundenen Bauteile auf der Rotationsplattform angebracht werden, da sich sonst im Betrieb die Kabel durch die Rotation aufwickeln würden!//
//

Die **Tragende Konstruktion** bzw. die Rotationsplattform besteht daher aus zwei runden Holzscheiben von denen jede einen Durchmesser von 400 mm aufweist, um genügend Platz für alle elektrischen und mechanischen Komponenten zu bieten. Die beiden Scheiben sind mit Schrauben und Muttern auf dem Innenring des Drehtellers befestigt und untereinander mit Schrauben, Muttern und Abstandshaltern verbunden. Sie bilden so zusammen zwei Ebenen://
//

  * Auf der **oberen Ebene** sind das Krokodil, das Smartphone samt Ständer und Hülle, sowie der Getränkevorrat vorgesehen. Um den Getränkeschlauch unter dem Krokodil durchführen zu können, ist dieses leicht erhöht auf zwei Holzleisten angebracht. Klettstreifen ermöglichen eine spätere Montage und Demontage des Krokodils um die Schlauchdurchführung besser erreichen zu können.//
//

  * Auf der **unteren Ebene** befinden sich die Komponenten für den Antrieb (Motor und Magnetsensor), die übrigen Elemente der Getränkeausgabe und die übergeordneten IT-Komponenten.//
//

<figure plattform>
{{:projektesose21:schnappi:rotierende_komponentenplattform_neu.png?800|}}
<caption>Rotierende Komponentenplattform</caption>
</figure>//
//

Trotz der Übersetzung und des hierdurch erhöhten Antriebsdrehmoments kann aufgrund des hohen Trägheitsmoments ein Überspringen einzelner Motorschritte beim Beschleunigen und Abbremsen der Plattform nicht gänzlich ausgeschlossen werden. Zudem kommt es bei der Umrechnung von Grad in Motorschritte und umgekehrt zu Rundungsdifferenzen. Der so entstehende Fehler würde sich mit der Zeit im Betrieb immer weiter aufbauen und die Genauigkeit der Ausrichtung des Krokodils auf die Spielenden beeinträchtigen. Um dies zu vermeiden, wurden ein Magnet an der Unterkonstruktion auf dem feststehenden Außenring des Drehtellers und ein **Magnetsensor** auf der unteren Ebene der rotierenden Plattform angebracht. Eine Bohrung unterhalb des Sensors ermöglicht den Magnetkontakt. Sobald der Magnet überfahren wird, wird dies von dem in Abbildung {{ref>magnetsensor}} dargestellten Magnetsensor erkannt und der Nullpunkt neu definiert. Näheres hierzu ist in der Beschreibung der offset() Funktion beschrieben.//
//

<figure magnetsensor>
{{:projektesose21:schnappi:magnetsensor_reed_switch_module_se015_neu_2.png?800|}}
<caption>Magnetsensor Reed Switch Module SE015</caption>
</figure>//
//



===== Krokodil =====

Das Krokodil ist der Teil des Roboters, welcher die meiste Interaktion mit dem Menschen erfordert. Anforderungen an diesen Projektteil waren:

  - Erkennung der Zahnzustände (gedrückt oder nicht gedrückt)
  - Erkennung des Maulzustands (offen oder geschlossen)

**Zu 1.**
Unsere Idee war hierbei jeden einzelnen Zahn mit einem eigenen Draht zu versehen und diese an digitale Pins des Arduinos anzuschließen. Zusätzlich haben wir einen Leiterdraht mit Kontakt zu allen Zähnen im Inneren des Mauls entlang gelegt und diesen dann am Arduino Pin Ground angeschlossen (vgl. Abbildung {{ref>zahnkontakte}}).

<figure zahnkontakte>
{{:projektesose21:schnappi:maul.png?800|}}
<caption>Zahnkontakte</caption>
</figure>//
//


Wie hier gut zu sehen ist besteht bei nicht gedrückten Zähnen ein Kontakt zwischen den Leiterbahnen und fließt Strom. Wird ein Zahn gedrückt löst sich der Kontakt und es fließt kein Strom. 

//
//
**Zu 2.**
Um den Maulzustand zu registrieren, befindet sich ein Schalter im hinteren Teil des Krokodils. Wenn dieser gedrückt wird, fließt Strom (Maul ist geöffnet) und wenn er nicht gedrückt ist fließt kein Strom (Maul geschlossen). Dieser Mechanismus ist in Abbildung {{ref>maulsensor}} zu sehen.


<figure maulsensor>
{{:projektesose21:schnappi:maul2.png?800|}}
<caption>Sensor für Maulstatus</caption>
</figure>//
//

//
//
Wie wir diese Zustände in unserem Programm verwendet haben, könnt Ihr hier[link zu Software, teethStatus] lesen.//
//

**Video:**//
//

In dem folgenden Video ist die Funktionsweise des Spiels (ohne die Getränkeausgabe) zu sehen. Es ist vor eingestellt, dass es vier Spielende gibt, obwohl in dem Video nur zwei Spielende zu sehen sind. Hier spielt also jeder zwei imaginäre Spielende, welche an den Ecken des Tisches sitzen sollen://
//

{{:projektesose21:schnappi:spielpraesentation.mp4?400|}}//
//

Video 1: Schnappi -- Spielpräsentation//
//



==== Getränkeausgabe ====

Die Getränkeausgabe besteht aus drei Schritten://
//

  - Finden der Position des Glases der/des Spielenden
  - Ausschenken des Getränks
  - Zurückkehren in die Ausgangsposition//
//

**Zu Schritt 1**//
//

Zunächst muss herausgefunden werden, an welcher Stelle (auf welchem Winkel) das Glas gerade steht. Dazu wird das Krokodil und die sich unterhalb befindliche Konstruktion der Getränkeausgabe samt Sensorik gegen den Uhrzeigersinn an die Untere Grenze des Winkelbereichs der/des gerade spielenden gedreht.//
//

Anschließend wird der Drehteller wieder in Uhrzeigerrichtung gedreht bis die obere Grenze der/des Spielenden erreicht ist. Dabei wird der gesamte Winkelbereich mit einem Ultraschallsensor (vgl. Abbildung {{ref>getraenkeausgabe}}) abgetastet und die Position des Gegenstands mit dem geringsten Abstand zum Drehteller abgespeichert. (Es wird die Annahme getroffen, dass das nächstgelegene Objekt das Glas ist.) Nachdem die Winkelposition des Glases ermittelt wurde, wird der das Krokodil wieder im Uhrzeigersinn zurück an diese Position gedreht.//
//

//Anmerkung zu Ultraschallsensoren:////
//

//Ultraschallsensoren können nicht punktgenau messen, sondern besitzen eine gewissen Abstrahlwinkel, in dem sie Objekte erkennen können. Damit nicht versehentlich Objekte außerhalb des Winkelbereichs der/des gerade Spielenden erkannt werden, beginnt die Messing nicht ganz am Rand und endet etwas vor der oberen Grenze. Dadurch entsteht ein kleiner Bereich, in dem kein Glas stehen darf, da es sonst vom Sensor nicht erkannt werden kann (vgl. Abbildung {{ref>sensorbereich}}).////
//

//Außerdem muss davon ausgegangen werden, dass die Messergebnisse nicht ganz exakt sind. Um kleiner Messabweichungen auszugleichen, wurden daher Führungsschienen im Vorderen Bereich der Ausgabevorrichtung angebracht, die das Glas zentrieren (vgl. Abbildung {{ref>getraenkeausgabe}}).//
////

<figure sensorbereich>
{{:projektesose21:schnappi:abtastbereich_neu.png?800|}}
<caption>Abtastbereich Ultraschallsensor</caption>
</figure>//
//

<figure flasche>
{{:projektesose21:schnappi:flasche.png?800|}}
<caption>Getränkevorrat</caption>
</figure>//
//

**Zu Schritt 2**//
//

Auf der oberen Ebene der Plattform befindet sich der Getränkevorrat in einer Kunststoffflasche (vgl. Abbildung {{ref>flasche}}). In diese führen zwei Schläuche://
//

Der erste Schlauch führt von einer auf der unteren Ebene angebrachten Luftpumpe (in Abbildung {{ref>getraenkeausgabe}} nicht sichtbar) in die Flasche. Durch ihn wird während der Getränkeausgabe Luft in die Flasche gepumpt. Dabei entsteht in der Flasche ein Überdruck.//
//

Der zweite Schlauch führt vom Grund der Flasche hinaus zur unteren Plattformebene. Durch den Überdruck in der Flasche wird die Flüssigkeit durch den zweiten Schlauch aus der Falsche gedrückt. Die Flüssigkeit wird jedoch zunächst durch ein Magnetventil (vgl. Abbildung {{ref>getraenkeausgabe}}) auf der unteren Plattformebene am Austreten gehindert.//
//

<figure getraenkeausgabe>
{{:projektesose21:schnappi:getraenkeausgabe_beschriftet.png?800|}}
<caption>Getränkeausgabe</caption>
</figure>//
//

Auf der unteren Ebene befindet sich eine Schubladenschiene mit einer Zahnstange. Die Zahnstange wird mit einen Steppermotor NEMA 17 über ein Ritzel angetrieben und so die rotatorische Bewegung in eine translatorische Bewegung überführt. Zwei Tastschalter dienen der Erkennung, ob die Schiene voll ein- oder voll ausgefahren ist.//
//

An der Spitze der Zahnstange befindet sich ein weiter Tastschalter, welcher bei Glaskontakt ausgelöst wird. Dahinter befindet sich das Magnetventil.//
//

Wenn ein Getränk ausgegeben werden soll, wird die Schubladenschiene nach vorne zum Glas bewegt. Sobald sich der Ausgießer über dem Glas befindet und der Schalter durch Druck gegen die Glaswand ausgelöst wird, wird das Magnetventil geöffnet, und die im Leitungssystem unter Druck stehende Flüssigkeit freigegeben. Die Flüssigkeit fließt dann über einen gebogenen Auslassschlauch direkt in das Glas. Die Füllmenge kann über die Öffnungsdauer des Magnetventils gesteuert werden. Nachdem das Magnetventil geschlossen wurde, fährt die Schiene wieder zurück in ihre Ausgangsposition.//
//

**Zu Schritt 3**//
//

Nach Abschluss der Getränkeausgabe wird das Krokodil wieder zur/zum Spielenden gedreht und darauf gewartet, dass das Krokodilmaul geöffnet wird.//
//

**Videos:**//
//

Die Schritte 2 und 3 der Getränkeausgabe können in den folgenden Videos nachvollzogen werden://
//

Video 2 zeigt die Getränkeausgabe.//
//

{{:projektesose21:schnappi:getraenkeausgabe_1.mp4?150|}}//
//

Video 2: Glas erkannt

Video 3 Zeigt den Fall, dass kein Glas gefunden wurde, bis das Ende der Zahnschiene erreicht wird und die Rückfahrt eingeleitet wird.//
//

{{:projektesose21:schnappi:getraenkeausgabe_2.mp4?150|}}//
//

Video 3 - Kein Glas in Reichweite//
//




==== Übrige IT-Komponenten ====

In dem Teilsystem "Übrige IT-Komponenten" sind jene Komponenten zusammengefasst, die keine speziellen Teilsystem zugeordnet werden können, sondern dem Zusammenspiel der einzelnen Teilsysteme dienen und von ihnen gleichermaßen genutzt werden. Hierzu gehören die folgenden Komponenten inkl. der jeweiligen Verkabelung://
//
  * Breadboard
  * Arduino Mega
  * Bluetooth Empfänger
  * Motortreiber
  * Magnetsensor//
//

Auf dem **Arduino Mega** findet die Hauptrechenleistung statt, und auf ihm läuft das Hauptprogramm schnappi.Main(). Aufgrund der Vielzahl benötigter Pins (jeder Zahnsensor benötigt bereits einen digitalen Pin) haben die Anschlüsse eines Arduino Nano hier nicht ausgereicht.//
//

Um den Steppermotor ansteuern zu können, ist ein **Motortreiber** erforderlich. Dieser wird über ein **Breadboard** und Kabel mit dem Motor und einem Akku verbunden. Der **Akku** dient als Stromquelle für den Motor und allen übrigen Komponenten (mit Ausnahme des Smartphones), da sich bei Verwendung einer externen Stromquelle das Kabel im Betrieb aufwickeln würde. Der **Bluetooth Empfänger** dient der Kommunikation zwischen Smartphone und Arduino und ist ebenfalls auf dem Breadboard untergebracht. Der **Magnetsensor** ist nicht auf dem Breadboard angebracht, sondern an einem separaten Aluwinkel direkt auf der Rotationsplattform, um (wie zuvor bereits beschrieben) die Nähe zum Magneten sicherzustellen.//
//

Der Schaltplan in Abbildung {{ref>schaltplan}} zeigt die einzelnen Bauelemente und ihre elektrische Verschaltung.//
//

<color #ed1c24>**ACHTUNG!!! Hier muss (anders als auf der Abbildung {{ref>schaltplan}}) ein GETEILTES Breadboard verwendet werden! Dabei ist die obere Leiste zu einer langen zu verbinden, und die untere Leiste bleibt getrennt!**</color>//
//

Im Ergebnis erhält man drei Stromkreise://
//

  * 12 V (unten links für die beiden Stepper)
  * 9,6 V (unten rechts für das Magnetventil und die Pumpe
  * 5 V (oben für die übrige Spannungsversorgung über den Arduino)

<color #ed1c24>**ACHTUNG!!! Beim letzten Anschließen kam es zu einem KURZSCHLUSS! Entweder wurde etwas falsch gesteckt, ein Bauteil/Kabel ist defekt, oder im Schaltplan leíegt ein Fehler vor. Bevor der Schaltplan so verwendet wird, muss er sorgfältig geprüft werden!**</color>//
//


<figure schaltplan>
{{:projektesose21:schnappi:schaltplan_breadboard_steckplatine_neu.png?1000|}}
<caption>Schaltplan Schnappi - Roboterspiel Schaltplan / Steckplatine</caption>
</figure>//
//

===== Software =====
//
//
Unser Hauptprogramm in Arduino ist die Schnappi.Main Datei. Hier werden alle Teilprogramme vereint und in einer bestimmten Reihenfolge ausgeführt. Der Ablauf aller Methoden ist als Flussdiagramm in Abbildung {{ref>uml}} dargestellt.

//
//

<figure uml>
{{:projektesose21:schnappi:uml.png?1000|}}
<caption>UML - Ablaufdiagramm - schnappi.Main</caption>
</figure>//
//


//
//

Im Folgenden wird erklärt wie die einzelnen Methoden funktionieren und wie Diese als Ganzes zusammenwirken.
//
//

===Initialization()===

Die Initialisierung() wird einmalig am Anfang des Spiels ausgeführt. Dabei dreht sich der Roboter um 360° und erhöht mit jedem Grad den Zähler einer Winkelvariable. Da der Roboter eine ganze Umrundung macht, fährt er genau einmal über den am unteren Zahnrad befestigten Magneten. Wenn das geschieht erfasst der Magnetsensor auf dem Drehteller für kurze Zeit ein Signal. An genau diesem Zeitpunkt wird der Wert der Winkelvariable mit Hilfe der Funktion offset() ausgelesen und als Fixpunkt in einer globalen Variable gespeichert. Dies dient dazu, dass sich der Roboter bei späteren Umdrehungen immer wieder neu ausrichten kann und der Fehler dadurch nicht maximiert wird. Nach der Initialisierung weiß der Roboter auf welcher Gradzahl er sich befindet (gleicher Punkt wie vor der Initialisierung) und wo sich der Fixpunkt zur Neuausrichtung befindet.

===getPlayersPosition()===

<figure fluss>
{{:projektesose21:schnappi:gesichtserkennung_flussdiagram.png?1000|}}
<caption>Ablaufdiagramm der Funktion getPlayersPosition() (vereinfachte Darstellung)</caption>
</figure>//
//



//
//

Schritt 1.
//
//

Unmittelbar nach der Initialization() wird die getPlayerPositions() Methode ausgeführt. Da diese Methode eine
Kommunikation zwischen dem Processing Programm in Form einer App auf dem Smartphone und dem Arduino verwendet,
schickt der Arduino ein Startsignal an das Processing Programm. Zur gleichen Zeit wird der Motor einen Schritt
gedreht. Auf der momentanen Winkelposition sucht das Processing Programm mit Hilfe einer eingebundenen Bibliothek*
nach Gesichtern. Wenn ein menschliches Gesicht mit hoher Wahrscheinlichkeit erkannt wurde, wird über das
Bluetoothmodul (HC05) eine "1" an den Arduino gesendet. Falls sicher kein Gesicht erkannt wurde, weine "0". Das
senden dieser Daten geschieht ebenfalls über eine eingebundene Bibliothek*. Dieser Prozess wird nun in einer 
Schleife Zehn mal ausgeführt. Dabei entspricht "n" der Anzahl von erkannten Nullen bzw. Einsen. 
Nach Zehn Durchläufen prüft der Arduino auf wie vielen der zehn zurückgelegten Schritte ein Gesicht erkannt bzw. 
nicht erkannt wurde. Wurden mehr als Sieben von 10 Gesichtern erkannt muss sich ein Spieler im Sichtfeld der Kamera
befinden. Ist dies der Fall wird in einem Array (Tabelle) der derzeitige Winkel als "Anfangsbereich" des erkannten 
Spielers gespeichert.

//
//

Schritt 2. 

//
//

Nun wird Schritt 1 so lange erneut ausgeführt, bis in 10 weiteren Schritten weniger als 2 Mal ein Gesicht erkannt
wurde. Das lässt nun nämlich darauf schließen, dass der selbe Spieler nun aus dem Sichtfeld der Kamera verschwunden
ist. Nun wird der momentane Winkel als "Endbereich" des Spielers in der Tabelle abgespeichert. 

//
//

Schritt 3. 

//
//

Aus dem Anfangs- und Endwinkel wird nun der ungefähre tatsächliche Winkel des erkannten Spielers ausgerechnet und 
ebenfalls in der Tabelle gespeichert.

//
//

Nun sind alle Daten des ersten Spielers erfasst und die Methode führt Schritt 1-3 weiterhin aus. Für jeden weiteren 
erkannten Spieler wird die Tabelle um "eine Spalte erweitert". Dieser Prozess wird so lange ausgeführt bis sich
der Roboter um 360° gedreht hat. Die Tabelle wird dabei gespeichert und auf die entsprechenden 
Spielerpositionen kann jederzeit erneut zugegriffen werden.

===jawStatus()===

Diese Methode überprüft alle Anschlüsse (digitale Pins) des Krokodils auf Strom. Dabei erhalten wir die Antworten 
auf folgende Fragen: 

  - ist das Maul offen?
  - wurde ein Zahn gedrückt/nicht gedrückt?
  - ist das Maul dabei zugeschnappt, oder nicht?

Punkt Eins muss erfüllt sein, damit das Spiel gestartet werden kann. Andernfalls wartet der Roboter so lange, bis
das Maul geöffnet wird. Punkt Zwei wird benötigt um zu prüfen ob ein Spieler an der Reihe war. Punkt Drei ist nötig
um zu überprüfen, ob nach dem Drücken eines Zahnes der nächste Spieler angefahren werden kann (-> Maul nicht 
zugeschnappt), oder ob der derzeitige Spieler ein Getränk eingeschenkt bekommt (-> Maul zugeschnappt).
Wie sich zeigt ist jawStatus() also eine Schlüsselmethode, die sehr oft im Programm aufgerufen werden muss und in
unserem Programm einen Hauptbestandteil der Interaktion zwischen Mensch und Roboter darstellt.

===doubleCheck()===

Durch diese Methode soll sichergestellt werden, dass das Resultat von jawStatus() ein permanenterZustand ist und 
keine zufälligen Abweichungen (durch Wackelkontakt oder Ähnliches) auftreten. Dazu sollen innerhalb von 2 Sekunden 
200 Abfragen von jawStatus() erfolgen, bei denen sich die Ausgaben nicht unterscheiden dürfen. Erst dann wird dieser 
Zustand als tatsächlicher Zustand angenommen. doublCheck() dient also zum Abfangen von potenziellen Fehlerquellen
bei den Zahn- und Maulkontakten und wird immer nach jawStatus() ausgeführt.

===saveStatus()===

Ist das Krokodilmaul nun offen, wird die Mehtode saveStatus() ausgeführt. Hier wird der derzeitige jawStatus()
zwischengespeichert, damit dieser mit dem jawStatus() des folgenden Spielers verglichen werden kann um mögliche
Unterschiede festzustellen.

===nextPlayer()===

Mit Hilfe dieser Methode wird der nächste Spieler angefahren. Dazu wird auf die Ausgangswerte der Funktion 
getPlayersPosition() zurückgegriffen. Die Gesamtanzahl der Spielenden, sowie die Werte der aktuellen Spielerzahl+1
werden aus der Tabelle entnommen. Um im späteren Verlauf des Spiels keine Spieler anzufahren, die nicht existieren
wird überprüft, ob der Spieler der angefahren werden soll durch die Gesamtspielerzahl restlos teilbar ist. Falls ja
wird der erste Spieler der Tabelle angefahren.

//
//
Zudem wird nach jedem Motorschritt die offset() Methode ausgeführt, damit sich der Roboter ggf. neu ausrichten
kann, sobald der Magnetsensor überfahren wurde.

===serveDrink()===

Diese Methode befindet sich noch in der Entwicklungsphase und es ist noch nicht sicher, ob Sie bis zum Semesterende
fertiggestellt werden kann. 

//
//
Voraussichtlich wird diese Methode, sobald das Krokodil bei einem Spieler zugeschnappt hat, auf 
getPlayersPosition() zugreifen und den Gesamtspielerbereich des aktuell angefahrenen Spielers entnehmen. 
Anschließend wird dieser Bereich einmalig abgefahren und ein Entfernungssensor prüft auf Gegenstände, die sich 
am nächsten befinden. Wurde eine solche Posotion gefunden, wird diese angefahren und ein Steppermotor wird 
aktiviert um ein Gestell für die Getränkeausgabe über dem Glas zu positionieren. Dies soll durch einen Taster
geschehen, welcher gedrückt wird, wenn das Glas erreicht ist. Anschließend soll ein Ventil für eine bestimmte
Zeit geöffnet werden, um das Glas zu füllen. Sobald dies geschehen ist, könnte das Gestell wieder eingefahren
werden und es wird gewartet, bis das Krokodilmaul geöffnet wird, um das Spiel fortzusetzen.//
//


Der komplette Programmcode kann hier heruntergeladen werden://
//

{{:projektesose21:schnappi:programmcode_schnappi.zip|}}

====== Ergebnis und Fazit ======


Der Fokus sollte vor allem auf der Entwicklung des Spiels und der Fähigkeit des Roboters liegen, die Spielenden zu erkennen, sich zu ihnen auszurichten und die Interaktion mit dem Krokodil zu detektieren und auszuwerten. Da es bereits aus einem früheren Semester einen Roboter gibt, der Getränke ausschenkt, kann auf diesen Ergebnissen aufgebaut werden. Der Mechanismus zum Ausschenken des Getränks sollte daher erst am Ende des Projekts in Anlehnung an den bestehenden Roboter realisiert werden, wenn noch ausreichend Zeit zur Verfügung steht. 

Wir schätzen unser Projekt für die gegebene Zeit als anspruchsvoll ein und sind daher nicht enttäuscht, dass wir
den Roboter bisher nicht vollständig fertig stellen konnten. Die "nicetohave" -und "soll" Methoden, welche wir in
unserem Projektplan definiert haben, konnten wir mit guten Ergebnissen fertigstellen. Rückblickend sind wir 
an vielen Stellen auf unerwartete Schwierigkeiten gestoßen. Beispiele dafür sind unter Anderen der Algorithmus der 
Gesichtserkennung, oder die vollständige Verkabelung des Krokodils. In Bezug auf die Gesichtserkennung ist hierbei von Lösungen, welche 
"Processing-Android" verwenden abzuraten, da diese viele Unvollständigkeiten mit sich bringen und sehr zeitaufwändig zu entwickeln sind. Trotzdem konnten wir für viele Probleme eigene Lösungen entwickeln. Wir sind sehr zufrieden damit, dass unser Roboter kein Theorieprojekt geblieben ist, sondern auch in der Praxis zuverlässig funktionieren kann.


====== Ausblick ======

Als Erstes sind hier natürlich die Methoden zu nennen, welche bisher aufgrund von Zeitmängel leider nicht umgesetzt
werden konnten. Denkbar wären zudem verschiedene Spielmodi in denen der Spielverlauf durch gewisse Ereignisse
geändert werden kann. Ein Bespiel hierfür wäre das Ansteuern von Spielern nach dem Zufallsprinzip.
Außerdem könnte der Roboter "antäuschen" Spieler anzufahren. Eine andere Idee wäre für jeden gedrückten Zahn in
Folge bei dem das Krokodil nicht zugeschnappt ist die Anzahl der auszuschenkenden Gertränke für den Verlierer zu 
erhöhen. Hier gibt es also zahlreiche Möglichkeiten um den Verlauf des Spiels noch interessanter zu gestalten.
Projektlabor Robotik MINTgrün

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Seiten-Werkzeuge
