Scribd
Importer
3 vues13 pages

Acc

Le document présente plusieurs programmes Arduino utilisant l'accéléromètre ADXL345 pour lire et afficher les données d'accélération en format hexadécimal ou en m/s². Les programmes incluent des fonctions pour initialiser l'accéléromètre, lire les données, convertir les valeurs et afficher les angles d'inclinaison. Les exemples montrent différentes approches pour traiter et afficher les données d'accélération, y compris l'utilisation de bibliothèques externes.

Transféré par

anarimanana
Copyright
© All Rights Reserved
Nous prenons très au sérieux les droits relatifs au contenu. Si vous pensez qu’il s’agit de votre contenu, signalez une atteinte au droit d’auteur ici.
Formats disponibles
Téléchargez aux formats DOCX, PDF, TXT ou lisez en ligne sur Scribd
3 vues13 pages

Acc

Le document présente plusieurs programmes Arduino utilisant l'accéléromètre ADXL345 pour lire et afficher les données d'accélération en format hexadécimal ou en m/s². Les programmes incluent des fonctions pour initialiser l'accéléromètre, lire les données, convertir les valeurs et afficher les angles d'inclinaison. Les exemples montrent différentes approches pour traiter et afficher les données d'accélération, y compris l'utilisation de bibliothèques externes.

Transféré par

anarimanana
Copyright
© All Rights Reserved
Nous prenons très au sérieux les droits relatifs au contenu. Si vous pensez qu’il s’agit de votre contenu, signalez une atteinte au droit d’auteur ici.
Formats disponibles
Téléchargez aux formats DOCX, PDF, TXT ou lisez en ligne sur Scribd

1)

#include <Wire.h>

#define ADXL345_ADDRESS (0x53) // Adresse I2C par défaut de l'ADXL345 (0x53 en écriture, 0x52 en
lecture)
int16_t accelerationData[3]; // Tableau pour stocker les données d'accélération (X, Y, Z)

void setup() {
[Link](); // Initialise la communication I2C
[Link](400000); // Définir la fréquence de l'horloge à 400 kHz

[Link](9600);

initializeADXL345(); // Appel de la fonction d'initialisation


}

void loop() {
readAccelerationData(); // Lire les données d'accélération depuis l'ADXL345
printAccelerationData(); // Afficher les données en format hexadécimal
delay(100); // Attendre un court laps de temps
}

void writeToRegister(int deviceAddress, byte address, byte val) {


[Link](deviceAddress);
[Link](address);
[Link](val);
[Link]();
}

void initializeADXL345() {
// Activer la mesure selon les protocoles du document
// Configurer la plage de mesure et le mode full resolution
writeToRegister(ADXL345_ADDRESS, 0x2D, 0x08); // 00001000 en binaire
writeToRegister(ADXL345_ADDRESS, 0x31, 0x09); // 00001001 en binaire
}

void readAccelerationData() {
[Link](ADXL345_ADDRESS);
[Link](0x32); // Adresse du premier registre de l'accélération (X0)
[Link]();
[Link](ADXL345_ADDRESS, 6);

if ([Link]() == 6) {
accelerationData[0] = [Link]() | ([Link]() << 8);
accelerationData[1] = [Link]() | ([Link]() << 8);
accelerationData[2] = [Link]() | ([Link]() << 8);
}
}

void printAccelerationData() {
[Link]("X: 0x");
[Link](accelerationData[0], HEX);
[Link](" Y: 0x");
[Link](accelerationData[1], HEX);
[Link](" Z: 0x");
[Link](accelerationData[2], HEX);
}

2)
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_ADXL345_U.h>

Adafruit_ADXL345_Unified accel = Adafruit_ADXL345_Unified(12345); // Créez un objet Accel avec


l'adresse I2C 0x53

void setup(void) {
[Link](9600);
if (![Link]()) {
[Link]("Could not find a valid ADXL345 sensor, check wiring!");
while (1);
}
[Link](ADXL345_RANGE_16_G); // Configurer la plage de mesure à +/-16g
}

