Aller au contenu


Information tutoriel

  • Ajouté le: juil. 19 2017 09:19
  • Date Updated: juil. 29 2017 11:44
  • Lectures: 2144
 


* * * * *
0 Notes

Affichage des données d'un Accelerometre et Gyroscope MPU6050

Muni d'un capteur MPU6050 (accéléromètre et Gyroscope) et d'une carte wemos D1 (esp8266 sp12), programmée avec l'interface de développement (IDE) arduino, je propose de faire afficher les données du capteur sur un PC avec Processing (produit open source). La transmission des data entre la carte wemos D1 et le PC se fera via Wifi.

Posté par Bernard on juil. 19 2017 09:19

Video 

 

 

 

 

Le capteur MPU6050 ( GY-521 )
 
Le MPU6050 est la première centrale inertielle 6 axes à avoir combiné un gyromètre à 3 axes et un accéléromètre à 3 axes. Il se connecte à la carte programmable de votre choix  via une interface I2C . Avec ce capteur, vous pouvez obtenir les accélérations de vos robots sur 3 axes, grâce à l'accéléromètre intégré,  les vitesses de rotations sur 3 axes grâce au gyromètre intégré, mais aussi les angles d'orientation de vos robots de manière stable, grâce à la fusion des deux données précédentes! 

 
 IMG_1252_b.jpg
 
 
La carte wemos D1 (esp8266 esp12)
 
On peut utiliser la carte wemos D1 ou la D1 mini , l'avantage de ces carte c'est quelles ont  à le wifi intégré (grace à la puce esp8266 sp12), ainsi que l'interface I2C device, (SDA,SLC), elle pourra donc communiquer facilement avec le capteur,  elle se programme avec l'IDE arduino.
 IMG_1253.JPG
 
Le cablage
 
Rien d'extraordinaire :
L'alimentation de la carte et du capteur en 5V, les GND ,la connexion du capteur avec la carte sur les pins SDA avec SDA et SLC avec SLC. Et c'est presque tout car il faudra connecter la broche D8 au + a travers une resistance de 2,2k,  pour espérer transférer le programme de l' IDE arduino dans la carte via le connecteur micro usb, je ne vous cache pas qu'une erreur apparait fréquement durant cette phase :
 
warning: espcomm_sync failed
error: espcomm_open failed
error: espcomm_upload_mem failed
error: espcomm_upload_mem failed
 
Plusieurs tentatives avec D8 à HIGH puis D8 en l'air, seront nécessaires pour obtenir le chargement de la carte wemos D1, je n'ai pas rencontré ce problème avec la wemos D1 mini.
 
Si problèmes, n'hésitez pas à en parler en commentaire ;)
 
 
IMG_1254.JPG
 
 
IDE Arduino
 
Il est nécessaire de choisir le type de carte wemos D1 dans le menu outil de l'IDE arduino.
Pour cela il suffit d'ajouter l'url de gestionnaire de carte supplémentaire :
http://arduino.esp82...6com_index.json
Dans le menu fichiers puis préférences de l'IDE arduino, et le package devrait se charger.
Le code arduino pour la carte wemos D1, est en document joint.
 
Si problèmes, n'hésitez pas à en parler en commentaire ! ;) 
 
 
IDE Arduino.jpg
 
 
Code IDE arduino pour wemos D1
 
 
Fichier joint  GY521_Wemos_D1_Processing_b.ino   7,63 Ko   191 téléchargement(s)
 
 
Code Processing
 


Charger puis installer Processing 3 : https://processing.org/download/
*********************************************************************************


import hypermedia.net.*; 

// Communication objet
UDP udp;  // define the UDP object
String ip       = "192.168.1.18";  // the remote IP address
int port        = 6100;    // the UDP destination port
String message="";

// Data en reception du capteur GY 521
String ax;
String ay;
String az;
String gx;
String gy;
String gz;
// Variables
int rafraichissement ;
int i =0;
int n;// nombre de cases des tables historique des positions
int [] tabXa ; // table historique des position précédentes de l'accéléro x
int [] tabYa ;
int [] tabXg ;
int [] tabYg ;



// Variables d'affichage
int xmax = 660; // dimension axe des X ecran affichage
int ymax = 660;// dimension axe des Y ecran affichage

int Xa;// tracer les courbes
int Ya;
int Za;
int Xg;
int Yg;
int Zg;
int effacement;


