Gruppenmitglieder: Luca, Jens, Carina, Max

Das Ziel des Roboters ist, sich auf einem Tisch selbstständig zu bewegen und kleine schwarz angemalte Metallplättchen, die sich auf dem Tisch verstreut befinden, auf einem am Roboter selbstgebauten Kästchen zu lagern. Die Bewegung des Roboters erfolgt mit Hilfe von zwei Servo-Motoren und Rädern. Als Stützhilfe haben wir am Anfang des Grundgerüsts zwei schräggesetzte Holzkanten angebaut. An beiden Holzkanten ist jeweils ein Infrarotsensor angebaut, welche verhindern sollen, dass der Roboter vom Tisch runterfällt. Um zu gewährleisten, dass unser Roboter die Metallplättchen erkennen und aufsammeln kann, befindet sich unter dem Grundgerüst ein Line-Tracking Sensor. Nach dem Lagern der Metallplättchen, soll er zum Ausgangspunkt zurückfahren.

Im Laufe der Projektarbeit haben wir uns andere Projekte angeschaut, um zu erfahren wie andere Gruppen sich mit den Sensoren auseinandergesetzt haben. Dabei haben wir bemerkt, dass der Roboter der Gruppe WALL-E, unserem sehr ähnlich ist. https://www.mintgruen.tu-berlin.de/robotikWiki/doku.php?id=projektewise18:wall-epublic:start

• fahren
• nicht vom Tisch runterfallen
• Metallplättchen aufsammeln
• Metallplättchen auf dem Roboter lagern

Die Aufgaben sind in vier Arbeitsschnitte unterteilt. Der Roboter muss auf einem Tisch fahren können und nicht vom Tisch runterfallen. Er muss die Metallplättchen erkennen und aufsammeln können. Die Metallplättchen müssen dann auf die Ablagestation abgelegt werden. Anschließend muss der Roboter zum Startpunkt zurückfahren.

Wir hatten die Idee, dass der Roboter den Tisch systematisch abfährt, das heißt er sollte einmal die gesamte Fläche des Tisches abfahren. Die Idee haben wir aber verworfen, da wir die Koordinaten des Tisches gebraucht hätten um es hard coden zu können, was schwierig umzusetzen wäre, da dies unseren code durcheinander bringen könnte.

Unser Roboter besteht aus drei Baugruppen: Nämlich dem Gerüst selbst, den Sensoren und den mechanischen Teilen (Motoren, Räder, Servo-Arm, Elektromagnet)

Abb.1 Skizze des Roboters, nicht maßstabgerecht

Das Gestell: Die Holzfläche des Gestells beträgt 16,5cm x 18cm und dient dazu, alle Einzelkomponenten auf oder unter dem Gestell einzubauen oder zu lagern. Auf der Holzfläche sind der Kran und das Ablagesystem verbaut worden, während unter der Holzfläche sich zwei Schrittmotoren mitsamt zwei Rädern, der Steckplatine, dem Akku, und dem Line-Tracking-Sensor befinden. Als „Stützrad“ fungieren zwei voneinander, schräg gesetzte Holzkanten. Ursprünglich wollten wir vier Schrittmotoren benutzen, jedoch wir haben es schließlich verworfen, weil die Nutzung von vier Schrittmotoren viel zu viele Kabel und Energie benötigt. Wir hätten es uns dementsprechend unnötig schwer gemacht mehr Teile zu benutzen, obwohl zwei Schrittmotoren und ein Stützrad, in unserem Falle zwei Holzkanten, völlig ausreichen. Unser Roboter ist relativ klein und kompakt, weil wir befürchtet hatten, dass je größer der Roboter desto schwerer wird es, dass der Roboter sich vernünftig wenden kann und daraus Probleme mit dem Aufheben der Metallplättchen entstehen könnten. Wegen der momentanen Größe des Roboters konnten wir den Hubmagneten nicht verwenden, weil der Hubmagnet zu viel Platz beansprucht.

Abb.2 Oberseite der Holzplatte

Schrittmotoren und Räder: Die Schrittmotoren sind parallel unter dem Gestell eingerichtet und vernagelt. Die Schrittmotoren müssen über Driver angesteuert werden. Schrittmotoren fahren wie der Name schon sagt in steps, sprich in ganz kurzen Strecken. Die Motoren können mit der Bibliothek “Stepper.h”, die wir benutzen angesteuert werden. Damit der Arduino mit den Motoren kommunizieren kann, benötigt man die Treiber. Die Treiber haben einen Step-Pin, womit man eine bestimmte Anzahl der Schritte machen kann. Des Weiteren haben sie einen Direction-Pin, womit sich die Richtungen der Motoren gelenkt werden kann. Wichtig anzumerken ist, dass die Schnelligkeit nicht bedeutet, dass die Treiber zum Motoren sagen, dass die Motoren mit zwei Umdrehungen pro Sekunde fahren, sondern, dass die im Code eigestellte Zahl für jeden Treiber/Treiberart eine andere Geschwindigkeit ist. Die Räder bewegen sich abwechselnd ganz kurz. Das machen sie in einem Loop . Wenn die Sensoren ausschlagen, hält er an und dreht sich oder sammelt die Plättchen auf. Dann geht das immer so weiter.

