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.
=======Dokumentation über George=======

===== Einleitung =====
Der Name des Roboters lautet George, weil der erste Mensch, der einen Industrieroboter erfand, George Charles Devol hieß.

Ziel war es, einen Roboter zu bauen, der mithilfe von einem Ultraschallsensor ein Objekt vermisst und die Maße des Objekts an den Computer schickt. Dort soll es dreidimensional ausgegeben werden.
Aufgrund der Komplexität, wurde sich dafür entschieden, sich bei dem Objekt auf quader- und würfelförmige Objekte zu beschränken, die nicht breiter, länger als 19,8 Zentimeter oder höher als ca. 16 Zentimeter sein dürfen. Es sollte jedoch eine Höhe von mindestens drei Zentimetern vorweisen.

Um das zu realisieren, wurde George mit einem Ultraschallsensor und Motoren ausgestattet.
In der Mitte der Konstruktion befindet sich eine Kreisplatte auf die man den Quader oder den Würfel parallel zum Ultraschallsensor stellt.
Zuerst fährt der Sensor von links nach rechts mithilfe eines Motors, wobei die Entfernung zum Objekt gemessen wird (Breite). Anschließend dreht sich die Kreisplatte um 90°, damit die andere Seite des Objektes dem Sensor gegenüber steht. Für die Länge fährt der Sensor also von links nach rechts und misst erneut die Entfernung. 
Um die Höhe des Objektes zu messen, fährt der Sensor in die Mitte und von dort aus Stück für Stück nach oben und zählt die benötigten Schritte, bis kein Objekt mehr zu messen ist. Anschließend werden die Werte in Zentimeter umgerechnet und an Processing-IDE geschickt, was auf Grafik, Simulation und Animation spezialisiert ist. Dort wird das Objekt auf Basis der Maße in orange dreidimensional ausgegeben.
Dieses Objekt hat, soweit keine Messfehler auftraten, die Form des Würfels oder des Quaders.
Außerdem lässt es sich über einen Mausklick drehen.

Ursprünglich gab es die Idee, die berechneten Werte über ein Bluetooth Modul vom Roboter an den Computer zu schicken.
Da ein Computer für die Ausgabe des Dreidimensionalen Objektes zuständig war, wurde diese Idee verworfen und stattdessen ein Kabel zur Datenübertragung verwendet.

{{:projektewise18:george:george_2_.mp4|  - Nummerierter Listenpunkt}}\\

Video 1: Funktionsvideo von George 


 --- //[[Erika Jessica Mamberger]] 2019/02/20 16:52//

 --- //[[Erika Jessica Mamberger]] 2019/03/09 16:37//
===== Methoden/Umsetzung:=====

{{:projektewise18:george:lia_s_beschirftung.png?nolink&800|}}\\

Abbildung 1: beschriftete Darstellung von George\\

Der Roboter besteht hauptsächlich aus Holz. Ganz unten befindet sich die Basis, auf ihr wurden Holzbeine festgeschraubt. Außerdem befinden sich dort das Steckbrett mit der elektronischen Schaltung. In der Mitte befindet sich eine Runde Plattform, die anschließend das Objekt drehen wird. An einer der vier Seiten befindet sich der Ultraschallsensor, der sich später horizontal und vertikal bewegen kann.

Die Aufgaben bestanden darin, die drei Motoren sowie den Ultraschallsensor an zu steuern, sowie die Konstruktion passend auf die Ziele des Roboters anzupassen. Der Sensor muss sich bewegen können, die Motoren sollen nicht zu viel Last bewegen müssen und die Plattform muss sich drehen. 
Dabei soll die Konstruktion eine stabile Grundlage bilden.

Zuerst war das Ziel, jedes beliebige Objekt vermessen zu können. Später wurde sich dafür entschieden, nur würfelförmige Objekte (oder auch quaderförmige) zu verwenden um erstmal ein erreichbares Ziel zu haben. Bei ausreichender Zeit am Ende könnte man dies dann weiter ausbauen.

====Konstruktion====

