Robot araignée Arduino (quadrupède)

Composants et fournitures

Arduino Nano R3

Module Bluetooth basse énergie (BLE) (générique)

Extension OLED d'Onion Corporation

Cathode commune diffuse RVB

JLCPCB PCB personnalisé

À propos de ce projet

Salut les gars! Voici un nouveau tutoriel pour vous guider pas à pas tout en réalisant ce genre de projets électroniques super étonnants, qu'est le "robot crawler" également connu sous le nom de "robot araignée" ou de "robot quadrupède".

Puisque tout le monde a remarqué l'évolution à grande vitesse de la technologie robotique, nous avons décidé de vous emmener à un niveau supérieur en robotique et en fabrication de robots. nous avons commencé il y a quelque temps en réalisant des projets électroniques de base et un robot de base comme PICTO92 le robot suiveur de ligne afin de vous familiariser un peu avec l'électronique et de vous retrouver capable d'inventer vos propres projets.

Passant à un autre niveau, nous avons commencé avec ce robot qui est basique dans le concept mais il deviendra un peu compliqué si vous approfondissez son programme. Et comme ces gadgets sont si chers dans la boutique en ligne, nous vous proposons ce guide étape par étape pour vous guider dans la création de votre propre Spiderbot .

Ce projet est si pratique à réaliser spécialement après avoir obtenu le PCB personnalisé que nous avons commandé à JLCPCB pour améliorer l'apparence de notre robot et il y a également suffisamment de documents et de codes dans ce guide pour vous permettre de créer votre robot facilement.

Nous avons réalisé ce projet en seulement 7 jours, seulement deux jours pour terminer la fabrication du matériel et l'assemblage, puis cinq jours pour préparer le code et l'application Android. afin de contrôler le robot à travers elle. Avant de commencer, voyons d'abord

Ce que vous apprendrez :

Sélectionner les bons composants en fonction des fonctionnalités de votre projet

Faire le circuit pour connecter tous les composants choisis

Assembler toutes les pièces du projet

Mise à l'échelle de la balance du robot

À l'aide de l'application Android. pour se connecter via Bluetooth et commencer à manipuler le système

Étape 1 :Qu'est-ce qu'un « robot araignée ? »

Comme son nom l'indique, notre robot est une représentation basique des mouvements de sipder mais il n'effectuera pas exactement les mêmes mouvements du corps puisque nous n'utilisons que quatre jambes au lieu de huit.

Nommé également Quadrupède robot puisqu'il a quatre jambes et effectue ses mouvements à l'aide de ces jambes, le mouvement de chaque jambe est lié aux autres jambes afin d'identifier la position du corps du robot et également de contrôler l'équilibre du corps du robot.

Les robots à pattes gèrent mieux le terrain que leurs homologues à roues et se déplacent de manière variée et animale. Cependant, cela rend les robots à pattes plus compliqués et moins accessibles à de nombreux fabricants. et aussi le coût de fabrication et les dépenses élevées qu'un fabricant devrait dépenser pour créer un quadrupède complet car il est basé sur des servomoteurs ou des moteurs pas à pas et les deux sont plus chers que les moteurs à courant continu qui pourraient être utilisés dans des robots à roues.

Avantages

Vous trouverez des quadrupèdes abondants dans la nature, car quatre pattes permettent une stabilité passive ou la capacité de rester debout sans ajuster activement la position. Il en est de même pour les robots. Un robot à quatre pattes est moins cher et plus simple qu'un robot avec plus de pattes, mais il peut quand même atteindre la stabilité.

Étape 2 :Les servomoteurs sont les principaux actionneurs

Un servomoteur, tel que défini dans wikipedia, est un actionneur rotatif ou un actionneur linéaire qui permet un contrôle précis de la position angulaire ou linéaire, de la vitesse et de l'accélération.[1] Il se compose d'un moteur approprié couplé à un capteur pour le retour de position. Il nécessite également un contrôleur relativement sophistiqué, souvent un module dédié conçu spécifiquement pour être utilisé avec des servomoteurs.

Les servomoteurs ne sont pas une classe spécifique de moteurs, bien que le terme servomoteur soit souvent utilisé pour désigner un moteur adapté à une utilisation dans un système de contrôle en boucle fermée.

