Code source autonome

Capteur - Accéléromètre - LG-ADXL345 en I2C

Bonjour,

Ce tutoriel explique comment monter un circuit qui utilise :

 Une carte Arduino Uno
 Une planche d'expérimentation "Solderless Breadboard"
 Un capteur infrarouge TSOP1838 (VS1838B)
 Une mini télécommande style MP3
 Un bouton-poussoir "Push Button Switches" à 4 pattes
 Un capteur accéléromètre LG-ADXL345 en communication I2C.

Que fait ce programme :

Ce programme utilise la communication I2C pour récupérer les données de base des trois axes (x, y, et z) d'un capteur accéléromètre LG-ADXL345 et affiche ces données dans le moniteur série de l'éditeur Arduino. De plus, il y a l'utilisation d'un bouton 4 broches et d'un capteur à infrarouge et d'une télécommande associée pour le contrôle d'une boucle initiale dans la section « setup () » et l'équivalant dans la section « loop () ».

Le code source :

En soi, le code source est très explicite et donne tous les détails requis pour son utilisation et le montage du circuit à réaliser.

Faites un copier-coller de ce code source dans l'éditeur Arduino et prenez le temps de le lire avant de l'exécuter, vous serez à même d'en apprécier toute la richesse et cela vous évitera bien des écueils.

Notez que le code source est plus lisible une fois copié dans l'éditeur Arduino. Ici la largeur d'une ligne de code n'est que de 40 à 50 caractères et le code source est mis en page pour une présentation sur 80 colonnes. Aussi, la coloration et la tabulation du code sont plus conforment et intéressantes dans l'éditeur Arduino. De ces faits, ici plusieurs lignes sont très difficiles a interpréter.


//*****************************************************************************
// Programme Arduino : ArduinoUnoBoutonTeleMP3_LG_ADXL345_Basic
//*****************************************************************************
/*
Écrit par : René Ross

Date : 2013-08-25

Que fait ce programme :

Ce programme utilise la communication I2C pour récupérer les données de base
des trois axes (x, y, et z) d'un capteur accéléromètre LG-ADXL345 et affiche
ces données dans le moniteur série de l'éditeur Arduino. De plus, il y a
l'utilisation d'un bouton 4 broches et d'un capteur à infrarouge et d'une
télécommande associée pour le contrôle d'une boucle initiale dans la section
« setup () » et l'équivalant dans la section « loop () ».

Bibliothèques utilisées :
https://github.com/shirriff/Arduino-IRremote
http://arduino.cc/en/Reference/Wire

Autres exemples d'utilisation en date du 6 aout 2013 :
https://www.sparkfun.com/tutorials/240
http://www.varesano.net/blog/fabio/exploring-advanced-features-adxl345-accelerometer-single-double-tap-activity-inactivity-f
http://codeyoung.blogspot.ca/2009/11/adxl345-accelerometer-breakout-board.html
http://bildr.org/2011/03/adxl345-arduino/
*/

