🏠 FabLab Startseite | Nutzungsbedingungen | Impressum | Wiki

Sumo-Bot - der Weg dahin


#1

Moin zusammen!

Dieses Thema soll zur Anregung dienen und mir evtl. mit Eurem Schwarm-Wissen helfen!

Die Sumobot Competition 2019 steht vor der Tür und ich durfte mich schon diese Woche davon überzeugen, dass es einen richtig guten Sumo-Ring für das Event gibt und ich habe schon einen Roboter in Aktion gesehen. wow! :dizzy_face:
So etwas bestärkt mich dann auch etwas in zwei Wochen auf die Beine zu stellen, was sich mit anderen messen kann. Wenn ich es bis zum 7.Januar am laufen habe melde ich mich noch an (8. Januar ist Anmeldeschluss), ansonsten baue ich das Ding fertig und benutze es als Kinderspielzeug.

1. Was soll der Roboter können?

  • nicht mehr als 1,5kg wiegen
  • Kettenantrieb haben
  • Autonom fahren und Gegner erkennen
  • fast nichts kosten
  • (die Weltherrschaft erlangen) das lieber nicht…

2. Was habe ich an Equipment? :face_with_monocle:

  • zwei bis drei HC-SR04 (Ultraschallsensoren)
  • zwei bis vier IR-Reflextions-Lichtschranken-Module (basierend auf TRCT5000)
  • zwei starke Getriebemotoren 12V bei 250U/min
  • einen Motortreiber (basierend auf dem L298N)
  • ein Arduino Mega oder UNO
  • einen 14V Lithium-Akku (die Spannung werden der Motortreiber und die Motoren überstehen)

3. Was fehlt mir? :thinking:

  • ein Chassis
  • Kettenantrieb
  • evtl. Zeit

Nachdem ich die Teile zusammen habe mache ich mir Gedanken zum Aufbau und der Stabilität im Sumo-Einsatz. Kettenantrieb wird es wohl nicht, dafür brauche ich zu viele Teile. Damit ich trotzdem eine gute Bodenhaftung und Stabilität hinbekomme, baue ich einen quadratischen Grundrahmen, der von vier Rädern bewegt wird. Jeweils zwei Räder einer Seite sollen über einen Zahnriemen synchronisiert werden. Somit sollte der Drehpunkt des Roboters im Zentrum des Grundrahmens liegen.


Das ist die Grundidee der Bodenplatte. Hinten sitzen die Motoren mit den grünen Motorhaltern und vorne die Radnabenhalter und die Ultraschallsensoren (HC-SR04).
Die HC-SR04 habe ich in einem Winkel von jeweils 10° nach rechts und links angeordnet und erhoffe mir dadurch Gegner “räumlicher” erfassen zu können. Durch die Charakteristik des Sensors müsste der Roboter somit ein “Sichtfeld” von ca. 50-60° erhalten.

Hier eine Idee zum Radbau:

Diese kam mir als ich nach Rädern bei Modellbau-Händlern stöberte und ich Leichtbauräder mit Moosgummi-Bereifung fand. Das kann man doch auch selber machen! :stuck_out_tongue_winking_eye:

Benötigt werden 3D-gedruckte Felgen , Moosgummi, Kontaktkleber (Patex), eine Schere und Schleifpapier.

Die Felgen entsprangen Fusion 360 und meinem 3D-Drucker, evtl. lasst Ihr Euch die im FabLab drucken und den Bogen Moosgummi gibt es in hiesigen Hobby- und Bastelgeschäften. Einen Streifen Moosgummi (Felgenbreite mal Umfang) und eine Felge mit Kontaktkleber bestreichen, ein paar Minuten den Kleber ausdünsten lassen (wenn der Kleber nicht mehr am Finger klebt) und beide Teile kurz fest aufeinander drücken. Fertig!

Damit die Räder auch etwas mehr Griff bekommen, habe ich die Oberfläche mit 120 Schleifpapier aufgeraut.

Wenn Ihr noch ein paar gute Ideen habt, dann immer raus damit! Vielleicht kann mir noch jemand sagen, wie ich Zahnriemen zusammenfügen kann, oder ich mir lieber gleich fertige kaufen sollte. Früher hatte man Riemen aus Leder vernäht, vernietet und verklebt.


#2

Hier noch ein Update: die wichtigsten Teile sind fertig und morgen wird noch mehr zusammengesetzt!

Ansonsten bin ich morgen im Lab, Laser das Chassis und freue mich dort auf weitere Roboterfreunde!


#3

Endspurt! So langsam sollte sich was bewegen…:thinking:

Ich habe mal überlegt, was der Roboter eigentlich für Funktionen haben soll. Natürlich mit so wenig Schnickschnack wie möglich.

Dazu eine Skizze:

Im folgenden Bild ist die simple logische Erklärung, welcher Sensor high(1) oder Low(0) mit der jeweiligen Funktion hat. Die Controller-Gurke bekommt dem entsprechend einen Code geschrieben, der die gewollte Funktion umsetzt.

