–
Mise à jour le 10/02/2019 – Rubrique traitant du capteur de mouvement 3D SEN0202 , il permet la détection de mouvements et la reconnaissance de gestes (gauche, droite, haut, bas, mouvement horaire et anti-horaire, etc).
Capteur de mouvement 3D SEN0202
Sommaire :
-
- Description du capteur de mouvement 3D SEN0202
- Schéma de principe du capteur de mouvement
- Principe de fonctionnement du Capteur de gestes
-
- Exemple de programme .
- Programme d’exemple du constructeur .
- Pilotage d’une tourelle 3 axes exemple d’application de chez RedOhm .
- Tutoriel sur le capteur de mouvement Sen0202
- Explication des 3 types de schéma de câblage
- Schéma de câblage de la tourelle 3 axes avec un régulateur 7806
- Schéma de câblage de la tourelle 3 axes avec un régulateur 7805 avec insertion d’une diode dans le circuit de retour à la masse .
- Schéma de câblage de la tourelle 3 axes . Avec en application comment augmenter le courant de sortie avec plusieurs régulateurs en parallèle pour l’alimentation des servomoteurs
- Programme pour le pilotage de la tourelle.
- Exemple de programme .
- Retour au menu principal
Description capteur de mouvement |
Ce module DFRobot permet la détection de mouvements et la reconnaissance de gestes (gauche, droite, haut, bas, mouvement horaire et anti-horaire, etc). Il est basé sur le MGC3130 et utilise la technologie GestIC de Microchip.Ce module communique avec une carte Arduino ou compatible via une interface I2C.
Caractéristiques et spécificités
- Alimentation: 3,3 à 5 Vcc
- Interface: I2C (adresse: 0x42)
- Distance de détection de mouvement: 5 cm
- Distance de détection inductif: 10 cm
- Résolution: 150 dpi
- Dimensions: 72 x 54 mm
- Température de service: -20 à 85 °C
- Référence DFRobot: SEN0202
Schéma de principe du capteur de mouvement |
Schéma de principe pour le capteur de mouvement 3D SEN0202
.
Retour au sommaire
Principe de fonctionnement du Capteur de mouvement |
Le GestIC de Microchip est une technologie de capteur 3D qui utilise un champ électrique (champ E) pour la détection de proximité avancée. Il permet la réalisation de nouvelles applications d’interface utilisateur par détection, il vous donne le suivi et la classification des gestes de la main d’un utilisateur dans l’espace.
Les champs électromagnétiques sont générés par des charges électriques et se propagent en trois dimensions autour de la surface, transportant la charge électrique.
L’application de tensions continues (CC) à une électrode entraîne un champ électrique constant. Appliquer des tensions alternatives (AC) il fait donc varier les charges au fil du temps et donc, le champ. Lorsque la charge varie d’une façon sinusoïdale avec la fréquence f, l’onde électromagnétique résultante est caractérisée par la longueur d’onde λ = c / f. Dans les cas où la longueur d’onde est beaucoup plus grande que la géométrie de l’électrode, la composante magnétique est pratiquement nulle et aucune propagation d’onde n’a lieu. Le résultat est un champ électrique quasi-statique qui peut être utilisé pour détecter des objets conducteurs tels que le corps humain.
La technologie GestIC de Microchip utilise des fréquences de transmission (Tx) de l’ordre de 100 kHz, ce qui correspond à une longueur d’onde d’environ trois kilomètres. Avec des géométries d’électrodes généralement inférieures à 14 x 14 centimètres, cette longueur d’onde est beaucoup plus grande en comparaison. Les systèmes GESTIC fonctionnent donc sans propagation d’onde.
Si la main ou le doigt d’une personne fait intrusion dans le champ électrique, le champ devient déformé. Les lignes de champ sont attirées sur la main en raison de la conductivité du corps humain lui-même shunté à la terre. Le champ électrique tridimensionnel diminue localement. La technologie GestIC de Microchip utilise un nombre minimal de quatre électrodes de réception (Rx) pour détecter les variations du champ E à différentes positions afin de mesurer l’origine de la distorsion du champ électrique à partir des signaux variables reçus. Les informations sont utilisées pour calculer la position, suivre les mouvements (MGC3130) et classer les mouvements (gestes, MGC3X30).
La figure 1 et la figure 2 montrent l’influence d’un corps mis à la terre sur le champ électrique. La proximité du corps provoque une compression des lignes équipotentielles et fait passer les niveaux de signal d’électrode Rx à un potentiel inférieur qui est mesuré.
Figure 1 :
figure 2 :
A savoir :
• Le capteur n’est pas affecté par des influences ambiantes telles que la lumière ou le son, qui ont un impact négatif sur la plupart des autres technologies 3D
Information d’aprés la fiche technique du document suivant : Fiche technique MGC3130
Retour au sommaire
Exemple de programme du constructeur |
Version IDE Arduino : 1.8.4
|
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 |
/************************************************** * * * * @copyright [DFRobot](http://www.dfrobot.com), 2016 * @copyright GNU Lesser General Public License * * Auteur [Carl](lei.wu@dfrobot.com) * @version V1.0 * @date 2016-09-9 * * Exemple de programme pour recupere les informations * capteur de mouvements * * Ajout de commentaires en francais par: RedOhm ***************************************************/ // je charge la bibliothèque qui permet de gerer // le capteur de geste #include <DFRobot_Gesture.h> // je charge la bibliothèque qui vous permet de communiquer // avec les composants utilisant le protocole I2C #include <Wire.h> // Declare la broche 7 en entier int testPin= 7; unsigned char cmd; DFRobot_Gesture myGesture; // --------------------------------------------------------------------------- // Un programme Arduino doit impérativement contenir la fonction "setup" // Elle ne sera exécuter une seule fois au démarrage du microcontroleur // Elle sert à configurer globalement les entrées sorties // --------------------------------------------------------------------------- void setup() { // Initialise la library Wire et se connecte au bus I2C en tant que maître Wire.begin(); // Ouvre le port série et fixe le debit de communication à 9600 bauds Serial.begin(9600); // Configure la broche spécifiée pour qu'elle se comporte en entrée pinMode(testPin, INPUT); // Ecrit des données sur le port série. // et affiche sur l'ecran le message suivant -> // Le capteur de mouvement 3D est en cours d'exécution Serial.write("3D Gesture sensor is now running....\r\n"); } // --------------------------------------------------------------------------- // Le programme principal s’exécute par une boucle infinie appelée Loop () // --------------------------------------------------------------------------- void loop() { if(digitalRead(testPin)==0) { // L'adresse du capteur de mouvement est: 0x42 myGesture.I2C1_MasterRead(md.buf,26,0x42); // Traitement du message issue du capteur de mouvement cmd = myGesture.mgcProcMsg(); if(cmd != GI_NOGESTURE ) { // L'instruction switch / case contrôle le déroulement du programme switch(cmd) { // Si ma variable est egal à GI_FLICK_R (information vers la droite) // alors j'exécute le morceau de programme jusqu'a l'instruction // break case GI_FLICK_R: Serial.println("RIGHT"); // Cette instruction est utilisée pour sortir d'une instruction switch. break; // Si ma variable est egal à GI_FLICK_L (information vers la gauche) // alors j'exécute le morceau de programme jusqu'a l'instruction // break case GI_FLICK_L: Serial.println("LEFT"); // Cette instruction est utilisée pour sortir d'une instruction switch. break; // Si ma variable est egal à GI_FLICK_D (information vers le bas) // alors j'exécute le morceau de programme jusqu'a l'instruction // break case GI_FLICK_D: Serial.println("DOWN"); // Cette instruction est utilisée pour sortir d'une instruction switch. break; // Si ma variable est egal à GI_FLICK_U (information vers le haut) // alors j'exécute le morceau de programme jusqu'a l'instruction // break case GI_FLICK_U: Serial.println("UP"); // Cette instruction est utilisée pour sortir d'une instruction switch. break; // Si ma variable est egal à GI_AIRWHEEL_CW // (information du deplacement dans le sens horaire) // alors j'exécute le morceau de programme // jusqu'a l'instruction break case GI_AIRWHEEL_CW: Serial.println("CW"); // Cette instruction est utilisée pour sortir d'une instruction switch. break; // Si ma variable est égal à GI_AIRWHEEL_CCW // (information du deplacement dans le sens antihoraire) // alors j'exécute le morceau de programme // jusqu'a l'instruction break case GI_AIRWHEEL_CCW://Counterclockwise circles Serial.println("CCW"); // Cette instruction est utilisée pour sortir d'une instruction switch. break; default: break; } } } else {}; } |
.
Retour au sommaire.
Le pilotage d’une tourelle 3 axes |
Tutoriel sur le capteur de mouvement Sen0202 :
–
Explication du schéma de câblage :
- Ce montage est alimenté en 12 V continu, prévoyez tout de même une alimentation capable de fournir au moins 1 A qui est dû surtout à la consommation des servomoteurs.
- Nous pouvons observer le branchement du capteur sur la carte Arduino .Ce capteur possède cinq fils. 2 fils d’alimentations, un appelé GND pour le 0 volt et un nommé Vcc pour le 5 V, ensuite nous avons 2 fils de communication SCL appeler aussi ligne d’horloge de synchronisation bidirectionnelle et le fil SDA (Serial Data Line) ligne de données bidirectionnelles. Ces deux fils, avec la masse, forment le réseau de communication I2c.
- Enfin, nous avons la borne D qui est reliée à l’entrée 7 de la carte Arduino. Cette patte nous avertie si le capteur de gestes est disponible. ( numéro 10-15 ).
-
Un élément important sur ce montage d’ailleurs comme tous les montages électroniques, c’est la masse commune à tous les équipements. Sur le schéma, vous pouvez remarquer que le capteur de gestes est relié à la masse de la carte Arduino, la masse de l’ensemble des servomoteurs est reliée aussi à la même référence d’ailleurs, pour vérifier que l’ensemble est bien commun, les fils 10–00 sont communs à tous les ensembles.
-
Sur le folio, vous avez pu remarquer qu’il y a un petit carré nommé régulateur de tensions. Ce petit composant électronique est là pour nous fournir une tension fixe et régulée pour des circuits électroniques. Il faut savoir qu’il existe deux familles, une pour les régulateurs positifs et une pour les régulateurs négatifs. Dans notre cas, nous avons opté pour un régulateur avec une entrée et une sortie positive. Les régulateurs peuvent se présenter avec différents types de boîtiers. Dans notre montage,nous avons choisi un boîtier type T0 220.
-
Il faut savoir aussi pour qu’un régulateur fonctionne dans de bonnes conditions, il lui faut une tension en entrée supérieure a la tension de sortie de minimum de 2.5 V.
Formule pour la valeur de la tension d’entrée
- À ne pas oublier, sur le régulateur, lors du câblage de l’ensemble, monter un radiateur pour évacuer la chaleur du composant.
| Exemple de radiateurs pour boitier TO220 | ||
 Dissipateur de chaleur 18K/W, 25 x 16 x 11mm |
 Dissipateur de chaleur, montage Vissé, pour A-220 6K/W, 50 x 32 x 20mm |
