======Aufräumroboter====== Gruppenmitglieder: Luca, Jens, Carina, Max ===== Einleitung ===== 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 ===== Methoden/Umsetzung ===== ==== Aufgaben des Roboters: ==== * 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. ==== Welche Aufgaben wurden bewusst ausgeklammert? ==== 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. ==== Bestandteile der Baugruppen: ==== Unser Roboter besteht aus drei Baugruppen: Nämlich dem Gerüst selbst, den Sensoren und den mechanischen Teilen (Motoren, Räder, Servo-Arm, Elektromagnet) {{:projektewise21:aufraeumroboter:skizze_geruest.jpg?825|}} //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. {{:projektewise21:aufraeumroboter:roboter_oben_beschriftung.png?650|}} //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. {{:projektewise21:aufraeumroboter:roboter_beschriftung_unten_2.png?650|}} //Abb.3 Line-Tracking-Sensor// {{:projektewise21:aufraeumroboter:metallplaettchen.png?650|}} //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. {{:projektewise21:aufraeumroboter:ablagestation.jpg?650|}} //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. ===== Schaltplan ===== {{:projektewise21:aufraeumroboter:arduinoschaltplan.jpg?850|}} ===== Pinbelegung ===== {{:projektewise21:aufraeumroboter:bild_2022-02-22_135811.png?500|}} ===== Code ===== #include //Bibliothek der Stepper-Motoren #include //Bibliothek der Servos #include //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