Eigentlich braucht man für einen Sumo-Bot nur Boolesche Algebra, da Erkennung und Fahr-Funktionen keine großartige Berechnung benötigen.
Natürlich sollen die Ultraschall-Sensoren vorher noch software-seitig justiert werden, so das nur Gegenstände im Nahbereich getriggert werden und nicht in fünf Meter Entfernung. In meinem Programm setzte ich auf die “NewPing-Bibliothek” um den HC-SR04 zu benutzen.

#include <NewPing.h>

NewPing sonar1(3,4,100); // UltraschallSensor (TRIGGER_PIN, ECHO_PIN, MAX_DISTANZ);
NewPing sonar2(5,6,100);

int value1=0;
int value2=0;
int value=0;

Weitere Erläuterungen werden folgen :wink:


#4

Eine kleine Anmerkung: was ist mit dem Fangnetz und dem Poller in der Mitte? Werden die als Gegner erkannt?

PS: ich finde es super dass du es dokumentierst.


#5

Das wird vielleicht auch passieren, macht aber nichts!
Hier unten findest Du die Arena. Außen und innen befindet sich jeweils ein 10cm breiter schwarzer Ring.
:point_up: spielen wir mal die Fahrt durch und beziehen uns auf die Tabelle die ich gepostet habe.
Der :robot: erkennt den inneren Poller als Gegner und macht sich nun auf den Weg, diesen zu treffen. Dann wird er vorher die schwarze Linie überfahren und sofort springt eine der IR-Reflexlichtschranken an. Der mechanische Sumo-Held wird nach seiner Programmierung drehen und wieder, wenn die Lichtschranken Ihn frei geben sich auf den Weg machen. Ich habe die Lichttschrankenfunktion dominanter als die Hinderniserkennung im Programm.
Falls wieder ein Hindernis erkannt wird, zum Beispiel das Netz macht er sich auf den Weg und wird wieder die Linie überfahren.
Ich gehe bei der kreisrunden Arena davon aus, dass der Roboter so lange Ping-Pong spielt, bis er ein Ziel erfasst, welches keine Linie um sich hat und es bezwingt. :muscle:

Es ist eine schnelle Lösung, autonom zu fahren und noch in sieben Tagen dabei zu sein. Zudem will ich nicht selber steuern, da ich dieses Spektakel mit einem Getränk zur Geistigen Meditation :beer: begleiten möchte.


#6

Kurzes Update zu den DIY-Moosgummirädern: Ich konnte den Griff erhöhen! :exploding_head:
Ein Zaubermittel stand bereit: PATTEX, das Zeug bleibt Flexibel wie Gummi, deshalb habe ich mir zwei Moosgummistreifen fertig gemacht. Einen unbehandelt gelassen und einen mit Klebstoff versehen und diesen trocknen lassen. Danach einfach mal eine gefüllte Tasse (klappt nur mit Mäusemilch) rauf stellen und versuchen die Streifen über den Holztisch zu ziehen. Wow, damit zieht der Bot nicht nur die Wurst vom Teller.
Und das Beste ist: Es ist relativ Robust, zumindest habe ich den Pattex-Streifen über eine Holzplatte gerieben, bis das Moosgummi heiß wurde - der Kleberfilm bleibt haften!
Um die Reifen von Staub und Dreck zu befreien, kann man diese mit Klebeband einwickeln und wieder abziehen.
Gestern Abend habe ich die letzten Teile bekommen: Keilriemen für das Synchronisieren von jeweils einem Radpaar:

Hier ein kleines Bild, wie ich mir das Gefährt vorstelle!


Vielleicht kommt irgendwann noch die Gurken-Reaktivpanzerung.


#7

Moin, ist die Gurken-Reaktivpanzerung noch rechtzeitig fertig geworden?

Grüße
Patrick


#8

Leider habe ich noch keine Panzerung, aber der Bot wird heute zeigen, was er kann.

Weitere Ausführungen zum Code werden folgen.


#9

Die Sumo-Bot Competition 2019 war ein Spaß, auch wenn mein dilettantisches Vehikel nicht sonderliche Leistungen vollbracht hat. Ich habe viel gelernt. :grinning:
Nachdem die Kameras aus und die Besucher weg waren, haben wir nochmal ein paar Roboter in den Ring gestellt. Da konnte mein kleiner Gurkenkarton zeigen, was er machen sollte. Interessant war, dass der mit Karbonfaser überzogene Schild von DonQuiBot eine Art Ultraschall-Tarnkappe war.:open_mouth: Meine Vermutung ist, dass der Winkel in Verbindung mit der Oberflächenbeschaffenheit die Ultraschallwellen abgelenkt hat und somit keine Echo gemessen werden konnte.
:man_teacher: Setzen und Hefte raus! (warum erinnert mich dieses Emoticon an Collin Furz)
Hier der Versprochene Arduino-Code:

