.
Mise à jour le 06/04/2021 : Voici les plans de montage du robot R2-D2 pour le panneau arrière qui nous donne accès au système électronique du robot. Les fichiers n’appartiennent pas à RedOhm pour cela ,il faut s’inscrire sur le lien ci-dessous.
https://www.patreon.com/mrbaddeley
Sommaire :
.
.
. 
.
.
.
.
.
.
.
.
.
.
Pour tout probléme |
.
Mise à jour le 03/03/2021 :
Sommaire :
Principe de fonctionnement |
.
Le but de ce tutoriel est de piloter un moteur pas à pas avec un joystick.
Nous verrons comment définir la valeur des positions de notre joystick pour créer un mouvement de marche avant ou de marche arrière et de conserver le couple maintien quand notre manipulateur est dans un état statique.
Dans le programme vous pourrez retrouver :
La création d’un générateur d’impulsion qui nous permettra de définir la vitesse et le déplacement du moteur pas à pas
La gestion du couple maintien par l’intermédiaire d’un bouton
Et enfin le pilotage du moteur pas à pas en avant et en arrière avec le joystick par l’intermédiaire de la borne DIR se trouvant sur notre driver
.
Retour au sommaire
Programme pour le pilotage d’un moteur pas à pas avec Arduino
|
.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 |
// // //*********************************************************** // RedOhm // le 06/02/2021 // // Pilotage d'un moteur pas a pas avec joystick // // but : // 1 - creation d'un generateur d'impulsion pour le deplacement // et la vitesse du moteur ( avec la fonction micros() ) // 2 - Creation de la fonction debrayage du moteur // 4 - Pilotage avec un Joystik // // Ce programme est un logiciel libre: vous pouvez le redistribuer // et / ou le modifier // Ce programme est distribué dans l'espoir qu'il vous sera utile, // mais sans aucune garantie de fonctionnement // // Par: Mazelin Herve // IDE Arduino 1.8.13 //********************************************************** // Declaration des variables demarrage // unsigned long-> déclare une variable de type long non signé // pour la base de temps il y a 1 000 microsecondes dans une milliseconde // et // 1 000 000 microsecondes dans une seconde. unsigned long demarrage = micros(); // Declaration des variables // int -> declare une variable du type int (pour integer, entier en anglais) // elles peuvent stocker des valeurs de - 32 768 à 32 767 int base_de_temps1 = 1 ; // Affectation des sorties de la carte Ardunio pour le pilotage // du driver DRI0043 // une impulsion montante ou descendante sur cette entrée fait // avancer le moteur d’un pas. La tension de l’impulsion doit // être de 4,5 à 5 V pour un état HAUT et 0 à 0,5 V pour un état BAS. // La largeur d’impulsion doit être de minimum 2,5 μs pour un // fonctionnement correct. int PUL=12; // Definit le sens de rotation en fonction de l'etat bas ou haut int DIR=10; // ce signal est utilisé pour permettre ou interdire l’utilisation du // driver. Le moteur est hors tension int ENA=11; // déclaration de l'entrée du bouton branché sur la broche 15 // pour le debrayage du moteur int bouton_debrayage = 15; int bouton_debrayage_v; // Declaration de pin pour le voyant marche avant vert int voyant_vert_mar = 20; // Declaration de pin pour le voyant marche arriere rouge int voyant_rouge_arr = 21; // declaration de l'entree analogique 6 pour l'axe x int JoyStick_X = 6; // axe x // declaration de la vitesse du joystick int vitesse=0 ; /* * Un programme Arduino doit impérativement contenir cette fonction * Elle ne sera exécutee une seule fois au démarrage du microcontroleur * Elle sert à configurer globalement les entrées sorties * */ void setup() { // Configure la broche spécifiée pour qu'elle se comporte soit en entrée, // soit en sortie. // Configuration des broches pour le driver pinMode (PUL, OUTPUT); pinMode (DIR, OUTPUT); pinMode (ENA, OUTPUT); // Configuration des broches pour les boutons et les voyants pinMode(bouton_debrayage,INPUT); pinMode(voyant_vert_mar,OUTPUT); pinMode(voyant_rouge_arr,OUTPUT); } // Le programme principal s’exécute par une boucle infinie appelée Loop () void loop() { // ******************************************* // Demande de debrayage du moteur // ******************************************* // debrayage du moteur de son driver bouton_debrayage_v = digitalRead(bouton_debrayage); if ( bouton_debrayage_v == 1 ) { digitalWrite(ENA,LOW); } // ******* Fin de demande debrayage ********** // ******************************************* // Traitement du JoyStick // ******************************************* int x; // Lecture de l'entree analogique x=analogRead(JoyStick_X); if ((x>501)&&(x<518)&&(bouton_debrayage_v==0)) { digitalWrite(voyant_vert_mar,LOW); digitalWrite(voyant_rouge_arr,LOW); digitalWrite(ENA,HIGH); digitalWrite(DIR,HIGH); digitalWrite(PUL,HIGH); } // si x est superieur a 520 les instructions comprises // entre les accolades sont exécutées. else if (x>520) { // Marche arriere digitalWrite(voyant_vert_mar,LOW); digitalWrite(voyant_rouge_arr,HIGH); digitalWrite(ENA,HIGH); digitalWrite(DIR,HIGH); vitesse = map ( x,520,1023,3500,5); deplacement(); } // sinon si x est inferieur a 500 les instructions comprises // entre les accolades sont exécutées. else if (x<500) { // Marche avant digitalWrite(voyant_rouge_arr,LOW); digitalWrite(voyant_vert_mar,HIGH); digitalWrite(DIR,LOW); digitalWrite(ENA,HIGH); vitesse = map ( x,500,0,3500,5); deplacement(); } // ***** Fin du traitement du JoyStick ********* } //============================================== //Fonction de deplacement du moteur //============================================== void deplacement() { // la ligne if effectue la difference entre le temps actuel et le // temps de debut de boucle . if (micros()-demarrage>vitesse) { //Inversion de la valeur de la variable memoire et envoie l'information //a la broche digitalWrite(PUL,base_de_temps1=!base_de_temps1); // on reinitialise la variable demarrage avec le contenu de micros() demarrage=micros(); } } |
.
Retour au sommaire
Vidéo pour le tuto |
.
.
Retour au sommaire
Pour tout probléme |
.
Pour tout problème de téléchargement ou pour nous suivre sur les réseaux sociaux voici les plateformes sur lesquelles nous éditons.
Cliquez sur celle qui vous intéresse .
Sommaire
2020/09/02 Changement de l’identifiant |
.
Le but de ce tutoriel est de vous initier aux changements de l’identifiant sur les servomoteurs dynamixel par le biais de la carte Arbotix-M . Cette carte est compatible avec l’IDE Arduino.
.
Retour au sommaire
2020/09/18 harmonisation de la vitesse de communication
|
.
Le but de ce tutoriel est de vous familiariser avec les commandes de changement de vitesse et d’identifiant pour les servomoteurs Dynamixel. Le problème est le suivant, la connexion d’un servomoteur MX-106 et d’un servo AX-12 sur la même carte. En sachant que ces deux servomoteurs ne possèdent pas la même vitesse de communication par défaut, et possèdent le même identifiant par défaut. Il faut donc changer la vitesse de communication dans un des servomoteurs pour que les deux fonctionnent sur le même réseau, et enfin que chacun des servomoteurs possède un identifiant propre.
.
.
Retour au sommaire.
2020/11/02 Lecture du registre de déplacement et de
|
.
Dans le cadre de ce tutoriel nous allons vous initiez à lire les registres se trouvant à l’intérieur du servomoteur qui nous permet de définir le déplacement de notre servo , ceci afin de déterminer la butée basse et haute que l’on devra appliquer par logiciel pour des deplacements future ainsi que le déverouillage du registre de couple .
.
.
Retour au sommaire
.
2021/01/03 Pilotage de moteur Dynamixel par Joystick |
.
Ce tutoriel a pour but de vous initier à la programmation des servomoteurs Dynamixel . Nous avons pris comme base la tête de L3 -37 qui est une réalisation de RedOhm pour vous expliquer l’étalonnage et le fonctionnement pour piloter celle-ci avec un joystick. Le tuto s’articule en 4 phases : la première étant la présentation de la base de la tête, le câblage d’un joystick et la carte contrôleur, vous avez aussi une explication sur le fonctionnement de la manette de jeu, et enfin une explication détaillée du programme. Vous pourrez récupérer le programme sur notre site RedOhm.fr celui-ci est abondamment commenté.
.
.
Retour au sommaire
Pour tout probléme |
.
Pour tout problème de téléchargement ou pour nous suivre sur les réseaux sociaux voici les plateformes sur lesquelles nous éditons.
Cliquez sur celle qui vous intéresse .
.
Retour au sommaireMise à jour le 25/02/2021 :
Sommaire :
.
Principe de fonctionnement pour le pilotage avec Arduino |
.
Lorsque la broche EN est à l’état bas sur le driver, le moteur n’est plus sous tension , il est en mode off-line . Dans ce mode, vous pouvez régler manuellement la position de l’arbre moteur
Lorsque la broche EN est à l’État haut on ne peut plus déplacer le moteur librement il est en mode automatique
La broche DIR permet de définir la direction du moteur
La broche PULSE permet de définir la vitesse et le nombre de pas sur le moteur.
.
Retour au sommaire
Sélection de la resolution et du réglage du courant |
.
Réglage du courant
Pour un moteur donné, plus le courant du driver est élevé, plus le couple est élevé, mais cela n’entraîne plus d’échauffement dans le moteur et le driver. Par conséquent, le courant de sortie est en général ajusté de façon à éviter une surchauffe du moteur lors d’une utilisation prolongée. Le raccordement en série ou en parallèle des bobinages modifie de manière significative les inductances et résistance résultantes d’où l’importance d’en tenir compte lors du choix du courant de sortie.
L’intensité communiquée par le fabricant du moteur est importante pour sélectionner le courant, mais il faut également tenir compte du mode de raccordement.
.
Retour au sommaire
Pilotage sommaire d’un moteur pas à pas avec driver avec
|
.
Commentaire sur le programme :
Dans ce programme, nous avons utilisé la fonction delay () car le principe de fonctionnement est relativement simple, mais qui a pour inconvénient de bloquer le programme pendant l’utilisation de celle-ci. Ce qui pose un problème lors d’autres exécutions comme par exemple des systèmes de synchronisation ou des mouvements qui doivent s’opérer en parallèle.
Il est donc plus intéressant dans un code plus élaboré d’utiliser la fonction Millis() ou Micros() qui est une fonction non bloquante
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 |
// // //*********************************************************** // RedOhm // le 08/01/2021 // // Principe de pilotage d'un moteur pas a pas avec un Arduino et // un driver de type DRI0043 (fonctionnement identique avec le DM860) // // Ce programme est un logiciel libre: vous pouvez le redistribuer // et / ou le modifier // Ce programme est distribué dans l'espoir qu'il vous sera utile, // mais sans aucune garantie de fonctionnement // // Par: Mazelin Herve // IDE Arduino 1.8.12 //********************************************************** // Affectation des sortie de la carte Ardunio pour le pilotage // du driver DRI0043 int PUL=12; //define Pulse pin int DIR=10; //define Direction pin int ENA=11; //define Enable Pin // Rappel sur les variables // Les variables déclarées en tête de programme sont des variables globales // et peuvent être utilisées partout dans le programme. int basse_de_temps ; //-------------------------------------------------------------------- // Un programme Arduino doit impérativement contenir cette fonction // Elle ne sera exécutée qu'une seule fois au démarrage du microcontroleur // Elle sert à configurer globalement les entrées sorties //-------------------------------------------------------------------- void setup() { pinMode (PUL, OUTPUT); pinMode (DIR, OUTPUT); pinMode (ENA, OUTPUT); basse_de_temps = 4550; } // ---------------------------------------------------------------------- // Le programme principal s’exécute par une boucle infinie appelée Loop () // ---------------------------------------------------------------------- void loop() { // Marche avant digitalWrite(DIR,LOW); digitalWrite(ENA,HIGH); for (int i=0; i<3200; i++) { digitalWrite(PUL,HIGH); delayMicroseconds(basse_de_temps); digitalWrite(PUL,LOW); delayMicroseconds(basse_de_temps); } delay (1000); digitalWrite(DIR,HIGH); digitalWrite(ENA,HIGH); for (int i=0; i<3200; i++) { digitalWrite(PUL,HIGH); delayMicroseconds(basse_de_temps); digitalWrite(PUL,LOW); delayMicroseconds(basse_de_temps); } delay (1000); } |
.
Retour au sommaire
Fonctionnement d’un moteur pas à pas avec Arduino
|
.
.
Shield E/S Mega DFR0165
Shield d’expansion E/S de DFRobot permettant d’accéder à toutes les entrées/sorties d’une carte compatible Arduino Mega® via des connecteurs 3 broches (Vcc, Gnd, Signal). La carte est équipée de 3 connecteurs pour module Xbee ou compatible et d’un port micro-SD. Sélection de la source d’alimentation.
.
Schema de principe – RedOhm –
.
Raccordement des boutons poussoir – RedOhm –
.
.
.
.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 |
// // //*********************************************************** // RedOhm // le 30/01/2021 // // Principe de pilotage d'un moteur pas a pas avec un Arduino et // un driver de type DRI0043 (fonctionnement identique avec le DM860) // but : // 1 - creation d'un generateur d'impulsion pour le deplacement // et la vitesse du moteur ( avec la fonction micros() ) // 2 - Creation de la fonction debrayage du moteur // 3 - Inversion du sens de rotation du moteur // 4 - Creation d'un bouton depart cycle // // Ce programme est un logiciel libre: vous pouvez le redistribuer // et / ou le modifier // Ce programme est distribué dans l'espoir qu'il vous sera utile, // mais sans aucune garantie de fonctionnement // // Par: Mazelin Herve // IDE Arduino 1.8.12 //********************************************************** // Declaration des variables demarrage // unsigned long-> déclare une variable de type long non signé // pour la base de temps il y a 1 000 microsecondes dans une milliseconde // et // 1 000 000 microsecondes dans une seconde. unsigned long demarrage = micros(); // Declaration des variables // int -> declare une variable du type int (pour integer, entier en anglais) // elles peuvent stocker des valeurs de - 32 768 à 32 767 int base_de_temps1 = 1 ; // Affectation des sorties de la carte Ardunio pour le pilotage // du driver DRI0043 // une impulsion montante ou descendante sur cette entrée fait // avancer le moteur d’un pas. La tension de l’impulsion doit // être de 4,5 à 5 V pour un état HAUT et 0 à 0,5 V pour un état BAS. // La largeur d’impulsion doit être de minimum 2,5 μs pour un // fonctionnement correct. int PUL=12; // Definit le sens de rotation en fonction de l'etat bas ou haut int DIR=10; // ce signal est utilisé pour permettre ou interdire l’utilisation du // driver. Le moteur est hors tension int ENA=11; // déclaration de l'entrée du bouton branché sur la broche 14 // de votre carte Arduino pour le bouton depart cycle avec la fonction // telerupteur int bouton14 = 14; // variable du type int pour stocker les valeurs de passage du bouton14 int bouton14v; // creation d'une memoire_2 et forçage a 0 de la variable // etat du telerupteur int memoire_2=0; // etat precedent du bouton et forçage a 0 de la variable int etat_bouton14v=0 ; // déclaration de l'entrée du bouton branché sur la broche 15 // pour le debrayage du moteur int bouton_debrayage = 15; int bouton_debrayage_v; // déclaration de l'entrée du bouton branché sur la broche 16 // de votre carte Arduino pour le bouton marche avant ou arriere int bp_avant_arriere = 16; // variable du type int pour stocker les valeurs de passage du bouton // bp_avant-arriere int bp_avant_arrierev; // creation d'une memoire_avant_arriere et forçage a 0 de la variable // etat du telerupteur int memoire_avant_arriere=0; // etat precedent du bouton et forçage a 0 de la variable int etat_avant_arriere=0 ; // Declaration de pin pour le voyant depart cycle int voyant_depart_cycle = 8; // Declaration de pin pour le voyant marche avant vert int voyant_vert_mar = 20; // Declaration de pin pour le voyant marche arriere rouge int voyant_rouge_arr = 21; /* * Un programme Arduino doit impérativement contenir cette fonction * Elle ne sera exécutee une seule fois au démarrage du microcontroleur * Elle sert à configurer globalement les entrées sorties * */ void setup() { // Configure la broche spécifiée pour qu'elle se comporte soit en entrée, // soit en sortie. // Configuration des broches pour le driver pinMode (PUL, OUTPUT); pinMode (DIR, OUTPUT); pinMode (ENA, OUTPUT); // Configuration des broches pour les boutons et le voyants pinMode(bouton14,INPUT); pinMode(bouton_debrayage,INPUT); pinMode(bp_avant_arriere,INPUT); pinMode(voyant_depart_cycle,OUTPUT); pinMode(voyant_vert_mar,OUTPUT); pinMode(voyant_rouge_arr,OUTPUT); } // Le programme principal s’exécute par une boucle infinie appelée Loop () void loop() { // ******************************************* // Demande de depart cycle // ******************************************* bouton14v = digitalRead(bouton14); // Creation un telerupteur // Compare la variable à gauche avec la valeur ou la variable // à droite . Renvoie l'information vraie lorsque les deux // variables ne sont pas égales. if (bouton14v!=etat_bouton14v) { if (!bouton14v) { //Inversion de la valeur de la variable memoire memoire_2=!memoire_2; } //Inversion de la valeur de la variable memoire memoire_2=!memoire_2; } // operation consitant a memoriser l'anciennne valeur de la // variable etat_bouton14v=bouton14v; if ( memoire_2 == 1) { digitalWrite(voyant_depart_cycle,HIGH); //appel de la fonction de deplacement moteur deplacement(); } else if ( memoire_2 == 0) { digitalWrite(voyant_depart_cycle,LOW); } // **** Fin de demande de depart cycle ******* // ******************************************* // Demande de debrayage du moteur // ******************************************* // debrayage du moteur de son driver bouton_debrayage_v = digitalRead(bouton_debrayage); if ( bouton_debrayage_v == 1 ) { digitalWrite(ENA,LOW); } // ******* Fin de demande debrayage ********** // ******************************************* // Selection du sens de deplacement // de l'actionneur // ******************************************* // selection du sens de deplacement du moteur bp_avant_arrierev = digitalRead(bp_avant_arriere); // Creation un telerupteur // Compare la variable à gauche avec la valeur ou la variable // à droite . Renvoie l'information vraie lorsque les deux // variables ne sont pas égales. if (bp_avant_arrierev!=etat_avant_arriere) { if (!bp_avant_arrierev) { //Inversion de la valeur de la variable memoire memoire_avant_arriere=!memoire_avant_arriere; } //Inversion de la valeur de la variable memoire memoire_avant_arriere=!memoire_avant_arriere; } // operation consitant a memoriser l'anciennne valeur de la // variable etat_avant_arriere = bp_avant_arrierev; if ( memoire_avant_arriere == 1 ) { digitalWrite(voyant_rouge_arr,LOW); digitalWrite(voyant_vert_mar,HIGH); // Marche avant digitalWrite(DIR,LOW); digitalWrite(ENA,HIGH); } else if (memoire_avant_arriere == 0) { digitalWrite(voyant_vert_mar,LOW); digitalWrite(voyant_rouge_arr,HIGH); // Marche arriere digitalWrite(DIR,HIGH); digitalWrite(ENA,HIGH); } // **** Fin de la selection avant arriere **** } //============================================== //Fonction de deplacement du moteur //============================================== void deplacement() { // la ligne if effectue la difference entre le temps actuel et le // temps de debut de boucle . if (micros()-demarrage>350) { //Inversion de la valeur de la variable memoire et envoie l'information //a la broche digitalWrite(PUL,base_de_temps1=!base_de_temps1); // on reinitialise la variable demarrage avec le contenu de micros() demarrage=micros(); } } |
.
Retour au sommaire
Pour tout probléme |
.
Pour tout problème de téléchargement ou pour nous suivre sur les réseaux sociaux voici les plateformes sur lesquelles nous éditons.
Cliquez sur celle qui vous intéresse .
.
Mise à jour le 27/12/2020 : Ce support de webcam peut être considéré comme un outil pour les passionnés de CAO et de DAO. Mais il peut être très utile pour faire de la photo macro ou bien d’autre utilisation.
002 – Plan de montage |
.
.
Retour au sommaire
003 – Plan de montage B1 |
.
.
Retour au sommaire
004 – Montage de l’ensemble |
.
.
Retour au sommaire
005 – Piece 001 – accessoire webcam |
.
.
Retour au sommaire
006 – Piece 002 – Socle |
.
.
Retour au sommaire
007 – Piece 003 – tablette |
.
Fiche 007 – Piece 003 – tablette – RedOhm
.
Retour au sommaire
008 – Piece 004 – bras porte tablette |
.
Fiche 008 – Piece 004 – bras porte tablette – RedOhm
.
Retour au sommaire
009 – Pièce 005-Targette |
.
Fiche 009 – Pièce 005-Targette RedOhm
.
Retour au sommaire
010 – Pièce 006 verrou tablette |
.
.
Retour au sommaire
011 – WebCam |
.
.
Retour au sommaire
012 – Insert |
.
.
Retour au sommaire
013 – Mise en situation |
.
.
Pour tout probléme |
.
Pour tout problème de téléchargement ou pour nous suivre sur les réseaux sociaux voici les plateformes sur lesquelles nous éditons.
Cliquez sur celle qui vous intéresse .
.
Retour au sommaireMise à jour le 02/01/2021 : Etude sur le fonctionnement et la programmation d’un servomoteur à retour d’information
Mise à jour le 11/12/2020 : Dans cet article vous retrouverez les fichiers à télécharger pour construire la tête et le buste du robot L3 -37 pour la version RC, mais aussi l’ensemble des fiches de montage pour y parvenir.
Matériel utile pour suivre les tutoriels |
.
ArbotiX-M Robocontroller
Spécifications techniques du Robocontroller ArbotiX-M :
Ressources pour le Robocontroller ArbotiX-M
Le Robocontroller ArbotiX-M peut être utilisé avec l’environnement de développement Arduino. Un certain nombre de bibliothèques permettant de contrôler les servomoteurs AX-12 sont disponibles dans la liste de téléchargement ci-dessous.
Module joystick Gravity DFRobot basé sur 2 potentiomètres (axes X et Y) et d’un bouton-poussoir pour des applications spécifiques. Il délivre deux sorties analogiques en fonction de la position des deux potentiomètres et une sortie logique en fonction du bouton-poussoir. Il est livré avec 3 cordons.
Référence DFRobot: DFR0061
Remarque: la nouvelle version du mappage des broches du port du capteur analogique a été modifiée comme ci-dessous :
Mappage du Joystik
.
Retour en haut de page
Etude des deplacements de la tête avec les servo Dynamixel |
.
Materiel utile pour le tuto :
.
Nous allons vous initiez à lire les registres se trouvant à l’intérieur du servomoteur qui nous permet de définir le déplacement de notre servo , ceci afin de déterminer la butée basse et haute que l’on devra appliquer par logiciel pour les mouvements de la tête.
Pour pouvoir lire ses registres, il faut déverrouiller le couple afin pouvoir déplacer la base de la tête de L3 -37 manuellement Avant de se lancer dans l’explication du programme, nous allons vous faire une démonstration du déverrouillage et de la lecture des registres de déplacement par le biai du tuto ci-dessous .
.
.
Programme :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 |
// // //************************************************************* //* //* IDE Arduino 1.0.6 //* //* Mesure de deplacement des moteurs dynamixel //* et verouillage du couple //* //* H-Mazelin //* 29/10/2020 //* //************************************************************* //librairie qui permet d'implémentez le code de communication série //de bas niveau pour communiquer avec le bus Bioloid. #include <ax12.h> //Cette librairies vous permet interagir avec les servos AX et MX #include <BioloidController.h> // definition de la vitesse de transmission // le debit en bauds détermine la vitesse de communication serie entre // le controleur et le servo Dynamixel BioloidController bioloid = BioloidController(1000000); /* * Un programme Arduino doit impérativement contenir cette fonction * Elle ne sera exécuter une seule fois au démarrage du microcontroleur * Elle sert à configurer globalement les entrées sorties * */ void setup () { //ouvre le port série et fixe le debit de communication à 9600 bauds Serial.begin(9600); // on attent que le port de communication soit pret delay(5000); // Information a l'operateur de l'ouverture du port de communication // sur le moniteur serie Serial.println("========================================"); Serial.println("Communication etablie"); Serial.println("========================================"); // Lecture de la temperature du servo de droite actuel int temperature_d =ax12GetRegister(2,43,1); // Lecture de la temperature du servo de gauche actuel int temperature_g =ax12GetRegister(3,43,1); // Affichage de la lecture des registres contenant la temperature Serial.print("Temperature du servo de droite : "); Serial.print(temperature_d);Serial.println(" Degres"); Serial.print("Temperature du servo de gauche : "); Serial.print(temperature_g);Serial.println(" Degres"); Serial.print(" "); Serial.println("Demarrage *********************"); // Procedure d'ecriture dans le registre 24 pour desactiver le couple // // modification de la valeur 1 par la valeur 0 // 1 parametre : numero d'identifiant du servo // 2 parametre : numero de registre a modifier // 3 parametre : Active ou desactive le couple ax12SetRegister(2,24,0); ax12SetRegister(3,24,0); Serial.println("Couple desactive sur le moteur de droite et de gauche"); } /* *Le programme principal s’exécute par une boucle infinie appelée Loop () * */ void loop() { // Procedure de lecture pour la position du servo dans le registre 36 // // // 1 parametre : numero d'identifiant du servo // 2 parametre : numero de registre a lire // 3 parametre : nombre d'octet a lire int deplacement_d =ax12GetRegister(2,36,2); int deplacement_g =ax12GetRegister(3,36,2); // Affichage de la lecture des registres contenant le deplacement Serial.print("Deplacement du moteur de gauche : "); Serial.print(deplacement_g);Serial.print(" en points "); Serial.print("Deplacement du moteur de droite : "); Serial.print(deplacement_d);Serial.println(" en points "); } |
.
Retour en haut de page.
.
Pilotage d’un Dynamixel par le biais d’un potentiometre |
.
Ce tutoriel a pour but de vous initier à la programmation des servomoteurs Dynamixel . Nous avons pris comme base la tête de L3 -37 qui est une réalisation de RedOhm pour vous expliquer l’étalonnage et le fonctionnement pour piloter celle-ci avec un joystick. Le tuto s’articule en 4 phases :
la première étant la présentation de la base de la tête, le câblage d’un joystick et la carte contrôleur, vous avez aussi une explication sur le fonctionnement de la manette de jeu, et enfin une explication détaillée du programme.
.
.
Materiel utile pour le tuto :
Module joystick Gravity DFR0061
.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 |
// // //************************************************************* //* //* IDE Arduino 1.0.6 //* //* Exemple de pilotage d'un servo Dynamixel //* avec un joystick pour la tete de L3-37 //* //* H-Mazelin //* 16/11/2020 //* //************************************************************* //librairie qui permet d'implémenter le code de communication série //de bas niveau pour communiquer avec le bus Bioloid. #include <ax12.h> //Cette librairie vous permet interagir avec les servos AX et MX #include <BioloidController.h> // definition de la vitesse de transmission // le debit en bauds détermine la vitesse de communication serie entre // le controleur et le servo Dynamixel BioloidController bioloid = BioloidController(1000000); // broche sur lequel est branche le potentiometre const int broche1 = A1; const int broche7 = A7; // variable contenant la valeur du potentiometre int valeurPotar1 = 0; int valeurPotar7 = 0; // valeur du potentiometre remis a l'echelle int valeurPotar7_re = 0; int valeurPotar1_re= 0; /* * Un programme Arduino doit impérativement contenir cette fonction * Elle ne sera exécutee une seule fois au démarrage du microcontroleur * Elle sert à configurer globalement les entrées sorties * */ void setup () { //ouvre le port série et fixe le debit de communication à 9600 bauds Serial.begin(9600); // on attent que le port de communication soit pret delay(5000); // Information a l'operateur de l'ouverture du port de communication // sur le moniteur serie Serial.println("========================================"); Serial.println("Communication etablie"); Serial.println("========================================"); // Lecture de la temperature du servo de droite actuel int temperature_d =ax12GetRegister(2,43,1); // Lecture de la temperature du servo de gauche actuel int temperature_g =ax12GetRegister(3,43,1); // Affichage de la lecture des registres contenant la temperature Serial.print("Temperature du servo de droite : "); Serial.print(temperature_d);Serial.println(" Degres"); Serial.print("Temperature du servo de gauche : "); Serial.print(temperature_g);Serial.println(" Degres"); Serial.print(" "); Serial.println("Demarrage *********************"); } /* *Le programme principal s’exécute par une boucle infinie appelée Loop () * */ void loop() { // lecture de la valeur du potentiomètre (valeur entre 0 et 1023) valeurPotar1=analogRead( broche1); valeurPotar7=analogRead( broche7); // mise a l'échelle (valeur entre 0 et 300 // Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette. // Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination valeurPotar7_re = map( valeurPotar7,0,1023,0,350); valeurPotar1_re = map( valeurPotar1,0,1023,0,350); // Affichage de la valeur des potentiometre Serial.print("A7 - deplacement en x du potentiometre x -> "); Serial.println(valeurPotar7); Serial.print("A1 - deplacement en y du potentiometre x -> "); Serial.println(valeurPotar1); // Affichage de la valeur re-etalonne des potentiometre Serial.print("A7 - Re-etalonne le deplacement en x du potentiometre -> "); Serial.println(valeurPotar7_re); Serial.print("A7 - Re-etalonne le deplacement en y du potentiometre -> "); Serial.println(valeurPotar1_re); // envoie l'information de deplacement au servomoteur dynamixel340 SetPosition(2,340+valeurPotar7_re); // envoie l'information de deplacement au servomoteur dynamixel // moteur de gauche SetPosition(3,340+valeurPotar1_re); // Affichage du code pour le moteur x avec le calcul Serial.print("Valeur de la position du moteur x => SetPosition(3,340+"); Serial.print(valeurPotar7_re); Serial.println(");"); Serial.print("Valeur du deplacement de moteur x => "); Serial.println(340 + valeurPotar7_re) ; Serial.println(""); Serial.print("Valeur de la position du moteur y => SetPosition(3,340+"); Serial.print(valeurPotar1_re); Serial.println(");"); Serial.print("Valeur du deplacement de moteur y => "); Serial.println(340 + valeurPotar1_re) ; Serial.println("------------------"); delay (100); } |
.
Retour en haut de page.
Mise à jour le 18/11/2020 :
.
Sommaire :
.
.
Ce petit robot est destiné à vous initier à la programmation, nous l’appellerons Golbotth8. La construction de cet engin passe déjà par l’impression 3D, vous trouverez l’ensemble des fichiers STL sur notre site ainsi que la matière que nous avons utilisée et les différents conseils techniques. Vous aurez la possibilité de suivre des tutoriels sur Arduino avec ce module. Nous avons surtout essayé de minimiser le coût de l’ensemble.
.
Retour au sommaire
|
.
.
Retour au sommaire..
.
..
.
Retour au sommaire..
.
Retour au sommaire
.
Retour au sommaire
.
Pièce g010 tourelle – RedOhm
.
.
Retour au sommaire
|
.
.
.
Retour au sommaire
|
.
Pièce g012 plateau pour châssis – RedOhm
.
.
Retour au sommaire
|
.
.
Retour au sommaire
|
.
.
.
Retour au sommaire
|
.
.
Retour au sommaire
|
.
.
Retour au sommaire
|
.
.
Retour au sommaire
|
.
.
Retour au sommaire
|
.
Ce module dispose d’un émetteur à ultrasons et d’un récepteur à ultrasons afin que vous puissiez le considérer comme un émetteur-récepteur à ultrasons. Familier avec le sonar, lorsque l’onde ultrasonore de 40 KHz générée par l’émetteur rencontre l’objet, l’onde sonore sera renvoyée et le récepteur peut recevoir l’onde ultrasonore réfléchie. Il suffit de calculer le temps entre l’émission et la réception, puis de multiplier la vitesse du son dans l’air (340 m / s) pour calculer la distance du capteur à l’objet.
.
.
Comment fonctionne le capteur de distance à ultrasons?
Voici un exemple simple de la façon dont un capteur à ultrasons fonctionne pour mesurer la distance:
Le lien pour le principe de fonctionnement : https://www.redohm.fr/2017/10/grove-telemetre-a-ultrasons-grove-101020010/
Téléchargez la bibliothèque UltrasonicRanger depuis Github.
.
.
Retour au sommaire
|
.
.
Retour au sommaire