Unser Roboter WALL-E 0.5 orientiert sich an dem kleinen Roboter aus dem Film „WALL-E - Der letzte räumt die Erde auf“, ist nun aber eher ein Vorvorläufer-Modell geworden.

Abbildung 1: WALL-E

Ganz grob ist seine Aufgabe Gegenstände zu suchen, sie zu erkennen, zu ihnen hinzufahren und sie dann anhand ihrer Farbe in Kisten auf sich drauf einzusortieren.
Angefangen haben wir mit den folgenden Skizzen und Überlegungen.

• Wie soll der Roboter aussehen?
• Welche Form soll er haben?
• Welche Sensoren benötigen wir, damit der Roboter das macht, was wir möchten?
• Wie genau müssen die einzelnen Teile angeordnet sein, dass alles passt?
  • eine Frage, die auch während wir den Roboter bauten immer wieder auftauchte, weil es dann doch nicht so funktioniert hat, wie wir uns das vorgestellt hatten
• Welchen Entfernungssensor nutzen wir?
  • Infrarot oder Ultraschall

Abbildung 2: Skizze

• Welchen Entfernungssensor nutzen wir?
  • Infrarot oder Ultraschall

• Wie ist der Greifarm aufgebaut?
• Von wo greift er die Objekte?
• Wie greift er die Objekte?
• Welche Form hat er am besten, damit er gut unter den Roboter kommt, nicht an den Boden stößt und das Objekt gut anheben kann?
• Wie groß können die Objekte sein?

• Welche Farben sollen unterschieden werden?
• …

Abbildung 3: Skizze Greifarm

Wie das ganze nun wirklich funktioniert, wird durch folgende Abbildungen verdeutlicht.
Zuerst sucht der Roboter ein Objekt. Wenn er direkt eins finden, richtet er sich zu ihm aus, überprüft noch einmal und fährt dann, sollte die Überprüfung positiv gewesen sein, darauf zu. Bei negativer Überprüfung beginnt er von vorn.
Sollte der Roboter nicht direkt ein Objekt sehen, fährt er nach vorn, wobei er auch ständig sucht. Entweder findet er dabei ein Objekt oder dreht sich dann um 90° nach links, um dort weiter zu suchen.

Abbildung 4: Ablauf

Wenn er nun zu dem Objekt hinfährt, misst eine Lichtschranke, ob er das Objekt schon erreicht hat. Dies ist der Fall, wenn sie unterbrochen ist, wodurch der Roboter anhält. Daraufhin wird die Farbe des Objektes erkannt. Anhand dieser wird das Objekt nun über einen Greifarm, an dem ein Elektromagnet befestigt ist, angehoben und entweder links oder rechts in eine Kiste sortiert.

Abbildung 5: Ablauf

Wir haben unsere Projektarbeit in folgende Schritte gegliedert:

1. Fahren (geradeaus, drehen, zu den Objekten fahren)
2. Entfernung messen, Objekte erkennen
3. Farbe der Objekte erkennen
4. die Objekte greifen und sortieren

Erstmal hinten angestellt haben wir hierbei den zweiten Punkt unser „Soll-Liste“, dass der Roboter, wenn er das Objekt aufgesammelt hat, ein passendes Wort sagt, da dies eher eine kleine Spielerei ist und nicht unbedingt notwendig für die Funktionsweise.
Zeitlich haben wir folgendermaßen geplant:

Abbildung 6: Projektplan

Um den geschriebenen Code auch ausprobieren zu können, haben wir meist zuerst die Teile, die wir für die jeweilige Funktion benötigen, gebaut und dann mit dem Programmieren begonnen.