D'une manière générale, le signal de commande est un train d'impulsions carré. Les fréquences communes pour les signaux de commande sont 44 Hz, 50 Hz et 400 Hz. La largeur d'impulsion positive est ce qui détermine la position du servo. Une largeur d'impulsion positive d'environ 0,5 ms entraînera une déviation maximale du palonnier du servo vers la gauche (généralement environ 45 à 90 degrés selon le servo en question). Une largeur d'impulsion positive d'environ 2,5 ms à 3,0 ms entraînera une déviation maximale du servo vers la droite. Une largeur d'impulsion d'environ 1,5 ms amènera le servo à maintenir la position neutre à 0 degré. La haute tension de sortie est généralement comprise entre 2,5 volts et 10 volts (avec 3V typique). La basse tension de sortie va de -40mV à 0V.

Étape 3 : La fabrication du PCB (produit par JLCPCB)

À propos de JLCPCB

JLCPCB (Shenzhen JIALICHUANG Electronic Technology Development Co., Ltd.) est la plus grande entreprise de prototypes de PCB en Chine et un fabricant de haute technologie spécialisé dans la production de prototypes rapides de PCB et de petits lots de PCB.

Avec plus de 10 ans d'expérience dans la fabrication de PCB, JLCPCB compte plus de 200 000 clients dans le pays et à l'étranger, avec plus de 8 000 commandes en ligne de prototypage de PCB et de production de PCB en petite quantité par jour. La capacité de production annuelle est de 200 000 m². pour divers circuits imprimés à 1 couche, 2 couches ou multicouches. JLC est un fabricant professionnel de circuits imprimés doté d'équipements de puits à grande échelle, d'une gestion stricte et d'une qualité supérieure.

Retour à notre projet

Afin de produire le PCB, j'ai comparé les prix de nombreux producteurs de PCB et j'ai choisi JLCPCB les meilleurs fournisseurs de PCB et les fournisseurs de PCB les moins chers pour commander ce circuit. Tout ce que je dois faire, c'est quelques clics simples pour télécharger le fichier gerber et définir certains paramètres comme la couleur et la quantité d'épaisseur du PCB, puis j'ai payé seulement 2 dollars pour obtenir mon PCB après cinq jours seulement.

Comme il montre l'image du schéma associé, j'ai utilisé un Arduino Nano pour contrôler l'ensemble du système. J'ai également conçu la forme de l'araignée du robot pour rendre ce projet bien meilleur.

Vous pouvez obtenir le fichier Circuit (PDF) ici. Comme vous pouvez le voir sur les images ci-dessus, le PCB est très bien fabriqué et j'ai la même forme d'araignée de PCB que nous avons conçue et toutes les étiquettes et logos sont là pour me guider pendant les étapes de soudure.

Vous pouvez également télécharger le fichier Gerber pour ce circuit à partir d'ici si vous souhaitez passer une commande pour la même conception de circuit.

Étape 4 :Ingrédients

Passons maintenant en revue les composants nécessaires dont nous avons besoin pour ce projet, donc comme je l'ai dit, j'utilise un Arduino Nano pour faire fonctionner les 12 servomoteurs du robot à quatre pattes. Le projet comprend également un écran OLED pour afficher les visages Cozmo et un module Bluetooth pour contrôler le robot via une application Android.

Afin de créer ce genre de projets nous aurons besoin de :

- Le PCB que nous avons commandé chez JLCPCB

- 12 servomoteurs comme vous vous en souvenez 3 servos pour chaque jambe :https://amzn.to/2B25XbG

- Un Arduino Nano :https://amzn.to/2MmZsVg

- Module Bluetooth HC-06 :https://amzn.to/2B1Z3CY

- Un écran d'affichage OLED :https://amzn.to/2OySnyn

- LED RGB 5mm :https://amzn.to/2B56hq3

- Quelques connecteurs d'en-tête :https://amzn.to/2nyZg7i

- Et le corps du robot sait que vous avez besoin de les imprimer à l'aide d'une imprimante 3D

Étape 5 :L'assemblage du robot

Maintenant, nous avons le PCB prêt et tous les composants très bien soudés, après cela nous devons assembler le corps du robot, la procédure est si simple, il suffit donc de suivre les étapes que je montre, nous devons d'abord préparer chaque jambe d'un côté et faire une led nous avons besoin de deux servomoteurs pour les articulations et les pièces imprimées Coxa, Fémur et Tibia avec cette petite pièce de fixation.

À propos des pièces du corps du robot, vous pouvez télécharger ses fichiers STL ici.