Die Räder sind die „Füße“ des Gestells und sind mit einer Schraube am Motor befestigt. Sie dienen zur Fortbewegung und zur Stabilität des Roboters. Wir haben uns für große Räder entschieden, weil wir uns schon Gedanken darüber gemacht haben, dass die Steckplatine unter dem Gerüstteil liegt und nicht beschädigt werden soll. Nachdem wir die Schrittmotoren an unserem Roboter befestigt haben, haben wir uns mit dem Fahren beschäftigt.

Befindet sich der Roboter auf dem Tisch, fährt er eine gerade Strecke bis er die Kante des Tisches erreicht hat. Mittels der Infrarotsensoren dreht er sich um und wiederholt den Vorgang. Dies geschieht solange bis der Roboter ausgesteckt wird.

Infrarotsensoren: Die Infrarotsensoren verhindern, dass der Roboter vom Tisch fällt, indem sie die Entfernung zum Tisch beziehungsweise zum Boden messen. Bei unseren Sensoren haben sich die Werte, die ausgegeben wurden, wenn sich die Sensoren über dem Tisch befinden deutlich von denen unterschieden, die gemessen wurden, wenn die Sensoren über den Tisch hinausragten. So wurden Werte über 300 bei sich über dem Tisch befindenden Sensoren ausgegeben. Drohte der Roboter vom Tisch zu fallen, waren es Werte unter 300. Im Code sorgt dann die if-Bedingung dafür, dass bei Werten der Infrarotsensoren über 300 die Räder drehen und bei Werten unter 300 die Räder stehen bleiben.

Die Infrarotsensoren sind jeweils am Anfang der zwei Holzkanten, die voneinander geneigt sind, angeklebt, damit der Roboter rechtzeitig erkennt, dass er droht runterzufallen. Quasi wenn die Infrarotsensoren anfangen Werte von unter 300 zu messen, stoppt der Roboter bevor ein Rad ganz am Rand der Tischkante ist. Demnach spielt auch der Winkel der Holzkanten eine wichtige Rolle, den wir durch Ausprobieren herausgefunden haben. Dabei war es wichtig die Entfernung durchgängig im Arduinoprogramm zu messen, bevor wir die Infrarotsensoren an der Holzkante angeklebt haben. Später haben wir an unsere Infrarotsensoren jeweils ein Kondensator gelötet, damit die Werte stabiler sind.

Abb.3 Line-Tracking-Sensor

Abb.4 schwarze Metallplättchen

Line-Tracking-Sensor: Der Line-Tracking-Sensor dient dem Erkennen der Metallplättchen. Er kann zwischen schwarz und weiß unterscheiden. Im Code wird eine schwarze Fläche als Wert „1“ ausgegeben und eine weiße Fläche entspricht der Zahl „0“. Bei dem Tisch, auf dem der Roboter fährt, haben wir uns bewusst für einen weißen entschieden und bei den aufzuhebenden Objekten für schwarze. Zuerst haben wir uns für Büroklammern zum Aufheben entschieden, jedoch stellte es sich heraus, dass der Line-Tracking-Sensor die Büroklammern überhaupt nicht erkennen kann. Deshalb kam die Idee etwas größere Metallobjekte zu verwenden, sprich Metallplättchen. In Bezug auf Metallplättchen gab es wiederum Komplikationen, denn die schwarz angemalten Metallplättchen wurden nur manchmal vom Line-Tracking-Sensor erfasst. Somit mussten wir auf eine andere Methode zugreifen, nämlich die Metallplättchen mit schwarzem Klebeband versehen.

Servo-Arm und Elektromagnet: Das Aufheben der magnetischen Plättchen erfolgt dann mittels des Dynamixel Set, das aus zwei zusammengefügten Servomotoren besteht, an dem der Elektromagnet angebracht wurde. Der erste Servomotor dreht sich von links nach rechts und der zweite Servomotor von unten nach oben. Die links nach rechts Drehung hat keine konkrete Nutzung, sondern sichert nur, dass falls die Metallplättchen sich zu linkseitig oder rechtsseitig liegen. Hingegen sorgt der zweite Servomotor dafür, dass der Servomotor sich so positioniert, dass der Elektromagnet die Metallplättchen aufheben kann.

