Annonce

>>> Bienvenue sur codelab! >>> Première visite ? >>> quelques mots sur codelab //// partage de liens //// une carte des membres//// (apéros) codelab


#1 2012-12-17 16:44:26 Les capteurs pour les nuls (avec Arduino)

Pertuit
membre
Date d'inscription: 2011-11-21
Messages: 51

Les capteurs pour les nuls (avec Arduino)



Bonjour,

Sous ce titre accrocheur, je voulais faire profiter de mon expérience sur les capteurs à ceux qui (comme moi) ne sont pas experts en informatique ou en électronique et qui recherchent une solution clé en main, peu onéreuse, pour se lancer dans l’aventure de l’interactivité avec Arduino et Pure Data. Cet article est un état des lieux personnel et a simplement pour objet de répondre à quelques questions élémentaires que l’on se pose et dont on ne trouve pas facilement les réponses à travers les multiples sources d’information sur le sujet : Quels capteurs ? Comment se les procurer ? Quel investissement ? Comment les brancher ? Les utiliser ? etc.

Il ne s’agit pas de traiter le sujet avec exhaustivité, mais simplement de proposer une solution fonctionnelle à partir de laquelle l’internaute intéressé pourra se baser pour aller plus loin : le matériel, l’installation d’un capteur analogique (type capteur de distance IR) ou d’un capteur numérique (type détecteur de mouvement IR) sur une carte Arduino, la programmation de la carte, la réception des données brutes dans Pure Data et plusieurs modes de traitement de ces données (calibrage, rampe, etc.).

Pour information, si l’on se contente d’une installation simple (capteur de distance IR avec Arduino), il faut compter 20€ pour l’Arduino, 15€ pour le capteur et 3€ pour le câble USB (reliant la carte à l’ordinateur), soit un investissement de 35 à 40€. Somme modique pour s’amuser un peu...

I. Le matériel

La carte Arduino est une carte électronique publiée en matériel libre pour l’industrie (domotique, robotique) et la création artistique interactive. Nous utiliserons une carte Arduino UNO qui est une carte de base, pas très onéreuse et que l’on achète auprès de différents fournisseurs Internet (comme Zartronic ou Snootlab, il y en a d’autres, mais je ne me suis adressé qu’à ces deux fournisseurs-là, désolé pour les autres...). La carte Arduino UNO Atmega328 coûte à peu près 20€ (les prix ont été évalués en décembre 2012).
http://codelab.fr/up/image1b.jpg

D’autres cartes compatibles existent (Arduino est "open"), comme la DFRduino Romeo Robotique 328 Rev1.1, un peu plus chères (vers 30€), qui fait un peu plus de choses et dont la connectique est simplifiée, mais j’ai préféré travailler sur la carte Italienne, d’une part parce qu’elle convient tout à fait pour ce que l’on veut en faire et aussi pour récompenser les sympathiques concepteurs de ce matériel libre.

Les capteurs sont de deux types : les capteurs analogiques, qui renvoient un flux de données en continu ; et les capteurs numériques, qui renvoient un signal 1 ou 0 (On/Off). En voici quelques exemples simples (non exhaustifs, bien sûr) :

Capteurs analogiques :
* http://codelab.fr/up/image2-2.png Capteur de distance IR : Capteur de distance à infrarouges mesurant la distance en continu et la retournant sous forme de tension analogique avec une portée de 10 à 80 cm, de 20 cm à 1,50 m ou de 1 m à 5,50 m, selon le modèle. De 15 à 25€.
* http://codelab.fr/up/image3-1.png Capteur d’intensité sonore : Microphone et amplificateur permettant de mesurer le volume sonore et de le restituer sous forme de tension analogique. La sensibilité du capteur est réglable. Vers 8€.
* http://codelab.fr/up/image4.png Capteur de lumière ambiante : Mesure l’intensité lumineuse et la restitue sous forme de tension analogique. Vers 8€.
* http://codelab.fr/up/image5.png Capteur de vibrations à disque Piezo : Détecteur de vibrations à disque piezo-électrique. Vers 5€.
* http://codelab.fr/up/image6.png Capteur rotatif analogique : Simple potentiomètre permettant de mesurer un mouvement de rotation. Utilisé dans des installations avec pédalier, par exemple. Vers 4€.
* http://codelab.fr/up/image7.png Accéléromètre trois axes : La tension de sortie est proportionnelle à l’accélération mesurée suivant trois axes (X, Y et Z). C’est ce qui est utilisé dans la manette Wiimote. Vers 17€.