// ************** Séquence d'intialisation ****************
void setup() {
  
  // affichage
  size(660, 660); // Dimension d'affichage
  background(0);
  noSmooth();
  stroke (255);
  frameRate(10);

 // Variables
 rafraichissement = 50; // affichage des rafraichissement dernières positions
 n=rafraichissement +1;
 tabXa = new int [n];// table historique des position précédentes de l'accéléro x
   tabYa = new int [n];
    tabXg = new int [n];
     tabYg = new int [n];
  
  // create a new datagram connection UDP on port 6000
  // and wait for incomming message
  udp = new UDP( this, 6000 );
  //udp.log( true ); // <-- printout the connection activity
  udp.listen( true );

  
noLoop();// affichage a la demande pas en boucle
  
}

//*********************BOUCLE d'affichage Ecran Dessine ****************
// ****************************************************
// ****************************************************

void draw() {

  //trace la marque du GY 521
  // Effacemment d'un coup
 //  if (effacement ==1) {background(0);noSmooth();stroke (255); effacement = 0;} // efface l'ecran au début de chaque nouveau balayage
  

 if(Xa>xmax){Xa=xmax-10;} // limite de l'ecran d'affichage
 if(Xa<0){Xa=10;}
 if(Ya>ymax){Ya=ymax-10;}
 if(Ya<0){Ya=10;}
 stroke (0, 0, 255);fill(0,0,255); // couleur bleue pour l'accelero
  Ya=ymax-Ya;
 rect(Xa,Ya,3,3); // Dessine un rectangle de 3 par 3 au point X,Y

 if(Xg>xmax){Xg=xmax-10;} // limite de l'ecran d'affichage
 if(Xg<0){Xg=10;}
 if(Yg>ymax){Yg=ymax-10;}
 if(Yg<0){Yg=10;}
 stroke (255, 0,0);fill(255,0,0); // couleur rouge pour le gyro
 Yg=ymax-Yg; // Changement de repère le 0 de l'axe des y est en bas
 Xg=xmax-Xg; // l'accélero et le gyro varient dans le meme sens a l'affichage
 rect(Xg,Yg,3,3); // Dessine un rectangle de 3 par 3 au point X,Y

// Gestion de l'effacement progressif des anciennes positions

// On rempli les tables histo jusqu' 100
tabXa [i] = Xa;
tabYa [i] = Ya;
tabXg [i] = Xg;
tabYg [i] = Yg;
i=i+1; // rang des anciennes positions on part de i=0
// Quand i == 100  on efface la position au rang 0 et on décale toutes les positions d'un rang +1, le rang 99 devient le rang 100
if (i==rafraichissement) { effacement =1;fill (0,0,0);stroke (0,0,0);rect(tabXa[0],tabYa[0],3,3);rect(tabXg[0],tabYg[0],3,3);
 for (int j=0;j<rafraichissement; j++) {tabXa[j]=tabXa[j+1];tabYa [j]=tabYa [j+1];tabXg[j]=tabXg[j+1];tabYg [j]=tabYg [j+1];}
i=rafraichissement-1; } 

}
// ******************* FIN Boucle affichage   ***************
// ********************************************************
// ********************************************************


// ************ BOUCLE Buffer qui Va voir si des data sont dans le buffer UDP , receive( byte[] data) tourne en boucle
// ********************************************************
// ********************************************************
void receive( byte[] data) { // <-- extended handler
  message = new String( data );// message contient les data
  //println( "receive: \""+message+"\" from "+ip+" on port "+port );

  program_principal(); 
}

// ******************* FIN Boucle Buffer   ***************
// ********************************************************
// ********************************************************

// ************ Retouve les données dans le message UDP recu, / Retrouver les points de capture


void program_principal() {
  
  // retrouve les data dans la trame UDP , on soustrait 100000 qui avait permis un envoi sur 6 caratères les data sont brutes mais non signées et comprisent entre 0 et 65535

  ax = message.substring (0, 6); Xa = (int (ax)-100000)/100; // valeur compris entre 0 et 655 pour un affichage en 660*660
  ay = message.substring (6,12 );Ya = (int (ay) -100000)/100;
  az = message.substring (12,18);Za = (int (az) -100000)/100;
  gx = message.substring (18,24);Yg = (int (gx)-100000 )/100; 
  gy = message.substring (24,30);Xg = (int (gy) -100000)/100;
  gz = message.substring (30,36);Zg = (int (gz) -100000)/100;
  
 redraw(); // demande l'affichage
}