Der erste Bereich, um den wir uns gekümmert haben, war das Fahren. Dabei haben wir zuerst das Gestell aus Holz gebaut und anschließend die Stepper mit Rädern an der Unterseite befestigt. Nachdem diese Aufgaben erledigt waren, haben wir uns mit der Funktionsweise der Stepper auseinandergesetzt. Wir haben die Stepper an unseren Arduino angeschlossen, wobei der Direction Pin am Treiber darüber entscheidet, in welche Richtung sich der Stepper dreht. Die Richtung kann man ändern, in dem man den Pin entweder auf HIGH oder LOW schaltet. Damit der Stepper einen Schritt machen kann, muss man am Stepp-Pin des Treibers den Pin einmal auf HIGH und danach auf LOW schalten, um einen Stepp zu machen. Um also mehrere Stepps zu machen, haben wir das zwischen HIGH und LOW Wechseln in eine for-Schleife geschrieben. Damit konnte unser Roboter nun geradeaus fahren.
Damit wir den Roboter aber auch drehen und um eine gewisse Distanz fahren lassen konnten, mussten wir einmal den Raddurchmesser ausmessen und ausprobieren, wie viele Stepps eine komplette Radumdrehung sind. Mit diesen Werten konnten wir dann ausrechnen, wie viele Stepps wir brauchen, um eine vorgegebene Distanz zurückzulegen.

Multiplikator = Strecke / (π * Raddurchmesser) -> wie viele Radumdrehungen?
Step Anzahl = Multiplikator * 200 

Dabei ist die Variable Strecke die Strecke, die wir zurücklegen wollen, die im Programm eingegeben wird. Der Wert 200 ist die Anzahl der Stepps, die wir für eine komplette Radumdrehung brauchen.
Wenn wir unseren Roboter um eine gewisse Gradzahl drehen lassen wollen, ist die Berechnung der Stepps sehr ähnlich.

Strecke Rad = (25 * π) / (360 / Grad Drehen)
Multiplikator = Strecke Rad / (π * 9)
Step Anzahl = (200 * Multiplikator)

Beim Drehen ist die Variable, die wir im Code eingeben, der Wert Grad Drehen. Den Wert Strecke Rad ermitteln wir aus dem Umfang des Kreises, auf dem der Roboter sich dreht, also π-mal der Entfernung der zwei Räder unseres Roboters (25cm), geteilt durch den Anteil, des Wertes Grad Drehen von 360 Grad.
Nachdem wir das Geradeausfahren für eine feste Strecke geübt haben und auch das Drehen, um eine feste Gradzahl gut funktioniert hat, haben wir zu beidem jeweils eine Funktion geschrieben, damit wir bei eventuellen späteren Änderungen nur zwei Werte ändern müssen.

Um die Entfernung unseres Roboters zu den Objekten zu ermitteln, nutzen wir einen Infrarot-Sensor. Dieser sendet einen Infrarot-Lichtstrahl aus, der an Objekten reflektiert und dadurch zurückgeworfen wird. Der Arduino gibt dann je nach Einfallswinkel einen Wert aus. Dieser muss in die tatsächliche Entfernung umgerechnet werden.
Dafür stellen wir eine Messreihe auf, in dem wir den IR-Sensor in 1-cm Abständen zwischen 6 und 110 cm messen lassen und die ausgegebenen Werte gemeinsam mit den Entfernungen in eine Tabelle eintragen. Die Werte stellen wir dann grafisch dar und lassen eine Trendlinie ermitteln, die eine so weit wie möglich angenäherte Funktion ist.
Da unsere Messwerte bei der ersten Messreihe ab Entfernungen von 20 cm sehr streuten, stellten wir noch eine neue Messreihe auf, die wir dann auch auf 6-70cm eingrenzten. Diese neuen Werte sieht man auch in Abb.7.
Mit der ermittelten neuen Trendlinie berechnen wir daraufhin zu jedem Messwert die Entfernung. Diese weicht durch die nicht perfekte Annäherung von der eigentlichen Entfernung ab. Zur Berechnung der durchschnittlichen Abweichung nutzten wir die Rechnung des RMSE-Wertes. Die Gleichung lautet:

  y= eigentliche Entfernung
  x= gemessene Entfernung
  n= Anzahl der Messungen

Als durchschnittliche Abweichung erhalten wir etwa 2 cm (s. Abb.7 rechts linke Spalten). Um die Abweichung noch etwas zu verringern, optimierten wir die Gleichung durch Ausprobieren. Es entstand die rote Linie (Abb.7), mit der die Abweichung nur noch 1,725 cm beträgt. Ihre Gleichung lautet: y=128330x^(-1,458).

Abbildung 7: IR-Messreihe