Capteurs numériques :
* http://codelab.fr/up/image8.png Détecteur à infrarouge : Capteur IR numérique très précis qui retourne 1 dès que l’on dépasse une certaine distance (3 cm à 80 cm). Cette distance est réglable sur le capteur. On ne peut utiliser que deux capteurs de ce type sur une Arduino en USB car il consomme beaucoup de courant. Vers 10€.
* http://codelab.fr/up/image9.png Capteur d’inclinaison numérique/tilt : Capteur d’inclinaison qui retourne 1 dès qu’il est en mouvement transversal. Vers 3€.
* http://codelab.fr/up/image10.png Détecteurs de mouvement IR : Détecte les mouvements par le changement de chaleur (infrarouges passifs). Très utilisé dans les antivols domestiques. Après la mise sous tension, il faut attendre 2 secondes pour qu’il se stabilise. Vers 8€.
* http://codelab.fr/up/image11.png Bouton poussoir numérique : Simple interrupteur permettant de déclencher un événement. Vers 4€.

Pour relier la carte Arduino à l’ordinateur, il faut un câble USB (3€) et pour brancher les câbles des capteurs (prises femelles) dans les entrées Arduino (femelles aussi), il faut se procurer une barrette sécable de connecteurs (petites tiges en cuivre que l’on enfonce dans les prises, le prix est négligeable : 0,40€) :
http://codelab.fr/up/image12.jpg

II. Programmation de la carte Arduino

Je ne travaille que sous MacOs X et Windows (XP et 7). Pour les utilisateurs d’UNIX, la procédure est la même (mais je ne l’ai pas testée).

Pour les capteurs précédents, on utilisera le protocole de communication fourni avec le logiciel Arduino : Standard Firmata. Une fois le programme installé, la carte est prête à fonctionner.

a) Installation sous MacOsX (10.7.5)

* Télécharger le programme Arduino pour Mac (http://arduino.cc/en/Main/Software) et le dezipper.
* Brancher le câble USB sur l’ordinateur. Sur Mac, il est inutile d’installer de driver.
* Lancer le programme Arduino et vérifier que :
- le menu Outils/Type de carte est positionné sur Arduino Uno,
http://codelab.fr/up/image13b.png

- le menu Outils/Port série est positionné sur tty.ubbmodemfa131.
http://codelab.fr/up/image14b.png

* Pour tous les capteurs ci-dessus, on utilisera le programme standard : Standard firmata. Le chargement se fait de la façon suivante :
- appuyer sur le bouton : http://codelab.fr/up/image15.png et chercher le programme Firmata/StandardFirmata,
- vérifier le programme : http://codelab.fr/up/image16.png, puis le transférer dans la carte électronique : http://codelab.fr/up/image17.png.

b) Installation sous Windows 7 ou Windows XP