En commençant par le premier servo, placez-le dans sa douille et maintenez-le avec ses vis, après cela tournez l'axe des servos à 180° sans placer la vis pour les attaches et passez à la pièce suivante qui est le fémur pour le connecter au tibia à l'aide du premier axe du servo-joint et de la pièce de fixation. La dernière étape pour terminer la jambe consiste à placer la deuxième articulation, je veux dire le deuxième servo pour maintenir la troisième partie de la jambe qui est la pièce Coxa.

Maintenant, répétez la même chose pour toutes les jambes pour préparer quatre jambes. Après cela, prenez le châssis supérieur et placez le reste des servos dans leurs prises, puis connectez chaque jambe au servo approprié. Il n'y a qu'une dernière pièce imprimée qui est le châssis inférieur du robot dans lequel nous placerons notre circuit imprimé

Étape 6 :L'application Android

En parlant de l'androïde, cela vous permet de

connectez-vous à votre robot via Bluetooth et effectuez des mouvements d'avant en arrière et des virages gauche droite, il vous permet également de contrôler la couleur de la lumière du robot en temps réel en choisissant la couleur souhaitée dans cette roue chromatique.

Vous pouvez télécharger gratuitement l'application Android à partir de ce lien :ici

Étape 7 : le code Arduino et la validation du test

Maintenant, nous avons le robot presque prêt à fonctionner mais nous devons d'abord configurer les angles des articulations, alors téléchargez le code de configuration qui vous permet de mettre chaque servo dans la bonne position en attachant les servos à 90 degrés n'oubliez pas de connecter le 7V Batterie CC pour faire fonctionner le robot.

Ensuite, nous devons télécharger le programme principal pour contrôler le robot à l'aide de l'application Android. Vous pouvez télécharger les deux programmes à partir des liens suivants :

- Code servo de mise à l'échelle :lien de téléchargement- Programme principal du robot Spider :lien de téléchargement

Après avoir téléchargé le code, j'ai connecté l'écran OLED afin d'afficher les sourires du robot Cozmo que j'ai créés dans le code principal.

Comme vous pouvez le voir les gars sur les photos ci-dessus, le robot suit toutes les instructions envoyées depuis mon smartphone et encore quelques autres améliorations à effectuer afin de le rendre bien meilleur.

Code

Code principal du robot araignée

Code principal de Spider RobotArduino