Letztendlich haben wir allerdings festgestellt, dass die Werte des IR-Sensor auch stark von dem vorliegenden Licht abhängen. Außerdem ist er dafür gedacht nur in bestimmten Abständen zu messen und nicht dauerhaft, weshalb wir immer wieder viel zu hohe Messwerte erhalten, die das Ergebnis verfälschen. Die Streuung der Werte werden in Abb. 8 deutlich (eigentliche Werte bei 510, doch Messspitzen bei 570).

Abbildung 8: Sensorrauschen ohne Tiefpassfilter und Kondensatoren

Um die falschen Werte etwas auszubügeln, haben wir nun zwischen 5V und Ground des IR-Sensors noch zwei Kondensatoren mit insgesamt 20 Mikrofarad geschaltet. Zusätzlich nutzen wir einen Tiefpassfilter mit einem 1 Megaohm Widerstand und 100 Nanofarad Kondensator am Analogen-Pin. Dadurch wurden die Messspitzen etwas abgeschwächt.
In Abb. 9 kann man nun links erkennen, dass die Werte, wenn wir kein Objekt davor legen zwischen etwa 87 und 113 schwanken. Die großen Schwankungen resultieren daraus, dass der Lichtstrahl nirgendwo reflektiert wird und der Arduino deshalb beliebige kleine Werte ausgibt.
In dem rechten Bild haben wir ein Objekt davor gelegt und auch seine Entfernung verändert. Man sieht aber trotzdem, dass die Messspitzen deutlich weniger von dem eigentlichen Wert entfernt sind, als ohne den Tiefpassfilter und die Kondensatoren (die Sprünge sind immer <20).

Abbildung 9: Sensorrauschen mit Tiefpassfilter und Kondensatoren

Um Objekte zu erkennen, hat der Roboter nun den Auftrag in einem Bereich zwischen etwa 6 und 30 cm zu suchen. Das heißt, dass er Objekte mit einer Entfernung bis zu 30 cm wahrnehmen sollte. Dies hängt, wie oben beschrieben, allerdings auch vom Umgebungslicht und der Abweichung ab.
Das Erkennen entsteht dadurch, dass der Wert des Arduinos bei Entfernungen über 30 cm kleiner als 300 ist. Das heißt bei Entfernungen in unserem Bereich ist der Wert größer als 300. Dadurch unterscheidet das Programm nun zwischen ObjectiveFound=false und ObjectiveFound=true.
Ursprünglich sollte unser Roboter in einem größeren Bereich suchen, allerdings erhalten wir durch die Messspitzen dann noch viel öfter ein positives (Ich habe etwas gefunden) Signal, obwohl gar kein Objekt zu sehen ist.

Da der IR-Sensor nur geradeaus misst und kaum streut, haben wir ihn an einem Servo befestigt, der ihn nun auf einem 100°-Winkel (30°-130°) suchen lässt. Dieser Servo ist wiederum an einem weiteren Servo befestigt, der ihn nach oben klappt sobald ein Objekt gefunden wurde, damit der Roboter auf das Objekt fahren kann. Geschaltet haben wir diese drei Bauteile so:

Abbildung 10: Objekte erkennen und Entfernung messen

Ein Problem, das wir bis in die letzte Woche hatten, war, dass es unser Roboter nur manchmal geschafft sich so zu dem Objekt zu drehen, dass es wirklich genau vor ihm liegt (75°). Dadurch fiel die Überprüfung dann oft negativ aus, obwohl das Objekt fast davor lag. Da wir an diesem Problem lange geknobelt haben, wird es hier noch einmal extra erwähnt.
Um es zu lösen, haben wir unterschiedliche Sachen ausprobiert, z.B., dass sich der Roboter nur bei ServoEntfernungsmesser-Positionen ≤70° (Objekt steht links) oder ≥80° (Objekt steht rechts) zu dem Objekt dreht und sonst stehen bleibt (s. Abb. 11).

Abbildung 11: Idee zur Erkennung der Objekte

Zusätzlich soll er sich bei ≤70° 5° weiter als normal drehen, weil die Objekte dadurch, dass aus dem rechten Auge der IR-Lichtstrahl kommt, später erkannt werden (s. Abb. 12), und bei ≥80° 5° weniger als normal drehen. Da das erste keine Wirkung erzielt hat, haben wir es wieder rausgenommen. Der zweite Punkt ist aber weiterhin drin und erfüllt seinen Zweck.

Abbildung 12: Infrarot-Lichtstrahl

