[Tuto] Accéléromètre ADXL 345

Ici sera présenté l’utilisation de l’accéléromètre ADXL 345
Pour cela, il vous faudra:

Cette accéléromètre présent en boutique est le suivant:

accelerometre-adxl345

Étape câblage:

La communication entre l’accéléromètre et l’arduino se fait via le bus I2C situé sur les broches A4 et A5 de l’arduino avec une vitesse par défaut de 100kHz.

  • GND (ADXL 345) ⇒ Arduino GND
  • 3V3 (ADXL 345) ⇒ Arduino 3V3
  • SDA (ADXL 345) ⇒ Arduino A4
  • SCL (ADXL 345) ⇒ Arduino A5

Étape logiciel:

Le programme qui suit n’a besoin d’aucune librairie, nous allons lire dans les registres les valeurs d’accélération selon X, Y et Z pour ensuite les afficher sur le terminal.

 

#include <Wire.h>

// 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.
//*****************************************************************************

// Adresses de communication I2C avec accéléromètre ADXL345.
const char Accellerometre3AxesAdresse = 0x53;
byte Accellerometre3AxesMemoire [6];
const char POWER_CTL = 0x2D;// Registre "Power Control".
const char DATA_FORMAT = 0x31;// Registre "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;

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


//*****************************************************************************
// FONCTION SETUP = Code d'initialisation.
//*****************************************************************************

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);

  // Initialisation de la communication I2C bus pour le capteur d’accélération.
  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);
}

void loop()
{
  
    // Pour affichage dans le moniteur série de l'éditeur Arduino.
    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 ();
  
}

//*****************************************************************************
// 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
//*****************************************************************************
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 ();
}

Les résultats sur le terminal arduino ide:

adxl345_results

Ressources:
http://playground.arduino.cc/French/TutorielsCodeSourceAutonome-Capteur-Accelerometre-LG-ADXL345-I2C-LCD1602Shield

[Tuto] Spark Core + écran I2C

Pour réaliser ce montage vous aurez besoin de :

Connecter votre spark core à l’internet en suivant le tutoriel de particle :

https://docs.particle.io/guide/getting-started/start/core/

Si vous rencontrez des problèmes pour configurer le spark en utilisant l’application, je vous invite à utiliser l’outil en ligne de commande de spark, qui permet, entre autre, de configurer le core par usb. https://github.com/spark/particle-cli

Une fois dans l’IDE build de particle, cliquer sur l’onglet “librairie” en bas à gauche de l’écran. Chercher “I2C” dans le moteur de recherche de librairie puis sélectionner la librairie LIQUIDCRYSTAL_I2C_SPARK.

Chaque librairie contient des exemples, ce sont les fichiers en .ino. Ici nous utiliserons “clockexample.ino”. Cliquer sur “use this example” pour l’inclure à vos applications et pouvoir l’utiliser pour votre core.

Remplacer l’adresse I2C de la ligne 16 par votre adresse I2C :

lcd = new LiquidCrystal_I2C(0x27, 16, 2);

Celle-ci peut varier en fonction du modèle d’écran que vous utilisez. J’ai rencontré l’adresse 0x3F et 0x27 avec deux écrans différents.

Ensuite réaliser le montage suivant :

Fil jaune relie D0 à SDA(lcd)

Fil violet relie D1 à SCL(lcd)

Fil blanc relie GND to GND(lcd)

Fil rouge relie VIM à VCC(LCD)

Le  deuxième fil rouge pour la ligne rouge de la breadboard.

Une première résistance de 1K ohm reliée de la ligne rouge de la breadboard au pin D0, une deuxième de la ligne rouge au pin D1.

tuto_spark_ecranI2C_1

tuto_spark_ecranI2C_2

Vérifier bien que le contraste de l’écran est bien réglé en tournant à l’aide d’un tournevis le petit potard situé derrière l’écran.

Il ne reste plus qu’à flasher votre spark core depuis l’IDE

[Tuto] Nunchuck et servo moteur

Nunchuck et Servo moteur