|
|
|
||
- Important : La puissance dissipée par le régulateur Pd est égale à la différence de tension entre son entrée et sa sortie, multipliée par le courant de sortie . ( en tenir compte pour le choix du radiateur )
Formule pour le calcul de la puissance dissipée par le régulateur ( pour une température ambiante de 35°C )
- A savoir un servomoteur de type Hitec réference HS-645MG consomme en fonctionnement à vide 450 mA . La tourelle possede 3 servomoteurs de ce type
Servomoteur Hitec HS645MG
- Voyons l’alimentation des servomoteurs. Comme la carte Arduino ne peut fournir plus de 200 milliampères et que nos servomoteurs ont une consommation bien supérieure. nous devons donc créer une alimentation distincte de l’alimentation de la carte contrôleur. Sur le folio 010, nous avons utilisé un régulateur 78 06 qui nous permet d’avoir la tension maximale pour les servomoteurs soit 6 V (Ce qui nous permet d’avoir le couple maximal du servomoteur donné par le constructeur) .Vous noterez que ce type de régulateur nécessite la présence d’un condensateur de 0.1 microfarad placé au plus près et en parallèle sur ses fils entrées et de sorties. Sans cela, le régulateur a tendance à se transformer en oscillateur.
- Nous avons sur le folio 010B créé une variante pour le régulateur. Si vous aviez des problèmes pour vous approvisionner en régulateur 78 06 , vous pouvez utiliser un régulateur 78 05 ( tension de sortie 5V ) et pour augmenter la tension de sortie . Il suffit d’insérer dans le circuit de retour à la masse une diode de façon à augmenter la tension de sortie de 0.7 V .Nous obtiendrons donc une tension de 5.7 V à la sortie du régulateur , et oui, il nous manque 0.3V mais là ce n’est pas très grave . La diode à utiliser peut-être du type 1N4001 ou équivalente (1n4002, 1n4007 etc.)
- Sur le folio 010c, l’alimentation des servomoteurs est assurée par deux régulateurs montés en parallèle, ce qui va nous permettre d’augmenter le courant de sortie. Il faut quand même s’assurer que les régulateurs possèdent les mêmes références pour ce type de montage
Schéma de cablage de la tourelle 3 axes
Schéma de cablage de la tourelle 3 axes
.
Schéma de cablage de la tourelle 3 axes.Version avec un régulateur 5V
Schéma de cablage de la tourelle 3 axes.Version avec un régulateur 5V
Schéma de cablage de la tourelle 3 axes . Avec en application comment augmenter le courant de sortie avec plusieurs régulateurs en paralléle pour l’alimentation des servomoteurs
A savoir :
- Pourquoi mettre des régulateurs en parallèles ?
- Simplement pour augmenter le courant de sortie.
- Comment calculer notre courant de sortie de notre montage ?
- Donc I_sortie = Nombre_de_régulateur * I_max soit 9A
- Le courant est-il identique dans chaque régulateur ?
- Il n’y a aucune importance que le courant de sortie se repartisse de façon identique dans chaque régulateur. Chaque régulateur va s’autoréguler.
Programme du pilotage de la tourelle 3 axes
( Version IDE Arduino : 1.8.4 )
|
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 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 |
/* * * * ************************************************************* * * Utilisation du capteur de geste reference SEN0202 * * * * Mise en application de * - Utilisation de 2 base de temps non bloquante * - Pilotage de 3 servomoteurs * - Utilisation de la communication serie * * * * * Le 20/01/2018 * Mazelin Herve * ************************************************************ */ // je charge la bibliothèque qui permet de gerer // le capteur de geste #include <DFRobot_Gesture.h> // je charge la bibliothèque qui vous permet de communiquer // avec les composants utilisant le protocole I2C #include <Wire.h> // Cette librairie permet à une carte Arduino de contrôler // des servomoteurs #include <Servo.h> int testPin= 7; unsigned char cmd; DFRobot_Gesture myGesture; //--------création des variables pour le detecteur de geste ----------- // //Déclare une variable de type boolean initialisée à zero boolean droit1 =0 ; boolean gauche1 =0 ; boolean haut1 =0 ; boolean bas1 =0 ; boolean horaire =0; boolean antihoraire =0 ; //------ creation des objets de type servo avec leurs variables ------- // // Crée un objet de type "Servo", nommé -> rotation_servo Servo rotation_servo; // Crée un objet de type "Servo", nommé -> elevation_servo Servo elevation_servo; // Crée un objet de type "Servo", nommé -> horaire_servo Servo horaire_servo; // // // variable contenant la valeur de la rotation int va_rotation; // variable contenant la valeur de l'elevation int va_elevation; // variable contenant la valeur de la rotation du petit plateau int va_horaire; // Declaration des variables temps_1 et temps_2 // unsigned long-> déclare une variable de type long non signé unsigned long temps_1 = millis(); unsigned long temps_2 = millis(); // Declaration de la variable valeur // int -> declare une variable du type int (pour integer, entier en anglais) // elles peuvent stocker des valeurs de - 32 768 à 32 767 int valeur ; // --------------------------------------------------------------------------- // Un programme Arduino doit impérativement contenir la fonction "setup" // Elle ne sera exécuter une seule fois au démarrage du microcontroleur // Elle sert à configurer globalement les entrées sorties // --------------------------------------------------------------------------- void setup() { // Initialise la library Wire et se connecte au bus I2C en tant que maître Wire.begin(); // Ouvre le port série et fixe le debit de communication à 9600 bauds Serial.begin(9600); pinMode(testPin, INPUT); // Ecrit des données sur le port série. // et affiche sur l'ecran le message suivant -> // Le capteur de mouvement 3D est en cours d'exécution Serial.println(" "); Serial.println(" Le capteur de mouvement 3D est en cours d'exécution"); // Affiche un espace blanc sur l'ecran Serial.println(" "); // Initialisation du servomoteur de la rotation // associe le servomoteur a la broche 3 rotation_servo.attach(3); // variable contenant la valeur de la rotation va_rotation =90 ; // Positionne le servo au centre rotation_servo.write(va_rotation); // Ecrit des données sur le port série. // et affiche sur l'ecran le message suivant -> // Initialisation du servomoteur de la rotation -> Serial.print( "Initialisation du servomoteur de la rotation -> " ); // Affiche sur l'écran la valeur de la variable va_rotation Serial.println (va_rotation); // Réalise une pause dans l'exécution du programme pour la durée // de 100 milliseconde le temps pour le deplacement // du servomoteur delay(100); // Initialisation du servomoteur de l'elevation // associe le servomoteur a la broche 4 elevation_servo.attach(4); // variable contenant la valeur de l'elevation va_elevation =90 ; // Positionne le servo au centre elevation_servo.write(va_elevation); // Affiche un espace blanc sur l'ecran Serial.println(" "); // Ecrit des données sur le port série. // et affiche sur l'ecran le message suivant -> // Initialisation du servo au centre pour l'elevation soit => Serial.print ("Initialisation du servo au centre pour l'elevation soit => "); // Affiche sur l'écran la valeur de la variable va_elevation Serial.println(va_elevation); // Réalise une pause dans l'exécution du programme pour la durée // de 100 milliseconde le temps pour le deplacement // du servomoteur delay(100); // Initialisation du servomoteur de rotation du petit plateau // associe le servomoteur a la broche 5 horaire_servo.attach(5); // variable contenant la valeur horaire du petit plateau va_horaire=90; // Positionne le servo au centre horaire_servo.write(va_horaire); // Affiche un espace blanc sur l'ecran Serial.println(" "); Serial.print ("Initialisation du servo au centre pour le petit plateau soit => "); // Affiche sur l'écran la valeur de la variable va_horaire Serial.println (va_horaire); // Réalise une pause dans l'exécution du programme pour la durée // de 100 milliseconde le temps pour le deplacement // du servomoteur delay(100); // Mise en forme du retour information Serial.println(" "); Serial.println("---------------------------------------------------------------"); Serial.println(" "); // Etat des variables pour la rotation Serial.print("etat de la variable droit1 =>"); Serial.println(droit1); Serial.print("etat de la variable gauche1 =>"); Serial.println(gauche1); // Etat des variables pour l'elevation Serial.print("etat de la variable haut1 =>"); Serial.println(haut1); Serial.print("etat de la variable bas1 =>"); Serial.println(bas1); // Etat des variables de la rotation tete Serial.print("etat de la variable horaire =>"); Serial.println(horaire); Serial.print("etat de la variable antihoraire =>"); Serial.println(antihoraire); } // -------------------------------------------------------------------------------- // Le programme principal s’exécute par une boucle infinie appelée Loop () // -------------------------------------------------------------------------------- void loop() { if(digitalRead(testPin)==0) { // Adresse du capteur 0x42 myGesture.I2C1_MasterRead(md.buf,26,0x42); cmd = myGesture.mgcProcMsg(); if(cmd != GI_NOGESTURE ) { //L'instruction switch / case contrôle le déroulement du programme switch(cmd) { // Si ma variable est egal à GI_FLICK_R (information vers la droite) // alors j'exécute le morceau de programme jusqu'a l'instruction // break case GI_FLICK_R: // affiche un saut de ligne Serial.println(""); Serial.println("Vers la droit"); // inverse la variable binaire droit1 droit1=!droit1; Serial.print("etat de la variable droit1 =>"); Serial.println(droit1); Serial.print("etat de la variable gauche1 =>"); Serial.println(gauche1); // affiche un saut de ligne Serial.println(""); // Cette instruction est utilisée pour sortir d'une instruction switch. break; // Si ma variable est egal à GI_FLICK_L (information vers la gauche) // alors j'exécute le morceau de programme jusqu'a l'instruction // break case GI_FLICK_L: // affiche un saut de ligne Serial.println(""); Serial.println("Vers la gauche"); //inverse la variable binaire gauche1 gauche1=!gauche1; Serial.print("etat de la variable droit1 =>"); Serial.println(droit1); Serial.print("etat de la variable gauche1 =>"); Serial.println(gauche1); // affiche un saut de ligne Serial.println(""); // Cette instruction est utilisée pour sortir d'une instruction switch. break; // Si ma variable est egal à GI_FLICK_D (information vers le bas) // alors j'exécute le morceau de programme jusqu'a l'instruction // break case GI_FLICK_D: // affiche un saut de ligne Serial.println(""); Serial.println("Vers le bas =>"); // inverse la variable binaire bas1 bas1=!bas1; Serial.print("Etat de la variable bas1 =>"); Serial.println(bas1); Serial.print("Etat de la variable haut1 =>"); Serial.println(haut1); // affiche un saut de ligne Serial.println(""); // Cette instruction est utilisée pour sortir d'une instruction switch. break; // Si ma variable est egal à GI_FLICK_U (information vers le haut) // alors j'exécute le morceau de programme jusqu'a l'instruction // break case GI_FLICK_U: // affiche un saut de ligne Serial.println(""); // Affiche sur l'ecran le message "Vers le haut =>" Serial.println("Vers le haut =>"); // inverse la variable binaire haut1 haut1=!haut1; // Affiche sur l'ecran le message:"Etat de la variable bas1 =>" Serial.print("Etat de la variable bas1 =>"); // Affiche sur l'ecran la valeur de la variable bas1 Serial.println(bas1); // Affiche sur l'ecran le message:"Etat de la variable haut1 =>" Serial.print("Etat de la variable haut1 =>"); // Affiche sur l'ecran la valeur de la variable haut1 Serial.println(haut1); // affiche un saut de ligne Serial.println(""); // Cette instruction est utilisée pour sortir d'une instruction switch. break; // Si ma variable est egal à GI_AIRWHEEL_CW // (information du deplacement dans le sens horaire) // alors j'exécute le morceau de programme // jusqu'a l'instruction break case GI_AIRWHEEL_CW: // affiche un saut de ligne Serial.println(""); // Affiche sur l'ecran le message Rotation dans le sens horaire Serial.println("Rotation dans le sens horaire"); horaire=!horaire; Serial.print("Etat de la variable horaire =>"); Serial.println(horaire); // Cette instruction est utilisée pour sortir d'une instruction switch. break; // Si ma variable est egal à GI_AIRWHEEL_CCW // (information du deplacement dans le sens antihoraire) // alors j'exécute le morceau de programme // jusqu'a l'instruction break case GI_AIRWHEEL_CCW: // affiche un saut de ligne Serial.println(""); // Affiche sur l'ecran le message "Rotation dans le sens antihoraire" Serial.println("Rotation dans le sens antihoraire"); //inverse la variable binaire antihoraire antihoraire=!antihoraire ; Serial.print("Etat de la variable antihoraire =>"); Serial.println(antihoraire); // Cette instruction est utilisée pour sortir d'une instruction switch. break; default: break; } } } else {}; // ---------- Servomoteur rotation ---------------------------- // // valeur de la base de temps 1 -> 500ms soit 0.5 seconde // la ligne if effectue la difference entre le temps actuel et le // temps de debut de la boucle .Cette derniere n'est interrompue que lorsque // cette difference = 500 millisecondes soit 0.5 seconde if (millis()-temps_1>500) { // Renvoie le nombre de millisecondes depuis que la carte // Arduino a commencé à exécuter le programme courant. temps_1=millis(); // la ligne if effectue le controle des conditions // entre parenthese pour le geste à droite if((droit1== 1)&(va_rotation<=160)) { // incrementation de la variable va_rotation de 1 soit // -> va_rotation = va_rotation + 1 va_rotation = va_rotation+1; // affiche sur le terminal le texte ci-dessous // valeur de la rotation à droite = Serial.print("valeur de la rotation a droite = "); // affiche sur le terminal la valeur de la rotation // avec va_rotation Serial.println(va_rotation); // positionne le servomoteur de rotation à sa // nouvelle valeur rotation_servo.write(va_rotation); } // la ligne else if effectue le controle des conditions // entre parenthese pour le geste à gauche else if ((gauche1== 1)&(va_rotation>=5)) { // décrémentation de la variable va_rotation de 1 soit // -> va_rotation = va_rotation - 1 va_rotation = va_rotation-1; // affiche sur le terminal le texte ci-dessous // valeur de la rotation à gauche = Serial.print("valeur de la rotation a gauche = "); // affiche sur le terminal la valeur de la rotation // avec va_rotation Serial.println(va_rotation); // positionne le servomoteur de rotation à sa // nouvelle valeur rotation_servo.write(va_rotation); } else { } } // ---------- Servomoteur elevation ---------------------------- // // valeur de la base de temps 2 -> 200ms soit 0.2 seconde // la ligne if effectue la difference entre le temps actuel et le // temps de debut de la boucle .Cette derniere n'est interrompue que lorsque // cette difference = 200 millisecondes soit 0.2 seconde if (millis()-temps_2>200) { // Renvoie le nombre de millisecondes depuis que la carte // Arduino a commencé à exécuter le programme courant. temps_2=millis(); // la ligne if effectue le controle des conditions // entre parenthese pour le geste vers le haut // et controle si nous ne sommes pas en butée // maxi pour le servomoteur if ((haut1==1)&(va_elevation<=110)) { // incrementation de la variable va_elevation de 1 soit // -> va_elevation = va_elevation + 1 va_elevation = va_elevation+1; // affiche sur le terminal le texte ci-dessous // valeur de l'elevation = Serial.print("valeur de l'elevation = "); // affiche sur le terminal la valeur de l'elevation // va_elevation Serial.println(va_elevation); // positionne le servomoteur d'elevation à sa // nouvelle valeur elevation_servo.write(va_elevation); } // la ligne else if effectue le controle des conditions // entre parenthese pour le geste en bas et controle // si nous ne sommes pas en butée minimum else if ((bas1==1)&(va_elevation>=30)) { // décrémentation de la variable va_elevation de 1 soit // -> va_elevation = va_elevation - 1 va_elevation = va_elevation-1; // affiche sur le terminal le texte ci-dessous // valeur de l'abaissement = Serial.print("valeur de l'abaissement = "); // affiche sur le terminal la valeur de l'elevation // va_elevation Serial.println(va_elevation); // positionne le servomoteur d'elevation à sa // nouvelle valeur elevation_servo.write(va_elevation); } else{ } } // la ligne if effectue le controle des conditions // entre parenthese pour le geste dans le sens horaire // à la vertical du capteur et controle si nous ne // sommes pas en butée maxi pour le servomoteur if ((horaire==1)&(va_horaire<=170)) { // incrementation de la variable va_horaire de 1 soit // -> va_horaire = va_horaire + 1 va_horaire=va_horaire+1; Serial.print("valeur de la rotation du petit plateau en horaire = "); Serial.println(va_horaire); horaire_servo.write(va_horaire); // Forcage de la variable horaire à 0 horaire=0; } else if ((antihoraire==1)&(va_horaire>=10)) { //décrémentation de la variable va_horaire // -> va_horaire=va_horaire-1 va_horaire=va_horaire-1; Serial.print("valeur de la rotation du petit plateau en antihoraire = "); Serial.println(va_horaire); horaire_servo.write(va_horaire); // Forcage de la variable antihoraire à 0 antihoraire=0; } else { } } |
.
Retour au sommaire