Bei Berechnung der Stepp-Anzahl für das Drehen zu einem Objekt, teilen wir unsere Step Anzahl außerdem noch durch 2, weil sich der Roboter vorher oft am Objekt vorbei gedreht hat, was damit seltener geworden ist. Der restliche Code ist identisch zum normalen Drehen.

Damit der Roboter nun auch weiß, wann sich Objekte unter ihm befinden und er anhalten soll, benutzen wir eine Lichtschranke.
Dafür haben wir eine sehr simple Schaltung ausgewählt. Alles was wir brauchen ist eine Infrarot-LED und eine Photodiode, die bei Infraroteinstrahlung schaltet.
Die LED und Diode sind beide vorne an unserem Roboter angebracht, wie in Abb.13 zu sehen ist, und sind direkt zueinander ausgerichtet. Die LED ist von Beginn bis Ende unseres Programms eingeschaltet und wir messen regelmäßig Werte an der Diode, um zu entscheiden, ob sich ein Objekt zwischen LED und Diode befindet oder nicht.
Wenn kein Objekt vorhanden ist, sind die gemessenen Werte sehr groß. Wenn ein Objekt zwischen LED und Photodiode liegt, dann dringt die Infrarot Strahlung nicht mehr zu der Photodiode durch und der Messwert an der Diode wird vergleichsweise sehr klein. Somit können wir sehr genau bestimmen, ob ein Objekt unter unserem Roboter liegt oder nicht.
Ein paar Probleme die dabei auftreten können sind zum einen das Sonnenlicht, welches zu einem gewissen Teil auch Infrarotlicht beinhaltet und somit zu einer Verfälschung der Messwerte führen kann, wenn es auf die Photodiode trifft. Deshalb lassen wir unseren Roboter immer mit dem Rücken zum Sonnenlicht starten, weil der Roboter ansonsten manchmal nicht anhält. Das zweite Problem ist, dass die LED eine gewisse Streuung mit sich bringt und somit manchmal an der Diode noch hohe Werte gemessen werden, wenn das Objekt mit der Kante eigentlich schon die Lichstschranke unterbricht. Dieser Fehler ist allerdings so minimal, dass wir damit nie größere Schwierigkeiten bekommen haben.

Abbildung 13: Lichtschranke

Unseren Farbsensor benutzen wir, um zwischen unseren zwei verschiedenen Objekten zu unterscheiden. Wir haben die Objekte aus Schaumstoff in Würfel geschnitten und auf die obere Fläche einmal ein helles gelbes und ein schwarzes Moosgummistück aufgeklebt, weil dieses das Licht nicht reflektiert und somit für unsere Zwecke ideal ist.

Abbildung 14: Objekte mit Moosgummi

Wir haben mit dem TCS230 Farbsensor gearbeitet, welcher mit einem 8×8 Feld aus Photodioden arbeitet. Dabei haben 16 Dioden rote Filter, 16 blaue Filter, 16 grüne Filter und nochmal 16 keine Filter. Die Dioden lassen bei Lichteinstrahlung Strom durch und je nachdem wie groß die Lichtintensität ist, wird der Widerstand der Photodioden kleiner, so dass mehr Strom im Schaltkreis fließen kann. Dieser Stromfluss wird im Farbsensor in ein Frequenzsignal umgewandelt, dass beim Arduino als Rechtecksignal ankommt und proportional zur Lichtintensität ist.

Abbildung 15: Signalumwandlung

Jeweils 16 Photodioden mit gleichen Filtern sind parallel geschaltet und können über die Pins S2 und S3 des Farbsensor angesteuert werden. Dabei spielt es nur eine Rolle, ob die Pins auf HIGH oder LOW geschaltet werden. Wie genau man die Pins für die entsprechenden Farben ansteuern muss, kann man in Abb.16 sehen. Die Pins S0 und S1 dienen der Skalierung der Messwerte, die beim Arduino ankommen. Hier ist wieder nur wichtig wie man die Pins schaltet.

Abbildung 16: Farbsensor Pin Belegung

