Projektlabor Robotik MINTgrün

Wir haben einen Roboter gebaut, der auf zwei verschiedene Weisen die Geschwindigkeit von Objekten bzw. Menschen misst. Ursprünglich stammte die Idee von mobilen Blitzern, wie man Sie vom Straßenverkehr kennt. Da diese allerdings mit einem Radar arbeiten, wollten wir uns etwas anderes ausdenken. Zuerst einigten wir uns auf eine Lichtschranke, welche mit einem Arduino kontrolliert wird. Wenn die Geschwindigkeit höher als ein festgelegter Wert ist, dann nimmt eine Webcam ein Foto und eine LED wird kurz angeschaltet. Da das aber relativ schnell zu machen war, haben wir uns zusätzlich auf eine zweite Methode geeinigt: Die Geschwindigkeitserfassung mittels einer Webcam. Da ein Arduino solche Berechnungen nicht machen kann, mussten wir die Berechnung und die Arbeit mit der Kamera mit einem Laptop machen.

Abb. 1: Kompletter Aufbau des Systems

Der Roboter besteht im Wesentlichen aus zwei Baugruppen, dem Kamera-Teil und dem Lichtschranken-Teil. Mit der Lichtschranke wollten wir so genau wie möglich die Geschwindigkeit des Objekts messen indem wir die Zeit festhalten, die ein Objekt brauch um beide Laser zu durchbrechen, und die Strecke zwischen den Lasern durch diese Zeit. Mit der Kamera wollten wir flexibler von der Ferne die Geschwindigkeit von Objekten messen können, dafür haben wir ihre Positionen zwischen den Bildern vergleichen und die Zeit zwischen den Bildern festgehalten.

Das Hauptaufgabenfeld der Lichtschranke war die mechanische Konstruktion des Gerüstes und das Löten der Laser, wobei wir Wert darauf gelegt haben, dass die Laser und die Phototransistoren fest verankert und stabil waren, sodass bei dem Transport und der Nutzung keine Probleme auftreten würden. Im Gegenzug war der Kamera-Teil eher Informationsverarbeitungslastig, da wir Bilder aufnehmen und analysieren mussten. Zudem war die Kommunikation mit dem Arduino, womit wir die Lichtschranke steuerten, ein Bestandteil beider Arbeitsteile der die beiden Aufgabenbereiche verband.

Die detailliertere Beschreibung ist wieder in zwei wesentliche Teile gegliedert: den Lichtschranken-Teil und den Kamera-Teil:

Lichtschranke :

• Der erste Teil, den wir bearbeitet haben, war die Lichtschranke. Diese läuft über Arduino-Code, welche die Zeitdifferenz berechnet. Auf der einen Seite des Aufbaus befinden sich zwei Laser (L1 bzw. L2), welche eine konstande Distanz von 0.94m von einander entfernt sind. Auf der anderen Seite befinden sich zwei Phototransistoren (PT1 bzw. PT2), die ebenfalls 0.94m von einander entfernt sind. Die Messwerte zur Geschwindigkeitsermittlung werden erfasst, indem eine Stoppuhr ausgelöst wird, sobald die erste Lichtschranke unterbrochen wird. Die Zeit wird so lange gemessen, bis die zweite Lichtschranke ebenfalls unterbrochen wird.

Abb. 2: Schematischer Aufbau der Lichtschranke

Abb. 3: Tatsächlicher Aufbau der Lichtschranke

• Es stellt sich allerdings die Frage, wie wir überhaupt diese Unterbrechung der Lichtschranke aufnehmen können. Da die Sonne und die Deckenlichter tagsüber recht hell sind und wir unseren Aufbau tagsüber benutzen wollten, mussten wir recht viel „noise“ rausfiltern. Das haben wir erreicht, indem wir uns auf einen PT-Wert von 700 festgelegt haben. Wenn dieser unterschritten wird, fängt die Stoppuhr an (bzw. hört auf, je nachdem ob es am PT1 oder PT2 ist). Dazu muss man wissen, dass der normale Wert selbst bei hellem Zimmer unter 600 liegt und der Maximalwert von 1000 nur erreicht werden kann, wenn der Laser auf den PT gerichtet ist (Siehe Abbildung).

Abb. 4: Darstellung der Arbeitsweise des Arduinocodes

• Somit haben wir also die Zeit in Sekunden sowie die Strecke (die Konstante 0.94m) festgelegt. Jetzt kann man ganz leicht die Geschwindigkeit ausrechnen, indem man die Strecke durch die Zeit teilt. Wenn man Beispielsweise 1 Sekunde braucht um die Lichtschranke zu durchqueren, dann würde man die Geschwindigkeit wie folgt ausrechenen: 0.94m/1s = 0.94m/s. Dieser Wert (in m/s) wird dann auf dem seriellen Monitor ausgegeben. Da man sich aber i.d.R. eher wenig unter m/s vorstellen kann, rechnen wir diesen Wert noch in km/h um, indem wir ihn Mal 3.6 nehmen. Dieser Wert wird ebenfalls ausgegeben.