void loop(void) {
sensors_event_t event;
[Link](&event);

[Link]("X: 0x");
[Link]([Link].x, HEX);
[Link](" Y: 0x");
[Link]([Link].y, HEX);
[Link](" Z: 0x");
[Link]([Link].z, HEX);

delay(100); // Attendre un court laps de temps


}
3)
#include <Wire.h>

#define ADXL345_ADDRESS (0x53) // Adresse I2C par défaut de l'ADXL345 (0x53 en écriture, 0x52 en
lecture)
int16_t accelerationData[3]; // Tableau pour stocker les données d'accélération (X, Y, Z)

void setup() {
[Link](); // Initialise la communication I2C
[Link](400000); // Définir la fréquence de l'horloge à 400 kHz

[Link](9600);

initializeADXL345(); // Appel de la fonction d'initialisation


}

void loop() {
readAccelerationData(); // Lire les données d'accélération depuis l'ADXL345
printAccelerationData(); // Afficher les données en format hexadécimal
delay(100); // Attendre un court laps de temps
}

void writeToRegister(int deviceAddress, byte address, byte val) {


[Link](deviceAddress);
[Link](address);
[Link](val);
[Link]();
}

void initializeADXL345() {
// Activer la mesure selon les protocoles du document
// Configurer la plage de mesure et le mode full resolution
writeToRegister(ADXL345_ADDRESS, 0x2D, 0x08); // 00001000 en binaire
writeToRegister(ADXL345_ADDRESS, 0x31, 0x09); // 00001001 en binaire
}

void readAccelerationData() {
[Link](ADXL345_ADDRESS);
[Link](0x32); // Adresse du premier registre de l'accélération (X0)
[Link]();
[Link](ADXL345_ADDRESS, 6);

if ([Link]() == 6) {
for (int i = 0; i < 3; i++) {
byte lowByte = [Link]();
byte highByte = [Link]();
accelerationData[i] = (int16_t)((highByte << 8) | lowByte);
}
}
}

void printAccelerationData() {
[Link]("X: 0x");
[Link](accelerationData[0], HEX);
[Link](" Y: 0x");
[Link](accelerationData[1], HEX);
[Link](" Z: 0x");
[Link](accelerationData[2], HEX);
}
La fonction writeToRegister est utilisée pour écrire une valeur dans un registre spécifique de l'appareil
I2C (dans ce cas, l'ADXL345). Elle est utilisée pour configurer l'appareil en écrivant des données dans
ses registres de contrôle, ce qui peut inclure la configuration de divers paramètres, tels que la plage
de mesure, le mode de fonctionnement, la fréquence d'échantillonnage, etc.

La fonction writeToRegister prend trois arguments :

deviceAddress : Il s'agit de l'adresse I2C de l'appareil auquel vous souhaitez écrire. Cela vous permet
de communiquer avec un appareil spécifique sur le bus I2C, en l'occurrence, l'ADXL345.

address : Il s'agit de l'adresse du registre dans l'appareil que vous souhaitez configurer. Chaque
registre dans l'appareil I2C a une adresse spécifique pour accéder à ses fonctionnalités.

val : Il s'agit de la valeur que vous souhaitez écrire dans le registre spécifié.

En utilisant cette fonction, vous pouvez envoyer les données de configuration nécessaires à l'appareil,
par exemple pour activer la mesure, définir la plage de mesure, ou effectuer d'autres ajustements
spécifiques à votre application. Elle fait partie du processus d'initialisation de l'ADXL345 et de la
configuration de ses paramètres.

Exo2
#include <Wire.h>

#define ADXL345_ADDRESS (0x53) // Adresse I2C par défaut de l'ADXL345 (0x53 en écriture, 0x52 en
lecture)
int16_t accelerationData[3]; // Tableau pour stocker les données d'accélération brutes (X, Y, Z)

float acceleration_m_per_s2[3]; // Tableau pour stocker les données d'accélération en m/s² (X, Y, Z)

void setup() {
[Link](); // Initialise la communication I2C
[Link](400000); // Définir la fréquence de l'horloge à 400 kHz

[Link](9600);

initializeADXL345(); // Appel de la fonction d'initialisation


}