//*****************************************************************************
// Matériel requis :
//*****************************************************************************
/*
1 x Contrôleur Arduino Uno :
http://arduino.cc/en/Main/ArduinoBoardUno
http://www.atmel.com/devices/atmega328.aspx
http://dx.com/p/funduino-uno-r3-mega328p-board-for-hw-sw-engineers-development-tools-150802
http://dx.com/p/robotale-uno-atmega8u2-development-board-with-usb-cable-blue-178262
http://dx.com/p/uno-r3-development-board-microcontroller-mega328p-atmega16u2-compat-for-arduino-blue-black-215600

1 x Planche d'expérimentation Circuit-Test MB-102J « BreadBoard » :
http://www.circuittest.com/mb-102j-breadboard-166x54x9mm-830-holes-with-70pc-wiring-kit.html

1 x Petit transformateur 110V à 9V, 1A pour Arduino :
http://dx.com/p/arduino-9v-1a-power-adapter-black-2-flat-pin-plug-100cm-cable-126288

1 x Mini télécommande type MP3 :
http://dx.com/p/ir-remote-control-diy-kit-for-arduino-1-x-cr2025-136284

1 x Capteur infra-rouge VS1838B :
http://www.dipmicro.com/store/VS1838B
http://dx.com/s/1838

1 x Condensateur 100uF 10V
1 x Condensateur 104
1 x Résistance 100 Ohm
1 x Résistance 20 KOhm

1 x Bouton-poussoir "Push Button Switches" a 4 pattes :
http://dx.com/p/square-style-electrical-power-control-4-pin-push-button-switches-10-pcs-158030

1 x Capteur accéléromètre LG-ADXL345 avec communication i2c :
http://www.analog.com/ADXL345
http://dx.com/p/adxl345-digital-sensor-acceleration-module-for-arduino-150968

Et des petits câbles électriques et connecteurs appropriés (mâle mâle, femelle
femelle et mâle femelle). Pour référence : MB-940, MB-910, MB-900, MB-102J,
LS-MMPJ-6, LS-FFPJ-6, etc. :
http://www.circuittest.com/mb-102j-breadboard-166x54x9mm-830-holes-with-70pc-wiring-kit.html
http://dx.com/p/breadboard-jumper-cables-wires-for-electronic-diy-100-male-to-male-40-female-to-female-203948
http://dx.com/p/breadboard-jumper-wires-for-electronic-diy-65-cable-pack-118826
http://dx.com/p/male-to-female-dupont-breadboard-jumper-wires-for-arduino-40-piece-pack-20cm-length-146935
http://dx.com/p/dupont-line-1p-1p-40-pack-20cm-length-121338
http://dx.com/p/30cm-breadboard-wires-for-electronic-diy-40-cable-pack-80207
http://dx.com/p/2-54mm-1x40-pin-breakaway-straight-male-header-10-piece-pack-144191
http://dx.com/p/breadboard-jumper-wire-cord-kit-for-arduino-diy-140-piece-pack-138220
*/

//*****************************************************************************

//*****************************************************************************
// Circuit à réaliser.
//*****************************************************************************
/*
Dans cette section, toutes les connexions des composantes du montage sont
listé, qu'ils soient utilisés ou non, et cela pour éviter tout oublie et
rendre le copier / coller par bloc complet pour une pièce plus facile d'un
montage à l'autre. Le plus souvent possible le libelle de la pièce précédé du
nom court de la pièce est utilisé, par exemple « ARDUINO_A3 », pour la broche
analogique A3 d'une carte contrôleur Arduino Uno R3.

Plaque d'expérimentation « BreanBoard » :

Pour identifier les broches d'une plaque d'expérimentation « BreanBoard »,
comme dans le jeu de bataille navale "Battle Ship", les lignes sont identifiées
pas des numéro (ici, de 1 a 63) et les colonnes sont identifiées par lettre des
lettres (ici, de a a j) et des signes (+) et (-). Donc (i10) indique
l'intersection de la colonne "i" avec la ligne numéro "10". Pour une broche
des colonnes négatives (-) ou GND et positives (+) ou Vcc, c'est le
signe de la colonne « + » ou « - », suivi du numéro de la rangée (de 1 a 63),
et suivit du côté de la plaque en majuscule, gauche « G » ou droite « D ».
Donc pour la colonne positive de la rangée 3, côté gauche, cela donne (+3G).
Le tout entre parenthèse « ( » et « ) » pour bien spécifier une position de la
planche d'expérimentation et pour éviter toutes confusions.
*/

