par Anne-Laure DELPECH | 10 Avr 2016 | arduino, astuces rapides
Dans le Mooc « Programmer un objet avec Arduino » de l’Institut Mines Télécom, nous sommes invités à utiliser 123d.circuits.io comme simulateur. Malheureusement, il fonctionne très mal : on croit sauvegarder et on se retrouve avec un circuit vide, on n’arrive pas à compiler le code pour simuler, …
Il existe une alternative à 123d.circuits.io, en anglais également, avec possibilité de poster ses réalisations en ligne. C’est fritzing. Mais malheureusement, ce logiciel ne permet pas de faire des simulations… Il est cependant très bien pour dessiner des schémas de montage.
Fritzing, comment ça fonctionne ?
Fritzing doit être téléchargé. Il est disponible pour Windows, Mac ou Linux.
On peut créer des montages et les mettre en ligne sur le site de Fritzing, comme pour 123d.circuits.io. Mais on ne peut pas incorporer les schémas de Fritzing dans un autre site comme on le fait sur 123d.circuits.io.
Pour savoir comment utiliser Fritzing pour dessiner des montages, on pourra consulter les guides ou tutoriels suivants :
Quand utiliser Fritzing ou 123d.circuits.io ?
123d.circuits.io est très bien pour :
- dessiner des circuits avec des composants déjà incorporés dans la bibliothèque de composants (il n’y en a pas beaucoup) ;
- faire des schémas que l’on veut incorporer dans un article de blog : si l’internaute veut des détails, il clique et arrive sur la vue en grande taille, avec tous les détails ;
- Faire des simulations de circuits.
Fritzing est beaucoup mieux lorsqu’on veut utiliser des composants spécifiques, qui n’existent pas, et qu’on ne peut pas créer avec 123d.circuits.io. Mais on est obligé de télécharger un logiciel pour visualiser les réalisations, et on ne peut pas simuler.
Dommage que ces deux propositions ne fusionnent pas !
par Anne-Laure DELPECH | 10 Avr 2016 | arduino
Cet article est le quatrième de la série Un robot arduino. Le NoRobo fonctionne sur 3 roues mais mon objectif reste de le transformer en robot à balancier. Il va donc falloir qu’il utilise un autre capteur, un gyroscope, pour mesurer l’accélération et l’angle en x,y et z.
Je vais procéder en plusieurs étapes :
- comprendre comment fonctionne un gyroscope (un gy-521, équipé d’un mpu6050) seul avec un arduino ;
- comprendre le code lié au gyroscope dans le programme du balancing robot qui me sert d’inspiration ;
- intégrer le gyroscope à mon NoRobo à 3 roues.
Comment fonctionne un gyroscope
Présentation du gyro MPU-6050
Ma source principale d’information est le site arduino, ici, en anglais.
Le gyroscope que j’utilise est un « gy-521 », équipé d’un MPU-6050 (ici pour 2.29 € sur amazon.fr). Le MPU6050 est un circuit contenant deux « MEMS » (microsystème électromécanique – cf wikipedia). Ces deux MEMS ont deux fonctions distinctes :
Les données sont calculées simultanément en x, y et z grâce à des convertisseurs 16-bits analogue à digital pour chaque canal.
Le capteur mesure également la température.
Le capteur communique avec l’arduino avec le protocole I2C.
Il existe aussi un autre circuit, le MPU-9150 qui combine le MPU-6050 avec un compas (un magnétomètre).
Premiers essais
J’ai simplement connecté le gyro à un arduino uno pour voir les valeurs lues.
Le cablage est très simple : VCC — 5V Arduino, GND — GND Arduino, SCI — A5 Arduino et SDA — A4 Arduino.
Le schéma est également ici sur Fritzing.
Le code arduino vient d’ici, je l’ai pris tel quel et il fonctionne correctement puisqu’il affiche des valeurs différentes lorsque je bouge le gyro. Voici un exemple de ce qui s’affiche (j’ai changé la vitesse de la liaison série dans le code pour qu’elle soit 57600 bauds, comme la console série.
Donc le gyro fonctionne. Reste maintenant à comprendre…
comprendre le protocole I2C
Pour une fois, je trouve une source d’information en français ! Il s’agit d’un excellent article expliquant le fonctionnement d’un capteur de température sur arduino et le protocole I2C. On peut le lire et comprendre comment fonctionne le code de lecture de notre prototype gyro-arduino.
Pour l’instant je n’ai qu’un capteur connecté en I2C à l’arduino. Je n’ai donc pas besoin d’ajouter des résistances. Je connecte donc directement A4 de l’arduino à SDA (les données) et A5 à SCL (l’horloge).
Par ailleurs l’adresse par défaut d’un gyro MPU-6050 est 0x68. On peut donc dire à l’arduino où il est puis, dans setup(), lancer la communication sachant qu’on a défini l’adresse du gyro par const int MPU_addr=0x68;
Ici notre Arduino Uno est le « maître » et le gyro est « esclave ». L’Arduino écrira (write) pour envoyer des données au gyro, ou lira (read) pour en recevoir des données. Par exemple :
Wire.write(0); // set to zero (wakes up the MPU-6050)
AcX=Wire.read()<<8|Wire.read(); // 0x3B (ACCEL_XOUT_H) & 0x3C (ACCEL_XOUT_L)
Pour communiquer en suivant le protocole I2C, on a inclus la bibliothèque Arduino Wire, avec #include<Wire.h> .
comprendre la lecture du gyro
C’est assez compliqué car il faut lire dans des registres de 16 bits les valeurs mesurées.
int16_t AcX,AcY,AcZ,Tmp,GyX,GyY,GyZ; définit que les variables mesurées sont des codés sur 16 bits et sont signées (peuvent être négatives). Elles peuvent donc prendre une valeur allant de -32 768 à 32 767, soit de 
à 
(source wikipedia).
Que signifient les lignes de code suivantes , dans la boucle ?
Wire.write(0x3B); // starting with register 0x3B (ACCEL_XOUT_H)
Wire.endTransmission(false);
Wire.requestFrom(MPU_addr,14,true); // request a total of 14 registers
AcX=Wire.read()<<8|Wire.read(); // 0x3B (ACCEL_XOUT_H) & 0x3C (ACCEL_XOUT_L)
AcY=Wire.read()<<8|Wire.read(); // 0x3D (ACCEL_YOUT_H) & 0x3E (ACCEL_YOUT_L)
Schématiquement (je ne suis pas sûre de tout comprendre), on doit lire dans un registre les valeurs stockées par le gyro.
On dit au gyro de commencer à fournir les données à partir du registre 0c3B qui contient une partie de l’accélération en x et on lui indique qu’on aura besoin de lire 14 registres en tout avec les lignes Wire.write(0x3B); et Wire.requestFrom(MPU_addr,14,true); .
Ensuite on lit les registres deux par deux car chaque valeur que l’on recherche est codée sur deux registres différents. Par exemple l’accélération en x est codée dans 0x3B (ACCEL_XOUT_H) et 0x3C (ACCEL_XOUT_L).
Pour les lire et les transformer en une seule valeur, on utilise, des « bit-shift », ou déplacements de bits comme expliqué par Edgar Bonet dans arduino.stackexchange ici, en anglais.
Le premier Wire.read() lit le premier registre : 0x3B puisqu’on a dit que c’est là qu’il faut commencer avec la commande Wire.write(0x3B); . Le deuxième lit le suivant (0x3C). L’accélération en x est calculée par la ligne AcX=Wire.read()<<8|Wire.read(); .
Chaque Wire.read() renvoie un entier de 16 bits et le suivant se décale d’un registre. La ligne AcX=Wire.read()<<8|Wire.read(); place aaaaaaaabbbbbbbb dans l’entier de 16 bits AcX par le mécanisme illustré dans cette image :
Le lien avec le programme du balancing robot
Il s’agit maintenant de comprendre le code lié au gyroscope dans le programme du balancing robot qui me sert d’inspiration ;
Dans ce programme, le setup() renvoit à une fonction, angle_setup(), qui réveille le gyro et lui donne quelques instructions.
On ne s’intéresse qu’à l’accélération en x et y et l’angle en z. On ne va donc lire que AcX, AcY et GyZ du programme précédent.
Pour celà, on se positionne d’abord sur le registre 0x3B, on déclare qu’on ne veut lire que 4 registres avec les lignes suivantes :
Wire.write(0x3B); // starting with register 0x3B (ACCEL_XOUT_H)
Wire.endTransmission(false);
Wire.requestFrom(MPU6050, 4, true);
On lit AcX et AcY puis on passe à la lecture de GyZ, dont le premier registre est en 0x47, et on ne lit que les deux registres correspondants :
Wire.write(0x47);
Wire.endTransmission(false);
Wire.requestFrom(MPU6050, 2, true); // request a total of 2 registers
Le code correspondant est visible ici : gyro-gyrobo.ino et sur GitHub ici.
Il fonctionne :
C’est un peu bizarre car je ne touchais pas au gyro, ni au bureau sur lequel il est posé. Je m’attendais donc à lire des valeurs stables…
Positionnement du gyro
Je vais profiter de ce prototype pour comprendre comment positionner le gyro sur le robot lorsque je l’intégrerai.
D’après les changements de valeur observés, voici les axes :
le gyro sera donc placé à l’horizontale, led vers le dessous, avec la flèche X pointant vers l’avant du robot et la flèche Y dans le même axe que les roues.
Et maintenant ?
La troisième étape de ces recherches sur le gyroscope va consister à l’intégrer à mon NoRobo à 3 roues. Ce sera l’objet de l’article suivant de cette série « Un robot arduino« .
par Anne-Laure DELPECH | 3 Avr 2016 | arduino
Commander un arduino avec l’application Blueterm
J’ai fait mes premiers essais avec cette application car j’avais déjà eu l’occasion de la tester sur un arduino et j’étais certaine qu’elle fonctionnerait ici.
L’application Blueterm (disponible ici pour android) permet d’envoyer des caractères un à un en connexion série bluetooth.
Le sketch complet est disponible ici, sur GitHub. Voici quelques explications sur son fonctionnement.
Utiliser la librairie SoftwareSerial.h
#include <SoftwareSerial.h> demande à l’arduino d’utiliser la librairie SoftwareSerial.h. Cette librairie est très utile car elle permet d’avoir plusieurs liaisons série entre l’arduino et divers appareils.
Ensuite, nous déclarons deux connexions séries distinctes :
Entre le module bluetooth et l’arduino :
SoftwareSerial AlSerial(2, 3); déclare une liaison série qui se fait via les ports 2 (correspondant à un « TX » de l’arduino) et 3 (RX de l’arduino).
AlSerial.begin(57600); déclare que cette liaison se fera à 57 600 bauds. Evidemment, cette vitesse doit être celle à laquelle on a réglé le module bluetooth précédemment.
La variable Btate prend la valeur de ce qui est écrit dans l’application android : int Btate = AlSerial.read() ;
Si cette variable est égale à « a », la led est allumée par la commande digitalWrite(WhiteLed, HIGH);
Entre l’ordinateur et l’arduino, par USB : 
Serial n’est pas déclaré car c’est une liaison par défaut.
Serial.begin(57600); déclare que cette liaison se fera à 57 600 bauds.
Serial.println(« Setup fait. »); imprime sur la console de l’ordinateur le texte « Setup fait. »
Et ça fonctionne !
Sur mon téléphone, si je tape « a », la led s’allume et « r » l’éteint.
C’est pareil dans la console série de l’ordinateur.
Avec l’application JoyStick Bluetooth Commander
Cette application est beaucoup plus sophistiquée puisqu’elle permet d’utiliser jusqu’à 6 boutons et un joystick pour commander notre arduino.
L’application android JoystickBluetooth Commander est disponible ici, sur google Play.
Un sketch arduino d’exemple est récupérable ici. C’est ce sketch que j’ai utilisé comme base pour réaliser mon propre sketch.
Mon sketch est disponible sur GitHub ici. J’ai réglé le bouton 1 pour qu’il allume la led de l’arduino (#13) et le bouton 2 pour qu’il allume la led connectée au port 7 de l’arduino. Les données dans les champs data1 et data2 sont bidon, générées par deux fonctions intégrées au sketch. Data3 contient un message généré lorsqu’on actionne un bouton, par l’intermédiaire de la variable displayStatus .
Voici le résultat sur mon téléphone android. Je viens d’appuyer sur le bouton B2 et le champs « Data3 » indique « White LED <ON> pour m’en informer. Comme B1 et B2 sont appuyés, la led blanche branchée sur le port #7 et la led intégrée à l’arduino sont toutes deux allumées. Tout fonctionne donc parfaitement.
Ca fonctionne aussi bien avec le module hc-05 qu’avec le module hc-06.
Et maintenant
Je vais pouvoir utiliser ce que j’ai appris ici pour commander un robot par mon téléphone android. Ce robot fait l’objet d’une série d’articles, dont le premier est Robot arduino – étape 0.
Commentaires récents