void loop() {
readAccelerationData(); // Lire les données d'accélération depuis l'ADXL345
convertAccelerationDataToMPerS2(); // Convertir les données en m/s²
printAccelerationData(); // Afficher les données en m/s²
delay(100); // Attendre un court laps de temps
}

void writeToRegister(int deviceAddress, byte address, byte val) {


[Link](deviceAddress);
[Link](address);
[Link](val);
[Link]();
}

void initializeADXL345() {
// Activer la mesure selon les protocoles du document
// Configurer la plage de mesure et le mode full resolution
writeToRegister(ADXL345_ADDRESS, 0x2D, 0x08); // 00001000 en binaire
writeToRegister(ADXL345_ADDRESS, 0x31, 0x09); // 00001001 en binaire
}

void readAccelerationData() {
[Link](ADXL345_ADDRESS);
[Link](0x32); // Adresse du premier registre de l'accélération (X0)
[Link]();
[Link](ADXL345_ADDRESS, 6);

if ([Link]() == 6) {
for (int i = 0; i < 3; i++) {
byte lowByte = [Link]();
byte highByte = [Link]();
accelerationData[i] = (int16_t)((highByte << 8) | lowByte);
}
}
}

void convertAccelerationDataToMPerS2() {
// Échelle ADXL345 à +/-16g (1g = 9.81 m/s²)
float scale = 16.0 * 9.81;

for (int i = 0; i < 3; i++) {


acceleration_m_per_s2[i] = (float)accelerationData[i] / scale;
}
}

void printAccelerationData() {
[Link]("X: ");
[Link](acceleration_m_per_s2[0], 3); // Affiche avec 3 décimales
[Link](" m/s² Y: ");
[Link](acceleration_m_per_s2[1], 3);
[Link](" m/s² Z: ");
[Link](acceleration_m_per_s2[2], 3);
}

Exo3
#include <Wire.h>
#include <math.h> // Inclure la bibliothèque mathématique pour les fonctions trigonométriques

#define ADXL345_ADDRESS (0x53) // Adresse I2C par défaut de l'ADXL345 (0x53 en écriture, 0x52 en
lecture)
int16_t accelerationData[3]; // Tableau pour stocker les données d'accélération brutes (X, Y, Z)
float acceleration_m_per_s2[3]; // Tableau pour stocker les données d'accélération en m/s² (X, Y, Z)

void setup() {
[Link](); // Initialise la communication I2C
[Link](400000); // Définir la fréquence de l'horloge à 400 kHz

[Link](9600);

initializeADXL345(); // Appel de la fonction d'initialisation


}

void loop() {
readAccelerationData(); // Lire les données d'accélération depuis l'ADXL345
convertAccelerationDataToMPerS2(); // Convertir les données en m/s²
printAccelerationData(); // Afficher les données d'accélération
printInclination(); // Afficher les valeurs d'inclinaison
delay(100); // Attendre un court laps de temps
}

void writeToRegister(int deviceAddress, byte address, byte val) {


[Link](deviceAddress);
[Link](address);
[Link](val);
[Link]();
}

void initializeADXL345() {
// Activer la mesure selon les protocoles du document
// Configurer la plage de mesure et le mode full resolution
writeToRegister(ADXL345_ADDRESS, 0x2D, 0x08); // 00001000 en binaire
writeToRegister(ADXL345_ADDRESS, 0x31, 0x09); // 00001001 en binaire
}

void readAccelerationData() {
[Link](ADXL345_ADDRESS);
[Link](0x32); // Adresse du premier registre de l'accélération (X0)
[Link]();
[Link](ADXL345_ADDRESS, 6);

if ([Link]() == 6) {
for (int i = 0; i < 3; i++) {
byte lowByte = [Link]();
byte highByte = [Link]();
accelerationData[i] = (int16_t)((highByte << 8) | lowByte);
}
}
}

void convertAccelerationDataToMPerS2() {
// Échelle ADXL345 à +/-16g (1g = 9.81 m/s²)
float scale = 16.0 * 9.81;

for (int i = 0; i < 3; i++) {


acceleration_m_per_s2[i] = (float)accelerationData[i] / scale;
}
}