#include <NewPing.h>

NewPing sonar1(10,11,100);  // rechter Ultraschallsensor(TRIGGER_PIN, ECHO_PIN, MAX_DISTANZ); 
NewPing sonar2(8,9,100);    //linker US-Sensor

int value1=0; //Variable (ganze Zahl) 
int value2=0;
int value=0;

int MR1= 2; //Deklaration der Motoren Pins
int MR2= 4;
int ML1= 3;
int ML2= 5; 

int ir_l=0;
int ir_r=0;
int gefunden=0;

void setup()
{
  pinMode(A4, INPUT); //linker Liniensensor (IR-Reflexlichtschranke) schwarz=HIGH(1); weiß=LOW(0)
  pinMode(A5, INPUT); //rechter Liniensensor 
  pinMode(ML1, OUTPUT); //Motoren-Pins als Output  
  pinMode(ML2, OUTPUT);
  pinMode(MR1, OUTPUT);
  pinMode(MR2, OUTPUT); 
  botstop();
}

void botstop() 
{
    analogWrite(MR1,0);
    analogWrite(MR2,0); 
    analogWrite(ML1,0);
    analogWrite(ML2,0); 
}

void ir_finden() //finde Gegner
{
  while (gefunden==0)
  {
    analogWrite(MR1,100); //Motor rechts langsam vorwärts
    analogWrite(MR2,0); 
    analogWrite(ML1,0);
    analogWrite(ML2,100); //Motor links langsam rückwärts
    value1=sonar1.ping_cm(); //*.ping_cm()* enthält den gemessenen Abstandswert in Zentimeter 
    value2=sonar2.ping_cm(); 
    delay(50);
   if ((value1>0)||(value2>0)) //Sonar1 und/oder Sonar2 größer 0  
    {
    botstop();                  //Roboter stoppen
    delay(10);
    gefunden=1;
    }
   ir_l=digitalRead(A4);
   ir_r=digitalRead(A5);  
   if ((ir_l==LOW )||(ir_r==LOW)) //Liniensensorenabfrage einer oder beide erfassen den Boden
    {
      botstop();
      delay(10);
      gefunden=1;
    }
  }
}



void fight() //wenn Gegner erfasst, Bot ausrichten
{
  value1=sonar1.ping_cm();
  value2=sonar2.ping_cm(); 
  delay(50);
  if ((value1>0)||(value2>0)) //Sonar1 und/oder Sonar2 senden Entfernungswert
  {
        value=value1-value2;  //Variable für Drehzahlsteuerung der Motoren errechnen
        if (value<0)
        {
        analogWrite(MR1,250+value);
        analogWrite(MR2,0); 
        analogWrite(ML1,250-value);
        analogWrite(ML2,0); 
        }
        else
        {
        analogWrite(MR1,250-value);
        analogWrite(MR2,0); 
        analogWrite(ML1,250+value);
        analogWrite(ML2,0); 
         }
        delay(10);
        gefunden=1;  
     }
    else 
    {
         gefunden=0; 
    }
}

void boden_weiss()
{
  ir_l=digitalRead(A4);
  ir_r=digitalRead(A5);  
  if ((ir_l==LOW)&&(ir_r==LOW)) //beide Liniensensoren erfassen weißen Boden
  {
      if (gefunden==0) //suche
      {
        ir_finden();
      }
      else //Gegner erfasst
      {
        fight();
      }
    }
   else if ((ir_l==HIGH)&&(ir_r==HIGH)) //beide Liniensensoren erfassen den Rand dann vollen Schub Rückwärts
   {
    analogWrite(MR1,0);
    analogWrite(MR2,250); 
    analogWrite(ML1,0);
    analogWrite(ML2,250);
    delay(50);
    botstop();
   }
   else if (ir_l==HIGH) //links=schwarz, drehe nach rechts
   {
    analogWrite(MR1,0);
    analogWrite(MR2,250); 
    analogWrite(ML1,0);
    analogWrite(ML2,250);
    delay(300);
    analogWrite(MR1,0);
    analogWrite(MR2,250); 
    analogWrite(ML1,250);
    analogWrite(ML2,0);
    delay(300);
    botstop();
   }
   else //andernfalls (rechts=schwarz), fahre nach links
   {
    analogWrite(MR1,0);
    analogWrite(MR2,250); 
    analogWrite(ML1,0);
    analogWrite(ML2,250);
    delay(300);
    analogWrite(MR1,250);
    analogWrite(MR2,0); 
    analogWrite(ML1,0);
    analogWrite(ML2,250);
    delay(300);
    botstop();
   }
}

void loop() 
{
boden_weiss();
}

Das ist der Code, mit dem der Bot autonom (aber dumm) sein Ziel suchen und rammen soll. Den ursprünglichen Code habe ich im Netz (nur wo?) gefunden und für mich umgeschrieben. Falls Ihr Fehler entdeckt oder einfach nur Fragen habt, dann einfach hier posten.