IMA4 2018/2019 P3 : Différence entre versions
(→Programmation des commandes du robot) |
(→Programmation des commandes du robot) |
||
| Ligne 462 : | Ligne 462 : | ||
**4 : 0xA857 associé au bouton décélérer de 10 (vitesse va de 0 à 90 en absolue) | **4 : 0xA857 associé au bouton décélérer de 10 (vitesse va de 0 à 90 en absolue) | ||
**5 : 0x906F associé au bouton accélérer de 10 (vitesse va de 0 à 90 en absolue) | **5 : 0x906F associé au bouton accélérer de 10 (vitesse va de 0 à 90 en absolue) | ||
| − | + | ||
Le code pour réaliser les différentes actions est le suivant : | Le code pour réaliser les différentes actions est le suivant : | ||
| Ligne 555 : | Ligne 555 : | ||
} | } | ||
} | } | ||
| + | [[Fichier:montage_ir_cmd.jpg|vignette|left|100px| Montage de la commande infrarouge du robot ]] | ||
==Références== | ==Références== | ||
Version du 14 décembre 2018 à 13:34
Sommaire
Présentation générale
Nom du projet : Robot régulé Hugo Delbroucq Encadrants : M. Redon ; M.Boé ; M. Vantroys
Description
Le projet consiste à construire un petit robot en s'appuyant sur les projets déjà réalisés sur ce thème et à réguler ses déplacements afin d'avoir des trajectoires sans erreur par rapport à la consigne. De plus, le projet aura pour ambition la réalisation d'un robot pouvant se relever d'une position d'attente et de rester en équilibre en position "debout". Cette partie s’appuiera sur des recherches faites sur le sujet dans un article concernant les robots à bascule sous arduino. La commande se fera tout d'abord à l'aide d'une télécommande infra rouge dans un premier temps puis si le temps le permet à l'aide d'un module bluetooth et d'une application.
Objectifs
Les objectifs vont être :
- d'améliorer la conception des circuits existants déjà sur le sujet.
- réaliser la commande à l'aide d'une télécommande infrarouge puis à l'aide d'une application android si le temps le permet.
- Régulation :
- régulation des roues afin de suivre la consigne sans erreur ni oscillation.
- régulation du bras balancier afin de conserver le robot proche de son point d'équilibre instable (position debout).
Préparation du projet
Cahier des charges
1) Actions
Le robot doit pouvoir assurer les commandes suivantes :
- faire une marche avant rectiligne
- faire une marche arrière rectiligne
- réaliser des virages d'un angle donné
- rester en équilibre lors de la durée du fonctionnement
2) Environnement
- le sol doit être lisse
- le sol doit avoir une inclinaison maximale de 1%
- l'environnement doit être sans vent
3) Alimentation
L'alimentation se fera à l'aide d'une pile reliée à un interrupteur
Choix techniques : matériel et logiciel
Les différents composants CMS seront de préférence de taille 0603 (1608 metric). Matériel :
- 1*Gyroscope et accéléromètre MPU6050 [1]
- 2*Roue [2]
- 2*Capteur de souris optique
- 1*ATMEGA328PU [3]
- 1*Régulateur de tension 9-5V [4]
- 1 Régulateur de tension 9-3.3V [5]
- 12*Condensateur 100nF [6]
- 2*Condensateur 10uF [7]
- 1*Condensateur 2.2nF [8]
- 1*Condensateur 10nF [9]
- 2*Condensateur 22pF [10]
- 1*Rectifier Diode [11]
- 2*Servomoteur [12]
- 1*émetteur infrarouge [13]
- 2*Résistance 1kΩ [14]
- 2*Résistance 4.7kΩ [15]
- 8*Résistance 220Ω [16]
- 1*Résistance 330Ω [17]
- 3*Résistance 10kΩ [18]
- 1*Résistance 1MΩ [19]
- 1*Résistance 470Ω [20]
- 3*Résistance 56Ω [21]
- 1*Appuie Bouton [22]
- 1*Quartz [23]
- 3*Récepteur infrarouge [24]
- 3*Pile 9V [25]
Liste des tâches à effectuer
- Lister le matériel
- faire les différents circuits imprimés du robot
- traiter les données du gyroscope
- traiter les données du capteur de souris laser
- réaliser un premier prototype avec la régulation en position
- mettre en place la commande par télécommande infrarouge
- réaliser le montage avec le bras à bascule
- équilibrer le robot
- faire une application android et la connexion bluetooth (penser à l'intégrer au système)
Calendrier prévisionnel
Réalisation du Projet
Feuille d'heures
| Tâche | Heures S1 | Heures S2 | Heures S3 | Heures S4 | Heures S5 | Heures S6 | Heures S7 | Heures S8 | Heures S9 | Heures S10 | Total |
|---|---|---|---|---|---|---|---|---|---|---|---|
| Analyse du projet | 12 |
Semaine 1
Régulation
Contrairement à la régulation des roues afin de conserver le robot en équilibre comme on peut le voir ici, il va nous falloir utiliser un bras afin d'avoir deux types de régulation indépendantes :
- une pour les roues : la position
- la seconde pour un bras transversale : l'équilibre
- Deux capteurs de type souris optique placé sous le robot pour contrôler la position
- Un gyroscope GY71 MPU5060 6 axes afin de réguler l'équilibre du robot
Semaine 2 et 3
La semaine deux m'a permis de confirmer mes choix de capteurs pour le robot qui seront les suivants :
- un gyroscope MPU6050 qui permet d'obtenir des informations en accélération linéaire et en vitesse de rotation pour le robot. Ce capteur est très souvent bruité, il faudra donc réaliser un filtrage du bruit avant de pouvoir analyser les données envoyées par un bus I2C compatible avec arduino. D'après la fiche constructeur, on a les données suivantes :
- Sa tension d'alimentation est comprise entre 2.375V et 3.45V
- Il utilise le bus I2C
- Il est constitué d'un accéléromètre 3 axes ET d'un gyroscope 3 axes
- Il utilise les interruptions
- Le gyroscope a une précision allant jusqu'à ±2000°/sec
- Le gyroscope a une consommation nominale de 3.6mA
- L'accéléromètre a une précision allant jusqu'à ±16g
Ces données sont envoyées de la manière suivante :
| AcX = 117 | AcY = 4624 | AcZ = -14732 | Tmp = 20.34 | GyX = 15.49 | GyY = 17.43 | GyZ = 0.01 |
Les valeurs qui nous intéresserons particulièrement sont GyY (pour l'équilibrage du robot), AcX et AcY pour confirmer la vitesse du robot. Si le MPU6050 renvoie des données de bonnes qualité on pourra aussi faire un contrôle de l'orientaiton du robot via GyZ.
- Ce capteur pouvant être plus ou moins bruité, il nous faut un autre capteur pour s'assurer de la fiabilité des résultats fournis par les capteurs. Nous allons donc ajouter deux capteurs de souris optique usb qui vont nous permettre de connaitre la position de notre robot en fonction de deux axes. Cette méthode est assez répandu du fait de sa précision et de sa mise en oeuvre peut coûteuse. Afin de faciliter le traitement des données et éviter les mauvaises surprises, nous allons prendre 2 souris identiques.
L'idéal serait de prendre des souris avec des connecteurs ps2 car fonctionnent mieux sous arduino mais les seules souris optiques disponibles étaient avec connectique usb. Le D+ et le D- renvoient les mêmes états inversés afin d'avoir une comparaison et d'éliminer le bruit qui pourrait gêner la communication.
Fonctionnement des différents types de souris
Type de capteur:
- Le type de capteur
Il existe 3 types de souris composées de capteurs différents qui assurent le bon fonctionnement des souris :
- 1. La souris mécanique contient une boule de contact reliée à des rouleaux qui assurent l'odométrie de la souris. Ce système a pour avantage d'être utilisable sur différents types de surfaces tant que la boule de contact est en contact avec le support.
- 2. La souris optique qui elle possède une petite caméra et d'un système de traitement d'image qui permet d'analyser les variations de nuance de la surface éclairé par la led de la souris. En analysant ainsi les variations de nuances, il est possible de reconstituer le déplacement de la souris. Le mieux est de positionner la souris à quelques millimètres du sol.
- 3. La souris laser qui possède le même type de caméra qui analyse la surface sur laquelle la souris repose à ceci prêt que la source lumineuse est une source laser. Cette souris permet une meilleure précision et une plus grande adaptabilité aux surfaces. La souris peut être positionnée plus éloignée du sol ce qui présente plusieurs avantages.
- Son type de connexion
- 1. Connectique PS2 : C'est l'une des plus anciennes connectiques de souris, et l'une des plus facile à lire. Il existe en effet de multiples tutoriels montrant comment lire ces données.
- 2. Connectique USB : l'USB est particulièrement embêtant à lire en brut. Mais certaines souris anciennes réalisent en fait une conversion PS2-->USB en interne. On peut donc récupérer des données en se reliant aux pins qui gèrent le transport de données sous PS2.
- 3. Souris sans fil : Ce type de connecteur ne nous intéresse pas car demande trop de ports pour être lu (deux fiches usb et j'en passe).
En poursuivant mes recherches, j'ai pu découvrir des possibilités d'application très intéressantes. Notamment le fait qu'il suffit de changer la focale de la lentille afin de régler la hauteur à laquelle nous positionnons le capteur pour rendre ce test efficace pour différentes positions. On découvre cette méthode dans l'article suivant qui propose l'utilisation d'une lentille afocale afin de réduire les erreurs obtenues par la position selon l'axe Z du capteur. Cet autre article explique comment "hacker" sa souris. L'avantage de l'utilisation d'une souris comme capteur odométrique est aussi exposé dans cet autre article de la NASA qui explique notamment l'alternative aux systèmes de capteurs s'inspirant de la vision des insectes pour se repérer depuis un drone volant par l'utilisation de capteurs de souris qui ont pour avantage de permettre une réduction du coût, poids embarqué, l'énergie utilisée et de la simplicité avec laquelle on peut en ajouter et placer en parallèle.
Mots clés optimaux : optical flow navigation mouse
- Pour la commande du robot, nous utiliserons une petite manette infrarouge programmable qui devra réaliser les fonctions suivantes :
- Un bouton pour accélérer par palier
- Un bouton pour décélérer par palier
- Un bouton ON/OFF
- Un bouton pour tourner à gauche
- Un bouton pour tourner à droite
Après réflexion, la partie "pendule inversé" se réalisera par contrôle direct sur les roues couplé à la commande déjà existante sur la position du robot. Cela afin d'éviter d'ajouter des parties en plus au robot en cours de réalisation
Il m'a fallu ensuite me décider sur le dimensionnement des composants à prendre pour la réalisation du circuit. En m'appuyant sur les anciens projets réalisés sur ce robot ainsi que la datasheet des composants que j'ai pris qui différent des anciens projets ( régulateur de tension, gyroscope et capteur optique), j'ai sélectionné le matériel nécessaire pour la réalisation du robot. Le matériel sélectionné est similaire au projet de be ima et au stage d'une étudiante de l'an passé si ce n'est le régulateur de tension 5V qui admet un courant supérieur en entrée. En effet, les deux servomoteurs acceptent de recevoir 2*3A donc j'ai décidé de prendre un régulateur 5V 6A afin d'optimiser la puissance reçue par les moteurs.
Semaine 4, 5 et 6
Les semaines suivantes concernent la création du PCB. J'ai tout d'abords fais l'erreur de réaliser un schéma sous draw.io ce qui m'a fait perdre du temps sur le début de la semaine puis je suis passé directement sur altium afin de réaliser le schéma de mon circuit. La stratégie adoptée ici est de reprendre les footprints déjà existants sur internet afin de simplifier la tâche puis de vérifier que les données simulées sous Altium correspondent bien à nos composants. Ce qui a été fait sur la carte :
- MPU6050
- Alimentation
- Driver
- Clock
- Reset
Il manque :
- Des headers
- Préparer les récepteurs infrarouges
- Interface usb
- connecteur usb
- régulateur de tension 5V-->3.3V
- Souris
Semaine 7
Pour la semaine de vacances il est prévu que je fasse les choses suivantes :
- Chassis
- PCB à finir (avant avis de Mr Boé)
- Analyse des données reçues par les souris
- Expliciter le wiki sur les choix faits pour la carte et présenter les parties recherches sur les composants
Semaine 10
Réalisation du châssis
Le châssis a été réalisé sous le logiciel Onshape qui est un logiciel de CAO libre de droit. La réalisation des pièces en context permet de diminuer grandement le nombre d'erreurs de dimension et permet une réalisation plus rapide des pièces à créer. Une fois le châssis réalisé sous Onshape il ne reste plus qu'à se rendre dans les "Parts" qui nous intéressent, faire un clic droit sur la face de la pièce qui nous intéresse (attention à ne pas cliquer sur le côté de la pièce sinon on imprime l'épaisseur et non notre face) puis séléctionner Export As DXF(Attention, Onshape doit être en Inch pour l'exportation sinon des problèmes de dimension apparaissent sous Inkscape). Une fois le fichier prêt, il suffit de l'ouvrir sous Inkscape et de placer les pièces sur le support pour enfin aller découper le support.
Semaine 11
Tests du MPU6050
crédits au site [26] pour avoir proposé une méthode simple de calibration du gyroscope. Et à Luis Rodenas pour son code de calibration
Nous allons commencer par effectuer des tests sur le MPU6050 format carte.
- La première étape est d'effectuer une calibration propre au capteur. Cette calibration est peut se trouver à l'aide du programme suivant :
// I2Cdev and MPU6050 must be installed as libraries #include "I2Cdev.h" #include "MPU6050.h" #include "Wire.h"
/////////////////////////////////// CONFIGURATION /////////////////////////////
//Change this 3 variables if you want to fine tune the skecth to your needs.
int buffersize=1000; //Amount of readings used to average, make it higher to get more precision but sketch will be slower (default:1000) int acel_deadzone=8; //Acelerometer error allowed, make it lower to get more precision, but sketch may not converge (default:8) int giro_deadzone=1; //Giro error allowed, make it lower to get more precision, but sketch may not converge (default:1)
// default I2C address is 0x68 // specific I2C addresses may be passed as a parameter here // AD0 low = 0x68 (default for InvenSense evaluation board) // AD0 high = 0x69 //MPU6050 accelgyro; MPU6050 accelgyro(0x68); // <-- use for AD0 high
int16_t ax, ay, az,gx, gy, gz;
int mean_ax,mean_ay,mean_az,mean_gx,mean_gy,mean_gz,state=0; int ax_offset,ay_offset,az_offset,gx_offset,gy_offset,gz_offset;
/////////////////////////////////// SETUP ////////////////////////////////////
void setup() {
// join I2C bus (I2Cdev library doesn't do this automatically)
Wire.begin();
// COMMENT NEXT LINE IF YOU ARE USING ARDUINO DUE
TWBR = 24; // 400kHz I2C clock (200kHz if CPU is 8MHz). Leonardo measured 250kHz.
// initialize serial communication Serial.begin(115200);
// initialize device accelgyro.initialize();
// wait for ready
while (Serial.available() && Serial.read()); // empty buffer
while (!Serial.available()){
Serial.println(F("Send any character to start sketch.\n"));
delay(1500);
}
while (Serial.available() && Serial.read()); // empty buffer again
// start message
Serial.println("\nMPU6050 Calibration Sketch");
delay(2000);
Serial.println("\nYour MPU6050 should be placed in horizontal position, with package letters facing up. \nDon't touch it until you see a finish message.\n");
delay(3000);
// verify connection
Serial.println(accelgyro.testConnection() ? "MPU6050 connection successful" : "MPU6050 connection failed");
delay(1000);
// reset offsets
accelgyro.setXAccelOffset(0);
accelgyro.setYAccelOffset(0);
accelgyro.setZAccelOffset(0);
accelgyro.setXGyroOffset(0);
accelgyro.setYGyroOffset(0);
accelgyro.setZGyroOffset(0);
}
/////////////////////////////////// LOOP ////////////////////////////////////
void loop() {
if (state==0){
Serial.println("\nReading sensors for first time...");
meansensors();
state++;
delay(1000);
}
if (state==1) {
Serial.println("\nCalculating offsets...");
calibration();
state++;
delay(1000);
}
if (state==2) {
meansensors();
Serial.println("\nFINISHED!");
Serial.print("\nSensor readings with offsets:\t");
Serial.print(mean_ax);
Serial.print("\t");
Serial.print(mean_ay);
Serial.print("\t");
Serial.print(mean_az);
Serial.print("\t");
Serial.print(mean_gx);
Serial.print("\t");
Serial.print(mean_gy);
Serial.print("\t");
Serial.println(mean_gz);
Serial.print("Your offsets:\t");
Serial.print(ax_offset);
Serial.print("\t");
Serial.print(ay_offset);
Serial.print("\t");
Serial.print(az_offset);
Serial.print("\t");
Serial.print(gx_offset);
Serial.print("\t");
Serial.print(gy_offset);
Serial.print("\t");
Serial.println(gz_offset);
Serial.println("\nData is printed as: acelX acelY acelZ giroX giroY giroZ");
Serial.println("Check that your sensor readings are close to 0 0 16384 0 0 0");
Serial.println("If calibration was succesful write down your offsets so you can set them in your projects using something similar to mpu.setXAccelOffset(youroffset)");
while (1);
}
}
/////////////////////////////////// FUNCTIONS ////////////////////////////////////
void meansensors(){
long i=0,buff_ax=0,buff_ay=0,buff_az=0,buff_gx=0,buff_gy=0,buff_gz=0;
while (i<(buffersize+101)){
// read raw accel/gyro measurements from device
accelgyro.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
if (i>100 && i<=(buffersize+100)){ //First 100 measures are discarded
buff_ax=buff_ax+ax;
buff_ay=buff_ay+ay;
buff_az=buff_az+az;
buff_gx=buff_gx+gx;
buff_gy=buff_gy+gy;
buff_gz=buff_gz+gz;
}
if (i==(buffersize+100)){
mean_ax=buff_ax/buffersize;
mean_ay=buff_ay/buffersize;
mean_az=buff_az/buffersize;
mean_gx=buff_gx/buffersize;
mean_gy=buff_gy/buffersize;
mean_gz=buff_gz/buffersize;
}
i++;
delay(2); //Needed so we don't get repeated measures
}
}
void calibration(){
ax_offset=-mean_ax/8;
ay_offset=-mean_ay/8;
az_offset=(16384-mean_az)/8;
gx_offset=-mean_gx/4;
gy_offset=-mean_gy/4;
gz_offset=-mean_gz/4;
while (1){
int ready=0;
accelgyro.setXAccelOffset(ax_offset);
accelgyro.setYAccelOffset(ay_offset);
accelgyro.setZAccelOffset(az_offset);
accelgyro.setXGyroOffset(gx_offset); accelgyro.setYGyroOffset(gy_offset); accelgyro.setZGyroOffset(gz_offset);
meansensors();
Serial.println("...");
if (abs(mean_ax)<=acel_deadzone) ready++; else ax_offset=ax_offset-mean_ax/acel_deadzone;
if (abs(mean_ay)<=acel_deadzone) ready++; else ay_offset=ay_offset-mean_ay/acel_deadzone;
if (abs(16384-mean_az)<=acel_deadzone) ready++; else az_offset=az_offset+(16384-mean_az)/acel_deadzone;
if (abs(mean_gx)<=giro_deadzone) ready++; else gx_offset=gx_offset-mean_gx/(giro_deadzone+1);
if (abs(mean_gy)<=giro_deadzone) ready++; else gy_offset=gy_offset-mean_gy/(giro_deadzone+1);
if (abs(mean_gz)<=giro_deadzone) ready++; else gz_offset=gz_offset-mean_gz/(giro_deadzone+1);
if (ready==6) break; }}
Ce code a pour objectif de lire les 100 premières données brutes avec un pas de temps de 2ms en sortie du gyroscope afin de trouver une valeur d'état initial moyenne. On vérifie ensuite que ces données ne sont pas trop éloignées les unes des autres puis on créer l'offset adéquat à notre capteur. Il faut effectuer cette calibration pour chaque nouveau capteur car chacun va différer.
- photo du montage
Les résultat obtenus pour le gyroscope sous forme de carte sont les suivants :{| class="wikitable" | AcX = 526 | AcY = -467 | AcZ = 1722 | GyX = 99 | GyY = 14 | GyZ = -3 |}
Semaine 12
Réglage des servo moteurs
Nous allons maintenant nous intéresser aux servomoteurs. Il faut, dans un premier temps les calibrer à l'aide de la vis à l'arrière des servomoteurs. Pour les tester, il suffit d'exécuter le programme suivant :
#include "Servo.h"
Servo myservo;
void setup(){
myservo.attach(9);
myservo.write(90);
}
void loop(){
}
Les valeurs de commande des moteurs vont de 0 (avancer dans le sens des aiguilles d'une montre) à 180 (avancer dans le sens inverse des aiguilles d'une montre). En fixant cette valeur à 90, cela signifie que le moteur est à l'arrêt. La roue est donc immobile et il est possible de régler la vis afin d'avoir effectivement un arrêt du moteur à 90.
Programmation des commandes du robot
En attendant que le circuit soit imprimé, j'ai réalisé la commande infrarouge des différentes fonctions du robot à l'aide de la télécommande suivante :
Les boutons sont associés aux codes et fonctions suivantes :
- 1 : 0xA25D associé au bouton ON/OFF du système IR
- 2 : 0x02FD associé au bouton tourner à gauche de 10°
- 3 : 0xC23D associé au bouton tourner à droite de 10°
- 4 : 0xA857 associé au bouton décélérer de 10 (vitesse va de 0 à 90 en absolue)
- 5 : 0x906F associé au bouton accélérer de 10 (vitesse va de 0 à 90 en absolue)
Le code pour réaliser les différentes actions est le suivant :
#include <IRremote.h> #include <Servo.h> int RECV_PIN = 2; int outputmotG = 9; //cmd moteur gauche int outputmotD = 10; //cmd moteur droite) int VmotG = 90; int VmotD = 90; int isON = 0; Servo ServoG; Servo ServoD; #define codeG 0x2FD //aller à gauche #define codeD 0xC23D// aller à droite #define ONOFF 0xA25D //ONOFF button #define accel 0x906F //acceleration par palier #define decel 0xA857 //décélération par palier IRrecv irrecv(RECV_PIN); decode_results results;
void setup()
{
Serial.begin(9600); irrecv.enableIRIn(); // Start the receiver pinMode(outputmotG,OUTPUT); pinMode(outputmotD,OUTPUT); ServoG.attach(9); ServoD.attach(10); ServoG.write(VmotG); // ServoD.write(VmotD); }
void loop(){
if (irrecv.decode(&results)) {
unsigned int value = results.value;
switch(value) {
fonction 1 :
case ONOFF :
if (isON == 0){
isON = 1;
ServoG.write(VmotG); //
ServoD.write(VmotD);}
else {
isON = 0;
VmotG=90;
VmotD=90;
}
break;
fonction 3 :
case codeD :
if(isON == 1) { //
ServoD.write(VmotD*19.0/18);
ServoG.write(VmotG*19.0/18); //
delay(1000);
}
break;
fonction 2 :
case codeG :
if(isON == 1) { //
ServoG.write(VmotG*17.0/18);
ServoD.write(VmotD*17.0/18);
delay(1000);
}
break;
fonction 5 :
case accel :
if (VmotG<=170){
VmotG = VmotG+10;
VmotD = VmotD-10;
ServoG.write(VmotG);
ServoD.write(VmotD);
}
break;
fonction 4 :
case decel :
if (VmotG>=10){
VmotG = VmotG-10;
VmotD = VmotD+10;
ServoG.write(VmotG);
ServoD.write(VmotD);
}
break;
}
remise à la vitesse normale des moteurs
ServoD.write(VmotD);
ServoG.write(VmotG);
Serial.println(value,HEX); // you can comment this line
irrecv.resume(); // Receive the next value
}
}