Wir haben in diesem Fall eine 100% Skalierung ausgewählt, weil unsere Messwerte sonst zu gering waren und wir schlecht Unterschiede bei verschiedenen Farben feststellen konnten.
Damit wir den Farbsensor aber richtig benutzen können, müssen wir ihn zuerst kalibrieren, damit er an unsere äußeren Umstände angepasst ist. Dafür haben wir die 4 verschiedenen Filter nacheinander eingeschaltet und zuerst ein weißes Blatt Papier unter den Farbsensor gelegt und dann ein schwarzes.

Der Grund dafür ist, dass wir am Ende RGB-Werte ausgeben möchten und dabei Schwarz der kleinstmögliche Wert ist(0) und Weiß der gröchstmöglichste (255). Die Werte, die wir dann erhalten haben sind die untere und obere Grenze für unsere Messwerte mit Objekten anderer Farben, weil diese Werte irgendwo dazwischen liegen müssen. Um die Werte dann in den RGB-Zahlenbereich umzurechnen, haben wir die map-Funktion benutzt, welche einen Wert aus einem Intervall in ein zweites Intervall umrechnet, sodass der Abstand zu den äußeren Grenzen im Verhältnis gleich ist. Ein Beispiel hierfür ist auch nochmal in Abb.17 zu sehen. Die erste Variable ist hier unser gemessener Wert und die zwei darauffolgenden sind die Grenzen unseres ersten Intervalls, also von unserer Sensorkalibrierung. Die zwei letzten Zahlen sind die Grenzen des zweiten Intervalls in den der Messwert umgerechnet werden soll.

Abbildung 17: map-Funktion

Das Problem, das sich uns dabei gestellt hat, ist, dass wir nicht zuverlässig die Farben erkennen konnten, sondern nur erkennen konnten, welches Objekt heller ist. Deshalb mussten wir von unserem ursprünglichen Gedanken, Objekte an zwei Farben zu unterscheiden, abweichen und unterscheiden jetzt zwischen hell und dunkel.

Unser Greifarm, war das letzte Teil unseres Roboters, mit dem wir uns beschäftigt haben. Es war auch zeitlich gesehen das Teil, für das wir am längsten gebraucht haben, bis es funktioniert hat.
Zu allererst mussten wir uns überlegen, wie der Greifarm überhaupt aufgebaut sein soll, und wie er Objekte aufgreifen soll. Das Objekte-Greifen war sehr schnell geklärt. Wir verwenden einen Elektromagneten und haben auf unsere Objekte kleine Eisen-Plättchen geklebt, so dass wir diese mit dem Elektromagneten greifen können. Bei dem Aufbau des Greifarms wollten wir, um den Arm zu knicken und in die richtige Position zu bringen, am Anfang mit 2 Steppern und einem Servo arbeiten, wie in unserer ersten Skizze (s. Abb. 3) zu sehen ist.
Unser erster Arbeitsschritt war, das Holz zurecht zu sägen, das wir als Verbindungsteile zwischen den Servos und Steppern benutzen. Nachdem wir diese Teile fertigstellten, konnten wir die Bewegungsabläufe des Greifarms nur mit den Holzteilen durchgehen, um zu überprüfen, ob wir mit unserer Idee die Objekte überhaupt gut greifen können. Das Ergebnis war, dass wir für den Greifarm lieber zwei Servos mit einem größeren Winkel benutzen, damit der Greifarm nicht so schwer ist. Dafür nutzen wir nun, um die Objekte in unterschiedliche Boxen einzusortieren, einen Stepper, über den wir den Greifarm am Roboter befestigen.

Abbildung 18: Greifarm

Die Servos können sich in einem 180 Grad Bereich drehen und den Stepper benutzen wir, um den Arm entweder nach vorn oder nach hinten zu den Boxen zu drehen. Die Objekte mussten wir auch sehr oft neu anpassen, weil der Greifarm mit dem Elektromagneten am Anfang die Objekte nicht ohne menschliche Hilfe greifen konnte. Wir hatten die Objekte am Anfang nur als Quader designt, doch da der Elektromagnet nicht im 90°-Winkel an die Objekte rankommt, sondern leicht nach oben zeigt, konnte er die Objekte so nicht anziehen. Deshalb haben wir am Ende an die Seiten noch kleine schräge Wände angeklebt, an denen die Metallscheiben sind (s. Abb. 19).

Abbildung 19: Objekte