/*
Câblage de l'Arduino Uno sur une planche d'expérimentation MB-104 :

ARDUIBO_USB    : Câble USB à l'ordinateur
ARDUIBO_PWR12V : Transformateur 110V à 9V ou batteries de 6V~12V

ARDUIBO_RECET  : câble à ARDUIBO_12
ARDUIBO_3_3V   :
ARDUIBO_5V_1   : (+52D) et câble de (+54D) à (+54G)
ARDUIBO_GND1   : (-53D) et câble de (-55D) à (-55G)
ARDUIBO_GND2   :
ARDUIBO_VIN    :

ARDUIBO_A0     :
ARDUIBO_A1     :
ARDUIBO_A2     :
ARDUIBO_A3     :
ARDUIBO_A4_SDA : ACCELEROMETRE_1_SDA, (c48)
ARDUIBO_A5_SCL : ACCELEROMETRE_1_SCL, (b47)

ARDUIBO_0_RX0  :
ARDUIBO_1_TX0  :
ARDUIBO_2      : (i63), l'état du bouton
ARDUIBO_3_PWM  : (j57), la sortie du capteur infrarouge
ARDUIBO_4      :
ARDUIBO_5_PWM  :
ARDUIBO_6_PWM  :
ARDUIBO_7      :

ARDUIBO_8      :
ARDUIBO_9_PWM  :
ARDUIBO_10_PWM :
ARDUIBO_11_PWM :
ARDUIBO_12     : câble à ARDUIBO_RECET
ARDUIBO_13     :
ARDUIBO_GND3   :
ARDUIBO_AREF   :

Câblage pour le capteur infra-rouge utiliser avec la télécommande, sur la
planche d'expérimentation  :

CAPTEUR_IR_1_SORTIE broche 1 : (f57) et câble de (j57) à ARDUIBO_3_PWM
CAPTEUR_IR_1_GND broche 2    : (f58) et câble de (j58) à (-58D)
CAPTEUR_IR_1_VIN broche 3    : (f59)
Condensateur 104 broche 1    : (g58)
Condensateur 104 broche 2    : (g59)
Condensateur 100uF 10V-      : (h58)
Condensateur 100uF 10V+      : (h59)
Résistance 100 Ohm 1         : (j59)
Résistance 100 Ohm 2         : (+59D)
Résistance 20 KOhm 1         : (i57)
Résistance 20 KOhm 2         : (i59)

Câblage pour le gros bouton sur la planche d'expérimentation  :

BOUTON_1Broche_1     : (d61)
BOUTON_1Broche_2     : (d63)
BOUTON_1Broche_3     : (g63) et câble de (i63) à ARDUIBO_2
BOUTON_1Broche_4     : (g61) et câble de (j61) à (+61D)
Résistance 100 Ohm 1 : (j63)
Résistance 100 Ohm 2 : (-61D)

Câblage pour le module LG-ADXL345 en i2c, sur la la planche d'expérimentation :

ACCELEROMETRE_1_SCL  broche  1 : (a41) et câble de (b41) à (b47) ARDUIBO_A5_SCL
ACCELEROMETRE_1_SDA  broche  2 : (a42) et câble de (c42) à (c48) ARDUIBO_A4_SDA
ACCELEROMETRE_1_SDO  broche  3 :
ACCELEROMETRE_1_INT2 broche  4 :
ACCELEROMETRE_1_INT1 broche  5 :
ACCELEROMETRE_1_CS   broche  6 : (i45) et câble de (j45) à (+45D)
ACCELEROMETRE_1_VS   broche  7 :
ACCELEROMETRE_1_GND  broche  8 : (i43) et câble de (j43) à (-43D)
ACCELEROMETRE_1_3V3  broche  9 :
ACCELEROMETRE_1_5V   broche 10 : (i41) et câble de (j41) à (+41D)
*/

//*****************************************************************************

//*****************************************************************************
// Inclusion des librairies utilisées.
//*****************************************************************************
#include <IRremote.h>
/*
Il s'agit de la bibliothèque irRemote pour l'Arduino.

Pour télécharger depuis github :

http://github.com/shirriff/Arduino-IRremote

Cliquez sur le lien "Télécharger" en haut à droite, cliquez sur « Télécharger
au format Zip", pour obtenir un fichier zip. Décompressez-le et renommez le
répertoire « Shirriff-Arduino-irRemote-NNN » pour « irRemote ». Pour
l'installer, déplacer le répertoire de irRemote téléchargée dans votre dossier
des bibliothèque Arduino « ~/Arduino/libraries/IRremote ». Pour avoir accès à la
nouvelle bibliothèque, vous devez redémarrer l'éditeur Arduino. Pour plus de
détails sur la bibliothèque voir le wiki sur github ou le poste :

http://arcfn.com/2009/08/multi-protocol-infrared-remote-library.html blog

Copyright 2009-2012 Ken Shirriff

Merci à cette personne pour sa contribution !
*/


#include <Wire.h>
/*
Cette bibliothèque vous permet de communiquer avec des périphériques I2C/TWI.
Sur les cartes Arduino révision R3, les broches SDA (ligne de données) et SCL
(ligne d'horloge) sont à proximité de la broche AREF.

En référence le tableau ci-dessous montre ont situés les broches avec les cartes
Arduino.

Carte         Broches I2C / TWI
Uno, Ethernet A4 (SDA), A5 (SCL)
Mega2560      20 (SDA), 21 (SCL)
Leonardo       2 (SDA), 3 (SCL)
Due           20 (SDA), 21 (SCL), SDA1, SCL1

Avec Arduino version 1.0 et plus, la bibliothèque hérite des fonctions de flux,
ce qui rend compatible avec les autres bibliothèques en lecture/écriture. Pour
cette raison, « send () » et « receive () » ont été remplacés par « read () » et
« write () ».

Remarque :

Il y a deux variante d'adresse de communication I2C, une de 7 bits et une de
8 bits. La variante 7 bits identifier le dispositif et le huitième bit
détermine si elle est en cours d'écriture ou de lecture à partir. La
bibliothèque de fil utilise des adresses 7 bits partout. Si vous avez un code
de fiche ou d'échantillon qui utilise 8 bits d'adresse, vous aurez besoin de
laisser tomber le bit bas, c'est a dire, de décaler la valeur d'un bit vers la
droite), ce qui donne une adresse entre 0 et 127.

Référence : http://arduino.cc/en/Reference/Wire
*/