Wie erwähnt, besteht der Roboter aus einer Holzplatte als Basis, auf der sich, neben der Schaltung, auch die Konstruktion aus Schienen, Motor und Riemen für die waagerechte Bewegung des Sensors, sowie die Stützen für die drehbare Plattform in der Mitte befindet.
Abgedeckt werden die Schaltung und die Beine von einer weiteren dünnen Holzplatte. In der Mitte wurde ein Kreis ausgesägt, damit dort die rotierende Kreisscheibe ihren Platz findet. Auf ihr gibt es Orientierungslinien, um das Objekt parallel zum Sensor ausrichten zu können.

Während der Arbeit kamen Fragen auf:

**Wie kann man den Sensor ohne viel Reibung waagerecht fahren lassen?**

Hierbei wurde sich entschieden, der Länge nach eine passende Gleitschiene mit Kugellager in das untere Holz zu schrauben. 
Mit Stäben wurde ein dünnes Stück Holz befestigt, auf dem sich wiederum ein anderer, leichter Holzblock befindet. Dort wurde der Sensor befestigt am Ende befestigt.

Außerdem wurden noch Riemenscheiben an einem Motor und an den Holzbeinen befestigt. Es wurde ein Riemen um einen Metallstab gewickelt und zusammengenäht an die Riemenscheiben gelegt. Somit kann sich der Sensor waagerecht bewegen.

Für die vertikale Bewegung wurden ebenfalls ein Motor, Riemenscheiben und ein Riemen verwendet, wo schließlich der Ultraschallsensor mit Klebeband befestigt wurde.

{{:projektewise18:george:schienen.jpeg?nolink&800|}}\\

Abbildung 2: Konstruktion für die waagerechte Fahrbewegung\\

**Wie wird die Kreisscheibe in der Mitte gedreht?**

Hier wurde viel überlegt, wie man die Scheibe so anbringt, dass sie stabil steht, jedoch trotzdem noch zu drehen ist. 
Die Kabel des Motors mussten nämlich so verlaufen, dass sie den Prozess nicht behindern, also im Weg sind.
Eine erste Überlegung war, im Holz eine Art "Weg" zu bohren, damit die Kabel sich nicht um den Metallstab unter der Scheibe wickeln. Dann wurde überlegt, den Motor einfach unter der Scheibe zu befestigen, jedoch würde sich ein ähnliches Problem ergeben. 

Unter die Kreisscheibe wurde also ein großes Zahnrad geklebt, damit sie sich überhaupt bewegen kann. Es wurde wieder ein Riemen verwendet. Damit er nicht verrutscht, wurden unter ihm, in das Zahnrad, Nägel geschlagen. 
Unter der Kreisscheibe befinden sich vier Beine, damit sie nicht wackelt. Auf diesen Beinen  befinden sich je eine Kugelrolle mit Befestigungsplatte. Somit wurde erreicht, dass die Scheibe sich
1. dreht und
2. stabil ist.


{{:projektewise18:george:kugel.jpeg?nolink&800|}}\\

Abbildung 3: Konstruktion Drehbewegung der Plattform\\

** Wie wird der Sensor senkrecht bewegt?**

Hierbei war die Überlegung, dass der Sensor nicht nur waagerecht, aber auch senkrecht vermessen können muss. Schnell war klar, dass wir eine Art Pfeiler benötigen, an dem der Sensor sich hoch und runter bewegen kann. Um möglichst wenig Reibung zu verursachen, entschieden wir uns für eine Riemen-Umlenkrollen-Konstruktion, die über diverse Zahnräder aus LEGO mit einem weiteren Motor verbunden war. 

Wir standen nun vor dem Problem, dass wir den Sensor an dem Riemen festbekommen, ohne das er verrutscht oder ruckelt. Unser erster Versuch mit starkem Klebeband half nicht wirklich viel. Nach vielem Herumkprobieren nahmen wir schließlich Heißkleber und legten das steife und gebogene Kabel über die obere Umlenkrolle, auf der der Riemen verläuft. So konnten wir sicherstellen, dass der Sensor sich während der Zeit nicht schräg verzieht.

{{:projektewise18:george:sensor.jpeg?nolink&400|}}


Abbildung 4: Sensorkonstruktion Senkrechtbewegung

 
** Wie wird die Größe des Objektes ermittelt? **

Der verwendete Ultraschallsensor misst die Entfernung, die zwischen ihm und dem Objekt besteht für die Breite und die Länge. Die Messung wird mehrmals durchgeführt, um jeweils den Durchschnitt der Entfernung für die Breite und die Länge zu berechnen.