Le but de ce montage est commander un servo moteur à l’aide d’un Nunchuck (Manette de Nintendo Wii). Cet exemple vous montrera comment intégrer d’autres objets à votre montage. Ceci est une adaptation du montage http://tutoarduino.com/comment-controler-un-servomoteur-avec-un-nunchuck-de-wii

 

Composants nécessaires :

 composants

Fonctionnement du Nunchuck :

La Nunchuck communique avec la manette Wii en I2C. Ce protocole est également utilisé dans le montage mettant en œuvre 2 Arduinos. La librairie « wire » simplifie l’usage de l’I2C.

Pour fonctionner le Nunchuck doit être connecté à 4 signaux :

  • SCL ↔ Analog 5 du Arduino

  • SDA ↔ Analog 4 du Arduino

  • 3,3V

  • GND

Pour simplifier son câblage, un accessoire existe (Voir ci-contre). Sans cet outillage le câblage est assez complexe.

cablage

 nunchuck-cable-schema

arduino_accessories_wiichuck_2

Fonctionnement du montage :

La Nunchuck est relié comme périphérique I2C.

Le servo moteur est connecté à une sortie PWM. Les sorties PWM sont indiquées sur le Arduino. Ce sont Digital 3, 5, 6, 9, 10, 11. Les signaux PWM sont des signaux carrés qui permettent la commande de divers éléments comme les servo moteurs.

Dans l’exemple nous utiliserons la PWM de la borne Digital 11.

arduino-nunchuck-servo-schema

Réalisation du montage :

Le montage est entièrement réalisable sur la breadboard. Le servo moteur doit être connecté par 3 fils au Arduino :

  • 5V ↔ Rouge

  • PWM ↔ Orange

  • GND ↔ Gris ou marron

 arduino-nunchuck-servo-platine

Programmation du montage :

Les informations envoyées via I2C par la Nunchuck comprennent les valeurs d’accélération de tous les axes (X, Y et Z).

Les informations numériques sont codées en une succession de 0 et 1. Chaque chiffre est appelé un bit. Un paquet de 8 bits est appelé octet. La Nunchuck envoie 6 octets présentés comme ceci :

  • Octet 1 :

    • Position du joystick sur l’axe x

  • Octet 2 :

    • Position du joystick sur l’axe y

  • Octet 3 :

    • Accélération sur l’axe x bit 9 à 2

  • Octet 4 :

    • Accélération sur l’axe y bit 9 à 2

  • Octet 5 :

    • Accélération sur l’axe z bit 9 à 2

  • Octet 6 :

    • Accélération sur l’axe z bit 1 et 0

    • Accélération sur l’axe y bit 1 et 0

    • Accélération sur l’axe x bit 1 et 0

    • Statut du bouton C

    • Statut du bouton Z

axenunchuck_data__1d73fa__

Le programme du Arduino va lire la valeur de l’accélération sur l’axe Y du Nunchuck grâce à la liaison I2C et faire tourner le servo moteur en lui envoyant une commande angulaire grace à la librairie « Servo ».

La valeur des accélérations est codée sur 10 bits et coupée en 2 parties : les bits de 9 à 2 dans un octet et les bits 1 et 0 dans un autre octet.

#include 
#include 

// Doit être ajusté en fonction de chaque nunchuck
#define ZEROX 530
#define ZEROY 530
#define ZEROZ 530

// adresse I2C du nunchuck
#define WII_NUNCHUK_I2C_ADDRESS 0x52

// définition d'une variable Servo
Servo servomoteur;

// définition d'une variable counter
int counter;

// définition d'un tableau de données
uint8_t data[6];

void setup()
{
// on attache le servomoteur à la pin 11 (PWM)
servomoteur.attach(11);

// initialisation du nunchuck
Wire.begin();

Wire.beginTransmission(WII_NUNCHUK_I2C_ADDRESS);
Wire.write(0xF0);
Wire.write(0x55);
Wire.endTransmission();

Wire.beginTransmission(WII_NUNCHUK_I2C_ADDRESS);
Wire.write(0xFB);
Wire.write(0x00);
Wire.endTransmission();
}