//*****************************************************************************

//*****************************************************************************
// Déclaration des constantes.
//*****************************************************************************
/*
Par convention, pour nommer une constante, nous utiliserons des noms écrits
tout en majuscule, en capitale, ce qui facilitera leur repérage et rendra le
code plus facilement compréhensible. Le mot devant notre nom de constante
indique à l'Arduino l'espace mémoire à réserver pour stocker cette donnée.
Après le nom de notre constante, on lui attribue sa valeur.
*/

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « ENTREE » est l'équivalent du paramètre « INPUT ». Ce paramètre
est pour prépare l'Arduino a recevoir une tension électrique pour ce
connecteur, sur ce port de communication, sur ce "pin".
*/

const byte ENTREE = INPUT;

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « ENTREE_ET_RESISTENCE_INTERNE » est l'équivalent du paramètre
« INPUT_PULLUP ». Ce paramètre est pour prépare l'Arduino en activant sa
résistance interne et a recevoir une tension électrique pour ce connecteur,
sur ce port de communication, sur ce "pin".
*/

const byte ENTREE_ET_RESISTENCE_INTERNE = INPUT_PULLUP;

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « SORTIE » est l'équivalent du paramètre « OUTPUT ». Ce paramètre
est pour prépare l'Arduino a émettre une tension électrique pour ce connecteur,
sur ce port de communication, sur ce "pin".
*/

const byte SORTIE = OUTPUT;

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « HAUT » est l'équivalent du paramètre « HIGH ». Ce paramètre fait
que l'Arduino maintiendra un voltage haut sur ce connecteur, soit 3.3 Volts,
soit 5 Volts, selon sa propre tension d'alimentation. En électronique, cela
correspondra aux valeurs logiques « 1 », « Oui », ou « Vrai », etc.
*/

const byte HAUT = HIGH;

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « BAS » est l'équivalent du paramètre « LOW ». Ce paramètre fait
que l'Arduino maintiendra un voltage bas sur ce connecteur, soit 0 Volt. En
électronique, cela correspondra aux valeurs logiques « 0 », « Non », ou
« Faut », etc.
*/

const byte BAS = LOW;

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « NON » est l'équivalent du paramètre « false », cela
correspondra aux valeurs logiques « 0 », « Non », ou « Faut », etc.
*/

const byte NON = false;

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « OUI » est l'équivalent du paramètre « true », cela
correspondra aux valeurs logiques « 1 », « Oui », ou « Vrai », etc.
*/

const byte OUI = true;

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « FAUX » est l'équivalent du paramètre « false », cela
correspondra aux valeurs logiques « 0 », « Non », etc.
*/

const byte FAUX = false;

/*
Constante pour franciser le code source du programme. Ici nous définissons que
la constante « VRAI » est l'équivalent du paramètre « true », cela
correspondra aux valeurs logiques « 1 », « Oui », etc.
*/

const byte VRAI = true;
//*****************************************************************************

//*****************************************************************************
// Constantes des connecteurs.
//*****************************************************************************
// Pour gérer l'action d'humains le bouton de la planche d'expérimentation.
const int BOUTON_1_SORTIE = 2;

// Broche d'Arduino pour recevoir le signale du capteur infrarouge.
const int CAPTEUR_IR_1_SORTIE = 3;

// En prévision d'un ARDUINO_RESET par télécommande.
const int ARDUINO_RESET = 12;

// Pour Activer et Déactiver la DEL sur le contrôleur Arduino.
const int ARDUINO_DEL = 13;

// Broche d'Arduino pour communication I2C avec accéléromètre LG-ADXL345.
const int ACCELEROMETRE_1_SCL = A5;
const int ACCELEROMETRE_1_SDA = A4;
//*****************************************************************************

