WALTER - L'insecte photovore Arduino

Outils et machines nécessaires

	Fer à souder (générique)
	Pistolet à colle chaude (générique)

Applications et services en ligne

Arduino IDE

À propos de ce projet

[Veuillez excuser mon anglais]

J'aime beaucoup la configuration populaire de 2 servos insectes arduino sur Youtube. Quand je l'ai regardé, je me souviens toujours de ce que les robots BEAM ont fait bien avant que cette configuration ne devienne la préférée. Ces gens qui sont des fanatiques de robots analogiques ont mieux réussi à la démarche en raison d'un meilleur angle entre les deux moteurs (microcore / bicore walker , etc.).

Cependant, à mon avis, aucun de ceux mentionnés précédemment ne semble plus vivant que VBug1.5 (également connu sous le nom de Walkman) créé par le fondateur de la robotique à faisceau, Mark Tilden. Il utilise 5 moteurs, il a donc plus de maniabilité.

Faire un simple robot BEAM n'est pas difficile, mais construire quelque chose d'aussi compliqué que VBug1.5 pourrait être pénible pour un novice en électronique comme moi. Donc, quand j'ai décidé de faire quelque chose comme les bugs de Tilden, j'ai dû me contenter de la plate-forme arduino, le choix le plus simple pour les non-ingénieurs (ou dans mon cas, ce qui est embarrassant, un ingénieur en herbe).

En conséquence, j'ai fait Walter , un robot arduino à 4 pattes avec 5 servos. Vous vous demandez peut-être si je voulais créer un robot bug qui semble vivant, alors pourquoi je n'ai pas opté pour 8 ou 12 servos à la place. Eh bien, je pensais à quelque chose de plus simple que je puisse faire pour obtenir la plus grande maniabilité possible. Je parle d'utiliser beaucoup de colle au lieu de faire des cadres.

COMPORTEMENTS

Comme beaucoup d'autres robots arduino, Walter peut éviter les obstacles à l'aide des capteurs à ultrasons HC-SR04. Pour ajouter du caractère comme un insecte, Walter aussi un photovore, signifie qu'il est attiré par la lumière. Les photodiodes sont utilisées pour détecter la lumière. Il y a des valeurs aléatoires générées dans le sketch arduino pour que Walter décide quand il veut s'arrêter pour se reposer, et aussi pour changer au hasard sa vitesse de marche (3 vitesses).

Quand j'ai commencé, j'avais l'intention d'avoir des boutons tactiles sous chacun des pieds de Walter afin qu'il ait des capteurs de surface. Mais la batterie (une banque d'alimentation portable pour smartphone) coûte trop cher aux servos. Je sais que les boutons tactiles ne pèsent presque rien pour s'inquiéter d'ajouter du poids, mais ironiquement, le poids du robot n'est pas suffisant pour pouvoir appuyer sur les boutons à l'envers.

J'avais prévu de faire Walter version 2 avec des servos plus gros, puis j'ai inclus ces boutons comme capteurs de surface.

plus de détails

Code

• WALTER.ino

WALTER.inoArduino