void loop()
{
// on demande 6 octets au nunchuck
Wire.requestFrom(WII_NUNCHUK_I2C_ADDRESS, 6);

counter = 0;
// tant qu'il y a des données
while(Wire.available())
{
// on récupère les données
data[counter++] = Wire.read();
}

// on réinitialise le nunchuck pour la prochaine demande
Wire.beginTransmission(WII_NUNCHUK_I2C_ADDRESS);
Wire.write(0x00);
Wire.endTransmission();

if(counter >= 5)
{
// on extrait les données
// dans mon exemple j'utilise uniquement les données d'accélération sur l'axe Y
double accelX = ((data[2] << 2) + ((data[5] >> 2) & 0x03) - ZEROX);
double accelY = ((data[3] << 2) + ((data[5] >> 4) & 0x03) - ZEROY);
double accelZ = ((data[4] << 2) + ((data[5] >>; 6) & 0x03) - ZEROZ);

// on limite la valeur entre -180 et 180
int value = constrain(accelY, -180, 180);
// on mappe cette valeur pour le servomoteur soit entre 0 et 180
value = map(value, -180, 180, 0, 180);
// on écrit sur le servomoteur la valeur
servomoteur.write(value);

// un petit delai pour pas saturer le servomoteur
delay(100);
}
}

Il reste à brancher le Arduino pour compiler le programme et le téléverser.

Pour aller plus loin :

Il est possible de rendre autonome le montage en lui ajoutant un coupleur de pile. Il est aussi possible d’ajouter un second mouvement ou action (Allumer une LED par exemple) sur un autre axe. On peut modifier le programme pour utiliser les informations des joysticks.

Il reste à brancher le Arduino pour compiler le programme et le téléverser.

Pour aller plus loin :

Il est possible de rendre autonome le montage en lui ajoutant un coupleur de pile. Il est aussi possible d’ajouter un second mouvement ou action (Allumer une LED par exemple) sur un autre axe. On peut modifier le programme pour utiliser les informations des joysticks.

[Tuto] Utiliser 2 Arduinos en série

Utiliser 2 Arduinos en série

Le but de ce montage est d’ allumer une LED connectée à un Arduino en la commandant depuis le second Arduino. Ce montage va utiliser le réseau I2C du Arduino.

 Composants nécessaires :

 composants

Pour mettre en réseau les 2 Arduinos, nous allons utiliser l’interface I2C du Arduino. Le réseau I2C fonctionne sur le principe Maître / Esclave. Il peut y avoir un seul maître par réseau et plusieurs esclaves (chaque esclave a un identifiant). Cette interface nécessite 2 fils le SDA (Broche Analog A4) et SCL (Broche Analog A5). Grâce au réseau I2C, il est possible de connecter différentes cartes électroniques ou simple circuit intégré (« puce ») facilement comme le montre le schéma suivant :

schema i2c On voit sur ce schéma que pour fonctionner les éléments du réseau doit être alimenté par la même alimentation. Pour simplifier ceci, nous allons alimenter le Arduino donnant la commande (qui sera le maître) avec le Arduino allumant la LED (qui sera l’esclave).

 Principe du montage :

Le montage va cette fois-ci se décomposer en 2 parties :

  • Le Arduino esclave: Le Arduino esclave aura une LED et sa résistance câblée entre sa sortie digital 2 et le GND. Il utilisera sa sortie 5V pour alimenter le Arduino maître.

  • Le Arduino maître : Le Arduino maître reçoit son alimentation du Arduino esclave sur son entrée Vin.

 Pour terminer la bonne connexion de l’alimentation, il reste à connecter entre eux les GND des 2 arduinos.

 Pour établir la connexion entre ces 2 Arduinos, il va être nécessaire de raccorder les signaux SDA/SCL:

  • Entre la borne Analog 4 (SDA) du Arduino maître et la borne Analog 4 du Arduino esclave

  • Entre la borne Analog 5 (SCL) du Arduino maître et la borne Analog 5 du Arduino esclave

2 arduino en serie_scéma

Réalisation du montage :

 Pour le Arduino esclave, ce montage est le même que le montage « Allumer une LED »

Pour le Arduino maître, uniquement des connexions avec le Arduino esclave.

