[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:

  • Un Arduino
  • Un Accéléromètre ADXL345
  • Jumper male-femelle

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

Résolution du problème de téléversement rencontré avec les clones Arduino Uno

Les clones Arduino sont des produits identiques aux Arduino officiels, pour un prix inférieur. Néanmoins, ils peuvent dans certains cas vous poser problème. Vous pouvez notamment rencontrer un problème de téléversement impossible, accompagné de l’erreur:

avrdude: skt500_recv(): programmer is not responding

ou

avrdude: skt500_getsync() attempt X of 10: not in sync: resp=0xXX

Lorsque votre Arduinho est branché à votre ordinateur, vous voyez la led ON et la led L allumée en permanence, et le bouton RESET ne fonctionne plus.

Nous vous proposons deux solutions pour palier à ce problème.

Avant tout vérifiez que :

  • Vous avez bien selectionné  » Arduino Uno  » dans le menu Outils > Type de carte.
  • Vous avez bien selectionné le bon port COM.

1ère solution: Mise à jour du pilote

Il se peut que le pilote de votre Arduino ne soit pas à jour, ou que ce ne soit pas le bon qui soit installé. Les clones Arduinos utilisent le chip CH340 pour la liaison USB. Vous pouvez télécharger son pilote ici:

http://www.wch.cn/download/CH341SER_EXE.html

Il ne vous reste plus qu’à l’installer. Votre Arduino devrait alors apparaître dans le gestionnaire de périphériques dans « Ports (COM et LPT) » sous cette forme:

hy

2ème solution: télécharger le bootloader sur l’ATmega

Il se peut que le bootloader de l’ATmega ne soit pas installé, ou non fonctionnel. Le tutoriel ci dessous est pour un Uno mais fonctionne également avec les autres modèles). Vous pouvez le télécharger vous même. Pour cela il vous suffit d’avoir:

  1. Branchez votre Arduino fonctionnel à votre ordinateur. Téléverser le programme que vous trouverez dans Fichier > Exemples > ArduinoISP (ne fonctionne pas si vous avez déjà placé le condensateur, pensez à l’enlever).
    arduinoisp
  2. Déconnectez votre Arduino de l’ordinateur.
  3. Réalisez le montage suivant:
Fix_Chinese_Arduino_clone_problems1629051120step4
IMG_7682
Arduino fonctionnelArduino clone non fonctionnel
Pin 10RESET
Pin 11Pin 11
Pin 12Pin 12
Pin 13Pin 13
5V5V
GNDGND

4. Rebranchez l’Arduino fonctionnel à votre ordinateur à l’aide du câble USB. Ouvrez un simple programme Blink par exemple. Allez dans Outils > Type de carte et selectionnez la carte que vous voulez « réparez ». Ici donc Arduino Uno.

5. Dans Outils > Programmeur , cliquez sur Arduino as ISP

6. Allez dans Outils et cliquez sur Graver la séquence d’initialisation, attendez jusqu’à bien avoir le message « Gravure de la séquence d’initialisation terminée ».

Voilà, votre Arduino devrait maintenant fonctionner ! Vous pouvez le vérifier en téléversant le programme de votre choix.

Laboîte au Numa

Hier avait lieu l’atelier Laboîte au Numa suite au crowdfunding de cet été http://www.kisskissbankbank.com/fr/projects/la-boite

Les pilotes nécessaires au clone de Arduino Uno sont:

Pour faire suite à cet atelier, voici quelques documents pour aller plus loin:

Si vous souhaitez trouver les composants pour refaire une boite voici quelques liens:

Retrouvez également des kits en boutique:

Et pour conclure quelques photos:

Baptiste
IMG_20140920_134307
IMG_20140920_134322
IMG_20140920_134333
IMG_20140920_134344
IMG_20140920_162615

Premier test de Inmoov

Inmoov est un projet de robot imprimable en 3D. Le premier test réalisable (pour ne pas devoir imprimer tout le corps pour voir ses premiers mouvements s’exécuter) est une plateforme de test d’un doigt: http://www.inmoov.fr/finger-starter/

Voici quelques photos du montage réalisé sur base d’Arduino Uno:

IMG_20140825_143159
IMG_20140825_143223

Ainsi qu’une vidéo:

L’une des pièces est un adaptateur créé pour utiliser notre servo 9g sur ce montage, voici le lien pour la télécharger: http://www.thingiverse.com/thing:440457

[Tuto] Utiliser un bargraph avec un Arduino Uno

Utiliser un bargraph

Le but de ce montage est de découvrir comment utiliser le bargraph. Le bargraph est un ensemble de LED très utile pour visualiser des informations sous forme d’échelle (puissance sonore, niveau d’eau…). Dans cet exemple, nous allons utiliser un capteur de type photo resistance mais vous pouvez utiliser n’importe quel capteur analogique pour le remplacer.

Composants nécessaires :

 
composants

Le montage consiste à relier le bargraph à 10 sorties numériques du Arduino et le capteur sur une entrée analogique comme sur le schéma ci-dessous :Principe du montage :

Bargraphe_schéma
Montage

Programmation du montage:

Le programme va lire le capteur et transposer sa valeur en allumant un nombre de LED proportionnel à sa valeur. On pourra aussi avoir la valeur lue par l’interface série.

#define SENS_PIN 0 // Pin utilisée pour le capteur
#define LED_COUNT 10 // Nombre de LEDs utilisées

double sens;// Variable comprenant la valeur du capteur
double V_IN =5.0;// Variable de la tension d'alimentation
double R1 =10000;// Valeur de la resistance en parallele
int ledPins[]={0,1,2,3,4,5,6,7,8,9};// Tableau comprenant les références des pins utilisées

void setup(){
Serial.begin(9600);
for(int thisLed =0; thisLed < LED_COUNT; thisLed++){
pinMode(ledPins[thisLed], OUTPUT);// Boucle pour définir les pin utilisees comme sorties
}

}

void loop(){

sens = analogRead(SENS_PIN);// Lecture de la valeur du capteur
Serial.print("Valeur mesuree = ");
Serial.print(sens);// Affichage de la valeur mesurée de 0 à 1024
Serial.print("n");

int ledLevel = map(sens,0,1023,0, LED_COUNT);// Creation d'une valeur en 0 et LED_COUNT fonction de la mesure

for(int thisLed =0; thisLed < LED_COUNT; thisLed++){

// Si la valeur est inferieur a LED_COUNT on allume la LED
if(thisLed < ledLevel){
digitalWrite(ledPins[thisLed], HIGH);
}

// turn off all pins higher than the ledLevel:
else{
digitalWrite(ledPins[thisLed], LOW);
}

}

// Pause de 1 seconde
delay(1000);
}

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

Une fois terminé cela nous donne :

ON 1
ON 2

Pour aller plus loin : Il sera ensuite possible d’optimiser l’échelle, de mettre en parallèle plusieurs bargraph…

[Tuto] Utiliser un shield LCD

Lire la valeur d’un capteur

Le but de ce montage est de mettre en place un montage rapide avec un shield (= carte d’extension) comprend un écran LCD et des boutons poussoirs. Le programme sera simple, il affichera sur l’écran le nom du bouton pressé.

Ce montage est une adaptation de http://www.dfrobot.com/wiki/index.php?title=Arduino_LCD_KeyPad_Shield_(SKU:_DFR0009)

Composants nécessaires :

Principe du montage :

Le montage de shield est très simple. Il suffit de poser le shield directement sur le Arduino.

Composants

 

Réalisation du montage :

Pour réaliser le montage poser le shield sur le Arduino (Attention au sens). Guidez vous en fonction des bornes A0 à A5.

Montage 1
Montage 2
Montage 4
Montage 3

Remarque : Le potentiomètre (composant bleu avec une vis) permet le réglage du contraste.

Fonctionnement du shield :

Voici comment est réellement câblé le shield :

Bornes

Fonction

Analog 0

Bouton (select, up, right, down and left)

Digital 4

DB4

Digital 5

DB5

Digital 6

DB6

Digital 7

DB7

Digital 8

RS (données ou sélection du signal)

Digital 9

Activation (Enable)

Digital 10

Contrôle du rétroéclairage

Programmation du montage :