Dieser Elektromagnet lässt sich an- und ausschalten. Zum Aufsammeln der Plättchen ist er angeschaltet und zum Ablagern dieser in den selbstgebauten Behälter ausgeschaltet.

Abb.5 Ablagestation

Ablagestation: Die Ablagestation ist ein ca.10 cm x 7 cm großer Zwischenspeicher, der sich auf dem Roboter befindet. Die Ablagestation besteht aus Holz und ist mit Wänden versehen, um zu verhindern, dass die Metallplättchen während der Fahrt nicht vom Roboter fallen. Die Aufgabe der Ablagestation besteht darin, die vom Servo-Arm aufgesammelte Metallplättchen auf dem Roboter zu lagern.

#include <Stepper.h>                //Bibliothek der Stepper-Motoren
#include <MySoftwareSerial.h>       //Bibliothek der Servos
#include <DynamixelSoftSerial.h>    //Bibliothek der Servos
///////////////////////////////////////////////////////////////
/////////////GLOBALE VARIABLEN UND KONSTANTEN//////////////////
///////////////////////////////////////////////////////////////
const int stepsPerRevolution = 3200;  //Anzahl an Steps pro Umdrehung
const double stepsPerCM = 29;  //Anzahl an Steps pro cm
const int LTSensor = 10; //Line-Tracking Sensor
const int hubMagnet = 11; //Hubmagnet
const int elektroMagnet = 12; //Elektromagnet
const int dirPinRechts = 6; //dir-Pin für den rechten Stepper
const int stepPinRechts = 7;  //step-Pin für den rechten Stepper
const int dirPinLinks = 8;  //dir-Pin für den linken Stepper
const int stepPinLinks = 9; //step-Pin für den linken Stepper
const int IRLinks = A0;
const int IRRechts = A1;
// initialisierung der Stepper, anhand der Bibliothek
Stepper myStepperLinks(stepsPerRevolution, dirPinLinks, stepPinLinks);
Stepper myStepperRechts(stepsPerRevolution,dirPinRechts,stepPinRechts);
///////////////////////////////////////////////////////////////
/////////////////////////////SETUP/////////////////////////////
///////////////////////////////////////////////////////////////
void setup() {
  pinMode(hubMagnet,OUTPUT);
  digitalWrite(hubMagnet,LOW);
  pinMode(elektroMagnet,OUTPUT);
  digitalWrite(elektroMagnet,LOW);
  myStepperRechts.setSpeed(40);
  myStepperLinks.setSpeed(40);
  pinMode (LTSensor,INPUT);
  pinMode(IRRechts,INPUT);
  pinMode(IRLinks,INPUT);
  Dynamixel.begin(19200, 2, 3, 4);
  Serial.begin(9600);
}

///////////////////////////////////////////////////////////////
/////////////////////////HAUPTCODE/////////////////////////////
///////////////////////////////////////////////////////////////
void loop() {

  boolean LTSWert = digitalRead(LTSensor);
   if(analogRead(IRLinks) > 300 && analogRead(IRRechts) > 300){
    forward(1);
   }
   if(analogRead(IRLinks) < 300){
    softTurnRight();
   }
   if(analogRead(IRLinks) < 300){
    softTurnLeft();
   }
   if(analogRead(IRLinks) < 300 && analogRead(IRRechts) < 300){
    backward(8);
    softTurnRight();
   }
   if(LTSWert == 1){
    backward(8);
    pickUp();
    delay(10000);
   }
  }
///////////////////////////////////////////////////////////////
/////////////////////////////METHODEN//////////////////////////
///////////////////////////////////////////////////////////////
//dreht den Roboter um 180° nach links
void turnLeft(double steps){
  backward(8);
  delay(500);
  myStepperRechts.step(steps);

}
//dreht den Roboter um 180° nach links
void turnRight(double steps){
  backward(8);
  //drehen
  delay(1000);
  myStepperLinks.step(steps);
}
//bewegt sich um ... cm nach vorne
void forward(double cm){
  for( int i = 0; i<cm;i++){
    myStepperRechts.step(stepsPerCM);
    myStepperLinks.step(stepsPerCM);
  }
}
//bewegt sich um ... cm nach hinten
void backward(double cm){
 for( int i = 0; i<cm;i++){
   myStepperRechts.step(-1*(stepsPerCM));
   myStepperLinks.step(-1*(stepsPerCM));
 }
}
void softTurnLeft(){
  backward(4);
  delay(1000);
  myStepperRechts.step(200);
}
void softTurnRight(){
  backward(4);
  delay(1000);
  myStepperLinks.step(200);
}
void pickUp(){
  //servos runter
  Dynamixel.moveSpeed(1,200, 200);
  Dynamixel.moveSpeed(3,810, 200); 
  delay(2000);

  digitalWrite(elektroMagnet,HIGH);

  //Ausgngsposition
  Dynamixel.moveSpeed(3,510, 200);
  Dynamixel.moveSpeed(1,810, 200);
  delay(2000);

  digitalWrite(elektroMagnet,LOW);
  delay(500);
  //Srvos in Ausgangsposition
  Dynamixel.moveSpeed(1,810, 200);
  Dynamixel.moveSpeed(3,510, 200);
  delay(10000);//zum Testen
}