//*****************************************************************************
// Déclaration des variables globales.
//*****************************************************************************
/*
Par convention, pour nommer une variable, nous utiliserons des noms écrits
avec un majuscule pour la première lettre de chaque mot composant le nom de la
variable, ce qui facilitera leur repérage et rendra le code plus facilement
compréhensible. Le mot devant notre nom de variable indique à l'Arduino l'espace
mémoire à réserver pour stocker cette donnée. Après le nom de notre variable, on
lui attribue sa valeur.
*/

/*
Ici, nous définissons la variable qui contrôlera la grande boucle principale,
qui s'active avec le bouton « Power » de la télécommande. Par défaut, le robot
ne fait rien a l’exception d'initialiser ses périphériques.
*/

boolean Boucler = NON;

// Pour la fonction « delay », qui compte le temps en milliseconde.
int UneSeconde = 1000;

// Délai pour réduire la vitesse de réaction entre les lectues des boutons.
int TempsRebonBouton = 5;

/*
Définition de la valeur retourné par les boutons de la télécommande.
*/

const unsigned long TelecommandeBoutonPower     = 16753245;
const unsigned long TelecommandeBoutonMode      = 16736925;
const unsigned long TelecommandeBoutonSon       = 16769565;
const unsigned long TelecommandeBoutonPlayPause = 16720605;
const unsigned long TelecommandeBoutonDebut     = 16712445;
const unsigned long TelecommandeBoutonFin       = 16761405;
const unsigned long TelecommandeBoutonEQ        = 16769055;
const unsigned long TelecommandeBoutonMoins     = 16754775;
const unsigned long TelecommandeBoutonPlus      = 16748655;
const unsigned long TelecommandeBouton0         = 16738455;
const unsigned long TelecommandeBoutonRecycle   = 16750695;
const unsigned long TelecommandeBoutonU_SD      = 16756815;
const unsigned long TelecommandeBouton1         = 16724175;
const unsigned long TelecommandeBouton2         = 16718055;
const unsigned long TelecommandeBouton3         = 16743045;
const unsigned long TelecommandeBouton4         = 16716015;
const unsigned long TelecommandeBouton5         = 16726215;
const unsigned long TelecommandeBouton6         = 16734885;
const unsigned long TelecommandeBouton7         = 16728765;
const unsigned long TelecommandeBouton8         = 16730805;
const unsigned long TelecommandeBouton9         = 16732845;
// Pour contenir la valeur du dernier bouton pressé.
      unsigned long TelecommandeBoutonValeur = 0;

// Adresses de communication I2C avec accéléromètre ADXL345.
const char Accellerometre3AxesAdresse = 0x53;
byte Accellerometre3AxesMemoire [6];
const char POWER_CTL = 0x2D;// Régistre "Power Control".
const char DATA_FORMAT = 0x31;// Régistre "Data Format".
const char DATAX0 = 0x32;//X-Axis Data 0
const char DATAX1 = 0x33;//X-Axis Data 1
const char DATAY0 = 0x34;//Y-Axis Data 0
const char DATAY1 = 0x35;//Y-Axis Data 1
const char DATAZ0 = 0x36;//Z-Axis Data 0
const char DATAZ1 = 0x37;//Z-Axis Data 1

const char Accellerometre_1_Precision2G  = 0x00;
const char Accellerometre_1_Precision4G  = 0x01;
const char Accellerometre_1_Precision8G  = 0x02;
const char Accellerometre_1_Precision16G = 0x03;
const char Accellerometre_1_ModeMesure   = 0x08;

// Pour recevoir les valeurs des 3 axes de l'accéléromètre.
int Accelerometre1_AxeX = 0;
int Accelerometre1_AxeY = 0;
int Accelerometre1_AxeZ = 0;
//*****************************************************************************

//*****************************************************************************
// Création en mémoire des objet pour les interfaces des périphériques.
//*****************************************************************************
// Pour le capteur infrarouge crée un objet sur la broche voulue.
IRrecv         Capteur_IR_1 (CAPTEUR_IR_1_SORTIE);
decode_results Capteur_IR_1_Results;
// ...
//*****************************************************************************