/************************************************ ******************************************************** ******************************************************** ************************* * - Auteur :BELKHIR Mohamed * * - Profession :(Ingénieur électricien) Propriétaire MEGA DAS * * - Objet principal :Application industrielle * * - Détenteur du copyright (c) :Tous droits réservés * * - Licence :Licence BSD 2-Clause * * - Date :20/04/2017 * * ****************** ******************************************************** ******************************************************** *******************************************************/ /*********************************** REMARQUE ************* *************************/// La redistribution et l'utilisation sous forme source et binaire, avec ou sans// modification, sont autorisées à condition que les éléments suivants les conditions sont remplies:// * Les redistributions du code source doivent conserver l'avis de droit d'auteur ci-dessus, cette// liste de conditions et la clause de non-responsabilité suivante.// * Les redistributions sous forme binaire doivent être reproduites ce l'avis de droit d'auteur ci-dessus,// cette liste de conditions et la clause de non-responsabilité suivante dans la documentation// et/ou d'autres documents fournis avec la distribution.// CE LOGICIEL EST FOURNI PAR LES TITULAIRES DES DROITS D'AUTEUR ET LES CONTRIBUTEURS « EN L'ÉTAT »// ET TOUTE GARANTIE EXPRESSE OU IMPLICITE, Y COMPRIS, MAIS SANS S'Y LIMITER, LES// GARANTIES IMPLICITES DE QUALITÉ MARCHANDE ET D'ADAPTATION À UN USAGE PARTICULIER SONT EXCLUES/* */#include //pour définir et contrôler les servos#include //pour définir une minuterie pour gérer tous les servos#include #include #include // Affichage OLED Adresse TWI#define OLED_ADDR 0x3CAdafruit_SSD1306 affichage(-1); /* Servos ------------------------------------------------ ---------------------*///définir 12 servos pour 4 jambesServo servo[4][3] ;//définir les ports des servosconst int servo_pin[4] [3] ={ {11, 12, 13}, {2, 4, 7}, {14, 15, 16},{8, 9, 10} } ;/* Taille du robot ------ -------------------------------------------------- -*/const float l ength_a =50;const float length_b =77.1;const float length_c =27.5;const float length_side =71;const float z_absolute =-28;/* Constantes pour le mouvement ---------------- ------------------------------------*/const float z_default =-50, z_up =-30, z_boot =z_absolute;const float x_default =62, x_offset =0;const float y_start =0, y_step =40;const float y_default =x_default;/* variables pour le mouvement --------------- -------------------------------------*/volatile float site_now[4][3] ; //coordonnées en temps réel de la fin de chaque legvolatile float site_expect[4][3] ; //coordonnées attendues de la fin de chaque legfloat temp_speed[4][3] ; //la vitesse de chaque axe doit être recalculée avant chaque movefloat move_speed; //mouvement speedfloat speed_multiple =1; //vitesse de mouvement multipleconst float spot_turn_speed =4;const float leg_move_speed =8;const float body_move_speed =3;const float stand_seat_speed =1;volatile int rest_counter; //+1/0.02s, pour le repos automatique//paramètre des fonctions const float KEEP =255;//define PI pour le calculconst float pi =3.1415926;/* Constantes pour le virage ------------- -------------------------------------------*///temp lengthconst float temp_a =sqrt(pow(2 * x_default + length_side, 2) + pow(y_step, 2));const float temp_b =2 * (y_start + y_step) + length_side;const float temp_c =sqrt(pow(2 * x_default + length_side , 2) + pow(2 * y_start + y_step + length_side, 2));const float temp_alpha =acos((pow(temp_a, 2) + pow(temp_b, 2) - pow(temp_c, 2)) / 2 / temp_a / temp_b);//site pour turnconst float turn_x1 =(temp_a - length_side) / 2;const float turn_y1 =y_start + y_step / 2;const float turn_x0 =turn_x1 - temp_b * cos(temp_alpha);const float turn_y0 =temp_b * sin (temp_alpha) - turn_y1 - length_side;const int lightR=3;const int lightG=5;const int lightB=6;int LedR=0;int LedG=0;int LedB=0;char SerialData; // Utilisez cette variable pour lire chaque caractère reçu via le port série String data="";void setup() { Serial.begin(9600); display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR); display.clearDisplay(); display.display(); retard (10000); set_site(0, x_default - x_offset, y_start + y_step, z_boot); set_site(1, x_default - x_offset, y_start + y_step, z_boot); set_site(2, x_default + x_offset, y_start, z_boot); set_site(3, x_default + x_offset, y_start, z_boot); for (int i =0; i <4; i++) { for (int j =0; j <3; j++) { site_now[i][j] =site_expect[i][j]; } } //démarrer le service d'asservissement FlexiTimer2::set(20, servo_service); FlexiTimer2::start(); //initialise les servos servo_attach(); stand();// retard(3000);// assis();// retard(3000);// stand();// retard(3000); content(); retard (aléatoire (500, 1000)); cierra(); retard (150); enfado(); retard (aléatoire (1000, 3000)); cierra(); retard (150); entorna(); retard (aléatoire (1000, 3000)); cierra(); retard (150); enfado1(); retard (aléatoire (1000, 3000)); cierra(); retard (150); triste(); retard (aléatoire (1000, 3000)); cierra(); retard (150); abre(); retard (aléatoire (500, 3000)); cierra(); retard (150); content(); delay (random (500, 1000));}void loop() { while(Serial.available()) // Tant que les données série sont disponibles, nous les stockons { delay(10); SerialData=Serial.read(); if(SerialData=='b') LedR=Serial.parseInt(); else if(SerialData=='g') LedG=Serial.parseInt(); else if(SerialData=='r') LedB=Serial.parseInt(); else data+=SerialData; } if(data=="f") // Si les données stockées sont un mouvement vers l'avant { cierra(); retard (150); content(); step_forward (1) ; } if(data=="p") // Si les données stockées sont un mouvement vers l'arrière { cierra(); retard (150); triste(); step_back(1); } if(data=="l") // Si les données stockées doivent tourner à gauche, la voiture { cierra(); retard (150); enfado1(); tourner_gauche(1) ; } if(data=="m") // Si les données stockées doivent tourner à droite, la voiture { cierra(); retard (150); enfado(); tourner_à droite(5) ; } données=""; analogWrite(lumièreR,LedR); analogWrite(lightG,LedG); analogWrite(lightB,LedB);}void servo_attach(void){ for (int i =0; i <4; i++) { for (int j =0; j <3; j++) { servo[i][j]. attach(servo_pin[i][j]); retard (100); } }}void servo_detach(void){ pour (int i =0; i <4; i++) { pour (int j =0; j <3; j++) { servo[i][j].detach(); retard (100); } }}void sit(void){ move_speed =stand_seat_speed; for (int leg =0; leg <4; leg++) { set_site(leg, KEEP, KEEP, z_boot); } wait_all_reach();}/* - stand - fonction de blocage ------------------------------------- ----------------------------------------------------*/void stand(void){ move_speed =stand_seat_speed; for (int leg =0; leg <4; leg++) { set_site(leg, KEEP, KEEP, z_default); } wait_all_reach();}/* - spot tourner vers la gauche - fonction de blocage - paramètres pas à pas voulus tourner --------------------------- ------------------------------------------------*/ void turn_left(unsigned int step){ move_speed =spot_turn_speed; while (step--> 0) { if (site_now[3][1] ==y_start) { //leg 3&1 move set_site(3, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(0, turn_x1 - x_offset, turn_y1, z_default); set_site(1, turn_x0 - x_offset, turn_y0, z_default); set_site(2, turn_x1 + x_offset, turn_y1, z_default); set_site(3, turn_x0 + x_offset, turn_y0, z_up); wait_all_reach(); set_site(3, turn_x0 + x_offset, turn_y0, z_default); wait_all_reach(); set_site(0, turn_x1 + x_offset, turn_y1, z_default); set_site(1, turn_x0 + x_offset, turn_y0, z_default); set_site(2, turn_x1 - x_offset, turn_y1, z_default); set_site(3, turn_x0 - x_offset, turn_y0, z_default); wait_all_reach(); set_site(1, turn_x0 + x_offset, turn_y0, z_up); wait_all_reach(); set_site(0, x_default + x_offset, y_start, z_default); set_site(1, x_default + x_offset, y_start, z_up); set_site(2, x_default - x_offset, y_start + y_step, z_default); set_site(3, x_default - x_offset, y_start + y_step, z_default); wait_all_reach(); set_site(1, x_default + x_offset, y_start, z_default); wait_all_reach(); } else { //leg 0&2 move set_site(0, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(0, turn_x0 + x_offset, turn_y0, z_up); set_site(1, turn_x1 + x_offset, turn_y1, z_default); set_site(2, turn_x0 - x_offset, turn_y0, z_default); set_site(3, turn_x1 - x_offset, turn_y1, z_default); wait_all_reach(); set_site(0, turn_x0 + x_offset, turn_y0, z_default); wait_all_reach(); set_site(0, turn_x0 - x_offset, turn_y0, z_default); set_site(1, turn_x1 - x_offset, turn_y1, z_default); set_site(2, turn_x0 + x_offset, turn_y0, z_default); set_site(3, turn_x1 + x_offset, turn_y1, z_default); wait_all_reach(); set_site(2, turn_x0 + x_offset, turn_y0, z_up); wait_all_reach(); set_site(0, x_default - x_offset, y_start + y_step, z_default); set_site(1, x_default - x_offset, y_start + y_step, z_default); set_site(2, x_default + x_offset, y_start, z_up); set_site(3, x_default + x_offset, y_start, z_default); wait_all_reach(); set_site(2, x_default + x_offset, y_start, z_default); wait_all_reach(); } }}/* - spot tourner à droite - fonction de blocage - paramètres pas à pas voulu tourner ------------------------------ ----------------------------------------------------------*/void turn_right( pas int non signé){ move_speed =spot_turn_speed; while (step--> 0) { if (site_now[2][1] ==y_start) { //leg 2&0 move set_site(2, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(0, turn_x0 - x_offset, turn_y0, z_default); set_site(1, turn_x1 - x_offset, turn_y1, z_default); set_site(2, turn_x0 + x_offset, turn_y0, z_up); set_site(3, turn_x1 + x_offset, turn_y1, z_default); wait_all_reach(); set_site(2, turn_x0 + x_offset, turn_y0, z_default); wait_all_reach(); set_site(0, turn_x0 + x_offset, turn_y0, z_default); set_site(1, turn_x1 + x_offset, turn_y1, z_default); set_site(2, turn_x0 - x_offset, turn_y0, z_default); set_site(3, turn_x1 - x_offset, turn_y1, z_default); wait_all_reach(); set_site(0, turn_x0 + x_offset, turn_y0, z_up); wait_all_reach(); set_site(0, x_default + x_offset, y_start, z_up); set_site(1, x_default + x_offset, y_start, z_default); set_site(2, x_default - x_offset, y_start + y_step, z_default); set_site(3, x_default - x_offset, y_start + y_step, z_default); wait_all_reach(); set_site(0, x_default + x_offset, y_start, z_default); wait_all_reach(); } else { //leg 1&3 move set_site(1, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(0, turn_x1 + x_offset, turn_y1, z_default); set_site(1, turn_x0 + x_offset, turn_y0, z_up); set_site(2, turn_x1 - x_offset, turn_y1, z_default); set_site(3, turn_x0 - x_offset, turn_y0, z_default); wait_all_reach(); set_site(1, turn_x0 + x_offset, turn_y0, z_default); wait_all_reach(); set_site(0, turn_x1 - x_offset, turn_y1, z_default); set_site(1, turn_x0 - x_offset, turn_y0, z_default); set_site(2, turn_x1 + x_offset, turn_y1, z_default); set_site(3, turn_x0 + x_offset, turn_y0, z_default); wait_all_reach(); set_site(3, turn_x0 + x_offset, turn_y0, z_up); wait_all_reach(); set_site(0, x_default - x_offset, y_start + y_step, z_default); set_site(1, x_default - x_offset, y_start + y_step, z_default); set_site(2, x_default + x_offset, y_start, z_default); set_site(3, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(3, x_default + x_offset, y_start, z_default); wait_all_reach(); } }}/* - aller de l'avant - fonction de blocage - étapes de l'étape de paramètre voulues -------------------------------- -------------------------------------------*/void step_forward(unsigned int step){ move_speed =leg_move_speed; while (step--> 0) { if (site_now[2][1] ==y_start) { //leg 2&1 move set_site(2, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(2, x_default + x_offset, y_start + 2 * y_step, z_up); wait_all_reach(); set_site(2, x_default + x_offset, y_start + 2 * y_step, z_default); wait_all_reach(); move_speed =body_move_speed; set_site(0, x_default + x_offset, y_start, z_default); set_site(1, x_default + x_offset, y_start + 2 * y_step, z_default); set_site(2, x_default - x_offset, y_start + y_step, z_default); set_site(3, x_default - x_offset, y_start + y_step, z_default); wait_all_reach(); move_speed =leg_move_speed; set_site(1, x_default + x_offset, y_start + 2 * y_step, z_up); wait_all_reach(); set_site(1, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(1, x_default + x_offset, y_start, z_default); wait_all_reach(); } else { //leg 0&3 move set_site(0, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(0, x_default + x_offset, y_start + 2 * y_step, z_up); wait_all_reach(); set_site(0, x_default + x_offset, y_start + 2 * y_step, z_default); wait_all_reach(); move_speed =body_move_speed; set_site(0, x_default - x_offset, y_start + y_step, z_default); set_site(1, x_default - x_offset, y_start + y_step, z_default); set_site(2, x_default + x_offset, y_start, z_default); set_site(3, x_default + x_offset, y_start + 2 * y_step, z_default); wait_all_reach(); move_speed =leg_move_speed; set_site(3, x_default + x_offset, y_start + 2 * y_step, z_up); wait_all_reach(); set_site(3, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(3, x_default + x_offset, y_start, z_default); wait_all_reach(); } }}/* - revenir en arrière - fonction de blocage - étapes de l'étape de paramètre souhaitées -------------------------------- -------------------------------------------*/void step_back(unsigned int step){ move_speed =leg_move_speed; while (step--> 0) { if (site_now[3][1] ==y_start) { //leg 3&0 move set_site(3, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(3, x_default + x_offset, y_start + 2 * y_step, z_up); wait_all_reach(); set_site(3, x_default + x_offset, y_start + 2 * y_step, z_default); wait_all_reach(); move_speed =body_move_speed; set_site(0, x_default + x_offset, y_start + 2 * y_step, z_default); set_site(1, x_default + x_offset, y_start, z_default); set_site(2, x_default - x_offset, y_start + y_step, z_default); set_site(3, x_default - x_offset, y_start + y_step, z_default); wait_all_reach(); move_speed =leg_move_speed; set_site(0, x_default + x_offset, y_start + 2 * y_step, z_up); wait_all_reach(); set_site(0, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(0, x_default + x_offset, y_start, z_default); wait_all_reach(); } else { //leg 1&2 move set_site(1, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(1, x_default + x_offset, y_start + 2 * y_step, z_up); wait_all_reach(); set_site(1, x_default + x_offset, y_start + 2 * y_step, z_default); wait_all_reach(); move_speed =body_move_speed; set_site(0, x_default - x_offset, y_start + y_step, z_default); set_site(1, x_default - x_offset, y_start + y_step, z_default); set_site(2, x_default + x_offset, y_start + 2 * y_step, z_default); set_site(3, x_default + x_offset, y_start, z_default); wait_all_reach(); move_speed =leg_move_speed; set_site(2, x_default + x_offset, y_start + 2 * y_step, z_up); wait_all_reach(); set_site(2, x_default + x_offset, y_start, z_up); wait_all_reach(); set_site(2, x_default + x_offset, y_start, z_default); wait_all_reach(); } }}// ajouter par RegisHsuvoid body_left(int i){ set_site(0, site_now[0][0] + i, KEEP, KEEP); set_site(1, site_now[1][0] + i, GARDER, GARDER); set_site(2, site_now[2][0] - i, GARDER, GARDER); set_site(3, site_now[3][0] - i, GARDER, GARDER); wait_all_reach();}void body_right(int i){ set_site(0, site_now[0][0] - i, KEEP, KEEP); set_site(1, site_now[1][0] - i, GARDER, GARDER); set_site(2, site_now[2][0] + i, GARDER, GARDER); set_site(3, site_now[3][0] + i, GARDER, GARDER); wait_all_reach();}void hand_wave(int i){ float x_tmp; float y_tmp; float z_tmp; move_speed =1 ; if (site_now[3][1] ==y_start) { body_right(15); x_tmp =site_now[2][0] ; y_tmp =site_now[2][1] ; z_tmp =site_now[2][2] ; move_speed =body_move_speed; for (int j =0; j i / 4)// move_speed =body_dance_speed * 2;// if (j> i / 2)// move_speed =body_dance_speed * 3;/ / set_site(0, KEEP, y_default - 20, KEEP); // set_site(1, KEEP, y_default + 20, KEEP); // set_site(2, KEEP, y_default - 20, KEEP); // set_site(3, KEEP, y_default + 20, KEEP);// wait_all_reach(); // set_site(0, KEEP, y_default + 2 0, KEEP);// set_site(1, KEEP, y_default - 20, KEEP); // set_site(2, KEEP, y_default + 20, KEEP); // set_site(3, KEEP, y_default - 20, KEEP); // wait_all_reach();// }// move_speed =body_dance_speed;// head_down(30);//}/* - service microservos /timer interrupt function/50Hz - lorsque le site est défini, cette fonction déplace le point final vers celui-ci en ligne droite - temp_speed[4][3] doit être défini avant de définir le site attendu, il s'assure que le point final se déplace en ligne droite et décide de la vitesse de déplacement. -------------------------------------------------- -------------------------*/void servo_service(void){ sei(); flottant statique alpha, bêta, gamma ; for (int i =0; i <4; i++) { for (int j =0; j <3; j++) { if (abs(site_now[i][j] - site_expect[i][j])>=abs(temp_speed[i][j])) site_now[i][j] +=temp_speed[i][j] ; else site_now[i][j] =site_expect[i][j] ; } cartésien_vers_polaire(alpha, bêta, gamma, site_now[i][0], site_now[i][1], site_now[i][2]); polar_to_servo(i, alpha, bêta, gamma); } rest_counter++;}/* - définit l'un des sites attendus des points de terminaison - cette fonction définira temp_speed[4][3] en même temps - fonction non bloquante --------------- -------------------------------------------------- ----------*/void set_site(int leg, float x, float y, float z){ float length_x =0, length_y =0, length_z =0; if (x !=KEEP) length_x =x - site_now[leg][0]; if (y !=KEEP) length_y =y - site_now[leg][1]; if (z !=KEEP) length_z =z - site_now[leg][2]; float length =sqrt(pow(length_x, 2) + pow(length_y, 2) + pow(length_z, 2)); temp_speed[leg][0] =length_x / length * move_speed * speed_multiple; temp_speed[leg][1] =length_y / length * move_speed * speed_multiple; temp_speed[leg][2] =length_z / length * move_speed * speed_multiple; if (x !=KEEP) site_expect[leg][0] =x; if (y !=KEEP) site_expect[leg][1] =y; if (z !=KEEP) site_expect[leg][2] =z;}/* - wait one of end points move to expect site - blocking function ---------------------------------------------------------------------------*/void wait_reach(int leg){ while (1) if (site_now[leg][0] ==site_expect[leg][0]) if (site_now[leg][1] ==site_expect[leg][1]) if (site_now[leg][2] ==site_expect[leg][2]) break;}/* - wait all of end points move to expect site - blocking function ---------------------------------------------------------------------------*/void wait_all_reach(void){ for (int i =0; i <4; i++) wait_reach(i);}/* - trans site from cartesian to polar - mathematical model 2/2 ---------------------------------------------------------------------------*/void cartesian_to_polar(volatile float &alpha, volatile float &beta, volatile float &gamma, volatile float x, volatile float y, volatile float z){ //calculate w-z degree float v, w; w =(x>=0 ? 1 :-1) * (sqrt(pow(x, 2) + pow(y, 2))); v =w - length_c; alpha =atan2(z, v) + acos((pow(length_a, 2) - pow(length_b, 2) + pow(v, 2) + pow(z, 2)) / 2 / length_a / sqrt(pow(v, 2) + pow(z, 2))); beta =acos((pow(length_a, 2) + pow(length_b, 2) - pow(v, 2) - pow(z, 2)) / 2 / length_a / length_b); //calculate x-y-z degree gamma =(w>=0) ? atan2(y, x) :atan2(-y, -x); //trans degree pi->180 alpha =alpha / pi * 180; beta =beta / pi * 180; gamma =gamma / pi * 180;}/* - trans site from polar to microservos - mathematical model map to fact - the errors saved in eeprom will be add ---------------------------------------------------------------------------*/void polar_to_servo(int leg, float alpha, float beta, float gamma){ if (leg ==0) { alpha =90 - alpha; beta =beta; gamma +=90; } else if (leg ==1) { alpha +=90; beta =180 - beta; gamma =90 - gamma; } else if (leg ==2) { alpha +=90; beta =180 - beta; gamma =90 - gamma; } else if (leg ==3) { alpha =90 - alpha; beta =beta; gamma +=90; } servo[leg][0].write(alpha); servo[leg][1].write(beta); servo[leg][2].write(gamma);}void abre() { display.clearDisplay(); display.fillCircle (50, 15, 12, WHITE); //ojo izquierdo grande display.fillCircle (82, 20, 7, WHITE); //ojo derecho pequeo display.display();}void cierra() { display.clearDisplay(); display.drawFastHLine(40, 15, 20, WHITE); display.drawFastHLine(72, 20, 15, WHITE); display.display();}void entorna() { display.clearDisplay(); display.fillCircle (42, 10, 20, WHITE); //ojo izquierdo grande display.fillCircle (82, 10, 15, WHITE); //ojo derecho pequeo display.fillRect (0, 0, 128, 15, BLACK); //ceja superior display.fillRect (0, 40, 128, 15, BLACK); //ceja inferior display.display();}void triste() { display.clearDisplay(); display.fillCircle (42, 10, 17, WHITE); //ojo izquierdo grande display.fillCircle (82, 10, 17, WHITE); //ojo derecho pequeo display.fillTriangle (0, 0, 0, 35, 78, 0, BLACK); //ceja superior display.fillTriangle (50, 0, 128, 35, 128, 0, BLACK); //ceja superior display.display();}void happy() { display.clearDisplay(); display.fillCircle (42, 25, 15, WHITE); //ojo izquierdo grande display.fillCircle (82, 25, 15, WHITE); //ojo derecho pequeo display.fillCircle (42, 33, 20, BLACK); //ojo izquierdo grande display.fillCircle (82, 33, 20, BLACK); //ojo derecho pequeo display.display();}void enfado() { display.clearDisplay(); display.fillCircle (42, 10, 18, WHITE); //ojo izquierdo grande display.fillCircle (82, 10, 12, WHITE); //ojo derecho pequeo display.fillTriangle (0, 0, 54, 26, 118, 0, BLACK); //ceja superior display.display();}void enfado1() { display.clearDisplay(); display.fillCircle (42, 10, 18, WHITE); //ojo izquierdo grande display.fillCircle (82, 10, 12, WHITE); //ojo derecho pequeo display.fillTriangle (0, 0, 65, 15, 120, 0, BLACK); //ceja superior display.display();}

Pièces et boîtiers personnalisés

Schémas

Dispositif de désinfection des masques faciaux — Needlab Arduino, surveillance de l'ouverture des portes via Gmail

Processus de fabrication

impression en 3D

Système de contrôle d'automatisation

Technologie industrielle