Nachdem wir uns darauf festgelegt haben den Greifarm mit 2 Servos zu steuern und den Stepper zum Drehen zu benutzen, haben wir angefangen unsere Schaltung für den Elektromagneten aufzubauen, welche ihr in Abb. 20 sehen könnt (Hier soll der Motor den Elektromagneten darstellen, es gab nur leider keinen in dem Programm mit dem wir den Schaltplan erstellt haben). Um den Elektromagneten benutzen zu können mussten wir einen MOSFET in unsere Schaltung einbauen. Dieser ist ein variabler Widerstand, mit dem man den Arduino als Logikschaltung für Bauteile verwenden kann, die eine größere Spannungsquelle als die 5V des Arduinos brauchen.

Abbildung 20: MOSFET Schaltung Elektromagnet

Anschließend beschäftigten wir uns mit der Programmierung des Greifarms. Dabei traten ein paar Probleme auf.
Zuerst bewegte sich der Stepper bei dem gleichen Programmcode unterschiedlich weit. Dann drehte er sich bei der gleichen Steppanzahl im Uhrzeigersinn weiter als gegen den Uhrzeigersinn. Dazu haben wir versucht die Anzahl der Schritte gegen den Uhrzeigersinn zu erhöhen und das Problem somit zu lösen. Nachdem dies aber nicht funktionierte, mussten wir nach einer anderen Lösung suchen. Letztendlich erhöhten wir an den Stepper-Treibern die Stromversorgung, was glücklicherweise funktionierte.
Außerdem mussten wir die Greifbewegung des Arms oft überarbeiten, weil die Objekte teilweise nicht richtig gefasst wurden oder kleine Änderungen an dem Aufbau unseres Roboters, wie zum Beispiel die Platzierung der Lichtschranke einen Einfluss auf die Position des Objekts haben.
Das letzte Problem, das aufgetreten ist, war die zu schwache Stromversorgung der Stepper. Unser Programm ist oft abgestürzt, weil die Servos mehr Strom benötigten, als der Arduino liefern kann, wodurch das Programm auf dem Arduino immer wieder neu gestartet hat. Die Lösung dazu ist, dass wir die Servos über einen Step-Down Konverter mit dem Akku betreiben, wodurch der Arduino nicht mehr belastet ist und das Programm ohne Abbrüche durchläuft.

Unser Roboter schafft es nun nach etwa vier Monaten Arbeit tatsächlich seine Grundaufgaben Suchen, Fahren, Farben erkennen, Aufheben und Sortieren auszuführen. Leider nicht alles so zuverlässig, wie wir es gern hätten.
Hauptsächlich haben wir Probleme bei der Objekterkennung, da trotz der Verbesserungen mit Tiefpassfilter und Kondensatoren immer noch nicht vorhandene Dinge gesehen werden.
Außerdem haben wir lange dafür gebraucht, dass sich unser Roboter ordentlich zu den Objekten dreht, sodass er nicht jedes Mal nach der Überprüfung neu anfängt zu suchen. Dafür haben wir in der letzten Woche glücklicherweise noch eine funktionierende Lösung gefunden. Das Ergebnis kann man in den den folgenden Videos sehen

Zusätzlich gibt es natürlich noch einige Möglichkeiten zur Erweiterung. Beispielsweise hatten wir uns noch überlegt, dass es ganz nett wäre, wenn der Roboter

• wenn er den Müll und/oder Wertvolles erfolgreich aufgesammelt hat, ein Wort sagt, das auf den Gegenstand zutrifft.
• wenn er keine Ladung mehr aufnehmen kann, zu seinem Startpunkt zurückfährt.
• erkennt, wenn seine Unterfläche aufhört zu existieren, dann anhält und in eine andere Richtung weiterfährt, wo er nicht die Unterfläche verlässt.
• eine Melodie abspielt, wenn er den Gegenstand in die Boxen einsortiert.
• automatisch zurückfährt, wenn sein Akku nur noch wenig Leistung hat → Berechnung von der Entfernung zum Startpunkt und wie viel Energie er zum Zurückfahren braucht.

Wir hätten auch Lust selbst noch weiter daran zu arbeiten.

Hier ist unser Programmcode:
Code

Abb.15 und Abb.16 : https://howtomechatronics.com/tutorials/arduino/arduino-color-sensing-tutorial-tcs230-tcs3200-color-sensor/