Kamera : Der vermutlich komplizierteste Teil und der, mit dem wir am meisten Zeit verbracht haben, war das Arbeiten mit der Kamera und die Bildverarbeitung. Die Bildverarbeitung haben wir über einen Laptop betrieben, der via USB-Kabel mit einer Webcam verbunden war. Auf dem Laptop haben wir mit dem Program Processing gearbeitet, einer nützlichen Open Source Software, die auch leicht zu benutzen ist und somit gut für Programmieranfänger ist.

Abb. 5: Die verwendete Kamera, eine Webcam

• Der erste Schritt beim Arbeiten mit Bildern ist das Beschaffen von Bildern. Dazu musste unser Laptop mit der Webcam kommunizieren können, was wir mit der Video-Library und insbesondere mithilfe der Capture-Library machen konnten. Wenn wir dann Bilder nehmen wollen um die Geschwindigkeit zu messen, können wir die Kamera mit einem Tastendruck „auslösen“ d.H. ca. von dem Moment an werden 20 der Bilder, die konstant von der Kamera übertragen werden, gespeichert und können dann für die Geschwindigkeitsberechnung benutzt werden. Man speichert nebenbei auch die Zeiten zu denen die Bilder genommen wurden.

• Der nächste Schritt ist die Etablierung des Maßstabs. Dazu haben wir hauptsächlich die void mousePressed() Funktion benutzt, um zwei Punkte anzuklicken deren echte Distanz von einander uns bekannt war, z.B. die Enden der Lichtschranke. Dann speicherten wir den X-Wert der Maus zum Zeitpunkt des jeweiligen Klicks, um eine Vergleichsdistanz in Pixeln zu bekommen. Die Reihenfolge der Klicks ist hierbei egal, weil wir den Betrag beim weiteren rechnen verwenden. Auf dem Bild unten sind unsere standard Click-Orte, die Laser der Lichtschranke, dargestellt, die mehr oder weniger genau 94 cm auseinander liegen.

Abb. 6: Ermittlung des Maßstabs

• Dann teilt man die echte Distanz durch die Pixel-Distanz der beiden angeklickten Punkte und bekommt damit ein Verhältnis womit man Pixel-Distanzen in echte Distanzen konvertieren kann.

• Die Kanten-Erfassung ist das Herzstück der Bildbearbeitung wenn nicht sogar des ganzen Projekts. Mit unseren Algorithmen konnten wir nämlich die Positionen von Objekten erkennen, vergleichen und damit letztendlich die Geschwindigkeit berechnen. Bilder in Processing werden als Arrays von Pixeln gespeichert, wobei für jeden Pixel bestimmte Eigenschaften gespeichert werden, wie z.B. die Helligkeit. Dies machen wir uns zu nutze indem wir die Helligkeit zwischen benachbarten Pixeln vergleichen, um Kanten zwischen einem Objekt und seine hellen Hintergrund zu finden. Um den Kontrast zu erhöhen iteriert man einmal durch das ganze Bild durch, und stellt jeden Pixel der heller als ein bestimmter Wert (ca. 120 in Processing) ist auf Weiß d.H. maximale Helligkeit und jeden Pixel der dunkler ist auf Schwarz d.h. minimale Helligkeit.
• Die Array-Speicherform der Bilder hat jedoch allerdings das Problem, dass sich damit nicht gut die Veränderung der Position eine Objektes messen lässt. Also haben wir stattdessen probiert das Bild eher wie ein Raster zu behandeln mit x- und y-Werten wobei man die Position im Array durch die folgende Formel ausdrücken kann: ArrayPosition = x-Position + y-Position * der Zeile in der man sich befindet. Dies kann man an folgendem vereinfachten Bild anschaulicher sehen:

Abb. 7: Vereinfachte Darstellung eines aufgenommenen Bildes, nachdem der Kontrast erhöht wurde.

• Als nächsten Schritt iteriert man dann mit zwei genesteten for-Schleifen durch das ganze Bild-Array durch und vergleicht die Helligkeit von (fast) jedem Pixel mit dem seines linken Nachbars. Dabei fängt man aber immer mit dem zweiten Pixel jeder Zeile an, da man den ersten Pixel mit Nichts nicht vergleichen kann. Wenn der Helligkeitsunterschied zwischen zwei benachbarten Pixeln groß genug ist, wird der x-Wert dieses Pixels gespeichert und am Ende, nachdem das ganze Array durchlaufen wurde, wird der Durchschnitt dieser x-Werte genommen um die Position der Kante auf dem Bild zu erfassen. Unten auf dem Bild ist am vereinfachten Beispiel von vorhin das Prinzip zu sehen. Die rot markierten Pixel sind die Kanten-Pixel und der hellgrüne Balken auf dem Bild ist die durchschnittliche Position des Objektes.