//*****************************************************************************
// FONCTION SETUP = Code d'initialisation.
//*****************************************************************************
/*
La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du
programme. Pour éviter de mettre des composantes sous tension avec la dernière
version du programme chargé dans l'Arduino, Nous utilisant une boucle « while »,
tant qu'une première action n'est pas accompli par l'utilisateur, on ne fait
rien (Télécommande, bouton, etc.).

L'activation du rappel au + interne des connecteurs en entrée si nécessaire.
L'instruction « digitalWrite (pin, HIGH); » écrit la valeur HIGH, qui vaux 1
sur le connecteur en entrée, ce qui active la résistance de "rappel au +"
(pullup) au plus de ce connecteur. L'utilisation de cette résistance interne
est une protection minimale pour l'intégrité physique pour la puce principale.
*/

void setup ()
{
  // Ici les instructions à exécuter au démarrage.

  // IMPORTANT : régler le terminal côté PC avec la même valeur de
  // transmission. Ici c'est 115200.
  Serial.begin (115200);
  // Pour affichage dans le moniteur série de l'éditeur Arduino.
  Serial.print ("********************************************************");
  Serial.println ();
  Serial.print ("* Debut de la procedure d'initialisation du systeme... *");
  Serial.println ();
  Serial.print ("********************************************************");
  Serial.println ();
  Serial.print ("*    Attente du bouton (Power) de la telecommande...   *");
  Serial.println ();
  Serial.print ("********************************************************");
  Serial.println ();
  Serial.println ();

  // Connecteurs en entrées et sorties.

  // Pour le bouton Marche/Arrêt sur la planche d'expérimentation.
  // Configurer le port Arduino en entrée pour le bouton.
  pinMode (BOUTON_1_SORTIE, ENTREE);
  // Activer la résistance au plus PULLUP.
  digitalWrite (BOUTON_1_SORTIE, HAUT);

  // Configurer le port Arduino en entrée pour le capteur infrarouge.
  pinMode (CAPTEUR_IR_1_SORTIE, ENTREE);
  // Initialisation et début de la réception du capteur infrarouge.
  Capteur_IR_1.enableIRIn ();

  // Boucle pour éviter qu'un ancien programme chargé ne s'exécute avec un
  // nouveau montage installé, en attente du chargement du nouveau programme.
  // Jusqu'ici, c'est le minimum qui est activé, le reste des connexions
  // seront activé après la boucle d'attente.
  while (Boucler != OUI)
  {
    GererBoutonMarcheArret ();
    GererBoutonTeleCommande ();
  }
  // Active la DEL de l'Arduino.
  pinMode (ARDUINO_DEL, SORTIE);
  digitalWrite (ARDUINO_DEL, Boucler);

  // Initialisation de la communication i2c bus pour le capteur d'acceleration.
  Wire.begin ();
  // Mettre le ADXL345 à plage +/-4G en écrivant la valeur 0x01 dans le
  // registre DATA_FORMAT.
  AccellerometreConfigure (DATA_FORMAT, Accellerometre_1_Precision4G);
  // Mettre le ADXL345 en mode de mesure en écrivant 0x08 dans le registre
  // POWER_CTL.
  AccellerometreConfigure (POWER_CTL, Accellerometre_1_ModeMesure);

  // Pour affichage dans le moniteur série de l'éditeur Arduino.
  Serial.print ("********************************************************");
  Serial.println ();
  Serial.print ("*  Fin de la procedure d'initialisation du systeme...  *");
  Serial.println ();
  Serial.print ("********************************************************");
  Serial.println ();
  Serial.println ();
}
//*****************************************************************************

//*****************************************************************************
// FONCTION LOOP = Boucle sans fin = coeur du programme.
//*****************************************************************************
/* La fonction loop() s'exécute sans fin en boucle aussi longtemps que
l'Arduino est sous tension.
*/


void loop()
{
  // Ici les instructions à exécuter par le programme principal.
  GererBoutonTeleCommande ();
  GererBoutonMarcheArret ();
  if (Boucler == OUI)
  {
    // C'est ici que vous ajoutez le code spécifique a votre montage.
    AccellerometreLecture ();
    Serial.print (" AxeX:");
    Serial.print (Accelerometre1_AxeX);
    Serial.println ();
    Serial.print (" AxeY:");
    Serial.print (Accelerometre1_AxeY);
    Serial.println ();
    Serial.print (" AxeZ:");
    Serial.print (Accelerometre1_AxeZ);
    Serial.println ();
    Serial.println ();
    delay (UneSeconde);
  }
}
//*****************************************************************************