2 arduino en serie_bb

Montage

Programmation du montage :

La programmation de ce montage s’appuie sur la librairie Wire. Comme c’est une librairie, pour utiliser ces fonctions, il faudra écrire «Wire.nomdelafonction » .Elle contient les fonctions suivantes :

  • begin(X) : Initialise la liaison I2C. Se place dans la section « setup ». Le paramètre X est l’adresse de la carte esclave. Pour le maître le paramètre reste vide.

  • RequestFrom(X, Y) : Commande utilisée par le maître pour demander des informations aux esclaves (requête). Le paramètre X est l’adresse de l’esclave. Le paramètre Y est le nombre d’octets demandé.

  • beginTransmission(X) : Commande utilisée par le maître pour démarrer une transmission avec l’esclave de l’adresse X.

  • endTransmission() : Commande utilisée par le maître pour clore une transmission.

  • Write(X) : Commande utilisée par l’esclave pour répondre le message X à une demande du maître.

  • Available() : Renvoi le nombre d’octet disponible pour la lecture. C’est une fonction très intéressante pour savoir s’il y a des messages en attente de lecture.

  • Read() : Lit les message en attente sur le bus. Attention : La fonction read lit caractère par caractère.

  • OnReceive(X) : C’est une commande destinée uniquement à l’esclave qui va être appelée lorsqu’il y a des messages à lire la fonction X.

  • onRequest() : C’est une commande destinée uniquement à l’esclave qui va être appelée lorsqu’il y a une requête du maître.

 Le programme va lui aussi être coupé en 2, un pour chaque Arduino.

 ATTENTION : Il faut déconnecter les Arduinos durant la programmation !

 Programme du Arduino Esclave :

 Le Arduino esclave définit qu’il a une sortie sur digital 2. Il dit que son adresse est la numéro 4. Il va attendre de recevoir le chiffre 1 sur l’interface I2C pour allumer la LED. Quand il reçoit 0 il éteint la LED.

#include <Wire.h> // Librairie pour la communication I2C

const int L1 = 2; // broche 2 du micro-contrôleur se nomme maintenant : L1

void setup()
{
Wire.begin(4); // Rejoindre le bus à l'adresse #4
Wire.onReceive(receiveEvent); // Preparer une fonction spécifique a la reception de donnee
Serial.begin(9600); // Demarrer la liaison serie avec le PC
pinMode(L1, OUTPUT); // L1 est une broche de sortie
}

void loop()
{
delay(100);
}

// Fonction qui s execute si quelque chose est present sur l interface
void receiveEvent(int howMany)
{
int x = Wire.read(); // recevoir un chiffre
Serial.println(x); // afficher ce chiffre sur l'interface serie
if(x == 1)
{
digitalWrite(L1, HIGH); // allumer L1
}
if(x == 0)
{
digitalWrite(L1, LOW); // eteindre L1
}
}

Programme du Arduino Maître :

Le Arduino maître envoie un 1 sur l’interface I2C, attend 1 seconde, envoi un 0 sur l’interface I2C, attend 2 secondes et recommence à l’infini.

#include <Wire.h>

void setup()
{
Wire.begin(); // Rejoindre le bus I2C (Pas besoin d adresse pour le maitre)
}

void loop()
{
//contenu du programme
Wire.beginTransmission(4); // Envoyer vers device #4
Wire.write(1); // Envoi un 1
Wire.endTransmission(); // Arreter la transmission
delay(1000); // Attendre 1s
Wire.beginTransmission(4); // Envoyer vers device #4
Wire.write(0); // Envoi un 0
Wire.endTransmission(); // Arreter la transmission
delay(2000); // Attendre 2s
}

Il reste à brancher le Arduino pour compiler le programme et le téléverser.

Une fois terminé cela nous donne :

led OFF

LED éteinte

led ON

LED allumée

série

Interface série

Pour aller plus loin :

Il est possible de rendre autonome le montage en lui ajoutant un coupleur de pile. Il est aussi possible de modifier les temps allumés et éteints. On peut remplacer les temps par un bouton poussoir ce qui ferait un système de bouton déporté.