* Télécharger le programme Arduino pour Windows (http://arduino.cc/en/Main/Software) et le dezipper.
* Le driver se trouve dans un sous-répertoire du programme. Brancher le câble USB de la carte Arduino sur le PC. Accéder au Gestionnaire de périphérique Windows et sélectionner le « périphérique inconnu ». Avec le clic droit de la souris aller rechercher le pilote dans le répertoire du programme Arduino. Après installation, on doit avoir :
http://codelab.fr/up/image18b.png
* Lancer le programme Arduino et vérifier que :
- le menu Outils/Type de carte est positionné sur Arduino Uno,
- le menu Outils/Port série est positionné sur COM3 (c’est a priori le port disponible, mais cela peut être éventuellement un autre port selon les connexions sur l’ordinateur).
http://codelab.fr/up/image19b.png

* On utilisera le programme standard : Standard firmata. Le chargement se fait de la façon suivante :
- appuyer sur le bouton : http://codelab.fr/up/image15.png et chercher le programme Firmata/StandardFirmata,
- vérifier le programme : http://codelab.fr/up/image16.png, puis le transférer dans la carte électronique : http://codelab.fr/up/image17.png.

III. Branchement des capteurs sur la carte Arduino

J’ai testé tous les capteurs analogiques et numériques cités ci-dessus et ils fonctionnent sans difficulté particulière. Chaque capteur est livré avec un câble de connexion qui comprend 3 fils de branchement (*) : une alimentation de 5V (généralement, fil rouge), un fil de terre (fil noir) et la valeur en sortie du capteur (fil bleu ou vert).

(*) sauf l’Accéléromètre trois axes qui a 3 x 3 fils de branchement (un triplet pour chaque axe) : les fils de terre sont à relier ensemble, ceux de l’alimentation doivent être réunis, et les trois fils des valeurs en sortie (X, Y, Z) doivent être associés à trois entrées différentes sur la carte Arduino (A0, A1, A2).

Le branchement des capteurs sur la carte Arduino n’est pas direct car, d’une part, les entrées Arduino et la prise des capteurs sont des prises femelles (et on a besoin de connecteurs en cuivre pour les relier),
http://codelab.fr/up/image20.png
et d’autre part, les 3 branchements ne se font pas au même endroit (les trois entrées sont séparées, on le verra ci-dessous).

Attention à bien faire le branchement. J’avoue avoir eu un peu peur au début de mes investigations, en lisant les forums, car certains évoquent les risques de griller la carte Arduino ou le capteur, voire le port USB de l’ordinateur... Il est certain qu’il ne faut pas brancher n’importe quoi n’importe où, mais si l’on respecte les branchements ci-dessous, il n’y a aucun problème. Il faut veiller à éviter les faux contacts et débrancher le câble USB (qui alimente la carte) avant chaque manipulation.

Pour fixer les branchements, j’ai utilisé un simple ruban adhésif de couleur (je vais peut-être faire hurler les puristes électroniciens, mais cela s’est avéré très efficace) et j’ai placé l’ensemble dans un boîtier pour protéger la carte et la connexion. On peut le confectionner soi-même ou se le procurer sur des sites (un peu cher, en comparaison du prix de la carte, mais très solide et pratique : à peu près 11€) : voici les deux cas de figure (à gauche, mon boîtier confectionné, comprenant un capteur de distance IR, et à droite, le boîtier du commerce).
http://codelab.fr/up/image21c.jpg

Remarquons que certaines cartes compatibles (DFRduino Romeo) ou certaines interfaces d’extension (Shield Extension IO V5) permettent un branchement simplifié et plus direct des capteurs (les prises femelles des capteurs se branchent dans des entrées mâles de la carte) et ajoutent quelques fonctionnalités. Mais je n’ai pas vu trop leur intérêt devant la facilité du branchement des capteurs sur l’Arduino (si l’on a à brancher 5 ou 6 capteurs, ces compléments sont peut-être utiles... mais je n’en suis pas complètement persuadé).

a) Branchement d’un capteur analogique

La carte Arduino UNO présente 6 entrées analogiques : A0, A1, ..., A5. On utilisera la première entrée A0.

Les trois fils des capteurs analogiques sont à brancher de la façon suivante :
- fil rouge 5V capteur : 5V (alimentation) Arduino
- fil noir GND capteur : GND (terre) Arduino
- fil bleu sortie capteur : ENTREE ANALOGIQUE A0 Arduino
http://codelab.fr/up/image22.png

b) Branchement d’un capteur numérique

Il y a 14 entrées numériques qui n’ont pas les mêmes fonctions. Nous utiliserons l’entrée 3 PMW.

Les capteurs numériques ci-dessus ont aussi 3 fils de branchement : une alimentation de 5V (généralement, fil rouge), un fil de terre (fil noir) et la valeur en sortie (fil vert).

Les trois fils sont à brancher de la façon suivante :
- fil rouge 5V capteur : 5V (alimentation) Arduino
- fil noir GND capteur : GND (terre) Arduino
- fil vert sortie capteur : ENTREE NUMERIQUE (DIGITAL) ~3 Arduino
http://codelab.fr/up/image23b.jpg

c) Branchement de plusieurs capteurs