Abb. 8: Weiterführung der Funktionsweise des Edgefinder-Algorithmus.

• Dieser Algorithmus ist allerdings nicht fehlerfrei, wenn es zu keinem auffinden einer Kante kommt, dann kann es dazu führen, dass NaN zurückgegeben wird, was bedeutet, dass 0 durch 0 geteilt wurde. Um diese Fälle abzufangen, gibt es bei dem Rückgabe-Wert der Funktion eine Differenzierung: wenn NaN rauskommt, dann wird 99999 zurückgegeben, ein Wert der vom Program normal nicht erreicht werden kann und wenn 99999 bei der Geschwindigkeitsmessungsfunktion aufgenommen wird, wird die Differenz zwischen den beiden Bildern bei er Rechnung verworfen.

• Man wendet nun diesen Algorithmus zur Kantenfindung auf alle zuletzt gespeicherten Bilder an und vergleicht die Kante in einem Bild mit dem darauffolgenden, um die Strecke zu berechnen, die ein Objekt zwischen den Bildern hinterlegt hat. Dann konvertiert man diese gemessene Pixel-Distanz in die echte Distanz mithilfe des am Anfang etablierten Masstabs und teilt diese Distanz dann durch die vergangene Zeit zwischen den Bildern. Dann bildet man den Durchschnitt all dieser gemessenen Geschwindigkeiten zwischen den einzelnen Bildern um auf eine Gesamtgeschwindigkeit zu kommen. Zudem vergleicht man am Ende diese Geschwindigkeit noch mit der, die man mit dem Arduino mit der Lichtschranke misst, die sehr genau ist, um die Genauigkeit der Messung zu erfassen.

Bauteile: 2x Laser; Kabel(rot/blau/schwarz); PSU; Breadboard; Arduino Nano; 2x Phototransistoren; 2x Widerstand; Webcam; LED; Holz; Heißkleber

Abb. 9: Darstellung der Arduinoschaltung

Rückblickend kann man glaub ich sagen, dass wir uns vor einigen Monaten am Anfang des Semesters nicht zu hohe Ziele gesetzt haben. Wir haben alles fertig bekommen, was wir am Anfang fertig bekommen wollten. Wir haben eine Lichtschranke mit der wir Geschwindigkeit messen können, ein kleines Blitz-Licht, und eine Kamera mit der wir Bilder nehmen können. Darüber hinaus haben wir noch die Kamera benutzt um Bilder zu nehmen, was letztendlich eigentlich der interessanteste Teil des Projekts dann war.

Obwohl beide Projekthälften interessant waren und ziemlich gut funktionieren, kann man am Ende, im Vergleich zwischen den Beiden, klar sagen, dass die Lichtschranke eigentlich immer genauer misst und weniger von der Umgebung abhängt. Die Umgebungsunabhängigkeit kommt davon, dass die Umgebungshelligkeit nie so hell wie unserer Grenzwert für die Messung wird, was wir in einem vorherigen Absatz erwähnten. Jedes mal wo wir die Lichtschranke getestet haben, und beim manuellen Messen mit der Stoppuhr das Gefühl hatten sehr gut gemessen zu haben, hatten wir das gleiche Resultat wie die Lichtschranke.

Im Vergleich hängt die Messgenauigkeit der Kamera sehr von der Umgebung und der Geschwindigkeit des Objektes ab. Es muss zwischen Objekt und Hintergrund ein Hell-Dunkel Kontrast vorhanden sein und die Messgenauigkeit hängt auch von der Geschwindigkeit des Objektes ab. Allgemein gilt, dass je mehr Bewegung es zwischen den Bildern gibt, desto besser kann man die Geschwindigkeit messen. Demnach kann man der Ungenauigkeit bei niedrigeren Geschwindigkeiten ein Stückweit mit einer niedrigeren Bildaufnahmefrequenz entgegenwirken. Die Schranke ist dennoch in den meisten Fällen die genauere Geschwindigkeits-Messmethode.

Das Projekt ist allerdings noch nicht perfekt. Die Genauigkeit der Geschwindigkeitserfassung ist von der Frequenz mit der man Bilder nimmt abhängig und funktioniert eigentlich am Besten wenn man sich schnell durch Schranke bewegt. Zudem funktioniert die Messung der Geschwindigkeit mit der Kamera nur wenn ein Kontrast zwischen Objekt und Hintergrund besteht. Beides sind Problemgebiete an denen man im nächsten Semester arbeiten könnte, zu denen uns aber jetzt die Zeit fehlte.

allcode.zip