Der Sensor ist genau 17,5 cm vom Mittelpunkt der Kreisscheibe entfernt. Steht nun das Objekt zentriert auf der Scheibe, muss die Entfernung weniger als 17,5 cm betragen.
Deswegen wird die gemessene Entfernung im Durchschnitt von den 17,5 cm subtrahiert und das Ergebnis ist die Hälfte der Breite des Objektes, weswegen mit 2 multipliziert werden muss. Folgendermaßen sieht die Rechnung aus:

breiteX = (17.5 - durchschnitt_x) * 2 .

Zur Veranschaulichung dient folgende Abbildung.

{{:projektewise18:george:berechnung.png?nolink&800|}} 

Abbildung 5: Ermitteln der Breite und der Länge

Nachdem die Entfernung für die Breite aufgenommen wurde, dreht sich die Scheibe und auf dieselbe Weise wird die Länge ermittelt.

Um die Höhe des Objektes zu ermitteln, fährt der Sensor nach rechts bis er dem Objekt gegenüber liegt und fährt nach oben. Jeder Schritt beträgt einen Millimeter. Die Schritte die er braucht, bis er keine Entfernung kleiner als 17,5 misst (wo das Objekt endet), werden summiert und betragen die Höhe in Millimeter. 

Der resultierende Wert wird im Code anschließend in Zentimeter umgerechnet.


====Code====

Unser Code lässt sich in drei Teile aufteilen:\\
-- die Bewegung der Motoren\\
-- die Aufnahme von Messwerten\\
-- die Verarbeitung der Messwerte zu einem 3D-Modell\\

Die ersten beiden Teile sind mit Arduino programmiert, der letzte Teil wird mit Processing ausgeführt. Zwischen beiden Programmen findet eine Kommunikation statt, sodass die Werte übermittelt und empfangen werden können. Unsere Kommunikation zwischen dem eingebauten Arduino und dem Laptop findet durch ein USB-Kabel statt.\\

Bei der Motorenbewegung gibt es drei verschiedene Teilstücke, da sich jeder Motor anders bewegen muss. Der erste Motor, der für die Waagerechte zuständig ist, fährt nur so lange, bis der Sensor einen größeren Wert als 20cm misst. 20cm deshalb, weil dies die Entfernung zwischen Sensor und Mittelpunkt der Plattform ist.  Der zweite Motor sorgt für die Drehung der Plattform. Hierbei muss beachtet werden, dass sich die Plattform um genau 90° dreht, damit das Objekt danach wieder parallel zum Sensor steht. Zum Schluss muss sich noch der Motor bewegen, der für die Senkrechtbewegung des Sensors zuständig ist. Hier ist wichtig, dass der Sensor sich nur schrittweise nach oben bewegt, da dieser sonst wackelt und ungenaue Werte aufnimmt. Auch kann das zu vermessende Objekt nur eine Höhe von 20 cm betragen, da unser Sensor nicht höher fahren kann.

<code cpp>
  stepperRotation.setSpeed(200);
  stepperRotation.step(-2400); 
</code>

Beispiel für eine Motorbewegung

Auch bei der Aufnahme von Messwerten wird in drei Teilen unterschieden:\\
-- Werte der x-Achse\\
-- Werte der y-Achse\\
-- Werte der z-Achse\\

Hierbei wird die x-Variable als die Breite, die y-Variable als die Höhe und die z-Variable als die Länge definiert. Für die Höhe werden die Schritte des dritten Motors (in Millimeterangabe) aufaddiert, bis der Sensor einen höheren Wert als 20cm zurückbekommt. Der herauskommende Wert wird anschließend durch 10 geteilt, damit man eine cm-Angabe herausbekommt. Um die Entfernung zu messen, wird der Sensor zunächst für 10 Mikrosekunden angeschaltet. Nach dem Abschalten des Sensors wird die Zeit gemessen, bis der Schall wieder beim Sensor angekommen ist. Diese gemessene Zeit wird anschließend durch zwei geteilt, da man nur eine Strecke zwischen Objekt und Sensor messen möchte und nicht beide. Der daraus resultierenden Wert wird mit der Schallgeschwindigkeit ([c_Schall]= cm/μs) dividiert. Das Ergebnis ist die Entfernung in Zentimeterangabe. Um mögliche Fehlwerte auszugleichen, wird aus den gemessenen Entfernungswerten der Durchschnitt gebildet.