Unser ursprüngliches Ziel war es, dass der Roboter den Tisch systematisch abfährt, kleine Metallobjekte aufsammelt und mit diesen dann zum Startpunkt zurückfährt.

Die Motoren und Räder stellten eine große Herausforderung dar, aufgrund der funktionsuntüchtigen Treibern, die nicht zum Motor passten und deshalb die Motoren und Räder stockartige Bewegungen durchführten oder sich überhaupt nicht bewegten. Um das Problem zu lösen, haben wir viele Treiber benutzt, bis zwei Treiber kompatibel mit unseren Motoren waren.

Im Einzelnen sind alle Komponenten des Roboters fertig und funktionstüchtig und fast alle Arbeitsschritte abgearbeitet. Der Roboter ist in der Lage auf einem Tisch eigenständig zu fahren und nicht runterzufallen. Die Infrarotsensoren geben vernünftige Werte aus, was dafür sorgt, dass der Roboter an der Kante des Tisches anhält. Der Line-Tracking-Sensor kann die mit schwarzem Klebeband beklebten Metallplättchen wahrnehmen und der Servo-Arm kann sich so positionieren, dass der Elektromagnet die Metallplättchen aufheben und auf die Ablagestation ablegen kann. Lediglich fährt der Roboter nicht zurück zum Ausgangspunkt. Diesen Arbeitsschritt haben wir verworfen, als wir entschlossen waren, dass es einfacher wäre, wenn der Roboter den Tisch nicht systematisch abfährt.

Im Verlaufe der Projektzeit hatten wir einige Probleme mit unseren Materialien, die wir beseitigen mussten. Zum einen gab es Probleme mit einem unserer Infrarotsensoren. Einer von diesen hatte nicht die von uns gewünschten Werte ausgegeben, weshalb wir versucht haben einen Kondensator auf dem Infrarotsensor zu löten. Zum anderen war das Ax12a Dynamixel Set, das wir erhalten haben, nicht komplett, weshalb die Idee, dass der Servo-Arm eine kranähnliche Funktion vollführt, verworfen werden musste. Um dieses Defizit zu beheben, musste die Länge des Arms vergrößert und der Arm ganz vorne auf dem Roboter positioniert werden, damit die Reichweite des Arms mit dem Boden übereinstimmt. Zudem stellten die Schrittmotoren eine Herausforderung dar, weil die Treiber nicht sonderlich kompatibel mit den Schrittmotoren waren, was dazu geführt hat, dass die Schrittmotoren beim Starten sich ständig aufgehängt haben. Dieses Problem haben wir gelöst, indem wir unterschiedliche Treiber verwendet haben, bis ein Treiber ganz ordentlich mit den Motoren funktioniert hat.

Im Verlauf der Projektzeit haben wir viele Veränderungen vorgenommen. Aktuell ist das Aussehen des gesamten Roboters, mitsamt der einzelnen Komponenten, abweichend von den Skizzen in der Projektplanung.

Es gibt einiges was man verbessern kann:

Angefangen mit der Ästhetik, denn der Roboter ist nicht wunderlich schön. Viele Schraubenspitzen stechen heraus und gerade eingeschraubt, weswegen das Berühren des Roboters relativ gefährlich sein kann, wenn einem die Gefahr nicht bewusst ist. Der Grund für das Aussehen des Roboters ist, dass wir uns auf die Funktion des Roboters konzentriert haben und eher schnell ein Grundgerüst gebraucht haben, um die einzelnen Komponenten auf dem Grundgerüst zu errichten. Was man im Ausblick noch verbessern könnte, wäre den Roboter etwas länger und breiter zu bauen, denn die Größe unseres Roboter bietet wenig Komfort und Platz, was dazu geführt hat, dass wir unseren Hubmagneten nicht hinzufügen konnten. Hinzu war es immer anstrengend die elektronischen Bauelemente aus der Steckplatine rein- und rauszuziehen.

Im Großen und Ganzen war es eine gute Möglichkeit gewesen, mit einer Gruppe an einem Projekt zu arbeiten und dieses auch zu verwirklichen. Auch wenn es Verbesserungsmöglichkeiten gibt, sind wir zufrieden mit unserem Resultat.

main.zip