//*****************************************************************************
//*****************************************************************************
//***************************** Fin du programme. *****************************
//*****************************************************************************
//*****************************************************************************

//*****************************************************************************
// FONCTION GererBoutonMarcheArret
//*****************************************************************************
/*
Gestion de l'utilisation d'un bouton sur la planche d'expérimentation.
*/

void GererBoutonMarcheArret ()
{
  int EtatBouton = digitalRead (BOUTON_1_SORTIE);
  if (EtatBouton == HAUT)
  {
    Serial.print ("Le bouton Marche Arret enclenche");
    Serial.println ();
    if (Boucler == OUI)
    {
      Boucler = NON;
      // Éteindre la DEL de l'Arduino.
      digitalWrite (ARDUINO_DEL, Boucler);
      Serial.print ("En attente d'une action d'humaine");
      Serial.println ();
    }
    else
    {
      Boucler = OUI;
      // Allumer la DEL de l'Arduino.
      digitalWrite (ARDUINO_DEL, Boucler);
      Serial.print ("Poursuite du programme");
      Serial.println ();
    }
    while (EtatBouton == HAUT)
    {
      // Pour absorber les micro-coupures des rebonds (minimum 5 ms).
      delay (TempsRebonBouton);
      EtatBouton = digitalRead (BOUTON_1_SORTIE);
    }
  }
}
//*****************************************************************************

//*****************************************************************************
// FONCTION GererBoutonTeleCommande
//*****************************************************************************
/*
Gérer l'utilisation d'une télécommande type MP3 avec capteur infrarouge.

Ici tous les boutons de la télécommande sont listés et la majorité ont un
effet sur le déroulement de de la boucle principale ou sur les paramètres de
fonctionnement du moteur ou les deux  la fois et la touche « Mode » est
l'actionneur de la broche RESET de la carte Arduino, donc du redémarrage du
Système complet.

En synthèse les boutons font :

Power     : Active/désactive la boucle principale du programme, arrêt moteur.
Mode      : Bouton kamikaze qui utilise la broche RESET de la carte Arduino.
Son       :
PlayPause :
Debut     :
Fin       :
EQ        :
Moins     :
Plus      :
0         :
Recycle   :
U_SD      :
1         :
2         :
3         :
4         :
5         :
6         :
7         :
8         :
9         :
default   : Une télécommande génère beaucoup d'autres codes qui sont inutiles ici.
*/

