WALTER - Das Arduino Photovore Insekt

Notwendige Werkzeuge und Maschinen

	Lötkolben (generisch)
	Heißklebepistole (generisch)

Apps und Onlinedienste

Arduino-IDE

Über dieses Projekt

[Bitte entschuldigen Sie mein Englisch]

Ich mag das beliebte Setup von 2 Servos Arduino Insekten sehr auf Youtube. Wenn ich es mir ansehe, erinnere ich mich immer daran, was die Roboter von BEAM gemacht haben, lange bevor dieses Setup zum Favoriten wurde. Diese Leute, die analoge Roboterfanatiker sind, schnitten aufgrund des besseren Winkels zwischen den beiden Motoren besser ab (Microcore / Bicore-Walker , usw.).

Meiner Meinung nach sieht jedoch keines der oben genannten Dinge lebendiger aus als VBug1.5 (auch bekannt als Walkman) vom Gründer der Beam Robotic, Mark Tilden. Es verwendet 5 Motoren, daher hat es mehr Manövrierfähigkeit.

Einen einfachen BEAM-Roboter zu bauen ist nicht schwer, aber etwas so Kompliziertes wie VBug1.5 zu bauen, könnte für einen Elektronik-Neuling wie mich peinlich sein. Als ich mich also entschied, so etwas wie Tildens Bugs zu machen, musste ich mich mit der Arduino-Plattform zufrieden geben, der einfachsten Wahl für Nicht-Ingenieure (oder in meinem Fall, peinlicherweise, einen Möchtegern-Ingenieur).

Als Ergebnis habe ich Walter . gemacht , ein 4-beiniger Arduino-Roboter mit 5 Servos. Sie fragen sich vielleicht, wenn ich einen Look-alive-Bug-Roboter bauen wollte, warum ich dann nicht mit 8 oder 12 Servos gegangen bin. Nun, ich dachte an das Einfachste, was ich tun kann, um die größtmögliche Manövrierfähigkeit zu erreichen. Ich rede davon, viel Kleber zu verwenden, anstatt Rahmen zu machen.

VERHALTEN

Wie viele andere Arduino-Roboter kann Walter mit den Ultraschallsensoren HC-SR04 Hindernissen ausweichen. Um Charakter als Käfer hinzuzufügen, Walter auch ein Fotofresser, bedeutet, dass er vom Licht angezogen wird. Photodioden werden verwendet, um Licht zu detektieren. In der Arduino-Skizze werden zufällige Werte generiert, damit Walter entscheidet, wann er aufhören möchte, um sich auszuruhen, und auch seine Ganggeschwindigkeit (3 Geschwindigkeiten) zufällig ändert.

Als ich anfing, wollte ich unter jedem von Walters Füßen Tastknöpfe haben, damit er einen Oberflächensensor hat. Aber der Akku (eine tragbare Powerbank fürs Smartphone) kostet die Servos zu viel Gewicht. Ich weiß, dass Takttasten fast nichts wiegen, um das Gewicht zu erhöhen, aber ironischerweise reicht das Gewicht des Roboters nicht aus, um die umgedrehten Tasten drücken zu können.

Ich hatte vor, Walter Version 2 mit größeren Servos zu machen und diese Tasten dann als Oberflächensensoren einzubauen.

weitere Details

Code

• WALTER.ino

WALTER.inoArduino