void printAccelerationData() {
[Link]("X: ");
[Link](acceleration_m_per_s2[0], 3); // Affiche avec 3 décimales
[Link](" m/s² Y: ");
[Link](acceleration_m_per_s2[1], 3);
[Link](" m/s² Z: ");
[Link](acceleration_m_per_s2[2], 3);
}

void printInclination() {
// Calculer l'inclinaison par rapport à l'horizontal (X, Y) et la verticale (Z)
float angleX = atan2(acceleration_m_per_s2[0], acceleration_m_per_s2[2]) * 180.0 / PI;
float angleY = atan2(acceleration_m_per_s2[1], acceleration_m_per_s2[2]) * 180.0 / PI;
[Link]("Angle X: ");
[Link](angleX, 2); // Afficher avec 2 décimales
[Link]("° Angle Y: ");
[Link](angleY, 2);
[Link]("°");
}

Exo4
#include <Wire.h>
#include <math.h>

#define ADXL345_ADDRESS (0x53)


int16_t accelerationData[3];
float acceleration_m_per_s2[3];
float inclinX, inclinY, inclinZ, accel_totale;

void setup() {
[Link]();
[Link](400000);
[Link](9600);
initializeADXL345();
}

void loop() {
lecture_accelerometre(&inclinX, &inclinY, &inclinZ, &accel_totale);
printAccelerationData();
printInclination();
delay(100);
}

void writeToRegister(int deviceAddress, byte address, byte val) {


[Link](deviceAddress);
[Link](address);
[Link](val);
[Link]();
}

void initializeADXL345() {
writeToRegister(ADXL345_ADDRESS, 0x2D, 0x08); // Activation de la mesure
writeToRegister(ADXL345_ADDRESS, 0x31, 0x09); // Configuration de la plage de mesure
}

void readAccelerationData() {
[Link](ADXL345_ADDRESS);
[Link](0x32);
[Link]();
[Link](ADXL345_ADDRESS, 6);

if ([Link]() == 6) {
for (int i = 0; i < 3; i++) {
byte lowByte = [Link]();
byte highByte = [Link]();
accelerationData[i] = (int16_t)((highByte << 8) | lowByte);
}
}
}

void convertAccelerationDataToMPerS2() {
float scale = 16.0 * 9.81;

for (int i = 0; i < 3; i++) {


acceleration_m_per_s2[i] = (float)accelerationData[i] / scale;
}
}

void printAccelerationData() {
[Link]("X: ");
[Link](acceleration_m_per_s2[0], 3);
[Link](" m/s² Y: ");
[Link](acceleration_m_per_s2[1], 3);
[Link](" m/s² Z: ");
[Link](acceleration_m_per_s2[2], 3);
}

void printInclination() {
[Link]("Angle X: ");
[Link](inclinX, 2);
[Link]("° Angle Y: ");
[Link](inclinY, 2);
[Link]("° Angle Z: ");
[Link](inclinZ, 2);
[Link]("° Accélération totale: ");
[Link](accel_totale, 2);
[Link](" m/s²");
}