<code cpp>
float messung () {
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);      
  digitalWrite(TRIG_PIN, LOW); 
  long dauer = pulseIn(ECHO_PIN, HIGH); 
  float entfernung;
  entfernung = dauer / 29.00 / 2.00; 
  return entfernung;
}
</code>

Code zur Berechnung der Entfernung in cm

Die Kommunikation zwischen Arduino und Processing wird durch die Bibliothek für serielle Kommunikation ermöglicht. Indem man die gesendeten Listen innerhalb eines Strings speichert, können die darin enthaltenen Werte später weiter verwendet werden. Anschließend wird eine Port-Variable definiert, die dafür sorgt, dass sowohl Processing als auch Arduino in gleicher Geschwindigkeit Daten übermitteln und empfangen.

<code cpp>
import processing.serial.*; 
import java.io.IOException;
Serial Port; 
</code>

Hochladen der Bibliothek zur seriellen Kommunikation

<code cpp>
String portName = Serial.list()[Serial.list().length-1];
Port = new Serial(this, portName, 9600);
</code>

Code, welcher den zuletzt geöffneten Port ermittelt, da dieser der Kommunikation dient

Die Objektdarstellung in Processing wird durch diverse Rahmenbedingungen ermöglicht. Nicht nur die erhaltenen Werte sorgen für die Objektdarstellung. Man muss sowohl die Hintergrundfarbe als auch die Farbe des Objekts definieren, damit sich das Objekt abhebt. Dazu kommt, dass die Werte für das Objekt verzwanzigfacht werden, da das Modell sonst zu klein ist. Durch die "mouseDragged"-Funktion kann das Objekt mithilfe der Mausbewegung gedreht werden. Außerdem werden in grünem Text die Werte für die Höhe, Breite und Länge angegeben. Zu guter letzt wird das Objekt noch zentriert dargestellt, da sonst möglicherweise ein Teil des Objekts beim Drehen außerhalb des Monitors wäre. Auch wäre das Objekt oben links in die Ecke gequetscht.