/*WALTER - THE 4 LEGGED PHOTOVOREDiese Arduino-Skizze ist mein Versuch, einen 5-Servo-Vierbeiner (4-beinigen) Roboter namens "WALTER" zu bauen. Um diese Skizze zu verwenden, müssen Sie möglicherweise einige Werte für Ihre bequeme oder zur Anpassung an Ihr eigenes Hardware-Setup.Suchen Sie (Strg + F) diese Markierungen, um leicht zu suchen, welche Werte möglicherweise geändert werden müssen:- ****:Diese Markierungen bedeuten, dass sie die Mittelposition der Servos sind und kalibriert werden müssen (Ihr Roboter Potitionierung der Beine, wenn es im Leerlauf ist). - ***:Diese Markierungen bedeuten die Belegung der Arduino-Pins (Sensoren und Servos, die mit Arduino verbunden sind). Beachten Sie dies, wenn Sie den Roboter bauen. - ** :Diese Markierungen bedeuten, dass die Werte optional nach Ihrem Geschmack geändert werden können (Schrittweite der Beine, wie viel Drehung bei Licht-/Hinderniserkennung usw.). Lassen Sie es einfach so, wie es ist, wenn Sie nicht wissen, was Sie tun. Sie können diese Skizze auf eigene Gefahr verwenden In veröffentlichten Quellcode schreiben??Der Punkt ist, dass ich nicht dafür verantwortlich gemacht werden möchte, wenn etwas Schlimmes passiert ist, wenn Sie diese Codes verwenden.Viel Spaß!Yohanes Martedi - 2015*/#include // ** **Kalibrieren Sie den Mittelwinkel der Servos (in Mikrosekunden, da wir den Befehl "xx.writeMicroseconds();" verwenden). Beginnen Sie mit 1500.const int ANGLE_mid_Shaft =1520;const int ANGLE_mid_FLeft =1550;const int ANGLE_mid_FRight =1570;const int ANGLE_mid_BLeft =1450;const int ANGLE_mid_BRight =1450;const int =250;_sweep // ** Stellen Sie diesen Wert (in Mikrosekunden) ein, um zu bestimmen, wie weit die Servos streichen (Schrittweite der Beine). Ein größerer Wert bedeutet einen größeren Sweep-Winkel.const int ANGLE_res =10; // ** Stellen Sie die Servobewegungsauflösung (in Mikrosekunden) mindestens auf die Standard-Totbandbreite des Servos (höchste Auflösung) oder mehr (weniger Auflösung) ein. Beispiel:SG90-Servo-Totbandbreite beträgt 10 Mikrosekunden.int SweepSPEED; // Variable, um zu bestimmen, wie schnell die Servos Sweep.int SweepSPEED_Rand[3] ={4, 6, 8}; // **Servogeschwindigkeit (Ganggeschwindigkeit) ändert sich zufällig in 3 Modi. Stellen Sie die Geschwindigkeit (in Millisekunden) für jeden Modus ein. Ein kleinerer Wert bedeutet schneller.const int ANGLE_turnMAX =ANGLE_sweep * 1.5; // **Stellen Sie diesen Wert ein, um zu bestimmen, wie viel Maximum der Bot in Richtung Licht dreht. Größerer Wert bedeutet größere turn.const int ANGLE_turnNARROW =ANGLE_sweep * 0.25; // **Stellen Sie diesen Wert ein, um zu bestimmen, wie viel maximal der Bot drehen wird, um Objekten an seinen Seiten in engen Räumen auszuweichen. Größerer Wert bedeutet größere turn.const int SONAR_sum =3; // Anzahl der verwendeten Sonare.const int PHOTO_sum =4; // Anzahl der verwendeten Fotodioden.int PIN_trig[SONAR_sum] ={13, 11, 8}; // *** Stellen Sie die Arduino-Pins ein, die mit den Triggerpins der Ultraschallsensoren verbunden sind; {vorne, links, rechts}.int PIN_ec[SONAR_sum] ={12, 10, 7}; // *** Stellen Sie die Arduino-Pins ein, die mit den Echo-Pins der Ultraschallsensoren verbunden sind; {vorne, links, rechts}.int PIN_PHOTO[PHOTO_sum] ={2, 3, 1, 0}; // *** Stellen Sie die analogen Arduino-Eingangspins ein, die mit Fotodioden verbunden sind; {vorne links, vorne rechts, hinten links, hinten rechts}.const int distRotate =25; // **Konfigurieren Sie den Mindestabstand (in cm) zwischen dem Roboter und dem Hindernis, bevor der Roboter ihm durch Rotation ausweicht.const int distRetreat =10; // **Konfigurieren Sie den Mindestabstand (in cm) zwischen Roboter und Hindernis, bevor der Roboter ihm ausweicht, indem Sie sich zurückziehen.const int distTurn =20; // **Konfigurieren Sie den Mindestabstand (in cm) zwischen dem Roboter und dem Hindernis, bevor der Roboter ihm ausweicht, indem Sie sich drehen.const int counter_gait_max =8; // **Konfigurieren Sie, wie viele Schritte der Roboter unternimmt, um Hindernissen auszuweichen (beim Drehen oder Zurückziehen). // **Konfigurieren Sie, wie lange der Bot ruht und läuft (in Millisekunden).const int RUN_time =25000;const int REST_time =3000;// IDs für Sonare:int SONAR_id;const int FRONT =0;const int LEFT =1;const int RIGHT =2;// IDs für Fotodioden:const int FRONT_LEFT =0;const int FRONT_RIGHT =1;const int BACK_LEFT =2;const int BACK_RIGHT =3;// Variablen für Photodioden lesen:int PHOTO_Front_Left;int PHOTO_Front_Right;int PHOTO_Back_Left;int PHOTO_Back_Right;const int SONAR_TrigSig =10; // Dauer (in S) des Triggersignals, das die Sensoren zur Erzeugung von Ultraschall benötigen (von den Produkten bereits vorgegeben, diesen Wert nicht ändern).const unsigned long SONAR_MaxEc =50000; // Maximale Dauer (in S) des von den Sensoren ausgegebenen Echosignals (von den Produkten bereits vorgegeben, diesen Wert nicht ändern).const float SOUND_speed =0.034; // Die Schallgeschwindigkeit auf Luft in S/cm (bereits von der Wissenschaft angegeben, Avatar Aang wird benötigt, um Luftbiegung durchzuführen, wenn dieser Wert geändert werden soll).int distance[SONAR_sum]; // Ergebnisse der Abstandsberechnung.// Ddeklaration der Servos:Servo SERVO_shaft;Servo SERVO_front_left;Servo SERVO_front_right;Servo SERVO_back_left;Servo SERVO_back_right;// Variablen für die Winkel der einzelnen Servos:int ANGLE_shaft =ANGLE_Mid_ANG_intFL ANGLE_front_right =ANGLE_mid_FRight;int ANGLE_back_left =ANGLE_mid_BLeft;int ANGLE_back_right =ANGLE_mid_BRight; // Winkelmanipulation für Mittelservo (Welle).const int ANGLE; Winkel der einzelnen Servos:int ANGLE_shaft_record;int ANGLE_front_left_record;int ANGLE_front_right_record;int ANGLE_back_left_record;int ANGLE_back_right_record;// Variablen für Servowinkelkorrektur entsprechend Lichterkennung:int LIGHT_left;int LIGHT_right;// Variablen für Servowinkelerkennung:Korrektur int SONAR_left;int SONAR_right;// Diese Dinge wie Flags, Zähler, Datensätze, bei denen ich immer nicht sicher bin, wie ich sie erklären soll. :(int ANGLE_prev;int flag_shaft_reverse;int flag_transition_rotate;int flag_transition_start =1;int flag_rest =0;int flag_RUN_time =0;int rotation_random;int counter_gait;void setup() { // Serial.begin (9600); // Serial. . Sie wissen, überprüfen und debuggen.. SERVO_shaft.attach (2); // *** Signalstift des horizontalen (Wellen-) Servos auf Arduino einrichten. SERVO_front_left.attach (4); // ***Vorne-links einrichten Signalstift des Servos auf Arduino. SERVO_front_right.attach (3); // *** Signalstift des vorderen rechten Servos auf Arduino einrichten. SERVO_back_left.attach (6); // *** Signalstift des hinteren linken Servos auf einrichten Arduino. SERVO_back_right.attach (5); // *** Signalstift des hinteren rechten Servos auf Arduino einrichten. // Die Servos in ihren mittleren Winkeln vorbereiten. SERVO_shaft.writeMicroseconds (ANGLE_mid_Shaft); SERVO_front_left.writeMicroseconds (ANGLE_mid_FLeft); SERVO_front_right.writeMicroseconds(ANGLE_mid_FRight); SERVO_back_left.writeMicroseconds(ANGLE_mid_BLeft); SERVO_back_right.writeMicroseconds(ANGLE_mid_BRight); // Einstellstift s für Sonare, sowohl PinMode als auch Wert. for(SONAR_id =0; SONAR_id  distRotate) { flag_RUN_time =0; while(flag_RUN_time ==0) { FORWARD(); } } while(distanz[FRONT]> distRetreat &&Distanz[FRONT] <=distRotate) { while(distanz[LINKS]> Distanz[RECHTS]) { ROTATE_LEFT_AVOID(); brechen; aufrechtzuerhalten. Während (Abstand [LINKS] =ANGLE_max_Shaft) { ANGLE_prev =ANGLE_shaft; ANGLE_Welle -=ANGLE_res; } else if (ANGLE_prev> ANGLE_shaft &&ANGLE_shaft> ANGLE_min_Shaft) { ANGLE_prev =ANGLE_shaft; ANGLE_Welle -=ANGLE_res; aufrechtzuerhalten. Sonst if (ANGLE_shaft <=ANGLE_min_Shaft) { ANGLE_prev =ANGLE_shaft; ANGLE_Welle +=ANGLE_res; } SERVO_shaft.writeMicroseconds(ANGLE_shaft);}void SHAFT_REVERSE() { if(ANGLE_prev  ANGLE_shaft) { ANGLE_prev =ANGLE_shaft - 1; }}/*===============================ENDE DER WELLENBEWEGUNG ================================*//*=====================================ÜBERGANG ====================================*/void TRANSITION_GAIT() { ANGLE_front_left_record =ANGLE_front_left; ANGLE_front_right_record =ANGLE_front_right; ANGLE_back_left_record =ANGLE_back_left; ANGLE_back_right_record =ANGLE_back_right; ANGLE_shaft_record =ANGLE_shaft; int-Flag =HOCH; int-Zähler =0; Während (Flag ==HOCH) { WELLE (); LICHT_links =0; LIGHT_right =0; Zähler++; ANGLE_front_left =map(counter, 1, ((ANGLE_sweep * 2) / ANGLE_res), ANGLE_front_left_record, ANGLE_mid_FLeft); ANGLE_front_right =map(counter, 1, ((ANGLE_sweep * 2) / ANGLE_res), ANGLE_front_right_record, ANGLE_mid_FRight); ANGLE_back_left =map(counter, 1, ((ANGLE_sweep * 2) / ANGLE_res), ANGLE_back_left_record, ANGLE_mid_BLeft); ANGLE_back_right =map(counter, 1, ((ANGLE_sweep * 2) / ANGLE_res), ANGLE_back_right_record, ANGLE_mid_BRight); SERVO_shaft.writeMicroseconds(ANGLE_shaft); SERVO_front_left.writeMicroseconds(ANGLE_front_left); SERVO_front_right.writeMicroseconds(ANGLE_front_right); SERVO_back_left.writeMicroseconds(ANGLE_back_left); SERVO_back_right.writeMicroseconds(ANGLE_back_right); if(counter ==((ANGLE_sweep * 2) / ANGLE_res)) { Flag =LOW; ANFANG(); flag_transition_rotate =0; } }}void TRANSITION_START() { if(ANGLE_shaft ==ANGLE_mid_Shaft || (ANGLE_shaft> ANGLE_mid_Shaft &&ANGLE_shaft> ANGLE_prev) || (ANGLE_shaft =ANGLE_mid_Shaft &&ANGLE_prev =ANGLE_mid_Shaft &&ANGLE_prev> ANGLE_shaft) { ANGLE_front_left =map(ANGLE_shaft, ANGLE_max_Shaft, ANGLE_mid_Shaft, ANGLE_mid_FLeft, ((ANGLE_mid_FLeft_left) -SON ANGLE_front_right =map(ANGLE_shaft, ANGLE_max_Shaft, ANGLE_mid_Shaft, ANGLE_mid_FRight, ((ANGLE_mid_FRight + ANGLE_sweep_val) + LIGHT_right + SONAR_right)); ANGLE_back_left =map(ANGLE_shaft, ANGLE_max_Shaft, ANGLE_mid_Shaft, ANGLE_mid_BLeft, ((ANGLE_mid_BLeft - ANGLE_sweep_val) + LIGHT_left + SONAR_left)); ANGLE_back_right =map(ANGLE_shaft, ANGLE_max_Shaft, ANGLE_mid_Shaft, ANGLE_mid_BRight, ((ANGLE_mid_BRight – ANGLE_sweep_val) – LIGHT_right – SONAR_right)); } else if(ANGLE_shaft  ANGLE_shaft) { ANGLE_front_left =map(ANGLE_shaft, ANGLE_mid_Shaft, ANGLE_min_Shaft, ((ANGLE_mid_FLeft + ANGLE_sweep_val) - LIGHT__left - ANGLE__left - ANGLE__left - ANGLE__left ANGLE_front_right =map(ANGLE_shaft, ANGLE_mid_Shaft, ANGLE_min_Shaft, ((ANGLE_mid_FRight + ANGLE_sweep_val) + LIGHT_right + SONAR_right), ANGLE_mid_FRight); ANGLE_back_left =map(ANGLE_shaft, ANGLE_mid_Shaft, ANGLE_min_Shaft, ((ANGLE_mid_BLeft - ANGLE_sweep_val) + LIGHT_left + SONAR_left), ANGLE_mid_BLeft); ANGLE_back_right =map(ANGLE_shaft, ANGLE_mid_Shaft, ANGLE_min_Shaft, ((ANGLE_mid_BRight - ANGLE_sweep_val) - LIGHT_right - SONAR_right), ANGLE_mid_BRight); } else if(ANGLE_shaft =ANGLE_mid_Shaft &&ANGLE_prev =ANGLE_mid_Shaft &&ANGLE_prev> ANGLE_shaft) { ANGLE_front_left =map(ANGLE_shaft, ANGLE_max_Shaft, ANGLE_mid_Shaft, ANGLE_mid_FLeft, (ANGLE_mid_FLeft - ANGLE)_swe; ANGLE_front_right =map(ANGLE_shaft, ANGLE_max_Shaft, ANGLE_mid_Shaft, ANGLE_mid_FRight, (ANGLE_mid_FRight + ANGLE_sweep_val)); ANGLE_back_left =map(ANGLE_shaft, ANGLE_max_Shaft, ANGLE_mid_Shaft, ANGLE_mid_BLeft, (ANGLE_mid_BLeft + ANGLE_sweep_val)); ANGLE_back_right =map(ANGLE_shaft, ANGLE_max_Shaft, ANGLE_mid_Shaft, ANGLE_mid_BRight, (ANGLE_mid_BRight – ANGLE_sweep_val)); } else if(ANGLE_shaft  ANGLE_shaft) { ANGLE_front_left =map(ANGLE_shaft, ANGLE_mid_Shaft, ANGLE_min_Shaft, (ANGLE_mid_FLeft - ANGLE_sweep_val), ANGLE_mid_FLeft; ANGLE_front_right =map(ANGLE_shaft, ANGLE_mid_Shaft, ANGLE_min_Shaft, (ANGLE_mid_FRight + ANGLE_sweep_val), ANGLE_mid_FRight); ANGLE_back_left =map(ANGLE_shaft, ANGLE_mid_Shaft, ANGLE_min_Shaft, (ANGLE_mid_BLeft + ANGLE_sweep_val), ANGLE_mid_BLeft); ANGLE_back_right =map(ANGLE_shaft, ANGLE_mid_Shaft, ANGLE_min_Shaft, (ANGLE_mid_BRight - ANGLE_sweep_val), ANGLE_mid_BRight); } else if(ANGLE_shaft  0.0) { SONAR_distance =SONAR_EcInterval * (SOUND_speed / 2.0); brechen; aufrechtzuerhalten. Während (SONAR_EcInterval ==0.0) { SONAR_distance =501.0; brechen; } return SONAR_distance;}/*============================ENDE DER ULTRASCHALLLESEN =============================*//*===================================LICHTERKENNUNG ===================================*/void LIGHT_COMPARE_EXECUTE () {//PHOTO_FLeft_RAW =analogRead (PIN_PHOTO [FRONT_LEFT]); //PHOTO_FRight_RAW =analogRead (PIN_PHOTO[FRONT_RIGHT]); PHOTO_Front_Left =analogRead(PIN_PHOTO[FRONT_LEFT]); PHOTO_Front_Right =analogRead(PIN_PHOTO[FRONT_RIGHT]); PHOTO_Back_Left =analogRead(PIN_PHOTO[BACK_LEFT]); PHOTO_Back_Right =analogRead(PIN_PHOTO[BACK_RIGHT]); if((PHOTO_Front_Left + PHOTO_Front_Right)>=(PHOTO_Back_Left + PHOTO_Back_Right)) { int LIGHT_Sensitivity =50; if(LIGHT_COMPARE()> LIGHT_Sensitivity) { LIGHT_left =LIGHT_COMPARE(); LIGHT_right =0; aufrechtzuerhalten. Sonst if (LIGHT_COMPARE() <-LIGHT_Sensitivity) {LIGHT_left =0; LIGHT_right =LIGHT_COMPARE(); } sonst { LIGHT_left =0; LIGHT_right =0; }} else { if(PHOTO_Back_Left> PHOTO_Back_Right) {LIGHT_right =0; LIGHT_left =ANGLE_turnMAX; } else if(PHOTO_Back_Left  PHOTO_Front_Right) { LIGHT_rate =PHOTO_Front_Left; } else if(PHOTO_Front_Right> PHOTO_Front_Left) { LIGHT_rate =PHOTO_Front_Right; } else { // Wählen Sie eine dieser Variablen und kommentieren Sie die andere unten // LIGHT_rate =PHOTO_Front_Left; LIGHT_rate =PHOTO_Front_Right; } int LIGHT_compareRAW =PHOTO_Front_Left - PHOTO_Front_Right; LIGHT_compareRAW =map(LIGHT_compareRAW, -LIGHT_rate, LIGHT_rate, -ANGLE_turnMAX, ANGLE_turnMAX);; return LIGHT_compareRAW;}/*================================END OF LIGHT DETECT =================================*//*======================================VERHALTEN =====================================*/void RETREAT_AVOID() { counter_gait =0; while(counter_gait <=counter_gait_max) { RETREAT(); }}void ROTATE_LEFT_AVOID() { counter_gait =0; rotation_zufällig =2; while(counter_gait <=counter_gait_max) { ROTATE_LEFT(); }}void ROTATE_RIGHT_AVOID() { counter_gait =0; rotation_zufällig =2; while(counter_gait <=counter_gait_max) { ROTATE_RIGHT(); }}void ROTATE_RANDOM_AVOID() { rotation_random =ROTATE_RANDOM(); while(rotate_random ==0) { ROTATE_LEFT_AVOID(); aufrechtzuerhalten. Während (rotate_random ==1) { ROTATE_RIGHT_AVOID(); }}void SIDE_AVOID() { if(distance[LEFT] <=distTurn &&Distance[RIGHT]> distTurn) { LIGHT_left =0; LIGHT_right =0; SONAR_links =0; SONAR_right =-(map(distanz[LEFT], 0, distTurn, ANGLE_turnMAX, 0)); aufrechtzuerhalten. Sonst if (Entfernung [RIGHT] <=distTurn &&Distance [LEFT]> distTurn) { LIGHT_left =0; LIGHT_right =0; SONAR_rechts =0; SONAR_left =map(distanz[RIGHT], 0, distTurn, ANGLE_turnMAX, 0); aufrechtzuerhalten. Sonst if(distanz[LEFT] <=distTurn &&distance[RIGHT] <=distTurn) { LIGHT_left =0; LIGHT_right =0; if (distanz [LINKS]  

Schaltpläne