Le programme va nous afficher sur l’écran le nom des boutons appuyés. Pour cela il va utiliser une librairie spécific au LCD, la librairie « LiquidCrystal.h ». Cette librairie comprend de très nombreuses fonctions pour en avoir la liste complète et la description, je vous invite à aller visiter le site officiel http://arduino.cc/en/Reference/LiquidCrystal?from=Tutorial.LCDLibrary

// Charger la librairie LiquidCrystal
#include <LiquidCrystal.h>

// Définir les pins utilisées par le LCD
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

// Définir les variables globales
int lcd_key = 0;
int adc_key_in = 0;
#define btnRIGHT 0
#define btnUP 1
#define btnDOWN 2
#define btnLEFT 3
#define btnSELECT 4
#define btnNONE 5

// Fonction lire les boutons
int read_LCD_buttons()
{
adc_key_in = analogRead(0); // Lire les valeurs du capteurs
// Les valeurs renvoyées sont sensés être: 0, 144, 329, 504, 741
// Il y a une erreur possible de 50
if (adc_key_in > 1000) return btnNONE; // Nous découpons les valeurs possibles en zone pour chaque bouton
if (adc_key_in < 50) return btnRIGHT;
if (adc_key_in < 250) return btnUP;
if (adc_key_in < 450) return btnDOWN;
if (adc_key_in < 650) return btnLEFT;
if (adc_key_in < 850) return btnSELECT;
return btnNONE; // On renvoie cela si l'on est au dessus de 850
}

void setup() // Initialisation
{
lcd.begin(16, 2); // Démarrer la librairie
lcd.setCursor(0,0);
lcd.print("Appuyer"); // Afficher un message simple
}

void loop() // Fonction principale
{
lcd.setCursor(0,1); // Placer le curseur au début de la seconde ligne
lcd_key = read_LCD_buttons(); // Lire les boutons

switch (lcd_key) // Selon le bouton appuyer
{
case btnRIGHT: // Pour le bouton "Right"
{
lcd.print("RIGHT "); // Afficher "Right"
break;
}
case btnLEFT: // Pour le bouton "left"
{
lcd.print("LEFT "); // Afficher "Left"
break;
}
case btnUP: // Pour le bouton "Up"
{
lcd.print("UP "); // Afficher "Up"
break;
}
case btnDOWN: // Pour le bouton "Down"
{
lcd.print("DOWN "); // Afficher "Down"
break;
}
case btnSELECT: // Pour le bouton "Select"
{
lcd.print("SELECT"); // Afficher "Select"
break;
}
case btnNONE: // Sinon
{
lcd.print("NONE "); // Afficher "None"
break;
}
}

}

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

Une fois terminé cela nous donne :

NONE
LEFT
RIGHT

 Pour aller plus loin :

On peut à partir de là afficher tout ce que l’on veut. Les possibilités sont très grande.

[Tuto] Rendre le Arduino autonome

Cette fiche ne va pas présenter un montage en particulier mais plusieurs parties de montages pour vous montrer les différentes manières de rendre le Arduino autonome. Après programmation, votre montage va fonctionner grâce à l’alimentation électrique fourni par le port USB de votre ordinateur.

Caractéristiques électriques du Arduino

Les sorties du Arduino peuvent fournir 50mA à votre montage. Le port USB a une protection qui se met en sécurité si il consomme plus de 500mA. En arrondissant grossièrement, on peut donc conclure que si l’on utilise plus de 10 sorties à 50mA le montage ne fonctionnera pas en étant utilisé en USB.

Le Arduino Uno (compris dans le kit) contient 2 possibilités d’alimentation externe :

 
prise

Le port d’alimentation en utilisant une alimentation secteur

 
borne vin

La borne d’entrée Vin (ici avec un coupleur de pile 9V). Dans le cas de ce branchement, il faut mettre le fil + sur le Vi et le fil – sur l’un des GND (le choix n’a pas d’importance). Les possibilités de source d’alimentation sur cette borne sont vastes : coupleur de pile, panneau solaire, batterie…

La borne Vin et le port d’alimentation ont les mêmes caractéristiques, ils doivent fournir une tension entre 6 et 20V. Les tensions d’alimentation recommandées sont de 7 à 12V. Comme le Arduino est susceptible de consommé jusque 500mA, il vaut mieux prévoir une marge et prendre une alimentation 1A.

 
acdc
 
montage