Mesurer le pourcentage d'inclinaison avec un ADXL345

Bonsoir,

Je souhaite réaliser un programme permettant de mesurer le pourcentage d’inclinaison d’un ADXL345 et d’afficher le pourcentage d’inclinaison sur un afficheur LCD.

Rien de compliqué à première vue, j’ai réussi à trouver un programme tout fait pour récupérer les données du ADXL345 sur les axes X, Y et Z, il me suffit donc d’intégrer le calcul du pourcentage de la pente et la gestion de l’afficheur LCD.

Sauf qu’évidemment ça ne marche pas, et je n’arrive pas à comprendre pourquoi. J’obtiens des valeurs de pourcentage allant par incrément de 100, càd que si mon accéléromètre est à plat, j’ai 0% et je dois l’incliner à 45° pour obtenir 100%, puis 63.5° pour obtenir 200%, etc … je n’arrive pas à obtenir de valeurs intermédiaires.

Mon code :

#include <Wire.h>
#include <LiquidCrystal.h>
#include <math.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;

// Afficheur LCD
LiquidCrystal screen(12,11,5,4,3,2);

int pente = 0; //pourcentage de la pente initialisé à 0

void setup ()
{
// 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);

// Ecran
screen.begin(16,2);

}

void loop()
{
AccellerometreLecture (); //Lecture des données de l’accéléromètre

pente = fabs(Accelerometre1_AxeX/Accelerometre1_AxeZ)*100; //Calcul du pourcentage de la pente
screen.print(pente); //Affichage du pourcentage de la pente
delay(1000);
screen.clear();
}

//*****************************************************************************
// 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 = Wire.read ();

  • i++;*
  • }*
  • // Fin de la transmission.*
  • Wire.endTransmission ();*
    }[/quote]

C’est parce qu’il y a des smileys à lunettes dans le code.... 8)

(Et surtout des calculs en entier)