La carte Arduino dispose de plusieurs entrées analogiques (au total 6) et numériques (14), on peut donc envisager de brancher plusieurs capteurs, selon les besoins de l’installation que l’on veut réaliser. Dans ce cas, la source d’alimentation de 5V et la prise de terre doivent être reliés à un domino permettant de joindre les fils correspondant des différents capteurs. Mais il faut noter que, dans ce cas, l’alimentation de la carte Arduino via le câble USB risque de ne pas être suffisante (cela dépend du nombre et de la nature des capteurs). Si l’on envisage de brancher un grand nombre de capteurs, il est préférable brancher la carte Arduino sur un adaptateur secteur (une entrée de la carte est prévue à cet effet). Mais pour 2 ou 3 capteurs de distance IR, normalement, l’alimentation USB de l’ordinateur suffit (j’ai fait le test avec 3 capteurs IR sur l’Arduino reliés à mon MacBook Pro et cela fonctionne très bien).   

Les programmes Pure Data doivent, bien sûr, être paramétrés et adaptés pour prendre en compte les différentes sources de données venant des capteurs (voir le code).

IV. Réception des données dans Pure Data

A ce stade, le capteur (analogique ou numérique) doit être branché sur le boîtier Arduino, lui-même relié, par le câble USB, à l’ordinateur (le branchement doit être fait avant d’ouvrir le patch de Pure Data).

Ouvrir avec Pure Data (Pd 0.42.5-extended) le programme ci-joint "patch-capteur.pd".
http://codelab.fr/up/image24b.png

Le mode d’emploi est indiqué, il suffit de tester...
A vous de jouer !

Dernière modification par Pertuit (2012-12-17 17:37:50)

Hors ligne

 

#2 2012-12-18 15:31:17 Re : Les capteurs pour les nuls (avec Arduino)

nononononono
membre
Lieu: Toulouse
Date d'inscription: 2011-02-04
Messages: 608

Re: Les capteurs pour les nuls (avec Arduino)



Super tuto! A épingler!

Hors ligne

 

#3 2012-12-18 23:11:49 Re : Les capteurs pour les nuls (avec Arduino)

steadam
membre
Lieu: Rezé - Nantes
Date d'inscription: 2012-11-30
Messages: 20
Site web

Re: Les capteurs pour les nuls (avec Arduino)



Ouh pinaise ! Ça s'est bon ça !

Hors ligne

 

#4 2012-12-19 00:53:55 Re : Les capteurs pour les nuls (avec Arduino)

Olivier
N°4
Lieu: Chalon sur la Saône
Date d'inscription: 2009-04-07
Messages: 1471
Site web

Re: Les capteurs pour les nuls (avec Arduino)



smilesmilesmilesmilesmile


L'Amour au Peuple !

Hors ligne

 

#5 2012-12-19 02:11:38 Re : Les capteurs pour les nuls (avec Arduino)

rep
modérateur
Lieu: Toulouse
Date d'inscription: 2008-02-27
Messages: 1422
Site web

Re: Les capteurs pour les nuls (avec Arduino)



Ouais chouette tutorial !
Epinglé !


La réalité, c'est pour qui ne sait pas gérer autre chose.
http://cumulonimbus.fr/ | http://tetalab.org | http://mixart-myrys.org

Hors ligne

 

#6 2012-12-19 09:00:44 Re : Les capteurs pour les nuls (avec Arduino)

Laure Tiblanche
membre
Date d'inscription: 2012-04-26
Messages: 152

Re: Les capteurs pour les nuls (avec Arduino)



c cool
manque la partie sous Linux avis aux amateurs

Hors ligne

 

#7 2013-06-17 18:49:51 Re : Les capteurs pour les nuls (avec Arduino)

sakramh
membre
Lieu: clichy-sous-bois
Date d'inscription: 2008-12-02
Messages: 829
Site web

Re: Les capteurs pour les nuls (avec Arduino)