<code cpp>
  background(32); 
  lights(); 

  fill(#FF9F03); 
  noStroke();
  box(X * f, Y* f, Z * f);
</code>

Code, um das Objekt darzustellen

Der obige Code-Ausschnitt stellt einen schwarzen Hintergrund ein, und gibt dem Objekt die Farbe Orange. Die Funktion "lights()" verursacht die natürliche Schattierung am Objekt.
Das Objekt selber wird durch die Funktion "box(x, y, z)" dargestellt, wobei die Buchstaben für die Dimension in der x-, y-, oder z-Dimension stehen. Im Code steht neben jedem Buchstaben noch der Faktor f, denn die Werte die von Arduino empfangen und in die Funktion eingesetzt werden, ergeben ein Objekt, das zu klein wäre, wenn man es nicht mit einem vorher definierten Faktor multipliziert.



====Kommunikation zwischen Arduino und Processing IDE====

Um Werte von Arduino loszuschicken, muss man vorher definieren in welcher Geschwindigkeit Bits pro Sekunde übertragen werden:

<code cpp>
Serial.begin(9600);
</code>

In dem Fall sind es 9600 Bits pro Sekunde.
Dann startet man die Kommunikation und übergibt die umgerechneten Werte für die Breite, die Länge und die Höhe an den seriellen Port. 

<code cpp>
  Serial.print(breiteX);
  Serial.print(",");
  Serial.print(hoeheY);
  Serial.print(",");
  Serial.print(laengeZ);
  Serial.print(";");
</code>
  
Die Werte werden durch ein Komma getrennt, das letzte Zeichen ist ein Semikolon.

Wie bereits im Abschnitt "Code" erwähnt, sollte in **Processing** für die serielle Kommunikation die entsprechende Bibliothek verwendet werden und
mit der Klasse "Serial", zum Senden und Empfangen von Daten, das Objekt "Port" erzeugen.

Auch wurde erwähnt, dass der zuletzt geöffnete Port ermittelt werden soll, da er zur seriellen Kommunikation genutzt wird.
Auch da wählt man 9600 Bits pro Sekunde.

Besonders aufwendig war das Schreiben der **Funktion**, in der die Daten vom Seriellen Port eingelesen werden.
Zuerst werden die Daten von der nullten Stelle bis zum Semikolon, dem letzten Zeichen, gelesen und in dem String namens "daten" gespeichert, wie man hier sehen kann:

<code java>
void serial (Serial Port) { 
  if (Port.available() > 0) {
    daten = Port.readStringUntil(';'); 
    daten = daten.substring(0, daten.length()-1);
    System.out.println(daten.toString());
    System.out.println(daten.length()); 
    
    index1 = daten.indexOf(","); 
    System.out.println(index1); 
    breiteX= daten.substring(0, index1);
    
    index2 = daten.substring(index1+1, daten.length()-1).indexOf(",")+index1; 
    System.out.println(breiteX); 
    laengeZ= daten.substring(index1+1, index2+1);
     
    System.out.println(laengeZ); 
    hoeheY = daten.substring(index2+2, daten.length());

X = float(breiteX);
Z = float(laengeZ);
Y = float(hoeheY);
} 
</code>  

Weiterhin wird die Postion und die Länge des Strings ausgegeben, was beim Schreiben der Funktion hilfreich war. Da die drei Werte für die Größe des Objekts in einem String übergeben, mit Kommata getrennt wurden und der String mit einem Semikolon endet, müssen die Werte korrekt aus dem String ausgeschnitten werden, weswegen die Position benötigt wird. Damit wird verhindert, dass Daten verloren gehen.

Danach wird das erste Komma gesucht, seine Indexposition ausgegeben und der String von der Nullten Position bis zum dem Komma ausgeschnitten. Das ergibt den Wert für die Breite in Zentimeter, die Variable lautet dann "breiteX".

Die Breite wird ausgegeben, um zu überprüfen ob der String korrekt geschnitten wurde.
Es wird erneut aus dem Ursprungsstring ausgeschnitten, diesmal der Teil für die Länge des Objekts.
Ausgeschnitten wird eine Stelle nach dem ersten Komma (″index1+1″) bis zum zweiten Komma (″index2+1″).
Die Länge wird aus oben genanntem Grund ebenfalls ausgegeben.
Der Wert für die Höhe liegt im Ursprungsstring zwischen dem zweiten Komma ″index2+2″ und dem Semikolon, also dem Ende vom String.
  
Da die Werte als String unbrauchbar sind, müssen sie in float Variablen konvertiert werden. Die Werte dienen dann der Ausgabe des dreidimensionalen Objekts.
  
Wichtig ist, dass die Variablen am Anfang des Codes initialisiert wurden:

<code java>  
String breiteX = "";
String laengeZ = "";
String hoeheY = "";
String daten = "";
int index1 = 0;
int index2 = 0;
</code>

Was die Kommunikation beider Programme betrifft, gibt es Ähnlichkeiten zum folgenden Projekt:

https://howtomechatronics.com/projects/arduino-radar-project/ 

Es handelt von einem Radar, wobei ein Ultraschallsensor ein Objekt erkennt und die Werte an Processing zur Ausgabe schickt.


====Schaltung====

Die Schaltung besteht aus zwei größeren Unterteilungen.\\
1. Die Schaltung der Motoren\\
2. Die Schaltung des Sensors\\

Für die Motoren benötigten wir Treiber, die man zwischen den Arduino und den jeweiligen Motor schaltete. Da wir drei Motoren verwendeten, brauchten wir auch drei Treiber. Diese wurden jeweils mit dem Motor, der externen Stromquelle, in unserem Fall einem Akku, und dem Arduino über Kabel verbunden.

Der Sensor wurde direkt an den Arduino angeschlossen.

{{:projektewise18:george:img-20190301-wa0002.jpg?nolink&800|}}\\

Abbildung 6: Schaltung am Roboter

====Schaltplan====

{{:projektewise18:george:15516237020661353864138.jpg?nolink&800|}}\\

Abbildung 7: handgezeichneter Schaltplan, Kabelfarben entsprechen zumeist Originalschaltung



====Verwendete Bauteile====
-- 1x Arduino Nano\\
-- 2x Steppermotor Nema 17\\
-- 1x Motor mit 2,7V\\
-- 3x Treiber "Driver PaP Pololu A4988" \\
-- 1x Ultraschallsensor "HC-SR04"\\
-- 3x 200μF Widerstand\\

**Pinbelegungstabelle am Arduino**\\

^ Was?       ^ Wo?        ^ 
| Treiber 1    | DIR (Treiber) → D2  | 
| Treiber 1    | STEP (Treiber) → D3  | 
| Treiber 1    | VDD(Treiber) → 5V |
| Treiber 1    | GND (Treiber) → GND |
| Treiber 2    | DIR (Treiber) → D4 |
| Treiber 2    | STEP (Treiber) → D5 |
| Treiber 2    | VDD(Treiber) → 5V |
| Treiber 2    | GND (Treiber) → GND |
| Treiber 3    | DIR (Treiber) → D6 |
| Treiber 3    | STEP (Treiber) → D7 |
| Treiber 3    | VDD(Treiber) → 5V |
| Treiber 3    | GND (Treiber) → GND |
|Ultraschallsensor| VCC → 5V |
|Ultraschallsensor| TRIG → D13 |
|Ultraschallsensor| ECHO → D12 |
|Ultraschallsensor| GND → GND |


\\
**Pintabelle an den Treibern**

^ Was?                  ^ Wo?                           ^ An welchem Treiber?  ^
|Treiber                |RESET → SLEEP                  |1,2,3|
|Stepper                |2B → Stepper ganz links        |1,2,3|
|Stepper                |2A → Stepper Mitte links       |1,2,3|
|Stepper                |1A → Stepper Mitte rechts      |1,2,3|
|Stepper                |1B → Stepper ganz rechts       |1,2,3|
|Arduino                |DIR → D2                       |1|
|Arduino                |STEP → D3                      |1|
|Arduino                |DIR → D4                       |2|
|Arduino                |STEP → D5                      |2|
|Arduino                |DIR → D6                       |3|
|Arduino                |STEP → D7                      |3|
|Arduino                |VDD → 5V                       |1,2,3|
|Arduino                |GND → GND                      |1,2,3|
|Externe Stromquelle    |VMOT → Pluspol                 |1,2,3|
|Externe Stromquelle    |GND → Minuspol                 |1,2,3|

Hierbei ist Treiber 1 am Motor für die Waagerechtbewegung, Treiber 2 am Motor für die Drehung und Treiber 3 am Motor für die Senkrechtbewegung angeschlossen.

--- //[[Lia Kruschke]] 2019/02/25 01:19// \\
--- //Überarbeitung [[Lia Kruschke]] 2019/03/03 15:39//

===== Ergebnis und Diskussion =====
__Was funktioniert?__\\
Der Roboter ist in der Lage, mithilfe des Motors, den Sensor von links nach rechts und andersrum fahren zu lassen, ohne das das Band hakt, oder sich vom Motor löst. Dafür wurden neben dem selbstklebenden Klettband auch Winkel für den Motor genutzt. Die Schraube der Riemenscheibe des Motors und die Riemenscheibe selbst wurden mit Kabelbindern und Klebeband befestigt, damit die Riemenscheibe sich nicht so schnell rausdreht und den Ablauf sabotiert.

Weiterhin bewegt sich der Ultraschallsensor mit einem anderen Motor nach oben und stoppt, wenn der Sensor eine Entfernung größer als 20 Zentimeter misst, da dort das Objekt „endet“. Der Ultraschallsensor selbst kann Werte aufnehmen, die man weiterverarbeiten kann. Die Entfernung wird in Zentimetern angegeben.

Die Kreisplatte dreht sich in etwa um 90° mit einem dritten Motor, sodass das Objekt in etwa parallel zum Ultraschallsensor stehen kann. Dieser Motor wurde mit einem Kabelbinder befestigt, damit dieser dem Zug, der durch das Band verursacht wird, grob standhalten kann. Dadurch wird verhindert, dass die Kreisscheibe sich um viel weniger als 90° dreht, weil die Riemenscheibe zum Beispiel das Problem hätte, den Riemen nicht richtig zu fassen.

Die berechneten Werte werden ohne Verlust an Processing-IDE geschickt, wobei ein Objekt anhand der Werte dreidimensional ausgegeben wird. Dazu wird ein grüner Text angezeigt, mit der Länge, Breite und der Höhe.

Was vorher problematisch und störend war, wurde noch verbessert: der Sensor fährt nach der Messung automatisch zu seiner Ausgangsposition zurück.
Somit gibt es keine großen Schwierigkeiten dies händisch zu erledigen.


__Welche Probleme treten auf?__

Ein Problem ist, dass sich die Plattform nicht genau um 90° dreht, was am Riemen liegt. Dort wurde eine „Stufe“ eingenäht. Der Riemen ist nicht an jeder Stelle gleich hoch beziehungsweise gleich dick, was jedoch zwingend erforderlich ist. Somit beugt sich der Motor trotz Kabelbinder leicht in die Mitte der Konstruktion. Wegen der leicht schrägen Position dreht sich die Riemenscheibe manchmal schneller als üblich, also ist es unvorhersehbar, um wie viel Grad sich die Kreisplatte genau gedreht hat.

Ein weiteres Problem besteht in der Messung. Dass Messfehler auftreten können, kann man nie ausschließen. Sie können öfter auftreten, je nach dem aus welchem Material das Objekt besteht oder welche Form das Objekt hat (Würfel/Quader reflektieren Ultraschall besser als Kugel oder Pyramide).



__Möglichkeiten zur Verbesserung__

Es gab noch mehrere Ideen, die verworfen wurden, jedoch ein Anreiz für **Verbesserungen** sind.

Ein Beispiel ist das Bluetoothmodul, dass die berechneten Werte an den Computer schicken sollte. Es war jedoch nicht notwendig, da ein Kabel in dem Fall gut geeignet war.

Des Weiteren sollte der Roboter erkennen können, welche Farbe das Objekt hat, und dementsprechend würde Processing-IDE das Objekt in dieser Farbe darstellen.

Woran man auf jeden Fall arbeiten kann, ist die Messung von Objekten mit unterschiedlichen Formen. Zum Beispiel könnte man eine Federtasche ausmessen lassen, die in Processing dann exakt so ausgegeben wird. Dafür könnte man den Ultraschallsensor mit einem Infrarotsensor austauschen, damit keine Messfehler entstehen können. 

Im Code würde man dann Arrays oder Matrizen anwenden, jeden einzelnen (oder vereinfacht mehrere Punkte) Punkt messen und in Processing jeden dieser Punkte ausgeben, sodass ein vollständiges Bild vom Objekt entsteht.

Weiterhin kann man die Rotation der Kreisplatte überarbeiten. Man könnte den Riemen neu nähen und dafür sorgen, dass die Platte sich exakt um einen gewählten Winkel dreht, je nachdem wie der Ablauf der Messung durch Verbesserung verändert wird.

Außerdem könnte man den Code für die anderen Motoren überarbeiten, sodass die Umdrehungen nicht vorher festgelegt werden, sondern flexibel vom Roboter während des Ablaufs bestimmt werden. Der Roboter würde nur das Objekt messen und nicht erst von links nach rechts fahren, messen und mit einer If-Abfrage das Objekt “erkennen”.

Was man ebenfalls verbessern könnte: Wenn der Sensor zur Ausgangsposition fährt, dreht der Motor für die senkrechte Bewegung sich zu oft, wodurch man vor jedem Start den Riemen mit dem Sensor um ca. 0,5 Zentimeter nach oben drehen muss. Besser wäre, der Roboter würde es ohne Hilfe schaffen.

__Fazit__ 

Alles in Allem kann der Roboter George ein quaderförmiges oder würfelförmiges Objekt vermessen und am Computer dreidimensional darstellen, rechts oben im Bildschirm wird die Maße des Objekts in grüner Farbe ausgegeben. Man sollte beachten, dass mit hoher Wahrscheinlichkeit geringe Messfehler auftreten können.

Verbessern könnte man George, indem er nicht nur auf quaderförmige oder würfelförmige Objekte beschränkt ist, und beliebige Objekte, unabhängig der Form vermessen und anschließend dreidimensional ausgeben kann. Schön wäre es, wenn Messfehler durch Konstruktionsmängel weitestgehend vermieden werden können und die Farbe des Objektes in der Darstellung berücksichtigt wird.





{{:projektewise18:george:george.zip|}}
Projektlabor Robotik MINTgrün

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Seiten-Werkzeuge