void lecture_accelerometre(float *inclinX, float *inclinY, float *inclinZ, float *accel_totale) {


readAccelerationData();
convertAccelerationDataToMPerS2();

*inclinX = atan2(acceleration_m_per_s2[0], acceleration_m_per_s2[2]) * 180.0 / PI;


*inclinY = atan2(acceleration_m_per_s2[1], acceleration_m_per_s2[2]) * 180.0 / PI;
*inclinZ = atan2(acceleration_m_per_s2[2], sqrt(acceleration_m_per_s2[0] *
acceleration_m_per_s2[0] + acceleration_m_per_s2[1] * acceleration_m_per_s2[1])) * 180.0 / PI;

*accel_totale = sqrt(acceleration_m_per_s2[0] * acceleration_m_per_s2[0] +


acceleration_m_per_s2[1] * acceleration_m_per_s2[1] + acceleration_m

Exo5
#include <Wire.h>
#include <math.h>

#define ADXL345_ADDRESS (0x53)


int16_t accelerationData[3];
float acceleration_m_per_s2[3];
float inclinX, inclinY, inclinZ, accel_totale;

// Offset de l'accéléromètre (peut nécessiter un ajustement)


int16_t offsetX = 0;
int16_t offsetY = 0;
int16_t offsetZ = 0;

void setup() {
[Link]();
[Link](400000);
[Link](9600);
initializeADXL345();
}

void loop() {
lecture_accelerometre(&inclinX, &inclinY, &inclinZ, &accel_totale);
printAccelerationData();
printInclination();
delay(100);
}

void writeToRegister(int deviceAddress, byte address, byte val) {


[Link](deviceAddress);
[Link](address);
[Link](val);
[Link]();
}

void initializeADXL345() {
// Activer la mesure selon les protocoles du document
// Configurer la plage de mesure et le mode full resolution
writeToRegister(ADXL345_ADDRESS, 0x2D, 0x08); // Activation de la mesure
writeToRegister(ADXL345_ADDRESS, 0x31, 0x09); // Configuration de la plage de mesure
// Configurer les offsets (ajustez ces valeurs en fonction de vos besoins)
writeToRegister(ADXL345_ADDRESS, 0x1E, lowByte(offsetX));
writeToRegister(ADXL345_ADDRESS, 0x1F, highByte(offsetX));
writeToRegister(ADXL345_ADDRESS, 0x20, lowByte(offsetY));
writeToRegister(ADXL345_ADDRESS, 0x21, highByte(offsetY));
writeToRegister(ADXL345_ADDRESS, 0x22, lowByte(offsetZ));
writeToRegister(ADXL345_ADDRESS, 0x23, highByte(offsetZ));
}

// ... (rest of the code remains the same)

Code of stranger
ADXL345 Accelerometer Calibration
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_ADXL345_U.h>

/* Assign a unique ID to this sensor at the same time */


Adafruit_ADXL345_Unified accel = Adafruit_ADXL345_Unified(12345);

float AccelMinX = 0;
float AccelMaxX = 0;
float AccelMinY = 0;
float AccelMaxY = 0;
float AccelMinZ = 0;
float AccelMaxZ = 0;

void setup(void)
{
[Link](9600);
[Link]("ADXL345 Accelerometer Calibration");
[Link]("");

/* Initialise the sensor */


if(![Link]())
{
/* There was a problem detecting the ADXL345 ... check your connections */
[Link]("Ooops, no ADXL345 detected ... Check your wiring!");
while(1);
}
}

void loop(void)
{
[Link]("Type key when ready...");
while (![Link]()){} // wait for a character

/* Get a new sensor event */


sensors_event_t accelEvent;
[Link](&accelEvent);

if ([Link].x < AccelMinX) AccelMinX = [Link].x;


if ([Link].x > AccelMaxX) AccelMaxX = [Link].x;

if ([Link].y < AccelMinY) AccelMinY = [Link].y;


if ([Link].y > AccelMaxY) AccelMaxY = [Link].y;

if ([Link].z < AccelMinZ) AccelMinZ = [Link].z;


if ([Link].z > AccelMaxZ) AccelMaxZ = [Link].z;

[Link]("Accel Minimums: "); [Link](AccelMinX); [Link](" ");[Link](AccelMinY);


[Link](" "); [Link](AccelMinZ); [Link]();
[Link]("Accel Maximums: "); [Link](AccelMaxX); [Link](" ");[Link](AccelMaxY);
[Link](" "); [Link](AccelMaxZ); [Link]();

while ([Link]())
{
[Link](); // clear the input buffer
}
}

Autre code
#include <Wire.h>

#include <Adafruit_Sensor.h>

#include <Adafruit_ADXL345_U.h>

Adafruit_ADXL345_Unified accel = Adafruit_ADXL345_Unified();

void setup(void)

[Link](9600);

if(![Link]())
{

[Link]("No valid sensor found");

while(1);

void loop(void)

sensors_event_t event;

[Link](&event);

[Link]("X: "); [Link]([Link].x); [Link](" ");

[Link]("Y: "); [Link]([Link].y); [Link](" ");

[Link]("Z: "); [Link]([Link].z); [Link](" ");

[Link]("m/s^2 ");

delay(500);

Vous aimerez peut-être aussi