Me suis pas encore frotté à Arduino (mais çà me tente de plus en plus , la kinect m'ayant un peu déçu) .
Premier constat sur Linux (du moins Debian mais y a pas de raisons que çà soit pas la même sur Fedora, etc...) :
c'est dans les dépôts officiels (et bien plus cf. recherche synaptic) .

Dernière modification par sakramh (2013-06-17 18:51:19)


le code est l'alchimie de l'âge du silicium

Hors ligne

 

#8 2015-02-08 20:11:59 Re : Les capteurs pour les nuls (avec Arduino)

EricDT
nouveau membre
Date d'inscription: 2015-02-05
Messages: 6

Re: Les capteurs pour les nuls (avec Arduino)



Merci, super démarrage pour aider un débutant comme moi..
Je bloque rapidement malheureusement. Dans le patchcapteur-pd, il ne se passe rien quand je clique sur "Init". Le port devrait s'afficher dans la console ?
La console me dit:
" flatspace/comport $1 57600
... couldn't create  "

Avez-vous une idée de que j'ai pu rater?
N'hésitez pas à me faire des réponses évidentes, je débute vraiment...

Merci !
Eric

Hors ligne

 

#9 2015-02-11 19:15:55 Re : Les capteurs pour les nuls (avec Arduino)

Pertuit
membre
Date d'inscription: 2011-11-21
Messages: 51

Re: Les capteurs pour les nuls (avec Arduino)



Bonsoir. Pourrais-tu être plus précis pour décrire ton problème ? Quel système utilises-tu ? Quelle version de Pd ? Extended ou Vanilla ?
Pour ce que j'ai testé (Windows 7, Windows XP, MAC 10.7.5) avec Pd-extended 0.43.4, ça marche tout seul : en cliquant sur le bouton init, les ports disponibles s'affichent sur la console. Il reste à cliquer sur le bon numéro dans le patch. (Je présume que tu as suivi les instructions décrites dans la discussion pour le branchement de la carte arduino, le chargement du firmata standard, l'affectation du port, etc.)
Si tu reçois le message "comport couldn't create", c'est étonnant avec Pd-extended car la bibliothèque "comport" fait partie des extensions... Mais si tu travailles avec Vanilla, c'est normal : il te faut télécharger cette bibliothèque. Bref, tout cela dépend de ta config.

Hors ligne

 

#10 2015-02-11 20:12:53 Re : Les capteurs pour les nuls (avec Arduino)

Nicolas Lhommet
membre
Date d'inscription: 2014-01-18
Messages: 194

Re: Les capteurs pour les nuls (avec Arduino)



Pertuit a écrit:

"comport couldn't create", c'est étonnant avec Pd-extended car la bibliothèque "comport" fait partie des extensions...

euh, sauf que le message c'est "flatspace/comport $1 57600 ... couldn't create  ", et chez moi (Pd-Extended 0.43.4 sur Windows 7) ça marche pas tout seul non plus... parce que "comport" existe, mais plus dans la librairie "flatspace" (apparemment retirée depuis la 0.43 ?: http://puredata.info/docs/LibrariesInPdExtended ).

En attendant une éventuelle mise à jour de ton archive, Eric pourrait simplement éditer le patch "arduino.pd" (dans le dossier src) et remplacer [flatspace/comport $1 57600] par [comport $1 57600]  (en oubliant pas de sauver avant de relancer le patch principal).

Hors ligne

 

#11 2015-02-11 23:47:23 Re : Les capteurs pour les nuls (avec Arduino)

EricDT
nouveau membre
Date d'inscription: 2015-02-05
Messages: 6

Re: Les capteurs pour les nuls (avec Arduino)



Merci à tous les 2.
j'essaye demain ce que tu me conseilles, Nicolas, et je vous dis.
Je suis sur MacOSX 10.5.8, avec PDextented 0.43.4

Hors ligne

 

#12 2015-02-12 21:29:01 Re : Les capteurs pour les nuls (avec Arduino)

EricDT
nouveau membre
Date d'inscription: 2015-02-05
Messages: 6

Re: Les capteurs pour les nuls (avec Arduino)



ça marche !
effectivement, il suffisait de remplacer [flatspace/comport $1 57600] par [comport $1 57600] dans arduino.pd
reste à déclencher une vidéo avec ça, je m'y mets.
Merci beaucoup à tous les 2.
Eric

Hors ligne

 

#13 2015-06-29 20:54:45 Re : Les capteurs pour les nuls (avec Arduino)

EMA883
membre
Lieu: Toulon
Date d'inscription: 2014-11-07
Messages: 24

Re: Les capteurs pour les nuls (avec Arduino)



Bonjour,
je souhaite utiliser des capteurs IR en digital pour une barrière de détection

Y a t il du code à prévoir au niveau de l'arduino pour faire fonctionner ces capteurs (en plus de l'installation de Fimata standard). 

Merci!smile

Hors ligne

 

#14 2015-07-09 15:38:33 Re : Les capteurs pour les nuls (avec Arduino)

Pertuit
membre
Date d'inscription: 2011-11-21
Messages: 51

Re: Les capteurs pour les nuls (avec Arduino)



Bonjour. S'il s'agit du détecteur infrarouge numérique que j'ai décrit ci-dessus, le firmata standard et le code Pd joint plus haut suffisent.

Hors ligne

 

#15 2016-05-13 14:06:44 Re : Les capteurs pour les nuls (avec Arduino)

Pi-af
nouveau membre
Date d'inscription: 2014-03-11
Messages: 7

Re: Les capteurs pour les nuls (avec Arduino)



Hello, je travaille avec un arduino uno, deux gyroscope ( mpu 6050) et pure data. Mon soucis c'est la récupération bien distincte des données des deux gyro dans le patch pure data. Sur le code arduino, dans la console les deux groupes de valeurs sont bien distinctes, mais pure data récupère un mix de ces deux groupes de données. Je me demande si ce n'est pas un problème de format ou alors de int ou float. Je n'arrive pas à trouver de solution.
Voiçi mon code arduino.

 
#include "I2Cdev.h"
 
#include "MPU6050_6Axis_MotionApps20.h"
//#include "MPU6050.h" // not necessary if using MotionApps include file

// Arduino Wire library is required if I2Cdev I2CDEV_ARDUINO_WIRE implementation
// is used in I2Cdev.h
#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
#include "Wire.h"
#endif

// class default I2C address is 0x68
// specific I2C addresses may be passed as a parameter here
// AD0 low = 0x68 (default for SparkFun breakout and InvenSense evaluation board)
// AD0 high = 0x69
MPU6050 mpu;
MPU6050 mpu1(0x69); // <-- use for AD0 high

#define OUTPUT_READABLE_REALACCEL



#define INTERRUPT_PIN 2  // use pin 2 on Arduino Uno & most boards
#define INTERRUPT_PIN1 3  // use pin 3 on Arduino Uno & most boards

#define LED_PIN 13 // (Arduino is 13, Teensy is 11, Teensy++ is 6)
bool blinkState = false;

// MPU control/status vars
bool dmpReady = false;  // set true if DMP init was successful
uint8_t mpuIntStatus;   // holds actual interrupt status byte from MPU
uint8_t devStatus;      // return status after each device operation (0 = success, !0 = error)
uint16_t packetSize;    // expected DMP packet size (default is 42 bytes)
uint16_t fifoCount;     // count of all bytes currently in FIFO
uint8_t fifoBuffer[64]; // FIFO storage buffer

// MPU control/status vars
bool dmpReady1 = false;  // set true if DMP init was successful
uint8_t mpuIntStatus1;   // holds actual interrupt status byte from MPU
uint8_t devStatus1;      // return status after each device operation (0 = success, !0 = error)
uint16_t packetSize1;    // expected DMP packet size (default is 42 bytes)
uint16_t fifoCount1;     // count of all bytes currently in FIFO
uint8_t fifoBuffer1[64]; // FIFO storage buffer

// orientation/motion vars
Quaternion q;           // [w, x, y, z]         quaternion container
VectorInt16 aa;         // [x, y, z]            accel sensor measurements
VectorInt16 aaReal;     // [x, y, z]            gravity-free accel sensor measurements
VectorInt16 aaWorld;    // [x, y, z]            world-frame accel sensor measurements
VectorFloat gravity;    // [x, y, z]            gravity vector
VectorInt16 last;
float euler[3];         // [psi, theta, phi]    Euler angle container
float ypr[3];           // [yaw, pitch, roll]   yaw/pitch/roll container and gravity vector

// orientation/motion vars
Quaternion q1;           // [w, x, y, z]         quaternion container
VectorInt16 aa1;         // [x, y, z]            accel sensor measurements
VectorInt16 aaReal1;     // [x, y, z]            gravity-free accel sensor measurements
VectorInt16 aaWorld1;    // [x, y, z]            world-frame accel sensor measurements
VectorFloat gravity1;    // [x, y, z]            gravity vector
VectorInt16 last1;
float euler1[3];         // [psi, theta, phi]    Euler angle container
float ypr1[3];           // [yaw, pitch, roll]   yaw/pitch/roll container and gravity vector


// packet structure for InvenSense teapot demo
uint8_t teapotPacket[14] = { '$', 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0x00, 0x00, '\r', '\n' };



// ================================================================
// ===               INTERRUPT DETECTION ROUTINE                ===
// ================================================================

volatile bool mpuInterrupt = false;     // indicates whether MPU interrupt pin has gone high
void dmpDataReady() {
  mpuInterrupt = true;
}

volatile bool mpuInterrupt1 = false;     // indicates whether MPU1 interrupt pin has gone high
void dmpDataReady1() {
  mpuInterrupt1 = true;
}

// ================================================================
// ===                      INITIAL SETUP                       ===
// ================================================================

void setup() {
  // join I2C bus (I2Cdev library doesn't do this automatically)
#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
  Wire.begin();
  Wire.setClock(400000); // 400kHz I2C clock. Comment this line if having compilation difficulties
#elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE
  Fastwire::setup(400, true);
#endif

  // initialize serial communication
  // (115200 chosen because it is required for Teapot Demo output, but it's
  // really up to you depending on your project)
  Serial.begin(115200);
  while (!Serial); // wait for Leonardo enumeration, others continue immediately


  // initialize device
  // Serial.println(F("Initializing I2C devices..."));
  mpu.initialize();
  pinMode(INTERRUPT_PIN, INPUT);
  pinMode(INTERRUPT_PIN1, INPUT);
  
  // verify connection
  // Serial.println(F("Testing device connections..."));
  // Serial.println(mpu.testConnection() ? F("MPU6050 connection successful") : F("MPU6050 connection failed"));

  // wait for ready
  /*Serial.println(F("\nSend any character to begin DMP programming and demo: "));
  while (Serial.available() && Serial.read()); // empty buffer
  while (!Serial.available());                 // wait for data
  while (Serial.available() && Serial.read()); // empty buffer again*/

  // load and configure the DMP
  //Serial.println(F("Initializing DMP..."));
  devStatus = mpu.dmpInitialize();
  devStatus1 = mpu1.dmpInitialize();  // second MPU

  // supply your own gyro offsets here, scaled for min sensitivity
  mpu.setXGyroOffset(220);
  mpu.setYGyroOffset(76);
  mpu.setZGyroOffset(-85);
  mpu.setZAccelOffset(1788); // 1688 factory default for my test chip
  
  mpu1.setXGyroOffset(220);
  mpu1.setYGyroOffset(76);
  mpu1.setZGyroOffset(-85);
  mpu1.setZAccelOffset(1788); // 1688 factory default for my test chip 

  // make sure it worked (returns 0 if so)
  if (devStatus == 0) {
    // turn on the DMP, now that it's ready
    // Serial.println(F("Enabling DMP..."));
    mpu.setDMPEnabled(true);
    
    // enable Arduino interrupt detection
    //Serial.println(F("Enabling interrupt detection (Arduino external interrupt 0)..."));
    attachInterrupt(digitalPinToInterrupt(INTERRUPT_PIN), dmpDataReady, RISING);
    mpuIntStatus = mpu.getIntStatus();

    // set our DMP Ready flag so the main loop() function knows it's okay to use it
    // Serial.println(F("DMP ready! Waiting for first interrupt..."));
    dmpReady = true;

    // get expected DMP packet size for later comparison
    packetSize = mpu.dmpGetFIFOPacketSize();
  } else {
    // ERROR!
    // 1 = initial memory load failed
    // 2 = DMP configuration updates failed
    // (if it's going to break, usually the code will be 1)
    //Serial.print(F("DMP Initialization failed (code "));
    //Serial.print(devStatus);
    //Serial.println(F(")"));
  }

if (devStatus1 == 0) {
    // turn on the DMP, now that it's ready
    // Serial.println(F("Enabling DMP..."));
    mpu1.setDMPEnabled(true);
    
    attachInterrupt(digitalPinToInterrupt(INTERRUPT_PIN1), dmpDataReady1, RISING);
    mpuIntStatus1 = mpu1.getIntStatus();
    dmpReady1 = true;
    packetSize1 = mpu1.dmpGetFIFOPacketSize();
    }
  // configure LED for output
  pinMode(LED_PIN, OUTPUT);
}



// ================================================================
// ===                    MAIN PROGRAM LOOP                     ===
// ================================================================

void loop() {
  // if programming failed, don't try to do anything
  if (!dmpReady) return;
  if (!dmpReady1) return;

  // wait for MPU interrupt or extra packet(s) available
  while (!mpuInterrupt1 && fifoCount1 < packetSize1) {

  }
  while (!mpuInterrupt && fifoCount < packetSize) {

  }

  // reset interrupt flag and get INT_STATUS byte
  mpuInterrupt = false;
  mpuIntStatus = mpu.getIntStatus();
  
  mpuInterrupt1 = false;
  mpuIntStatus1 = mpu1.getIntStatus();

  // get current FIFO count
  fifoCount = mpu.getFIFOCount();
  fifoCount1 = mpu1.getFIFOCount(); 

  // check for overflow (this should never happen unless our code is too inefficient)
  if ((mpuIntStatus & 0x10) || fifoCount == 1024) {
    // reset so we can continue cleanly
    mpu.resetFIFO();
    //Serial.println(F("FIFO overflow!"))
    
    // otherwise, check for DMP data ready interrupt (this should happen frequently)
  } else if (mpuIntStatus & 0x02) {
    // wait for correct available data length, should be a VERY short wait
    while (fifoCount < packetSize) fifoCount = mpu.getFIFOCount();

    // read a packet from FIFO
    mpu.getFIFOBytes(fifoBuffer, packetSize);

    // track FIFO count here in case there is > 1 packet available
    // (this lets us immediately read more without waiting for an interrupt)
    fifoCount -= packetSize;


    mpu.dmpGetQuaternion(&q, fifoBuffer);
    mpu.dmpGetAccel(&aa, fifoBuffer);
    mpu.dmpGetGravity(&gravity, &q);
    mpu.dmpGetLinearAccel(&aaReal, &aa, &gravity);

    int q = abs(aaReal.x - last.x);
    q += abs(aaReal.y - last.y);
    q += abs(aaReal.z - last.z);

    q /= 3;

    Serial.print("accel1=");
    Serial.println(q);
    delay(200);
    last.x = aaReal.x;
    last.y = aaReal.y;
    last.z = aaReal.z;

    // blink LED to indicate activity
    blinkState = !blinkState;
    digitalWrite(LED_PIN, blinkState);
  }
  
  if ((mpuIntStatus1 & 0x10) || fifoCount1 == 1024) {
    // reset so we can continue cleanly
    mpu1.resetFIFO();
    //Serial.println(F("FIFO overflow!"))
    
    // otherwise, check for DMP data ready interrupt (this should happen frequently)
  } else if (mpuIntStatus1 & 0x02) {
    // wait for correct available data length, should be a VERY short wait
    while (fifoCount1 < packetSize1) fifoCount1 = mpu1.getFIFOCount();

    // read a packet from FIFO
    mpu1.getFIFOBytes(fifoBuffer1, packetSize1);

    // track FIFO count here in case there is > 1 packet available
    // (this lets us immediately read more without waiting for an interrupt)
    fifoCount1 -= packetSize1;


    mpu1.dmpGetQuaternion(&q1, fifoBuffer1);
    mpu1.dmpGetAccel(&aa1, fifoBuffer1);
    mpu1.dmpGetGravity(&gravity1, &q1);
    mpu1.dmpGetLinearAccel(&aaReal1, &aa1, &gravity1);

    int q1 = abs(aaReal1.x - last1.x);
    q1 += abs(aaReal1.y - last1.y);
    q1 += abs(aaReal1.z - last1.z);

    q1 /= 3;

    Serial.print("accel2=");
    Serial.println(q1);
    delay(200);
    last1.x = aaReal1.x;
    last1.y = aaReal1.y;
    last1.z = aaReal1.z;

    // blink LED to indicate activity
    blinkState = !blinkState;
    digitalWrite(LED_PIN, blinkState);
  }
}

Hors ligne

 

fil rss de cette discussion : rss

Pied de page des forums

Powered by FluxBB

codelab, graphisme & code : emoc / 2008-2017