/*WALTER - LE PHOTOVORE À 4 PATTESCe croquis Arduino est ma tentative de construire un robot quadrupède à 5 servomoteurs (4 pattes) nommé "WALTER". Afin d'utiliser ce croquis, vous devrez peut-être modifier certaines valeurs pour votre pratique ou pour s'adapter à votre propre configuration matérielle. Trouvez (Ctrl + F) ces marques pour rechercher facilement les valeurs qui pourraient avoir besoin d'être modifiées :- **** :Ces marques signifient qu'elles sont la potion centrale des servos et doivent potitionnement des jambes quand il est inactif). - *** :Ces marques signifient l'affectation des broches de l'arduino (connexion des capteurs et des servos à l'arduino). Référez-vous à cela lorsque vous construisez le robot. - ** :Ces marques signifient que les valeurs peuvent être modifiées en option selon vos goûts (largeur de pas des jambes, combien tourner lors de la détection de lumière/obstacle, etc.). Laissez-le tel quel si vous ne savez pas ce que vous faisiez. Vous pouvez utiliser ce croquis à vos risques et périls. écrire au code source publié ?? Le fait est que je ne veux pas être tenu responsable si quelque chose de mal s'est produit lorsque vous utilisiez ces codes. Amusez-vous bien ! Yohanes Martedi - 2015*/#include // ** ** Calibrer l'angle central des servos (en microsecondes car nous utiliserons la commande "xx.writeMicroseconds();"). Commencer par 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;ANGLE_sweep // **Définir cette valeur (en microsecondes) pour déterminer la largeur de balayage des servos (largeur de pas des jambes). Une valeur plus élevée signifie un angle de balayage plus large.const int ANGLE_res =10; // **Définir la résolution du mouvement du servo (en microsecondes) au moins à la largeur de bande morte par défaut du servo minimum (résolution la plus élevée) ou plus (résolution moindre). Exemple :la largeur de bande morte du servomoteur SG90 est de 10 microsecondes.int sweepSPEED; // variable pour déterminer à quelle vitesse les servos vont balayer.int sweepSPEED_Rand[3] ={4, 6, 8}; // **La vitesse du servo (vitesse de marche) changera de manière aléatoire dans 3 modes. Réglez la vitesse (en millisecondes) pour chaque mode. Une valeur plus petite signifie plus rapide.const int ANGLE_turnMAX =ANGLE_sweep * 1.5; // **Définir cette valeur pour déterminer de combien maximum le bot se tournera vers la lumière. Une valeur plus grande signifie un turn.const plus grand int ANGLE_turnNARROW =ANGLE_sweep * 0.25; // **Définir cette valeur pour déterminer de combien maximum le bot va tourner en évitant les objets à ses côtés dans un espace étroit. Une plus grande valeur signifie un plus grand turn.const int SONAR_sum =3; // Nombre de sonars utilisés.const int PHOTO_sum =4; // Quantité de photodiodes utilisées.int PIN_trig[SONAR_sum] ={13, 11, 8}; // ***Définir les broches arduino connectées aux broches de déclenchement des capteurs à ultrasons ; {avant, gauche, droite}.int PIN_ec[SONAR_sum] ={12, 10, 7} ; // ***Définir les broches arduino connectées aux broches d'écho des capteurs à ultrasons ; {avant, gauche, droite}.int PIN_PHOTO[PHOTO_sum] ={2, 3, 1, 0} ; // ***Définir les broches d'entrée analogiques arduino connectées aux photodiodes ; {avant gauche, avant droit, arrière gauche, arrière droit}.const int distRotate =25; // **Configurez la distance minimale (en cm) entre le robot et l'obstacle avant que le robot ne l'évite en tournant.const int distRetreat =10; // **Configurez la distance minimale (en cm) entre le robot et l'obstacle avant que le robot ne l'évite en reculant.const int distTurn =20; // **Configurez la distance minimale (en cm) entre le robot et l'obstacle avant que le robot ne l'évite en tournant.const int counter_gait_max =8; // **Configurez le nombre de pas que le robot effectuera pour éviter un obstacle (lors de la rotation ou du retrait).// **Configurez la durée pendant laquelle le robot reste et s'exécute (en millisecondes).const int RUN_time =25000;const int REST_time =3000;// ID des sonars:int SONAR_id;const int FRONT =0;const int LEFT =1;const int RIGHT =2;// ID des photodiodes:const int FRONT_LEFT =0;const int FRONT_RIGHT =1;const int BACK_LEFT =2;const int BACK_RIGHT =3;// Variables pour la lecture des photodiodes:int PHOTO_Front_Left;int PHOTO_Front_Right;int PHOTO_Back_Left;int PHOTO_Back_Right;const int SONAR_TrigSig =10; // Durée (en S) du signal de déclenchement nécessaire aux capteurs pour produire un son ultrasonore (déjà spécifié par les produits, ne modifiez pas cette valeur).const unsigned long SONAR_MaxEc =50000; // Durée maximale (en S) du signal d'écho donné par les capteurs (déjà spécifié par les produits, ne pas modifier cette valeur).const float SOUND_speed =0.034; // La vitesse du son dans l'air en S/cm (déjà spécifiée par la sciene, l'avatar Aang est nécessaire pour effectuer la flexion de l'air si cette valeur doit être modifiée).int distance[SONAR_sum]; // Résultats du calcul de distance.// Ddeclaration des servos:Servo SERVO_shaft;Servo SERVO_front_left;Servo SERVO_front_right;Servo SERVO_back_left;Servo SERVO_back_right;// Variables pour les angles de chaque servos:int ANGLE_shaft =ANGLE_mid_eft_avant gauche;int ANGLE ANGLE_front_right =ANGLE_mid_FRight;int ANGLE_back_left =ANGLE_mid_BLeft;int ANGLE_back_right =ANGLE_mid_BRight;// Manipulation de l'angle pour le servo central (arbre).const int ANGLE_max_Shaft =ANGLE_mid_Shaft + ANGLE_sweep_int =ANGLE_sweep;constANGt int angles de chaque 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;// Variables pour la correction des angles des servos en fonction de la détection de la lumière:int LIGHT_left;int LIGHT_right_right;// Variables pour la correction des angles des servos en fonction de la détection de la lumière:int LIGHT_left;int LIGHT_right_right;// Variables pour la correction des angles des servos en fonction de la détection de la lumière:int LIGHT_left;int LIGHT_right int SONAR_left;int SONAR_right;// Que des choses tels que des drapeaux, des compteurs, des enregistrements que je ne sais toujours pas comment expliquer. :(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 rotate_random;int counter_gait;void setup() { // Serial.begin (9600); // Serial. . vous savez, vérifier et déboguer .. SERVO_shaft.attach (2); // *** Configurer la broche de signal du servo horizontal (arbre) sur arduino. SERVO_front_left.attach (4); // *** Configurer l'avant gauche broche de signal du servo sur arduino. SERVO_front_right.attach (3) ; // *** Configurer la broche de signal du servo avant droit sur arduino. SERVO_back_left.attach (6) ; // *** Configurer la broche de signal du servo arrière gauche sur arduino. SERVO_back_right.attach (5) ; // *** Configurez la broche de signal du servo arrière droit sur l'arduino. // Préparez les servos à leurs angles médians. 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); // Goupille de réglage s pour les sonars, à la fois pinMode et value. for(SONAR_id =0; SONAR_id  distRotate) { flag_RUN_time =0; while(flag_RUN_time ==0) { FORWARD(); } } while(distance[AVANT]> distRetreat &&distance[AVANT] <=distRotate) { while(distance[LEFT]> distance[RIGHT]) { ROTATE_LEFT_AVOID(); Pause; } while(distance[LEFT] =ANGLE_max_Shaft) { ANGLE_prev =ANGLE_shaft ; ANGLE_arbre -=ANGLE_res; } else if(ANGLE_prev> ANGLE_shaft &&ANGLE_shaft> ANGLE_min_Shaft) { ANGLE_prev =ANGLE_shaft; ANGLE_arbre -=ANGLE_res; } else if(ANGLE_shaft <=ANGLE_min_Shaft) { ANGLE_prev =ANGLE_shaft ; ANGLE_arbre +=ANGLE_res; } SERVO_shaft.writeMicroseconds(ANGLE_shaft);}void SHAFT_REVERSE() { if(ANGLE_prev  ANGLE_shaft) { ANGLE_prev =ANGLE_shaft - 1; }}/*================================FIN DE MOUVEMENT DE L'ARBRE =================================*//*=====================================TRANSITION =====================================*/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; indicateur int =HAUT ; compteur entier =0 ; while(drapeau ==HAUT) { SHAFT(); LUMIÈRE_gauche =0 ; LUMIÈRE_droite =0 ; compteur++; 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; DÉBUT(); 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) -_sweep_val) ; 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_left), - SONAR 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_val)); 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); Pause; } while(SONAR_EcInterval ==0.0) { SONAR_distance =501.0; Pause; } return SONAR_distance;}/*=============================FIN DE LA LECTURE ULTRASONIQUE ==============================*//*====================================DETECTION DE LUMIERE =====================================*/vide 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(); LUMIÈRE_droite =0 ; } else if(LIGHT_COMPARE() <-LIGHT_Sensitivity) { LIGHT_left =0; LIGHT_right =LIGHT_COMPARE(); } else { LUMIÈRE_gauche =0; LUMIÈRE_droite =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 { // choisissez d'en utiliser une et commentez l'autre de ces variables ci-dessous // LIGHT_rate =PHOTO_Front_Left; LIGHT_rate =PHOTO_Front_Right; } int LIGHT_compareRAW =PHOTO_Front_Left - PHOTO_Front_Right ; LIGHT_comparerRAW =map(LIGHT_comparerRAW, -LIGHT_rate, LIGHT_rate, -ANGLE_turnMAX, ANGLE_turnMAX);; return LIGHT_compareRAW;}/*=================================FIN DE DETECTION DE LUMIERE ==================================*//*======================================COMPORTEMENT =======================================*/void RETREAT_AVOID() { counter_gait =0; while(counter_gait <=counter_gait_max) { RETRAITE(); }}void ROTATE_LEFT_AVOID() { counter_gait =0; rotation_aléatoire =2 ; while(counter_gait <=counter_gait_max) { ROTATE_LEFT(); }}void ROTATE_RIGHT_AVOID() { counter_gait =0; rotation_aléatoire =2 ; while(counter_gait <=counter_gait_max) { ROTATE_RIGHT(); }}void ROTATE_RANDOM_AVOID() { rotate_random =ROTATE_RANDOM(); while(rotate_random ==0) { ROTATE_LEFT_AVOID(); } while(rotate_random ==1) { ROTATE_RIGHT_AVOID(); }}void SIDE_AVOID() { if(distance[LEFT] <=distTurn &&distance[RIGHT]> distTurn) { LIGHT_left =0; LUMIÈRE_droite =0 ; SONAR_gauche =0 ; SONAR_right =-(map(distance[LEFT], 0, distTurn, ANGLE_turnMAX, 0)); } else if(distance[RIGHT] <=distTurn &&distance[LEFT]> distTurn) { LIGHT_left =0; LUMIÈRE_droite =0 ; SONAR_right =0 ; SONAR_left =map(distance[RIGHT], 0, distTurn, ANGLE_turnMAX, 0); } else if(distance[LEFT] <=distTurn &&distance[RIGHT] <=distTurn) { LIGHT_left =0; LUMIÈRE_droite =0 ; if(distance[LEFT]  

Schémas