void GererBoutonTeleCommande ()
{
  if (Capteur_IR_1.decode (&Capteur_IR_1_Results))
  {
    Capteur_IR_1.resume (); // Récupérer la valeur suivante.
    TelecommandeBoutonValeur = Capteur_IR_1_Results.value;
    switch (TelecommandeBoutonValeur)
    {
      case TelecommandeBoutonPower:
        Serial.print (" TelecommandeBoutonPower : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        if (Boucler == OUI)
        {
          Boucler = NON;
          digitalWrite (ARDUINO_DEL, Boucler);
          Serial.print ("En attente d'une action d'humaine");
          Serial.println ();
          digitalWrite (ARDUINO_DEL, Boucler);
        }
        else
        {
          Boucler = OUI;
          digitalWrite (ARDUINO_DEL, Boucler);
          Serial.print ("Poursuite du programme");
          Serial.println ();
          digitalWrite (ARDUINO_DEL, Boucler);
        }
        break;
      case TelecommandeBoutonMode:
        Serial.print (" TelecommandeBoutonMode : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        Serial.print (" Redemarrage du controleur Arduino!! ");
        Serial.println ();
        delay (UneSeconde);
        // Configurer le port Arduino pour un RESET par télécommande.
        pinMode (ARDUINO_RESET, SORTIE);
        // Activer la broche ARDUINO_RESET.
        digitalWrite (ARDUINO_RESET, BAS);
        delay (UneSeconde);
        break;
      case TelecommandeBoutonSon:
        Serial.print (" TelecommandeBoutonSon : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBoutonPlayPause:
        Serial.print (" TelecommandeBoutonPlayPause : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBoutonDebut:
        Serial.print (" TelecommandeBoutonDebut : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBoutonFin:
        Serial.print (" TelecommandeBoutonFin : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBoutonEQ:
        Serial.print (" TelecommandeBoutonEQ : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBoutonMoins:
        Serial.print (" TelecommandeBoutonMoins : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBoutonPlus:
        Serial.print (" TelecommandeBoutonPlus : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBouton0:
        Serial.print (" TelecommandeBouton0 : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBoutonRecycle:
        Serial.print (" TelecommandeBoutonRecycle : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBoutonU_SD:
        Serial.print (" TelecommandeBoutonU_SD : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBouton1:
        Serial.print (" TelecommandeBouton1 : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBouton2:
        Serial.print (" TelecommandeBouton2 : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBouton3:
        Serial.print (" TelecommandeBouton3 : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBouton4:
        Serial.print (" TelecommandeBouton4 : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBouton5:
        Serial.print (" TelecommandeBouton5 : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBouton6:
        Serial.print (" TelecommandeBouton6 : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBouton7:
        Serial.print (" TelecommandeBouton7 : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBouton8:
        Serial.print (" TelecommandeBouton8 : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      case TelecommandeBouton9:
        Serial.print (" TelecommandeBouton9 : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
        break;
      default:
        Serial.print (" Code inconnu : ");
        Serial.print (TelecommandeBoutonValeur);
        Serial.println ();
    }
  }
  while (Capteur_IR_1.decode (&Capteur_IR_1_Results))
  {
    // Pour absorber les micro-coupures des rebonds (minimum 5 ms).
    delay (TempsRebonBouton);
    Capteur_IR_1.resume (); // Récupéré la valeur suivante.
    TelecommandeBoutonValeur = Capteur_IR_1_Results.value;
  }
}
//*****************************************************************************

//*****************************************************************************
// FONCTION AccellerometreConfigure
//*****************************************************************************
void AccellerometreConfigure (byte address, byte val)
{
  // Commencer la transmission à trois axes accéléromètre
  Wire.beginTransmission (Accellerometre3AxesAdresse);
  // Envoyer l'adresse de registre
  Wire.write (address);
  // Envoyer la valeur à écrire.
  Wire.write (val);
  // Fin de la transmission.
  Wire.endTransmission ();
}
//*****************************************************************************

//*****************************************************************************
// FONCTION AccellerometreLecture ()
//*****************************************************************************
void AccellerometreLecture ()
{
  uint8_t NombreOctets_a_Lire = 6;
  // Lire les données d'accélération à partir du module ADXL345.
  AccellerometreLectureMemoire (DATAX0, NombreOctets_a_Lire,
                                Accellerometre3AxesMemoire);

  // Chaque lecture de l'axe vient dans une résolution de 10 bits, soit 2 octets.
  // Première Octet significatif !
  // Donc nous convertissons les deux octets pour un « int ».
  Accelerometre1_AxeX = (((int)Accellerometre3AxesMemoire[1]) << 8) |
      Accellerometre3AxesMemoire[0];
  Accelerometre1_AxeY = (((int)Accellerometre3AxesMemoire[3]) << 8) |
      Accellerometre3AxesMemoire[2];
  Accelerometre1_AxeZ = (((int)Accellerometre3AxesMemoire[5]) << 8) |
      Accellerometre3AxesMemoire[4];
}
//*****************************************************************************

//*****************************************************************************
// FONCTION AccellerometreLectureMemoire
//*****************************************************************************
/*
Lit le nombre d'octets à partir du registre d'adresse sur accéléromètre dans le
tableau en mémoire de l'accéléromètre.
*/

void AccellerometreLectureMemoire (byte address, int num, byte
                                   Accellerometre3AxesMemoire[])
{
  // Démarrer la transmission à accéléromètre.
  Wire.beginTransmission (Accellerometre3AxesAdresse);
  // Envoie l'adresse de lire.
  Wire.write (address);
  // Fin de la transmission.
  Wire.endTransmission ();
  // Démarrer la transmission à accéléromètre.
  Wire.beginTransmission (Accellerometre3AxesAdresse);
  // Demande 6 octets à l'accéléromètre.
  Wire.requestFrom (Accellerometre3AxesAdresse, num);

  int i = 0;
  // L'accéléromètre peut envoyer moins que demandé, c'est anormal, mais...
  while (Wire.available())
  {
    // Recevoir un octet.
    Accellerometre3AxesMemoire[i] = Wire.read ();
    i++;
  }
    // Fin de la transmission.
  Wire.endTransmission ();
}
//*****************************************************************************
 


En souhaitant que vous y trouviez ce que vous cherchiez !

Bon montage !

L'ami René

Un pour tous, et tous pour un !

Share