Recueillir les positions d'un accéléromètre dans un fichier csv

Bonjour,

Etant en prépa scientifique je dois réaliser un projet. Dans mon sujet, j'enregistrer les positions d'un accéléromètre (sur les axes X,Y,Z) sur une carte SD au format csv.

Actuellement je dispose d'un programme (trouvé sur internet) qui m'affiche les positions sur le moniteur série :

//---------- 16x2 LCD ---------------------------------------------------------------------------
#include <LiquidCrystal.h>
LiquidCrystal lcd(13, 12, 11, 10, 9, 8);

//---------- I2C --------------------------------------------------------------------------------
#include<Wire.h>

//---------- MPU6050 Measurement & Filtering Range ----------------------------------------------
#define AFS_SEL 2  // Accelerometer Configuration Settings   AFS_SEL=2, Full Scale Range = +/- 8 [g]
#define DLPF_SEL  0  // DLPF Configuration Settings  Accel BW 260Hz, Delay 0ms / Gyro BW 256Hz, Delay 0.98ms, Fs 8KHz 

//---------- Variables for gravity --------------------------------------------------------------
const int MPU_ADDR=0x68;  // I2C address of the MPU-6050
int AcX,AcY,AcZ;  // Accelerometer values
long Cal_AcX, Cal_AcY, Cal_AcZ; // Calibration values
float GAcX, GAcY, GAcZ; // Convert accelerometer to gravity value
float Min_GAcX=0, Max_GAcX=0, PtoP_GAcX, Min_GAcY=0, Max_GAcY=0, PtoP_GAcY, Min_GAcZ=0, Max_GAcZ=0, PtoP_GAcZ; // Finding Min, Max & Peak to Peak of gravity value
float Min = 0, Max = 0; // Initial value of Min, Max
int cnt; // Count of calibration process
float Grvt_unit; // Gravity value unit
long period, prev_time; // Period of calculation


void setup(){
  Wire.begin();
 
  init_MPU6050();
  
  Serial.begin(115200);

  lcd.begin(16, 2);

  Gravity_Range_Option();
  
  Calib_MPU6050(); // Calculating calibration value
}

void loop(){

  ReadDate_MPU6050();

  Calc_Grvt();

  Display_Grvt();
  
}

void init_MPU6050(){
  //MPU6050 Initializing & Reset
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(0x6B);  // PWR_MGMT_1 register
  Wire.write(0);     // set to zero (wakes up the MPU-6050)
  Wire.endTransmission(true);

  //MPU6050 Clock Type
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(0x6B);  // PWR_MGMT_1 register
  Wire.write(0x03);     // Selection Clock 'PLL with Z axis gyroscope reference'
  Wire.endTransmission(true);

  //MPU6050 Accelerometer Configuration Setting
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(0x1C);  // Accelerometer Configuration register
  if(AFS_SEL == 0) Wire.write(0x00);     // AFS_SEL=0, Full Scale Range = +/- 2 [g]
  else if(AFS_SEL == 1) Wire.write(0x08);     // AFS_SEL=1, Full Scale Range = +/- 4 [g]
  else if(AFS_SEL == 2) Wire.write(0x10);     // AFS_SEL=2, Full Scale Range = +/- 8 [g]
  else  Wire.write(0x18);     // AFS_SEL=3, Full Scale Range = +/- 10 [g]
  Wire.endTransmission(true);

  //MPU6050 DLPF(Digital Low Pass Filter)
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(0x1A);  // DLPF_CFG register
  if(DLPF_SEL == 0) Wire.write(0x00);     // Accel BW 260Hz, Delay 0ms / Gyro BW 256Hz, Delay 0.98ms, Fs 8KHz 
  else if(DLPF_SEL == 1)  Wire.write(0x01);     // Accel BW 184Hz, Delay 2ms / Gyro BW 188Hz, Delay 1.9ms, Fs 1KHz 
  else if(DLPF_SEL == 2)  Wire.write(0x02);     // Accel BW 94Hz, Delay 3ms / Gyro BW 98Hz, Delay 2.8ms, Fs 1KHz 
  else if(DLPF_SEL == 3)  Wire.write(0x03);     // Accel BW 44Hz, Delay 4.9ms / Gyro BW 42Hz, Delay 4.8ms, Fs 1KHz 
  else if(DLPF_SEL == 4)  Wire.write(0x04);     // Accel BW 21Hz, Delay 8.5ms / Gyro BW 20Hz, Delay 8.3ms, Fs 1KHz 
  else if(DLPF_SEL == 5)  Wire.write(0x05);     // Accel BW 10Hz, Delay 13.8ms / Gyro BW 10Hz, Delay 13.4ms, Fs 1KHz 
  else  Wire.write(0x06);     // Accel BW 5Hz, Delay 19ms / Gyro BW 5Hz, Delay 18.6ms, Fs 1KHz 
  Wire.endTransmission(true);
}

void Gravity_Range_Option(){
  switch(AFS_SEL) { // Selecting Gravity unit value
    case 0:
      Grvt_unit = 16384;
      break;
    case 1:
      Grvt_unit = 8192;
      break;
    case 2:
      Grvt_unit = 4096;
      break;
    case 3:
      Grvt_unit = 3276.8;
      break;
  }
}  

void Calib_MPU6050() {  
  for(int i = 0 ; i < 2000 ; i++) { // Summing Iteration for finding calibration value
    if(i % 200 == 0) {  // Display progress every 200 cycles
      cnt++;
      if(cnt == 1)  { // Characters to display first
        Serial.print("Calculating .");
        
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Calculating");
        lcd.setCursor(0,1);
        lcd.print(".");
      }
      else  { // Display progress by point
        Serial.print(".");
        lcd.print(".");
      }      
    }    
    
    ReadDate_MPU6050(); // Read Accelerometer data
    
    delay(10);

    // Sum data
    Cal_AcX += AcX;
    Cal_AcY += AcY;
    Cal_AcZ += AcZ;
  }

  // Average Data
  Cal_AcX /= 2000;
  Cal_AcY /= 2000;
  Cal_AcZ /= 2000;

  // Serial Print
  Serial.println("");
  Serial.println("End of Calculation");
  Serial.print("Cal_AcX = "); Serial.print(Cal_AcX);
  Serial.print(" | Cal_AcY = "); Serial.print(Cal_AcY);
  Serial.print(" | Cal_AcZ = "); Serial.println(Cal_AcZ);

  // LCD Display
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("CalibValue X|Y|Z");
  lcd.setCursor(0,1);
  lcd.print(String(Cal_AcX) + "|" + String(Cal_AcY) + "|" + String(Cal_AcZ));
  delay(2000);
}

void ReadDate_MPU6050() {
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(0x3B);  // starting with register 0x3B (ACCEL_XOUT_H)
  Wire.endTransmission(false);
  //Wire.requestFrom(MPU_ADDR,14,true);  // request a total of 14 registers
  Wire.requestFrom(MPU_ADDR,6,true);  // request a total of 14 registers
  AcX=Wire.read()<<8|Wire.read();  // 0x3B (ACCEL_XOUT_H) & 0x3C (ACCEL_XOUT_L)     
  AcY=Wire.read()<<8|Wire.read();  // 0x3D (ACCEL_YOUT_H) & 0x3E (ACCEL_YOUT_L)
  AcZ=Wire.read()<<8|Wire.read();  // 0x3F (ACCEL_ZOUT_H) & 0x40 (ACCEL_ZOUT_L)
}

void Calc_Grvt() {
  AcX = (AcX - Cal_AcX);  // Calibrated Accelerometer value
  AcY = (AcY - Cal_AcY);  // Calibrated Accelerometer value
  AcZ = (AcZ - Cal_AcZ);  // Calibrated Accelerometer value
  
  GAcX = AcX / Grvt_unit; // Converting the Calibrated value to Gravity value
  GAcY = AcY / Grvt_unit; // Converting the Calibrated value to Gravity value
  GAcZ = AcZ / Grvt_unit; // Converting the Calibrated value to Gravity value

  //---------- Calculating Min, Max & Peak to Peak of Gravity --------------------------------------

  Min_GAcX = min(Min_GAcX, GAcX);
  Max_GAcX = max(Max_GAcX, GAcX);
  PtoP_GAcX = Max_GAcX - Min_GAcX;

  Min_GAcY = min(Min_GAcY, GAcY);
  Max_GAcY = max(Max_GAcY, GAcY);
  PtoP_GAcY = Max_GAcY - Min_GAcY;

  Min_GAcZ = min(Min_GAcZ, GAcZ);
  Max_GAcZ = max(Max_GAcZ, GAcZ);
  PtoP_GAcZ = Max_GAcZ - Min_GAcZ;
}  

void Display_Grvt() {
  //---------- Serial print ----------------------------------------------------------------------
  Serial.print("AcX= " + String(AcX));
  Serial.print(" |AcY= " + String(AcY));
  Serial.println(" |AcZ= " + String(AcZ));

  //---------- LCD Display -----------------------------------------------------------------------
  period = millis() - prev_time;
  
  if(period > 1000) {
    
    prev_time = millis();
    
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("PeakToPeak X|Y|Z");
    lcd.setCursor(0,1);
    lcd.print(String(PtoP_GAcX) + "|" + String(PtoP_GAcY) + "|" + String(PtoP_GAcZ));

    Min_GAcX = 0;
    Max_GAcX = 0;
    Min_GAcY = 0;
    Max_GAcY = 0;
    Min_GAcZ = 0;
    Max_GAcZ = 0;
  }
}

Mais aussi :

  • une carte Arduino UNO,
  • un accéléromètre (MPU6050),
  • une horloge (DS3231),
  • un module de carte microSD (40811_m000523).

Il faut maintenant que je créé le fichier et l'enregistre sur la carte SD au bon format afin de pouvoir l'exploiter sur python. Je me suis renseigné et j'ai appris qu'il fallait, en plus du module de carte sd, une horloge afin de sauvegarder des données correctement.
J'ai trouvé un autre programme basé la dessus :

/****************************************
 * ENREGISTREUR DE DONNEES
 * le 03.04.2016
 * par Alexandre Pailhoux
 * 
 * Ce programme permet de sauvegarger vos données au format csv sur une carte SD.
 * Vous pouvez ensuite ouvrir le fichier DONNEES.csv sous excel et créer facilement un graphique.
 * Cet exemple est adapté pour la lecture d'un capteur DHT
 * 
 * Nécessite les libraires DS3231 et DHT
 * Schéma de cablâge disponible sur www.les-electroniciens.com
 * 
 * Besoin d'aide? http://www.les-electroniciens.com/forum  
 */


/**************************************
 * Librairies
 */
#include <SD.h>
#include <SPI.h>
#include <DS3231.h> //Librairie à installer
#include "DHT.h"    //Librairie à installer

/**************************************
 * Affectation des broches
 */
#define CS_PIN 10
#define DHTPIN 2
#define DHTTYPE DHT22

/**************************************
 * Création des instances
 */
File monFichier;
DS3231  monRTC(SDA, SCL);
DHT monDHT(DHTPIN, DHTTYPE);

/**************************************
 * Initialisation
 */
void setup()
{
  Serial.begin(9600);
  monRTC.begin();
  monDHT.begin();

  Serial.print("Initialisation de la carte SD en cours...");
  if (SD.begin())
  {
    Serial.println(" Terminee.");
  } else
  {
    Serial.println(" Echec.");
    return;
  }  
  monFichier = SD.open("donnees.csv", FILE_WRITE);
  if (monFichier) 
  {   
    monFichier.println("Heure,Temperature,Humidite");
    Serial.println("");
    Serial.println("   Heure  | Temperature | Humidite");
    monFichier.close();    
  } 
}
/**************************************
 * Boucle Infinie
 */
void loop()
{  
  // On mesure par exemple l'humidité et la température.
  float humidite = monDHT.readHumidity();
  float temperature = monDHT.readTemperature();
  
  // On demande l'heure exacte au module Real Time Clock.
  String temps = String(monRTC.getTimeStr());

  // On met en forme la donnée au formar csv, c'est-à dire chaque paramètre séparé par une virgule.
  String donnee = temps + "," + String(temperature) + "," + String(humidite);

  // On enregistre la donnée 
  monFichier = SD.open("donnees.csv", FILE_WRITE); //Maximum 8 caractères avant le .csv
  if (monFichier) 
  {   
    monFichier.println(donnee);
    Serial.println(" " + temps + " |    " + String(temperature)+ "    |   " + String(humidite));
    monFichier.close();    
  } 
  else 
  {
    Serial.println("Impossible d'ouvrir le fichier");
  }  
  delay(60000);
}

mais je n'arrive pas a combiner les deux.
Il est important de préciser que je ne sais rien faire en Arduino et donc que ce n'est pas moi qui ai fait les programmes.

Je viens demander de l'aide pour la suite.

Merci de votre compréhension.
J.

Pour combiner deux programmes Arduino, on trouve des tutos sur internet. L'idée la plus simple est la suivante (elle ne marche pas forcément à tous les coups mais ça devrait aller dans ton cas) :

  1. Partir d'un fichier ino vide
  2. Combiner les déclarations (bibliothèques, variables globales) avant le setup
  3. Combiner les deux setup, en retirant les lignes dupliquées (genre Serial.begin)
  4. Prendre la loop la plus simple des deux et la transformer en une fonction (tu peux l'appeler ecritureSD par exemple), la mettre dans ton fichier ino
  5. Insérer dans le fichier l'autre loop et y mettre un appel de ta fonction au bon endroit
  6. Prier pour que ça marche

Vous comptez y remédier ?

Ce serait l'étape 0 de ma réponse...

Bonjour,

Merci de votre réponse.
J’ai déjà essayé mais j’avais rencontré des problèmes de librairies.
Sauf que lorsque j’ai chargé les programmes sur le forum il me les as mis en rouge. Je ne sais pas ce que c’est exactement.

De plus je ne sais pas si ça peut bien fonctionner car le nombre de bauds n’est pas le même dans chaque programme. Ça reste une supposition de ma part donc probablement faux.

Je ressaierai au plus tôt (samedi je pense).

Oui bien sûr.

Je n’ai pas, aujourd’hui, la prétention de devenir un professionnel dans ce domaine mais je veux avoir les capacités suffisantes à la compression et la correction d’un tel programme.

Bonjour,

Tu es en prépa scientifique ce qui veut dire que pour y être admis tu as montré des capacités d'analyse, il faut les mettre en application.

Rouge :
warning = avertissement mais compilation, ce n'est jamais bon de les ignorer.
error = impossible de compiler

Qu'est-ce qui peut se passer quand on fusionne deux programmes copiés sur internet ?
Le plus idiot : deux serial.begin() avec deux débits différents --> plantage assuré : le moniteur d'affichage ne comprendra rien.
Ensuite noms de variables et noms de fonctions dupliqués, --> Rouge Error assuré à la compilation, Interruption et pins déjà prise par l'autre programme -> plantage du programme assuré.
Timers qui ont été modifiés dans un des deux programmes.
+ ce que j'ai oublié.

L'IDE arduino dispense de faire les déclaration de fonction, c'est une simplification mais dans le cas de fusion c'est un inconvénient, tu va devoir le faire à la main sur une feuille de papier.

Tu prends une feuille de papier que tu sépares en deux verticalement.
D'un coté tu mets ce que je viens de citer pour le premier programme et de l'autre coté pour le second programme.
En un seul coup d'œil tu verras s'il y a des duplications qu'il faudra résoudre en priorité absolue.

L'étape suivante sera de répartir le contenu des deux setup() et des deux loop().
Pour le setup() qui est la fonction où les initialisations se font, tu peux tout réunir ou utiliser deux fonctions c'est ton choix : d'un coté simplification, de l'autre peut-être meilleure lisibilité.

Pour la loop() il faut réunir le contenu des deux loop() dans des fonctions. Une loop() qui tient sur plusieurs pages écran est dificile à lire. La répartition des fonction doit se faire "au mieux"
-> peut-être il y a des lignes de codes qui peuvent être communes,
-> peut-être que les deux fonctions ne pourront pas être exécuter l'une à la suite de l'autre mais que des ordres devront être imbriqués et que seulement deux fonctions ne suffiront pas.
-> Peut-être aussi que tu gagnera du temps a tout réécrire avec une meilleure cohérence.

Il n'existe pas de règle gravée dans le marbre tout dépend des deux programmes à fusionner.
D'où la justification de ce par quoi j'ai commencé : capacité d'analyse.

Bonjour juloss43

Ca tombe bien, moi non plus :wink:

Pour fusionner 2 programmes, j'en évalue "l'importance" et dans ce cas, pour moi c'est l'enregistrement sur carte SD et donc, dans ce cas, j'ajouterai la partie accéléromètre à la partie écriture sur carte SD.
Ainsi, une fois le mix fait on prends cette partie de l'accéléromètre

  Serial.print("AcX= " + String(AcX));
  Serial.print(" |AcY= " + String(AcY));
  Serial.println(" |AcZ= " + String(AcZ));

et on déroute le Sérial.print sur la carte SD en le mettant au format CSV comme fait ici (partie SD)

  // On met en forme la donnée au formar csv, c'est-à dire chaque paramètre séparé par une virgule.
  String donnee = temps + "," + String(temperature) + "," + String(humidite);

mais avec les valeurs de l'accéléromètre.

Bien sûre, il y a plein de détails à tenir compte, mais dans les grandes lignes, c'est ainsi que je procéderai.

Pour la partie accéléromètre, il faut se poser la question si ça ne serait pas plus simple d'utiliser la bibliothèque MPU6050 pour lire les valeurs.
Question, est-ce-que tu as toujours besoin de l'affichage LCD?

Cordialement
jpbbricole

Merci beaucoup pour votre réponse.
Je prends note de vos remarques.
Je vous informe dès que j’avance sur le programme (je pense samedi).

Merci beaucoup de votre réponse.
J’en prends note.
Je n’ai absolument pas besoin de la partie LCD sur mon système.
Je vous informe samedi des avancées.

Bonsoir,

Bon, j'ai bien avancé grâce à vous et je vous en remercie encore.

Tout d'abord, j'ai regardé si les programmes fonctionnaient bien avec mes composants puis après j'ai commencé à les combinés en suivant vos astuces.
Le résultat est plutôt satisfaisant, je pense que j'ai eu de la chance car je n'y connais vraiment rien. J'ai juste fais attention à comment étaient organisé les choses mais enfin bref voici le programme.

//---------- I2C --------------------------------------------------------------------------------
#include<Wire.h>

//---------- MPU6050 Measurement & Filtering Range ----------------------------------------------
#define AFS_SEL 2  // Accelerometer Configuration Settings   AFS_SEL=2, Full Scale Range = +/- 8 [g]
#define DLPF_SEL  0  // DLPF Configuration Settings  Accel BW 260Hz, Delay 0ms / Gyro BW 256Hz, Delay 0.98ms, Fs 8KHz 

//----Librairies
#include <SD.h>
#include <SPI.h>
#include <DS3231.h> //Librairie à installer
#include "DHT.h"    //Librairie à installer

//----Affectation des broches
#define CS_PIN 10
#define DHTPIN 2
#define DHTTYPE DHT22

//---------- Variables for gravity --------------------------------------------------------------
const int MPU_ADDR=0x68;  // I2C address of the MPU-6050
int AcX,AcY,AcZ;  // Accelerometer values
long Cal_AcX, Cal_AcY, Cal_AcZ; // Calibration values
float GAcX, GAcY, GAcZ; // Convert accelerometer to gravity value
float Min_GAcX=0, Max_GAcX=0, PtoP_GAcX, Min_GAcY=0, Max_GAcY=0, PtoP_GAcY, Min_GAcZ=0, Max_GAcZ=0, PtoP_GAcZ; // Finding Min, Max & Peak to Peak of gravity value
float Min = 0, Max = 0; // Initial value of Min, Max
int cnt; // Count of calibration process
float Grvt_unit; // Gravity value unit
long period, prev_time; // Period of calculation

//----Création des instances
File monFichier;
DS3231  monRTC(SDA, SCL);
DHT monDHT(DHTPIN, DHTTYPE);

void setup(){
{
  Wire.begin();
 
  init_MPU6050();
  
  Serial.begin(115200);

  Gravity_Range_Option();
  
  Calib_MPU6050(); // Calculating calibration value
}
{
  Serial.begin(115200);
  monRTC.begin();
  monDHT.begin();

  Serial.print("Initialisation de la carte SD en cours...");
  if (SD.begin())
  {
    Serial.println(" Terminee.");
  } else
  {
    Serial.println(" Echec.");
    return;
  }  
  monFichier = SD.open("donnees.csv", FILE_WRITE);
  if (monFichier) 
  {   
    monFichier.println("Heure,AcX,AcY,AcZ");
    Serial.println("");
    Serial.println("   Heure  | AcX | AcY | AcZ ");
    monFichier.close();    
  } 
}
}
void loop(){
{
  ReadDate_MPU6050();

  Calc_Grvt();

  Display_Grvt();
  
  // On demande l'heure exacte au module Real Time Clock.
  String temps = String(monRTC.getTimeStr());

  // On met en forme la donnée au formar csv, c'est-à dire chaque paramètre séparé par une virgule.
  String donnee = temps + "," + AcX + "," + AcY + "," + AcZ;

  // On enregistre la donnée 
  monFichier = SD.open("donnees.csv", FILE_WRITE); //Maximum 8 caractères avant le .csv
  if (monFichier) 
  {   
    monFichier.println(donnee);
    Serial.println(" " + temps + " |    " + AcX + "    |   " + AcY + "    |   " + AcZ);
    monFichier.close();    
  } 
  else 
  {
    Serial.println("Impossible d'ouvrir le fichier");
  }  
  delay(10);
  }
}
void init_MPU6050(){
  //MPU6050 Initializing & Reset
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(0x6B);  // PWR_MGMT_1 register
  Wire.write(0);     // set to zero (wakes up the MPU-6050)
  Wire.endTransmission(true);

  //MPU6050 Clock Type
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(0x6B);  // PWR_MGMT_1 register
  Wire.write(0x03);     // Selection Clock 'PLL with Z axis gyroscope reference'
  Wire.endTransmission(true);

  //MPU6050 Accelerometer Configuration Setting
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(0x1C);  // Accelerometer Configuration register
  if(AFS_SEL == 0) Wire.write(0x00);     // AFS_SEL=0, Full Scale Range = +/- 2 [g]
  else if(AFS_SEL == 1) Wire.write(0x08);     // AFS_SEL=1, Full Scale Range = +/- 4 [g]
  else if(AFS_SEL == 2) Wire.write(0x10);     // AFS_SEL=2, Full Scale Range = +/- 8 [g]
  else  Wire.write(0x18);     // AFS_SEL=3, Full Scale Range = +/- 10 [g]
  Wire.endTransmission(true);

  //MPU6050 DLPF(Digital Low Pass Filter)
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(0x1A);  // DLPF_CFG register
  if(DLPF_SEL == 0) Wire.write(0x00);     // Accel BW 260Hz, Delay 0ms / Gyro BW 256Hz, Delay 0.98ms, Fs 8KHz 
  else if(DLPF_SEL == 1)  Wire.write(0x01);     // Accel BW 184Hz, Delay 2ms / Gyro BW 188Hz, Delay 1.9ms, Fs 1KHz 
  else if(DLPF_SEL == 2)  Wire.write(0x02);     // Accel BW 94Hz, Delay 3ms / Gyro BW 98Hz, Delay 2.8ms, Fs 1KHz 
  else if(DLPF_SEL == 3)  Wire.write(0x03);     // Accel BW 44Hz, Delay 4.9ms / Gyro BW 42Hz, Delay 4.8ms, Fs 1KHz 
  else if(DLPF_SEL == 4)  Wire.write(0x04);     // Accel BW 21Hz, Delay 8.5ms / Gyro BW 20Hz, Delay 8.3ms, Fs 1KHz 
  else if(DLPF_SEL == 5)  Wire.write(0x05);     // Accel BW 10Hz, Delay 13.8ms / Gyro BW 10Hz, Delay 13.4ms, Fs 1KHz 
  else  Wire.write(0x06);     // Accel BW 5Hz, Delay 19ms / Gyro BW 5Hz, Delay 18.6ms, Fs 1KHz 
  Wire.endTransmission(true);
}

void Gravity_Range_Option(){
  switch(AFS_SEL) { // Selecting Gravity unit value
    case 0:
      Grvt_unit = 16384;
      break;
    case 1:
      Grvt_unit = 8192;
      break;
    case 2:
      Grvt_unit = 4096;
      break;
    case 3:
      Grvt_unit = 3276.8;
      break;
  }
}  

void Calib_MPU6050() {  
  for(int i = 0 ; i < 2000 ; i++) { // Summing Iteration for finding calibration value
    if(i % 200 == 0) {  // Display progress every 200 cycles
      cnt++;
      if(cnt == 1)  { // Characters to display first
        Serial.print("Calculating .");
      }
      else  { // Display progress by point
        Serial.print(".");
      }      
    }    
    
    ReadDate_MPU6050(); // Read Accelerometer data
    
    delay(10);

    // Sum data
    Cal_AcX += AcX;
    Cal_AcY += AcY;
    Cal_AcZ += AcZ;
  }

  // Average Data
  Cal_AcX /= 2000;
  Cal_AcY /= 2000;
  Cal_AcZ /= 2000;

  // Serial Print
  Serial.println("");
  Serial.println("End of Calculation");
  Serial.print("Cal_AcX = "); Serial.print(Cal_AcX);
  Serial.print(" | Cal_AcY = "); Serial.print(Cal_AcY);
  Serial.print(" | Cal_AcZ = "); Serial.println(Cal_AcZ);
  
  delay(2000);
}

void ReadDate_MPU6050() {
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(0x3B);  // starting with register 0x3B (ACCEL_XOUT_H)
  Wire.endTransmission(false);
  //Wire.requestFrom(MPU_ADDR,14,true);  // request a total of 14 registers
  Wire.requestFrom(MPU_ADDR,6,true);  // request a total of 14 registers
  AcX=Wire.read()<<8|Wire.read();  // 0x3B (ACCEL_XOUT_H) & 0x3C (ACCEL_XOUT_L)     
  AcY=Wire.read()<<8|Wire.read();  // 0x3D (ACCEL_YOUT_H) & 0x3E (ACCEL_YOUT_L)
  AcZ=Wire.read()<<8|Wire.read();  // 0x3F (ACCEL_ZOUT_H) & 0x40 (ACCEL_ZOUT_L)
}

void Calc_Grvt() {
  AcX = (AcX - Cal_AcX);  // Calibrated Accelerometer value
  AcY = (AcY - Cal_AcY);  // Calibrated Accelerometer value
  AcZ = (AcZ - Cal_AcZ);  // Calibrated Accelerometer value
  
  GAcX = AcX / Grvt_unit; // Converting the Calibrated value to Gravity value
  GAcY = AcY / Grvt_unit; // Converting the Calibrated value to Gravity value
  GAcZ = AcZ / Grvt_unit; // Converting the Calibrated value to Gravity value

  //---------- Calculating Min, Max & Peak to Peak of Gravity --------------------------------------

  Min_GAcX = min(Min_GAcX, GAcX);
  Max_GAcX = max(Max_GAcX, GAcX);
  PtoP_GAcX = Max_GAcX - Min_GAcX;

  Min_GAcY = min(Min_GAcY, GAcY);
  Max_GAcY = max(Max_GAcY, GAcY);
  PtoP_GAcY = Max_GAcY - Min_GAcY;

  Min_GAcZ = min(Min_GAcZ, GAcZ);
  Max_GAcZ = max(Max_GAcZ, GAcZ);
  PtoP_GAcZ = Max_GAcZ - Min_GAcZ;
}  

void Display_Grvt() {
  //---------- Serial print ----------------------------------------------------------------------

    Min_GAcX = 0;
    Max_GAcX = 0;
    Min_GAcY = 0;
    Max_GAcY = 0;
    Min_GAcZ = 0;
    Max_GAcZ = 0;
}

Toutefois, j'ai un problème dans mon fichier.
J'obtiens :
"Heure,AcX,AcY,AcZ
00:81:85,-1,15,12
00:81:85,-6,-5,3
00:81:85,-4,1,5
00:81:85,6,-16,-22
00:81:85,-23,-8,7
00:81:85,-4,27,-11
00:81:85,12,14,18
00:81:85,-11,5,-12
00:81:85,0,33,-12
00:81:85,15,2,-15
00:81:85,-22,17,-9"

Le moniteur continue et fait beaucoup de données à la seconde, c'est parfait.
Mais j'ai besoin de l'heure pour avoir une fréquence, c'est essentiel même.
Sauf que mon temps ne varie pas même si mon horloge est une DS3231 avec une pile et que je l'ai réglée au préalable.

Sauriez-vous où se trouve mon erreur ? Ou sinon : Avez-vous une piste ?

Merci de votre compréhension.
Cordialement.
J.

Prenez un des exemples de votre bibliothèque RTC et faites le tourner pour vérifier que la RTC est fonctionnelle

Rajoutez un println() sur le port série de monRTC.getTimeStr() dans votre code pour voir ce que ça lit, le 85 dans 00:81:85 n’inspire pas vraiment confiance !

(Perso j’utilise la bibliothèque adafruit RTClib, laquelle avez vous choisie ?)

il a choisi ds3231.h de rinky-dink ,
derniere maj 2014
quand on tape ds3231 dans github langage c++, on a 372 réponses, quantité et qualité ne sont pas synonymes, hier j'ai trouvé un fameux bug dans une biblio rtc que j'avais installée depuis plusieurs années dans l'ide
que vient faire DHT dans le croquis ?
Bien à vous

Vous avez raison le problème de mon horloge n'est toujours pas résolu.
J'utilise ce programme :

#include <DS3231.h>

DS3231 monRTC(SDA, SCL);

void setup()
{
  Serial.begin(9600);
  monRTC.begin();
  
  monRTC.setDOW(WEDNESDAY);     // Set Day-of-Week to SUNDAY
  monRTC.setTime(12, 0, 0);     // Set the time to 12:00:00 (24hr format)
  monRTC.setDate(1, 1, 2014);   // Set the date to January 1st, 2014
}

void loop()
{
  Serial.print(monRTC.getDOWStr());
  Serial.print(" ");
  
  Serial.print(monRTC.getDateStr());
  Serial.print(" -- ");
  
  Serial.println(monRTC.getTimeStr());
  
  delay (1000);
}

Je ne comprends pas pourquoi il ne reconnait plus SDA, SCL, setDOW et le jour.
Ce week-end tout fonctionné pourtant.

Cordialement.

J'ai enlevé DHT de mon programme c'était un outil pour enregistrer une température, et humidité.
Je suis bloqué, je ne sais pas si mon horloge est grillé du fait du nombre de bauds élevé que je lui ai donné ou que je n'ai pas installé les bonnes librairies alors que pourtant j'ai bien fait attention à ça.

ça je ne sais pas ce que ça veut dire...

installez cette bibliothèque: RTClib ➜ GitHub - adafruit/RTClib: A fork of Jeelab's fantastic RTC library
prenez votre UNO et DS3231
connectez la DS3231 de la façon suivante:

  • SDA à la broche A4
  • SCL à la broche A5
  • VCC à la broche 5V
  • GND à la broche GND

connectez le UNO via USB à votre Mac/PC; chargez ce code d'exemple et ouvrez le moniteur série à 57600 bauds.

Que voyez vous dans le moniteur série ?

Ok, merci beaucoup j’essaie ça dès que je peux.

Le programme doit me donner la date d’aujourd’hui avec l’année, mois, jour, le nom du jour, l’heure, les minutes et les secondes ?

Merci.
Cordialement.
J.

Oui c'est ça (et la température du module)

Bonsoir,

le programme fonctionne et après avoir entré la date d'aujourd'hui :

// Date and time functions using a DS3231 RTC connected via I2C and Wire lib
#include "RTClib.h"

RTC_DS3231 rtc;

char daysOfTheWeek[7][12] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};

void setup () {
  Serial.begin(57600);

#ifndef ESP8266
  while (!Serial); // wait for serial port to connect. Needed for native USB
#endif

  if (! rtc.begin()) {
    Serial.println("Couldn't find RTC");
    Serial.flush();
    while (1) delay(10);
  }

  if (rtc.lostPower()) {
    Serial.println("RTC lost power, let's set the time!");
    // When time needs to be set on a new device, or after a power loss, the
    // following line sets the RTC to the date & time this sketch was compiled
    rtc.adjust(DateTime(2021, 11, 23, 7, 38, 0));
    // This line sets the RTC with an explicit date & time, for example to set
    // January 21, 2014 at 3am you would call:
    //rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
  }

  // When time needs to be re-set on a previously configured device, the
  // following line sets the RTC to the date & time this sketch was compiled
  // rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  // This line sets the RTC with an explicit date & time, for example to set
  // January 21, 2014 at 3am you would call:
  // rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
}

void loop () {
    DateTime now = rtc.now();

    Serial.print(now.year(), DEC);
    Serial.print('/');
    Serial.print(now.month(), DEC);
    Serial.print('/');
    Serial.print(now.day(), DEC);
    Serial.print(" (");
    Serial.print(daysOfTheWeek[now.dayOfTheWeek()]);
    Serial.print(") ");
    Serial.print(now.hour(), DEC);
    Serial.print(':');
    Serial.print(now.minute(), DEC);
    Serial.print(':');
    Serial.print(now.second(), DEC);
    Serial.println();

    Serial.print(" since midnight 1/1/1970 = ");
    Serial.print(now.unixtime());
    Serial.print("s = ");
    Serial.print(now.unixtime() / 86400L);
    Serial.println("d");

    // calculate a date which is 7 days, 12 hours, 30 minutes, 6 seconds into the future
    DateTime future (now + TimeSpan(7,12,30,6));

    Serial.print(" now + 7d + 12h + 30m + 6s: ");
    Serial.print(future.year(), DEC);
    Serial.print('/');
    Serial.print(future.month(), DEC);
    Serial.print('/');
    Serial.print(future.day(), DEC);
    Serial.print(' ');
    Serial.print(future.hour(), DEC);
    Serial.print(':');
    Serial.print(future.minute(), DEC);
    Serial.print(':');
    Serial.print(future.second(), DEC);
    Serial.println();

    Serial.print("Temperature: ");
    Serial.print(rtc.getTemperature());
    Serial.println(" C");

    Serial.println();
    delay(3000);
}

j'obtiens sur le moniteur série :

19:45:29.085 -> 2021/11/23 (Tuesday) 19:45:24
19:45:29.085 ->  since midnight 1/1/1970 = 1637696724s = 18954d
19:45:29.085 ->  now + 7d + 12h + 30m + 6s: 2021/12/1 8:15:30
19:45:29.085 -> Temperature: 23.25 C
19:45:29.122 -> 
19:45:32.077 -> 2021/11/23 (Tuesday) 19:45:27
19:45:32.114 ->  since midnight 1/1/1970 = 1637696727s = 18954d
19:45:32.114 ->  now + 7d + 12h + 30m + 6s: 2021/12/1 8:15:33
19:45:32.114 -> Temperature: 23.25 C
19:45:32.114 -> 
19:45:35.117 -> 2021/11/23 (Tuesday) 19:45:30
19:45:35.117 ->  since midnight 1/1/1970 = 1637696730s = 18954d
19:45:35.117 ->  now + 7d + 12h + 30m + 6s: 2021/12/1 8:15:36
19:45:35.117 -> Temperature: 23.25 C
19:45:35.117 -> 
19:45:38.128 -> 2021/11/23 (Tuesday) 19:45:33
19:45:38.128 ->  since midnight 1/1/1970 = 1637696733s = 18954d
19:45:38.128 ->  now + 7d + 12h + 30m + 6s: 2021/12/1 8:15:39
19:45:38.166 -> Temperature: 23.25 C
19:45:38.166 -> 
19:45:41.125 -> 2021/11/23 (Tuesday) 19:45:36
19:45:41.162 ->  since midnight 1/1/1970 = 1637696736s = 18954d
19:45:41.162 ->  now + 7d + 12h + 30m + 6s: 2021/12/1 8:15:42
19:45:41.162 -> Temperature: 23.50 C
19:45:41.162 -> 
19:45:44.171 -> 2021/11/23 (Tuesday) 19:45:39
19:45:44.171 ->  since midnight 1/1/1970 = 1637696739s = 18954d
19:45:44.171 ->  now + 7d + 12h + 30m + 6s: 2021/12/1 8:15:45
19:45:44.171 -> Temperature: 23.25 C
19:45:44.171 -> 
19:45:47.192 -> 2021/11/23 (Tuesday) 19:45:42
19:45:47.192 ->  since midnight 1/1/1970 = 1637696742s = 18954d
19:45:47.192 ->  now + 7d + 12h + 30m + 6s: 2021/12/1 8:15:48
19:45:47.192 -> Temperature: 23.50 C
19:45:47.192 -> 
19:45:50.185 -> 2021/11/23 (Tuesday) 19:45:45
19:45:50.185 ->  since midnight 1/1/1970 = 1637696745s = 18954d
19:45:50.185 ->  now + 7d + 12h + 30m + 6s: 2021/12/1 8:15:51
19:45:50.221 -> Temperature: 23.25 C
19:45:50.221 -> 
19:45:53.202 -> 2021/11/23 (Tuesday) 19:45:48
19:45:53.202 ->  since midnight 1/1/1970 = 1637696748s = 18954d
19:45:53.202 ->  now + 7d + 12h + 30m + 6s: 2021/12/1 8:15:54
19:45:53.239 -> Temperature: 23.25 C
19:45:53.239 -> 
19:45:56.216 -> 2021/11/23 (Tuesday) 19:45:51
19:45:56.216 ->  since midnight 1/1/1970 = 1637696751s = 18954d
19:45:56.216 ->  now + 7d + 12h + 30m + 6s: 2021/12/1 8:15:57
19:45:56.252 -> Temperature: 23.25 C
19:45:56.252 -> 
19:45:59.244 -> 2021/11/23 (Tuesday) 19:45:54
19:45:59.244 ->  since midnight 1/1/1970 = 1637696754s = 18954d
19:45:59.244 ->  now + 7d + 12h + 30m + 6s: 2021/12/1 8:16:0
19:45:59.244 -> Temperature: 23.25 C
19:45:59.244 -> 

J'ai l'impression que mon horloge fonctionne.

Pour éviter toute mauvaise compréhension je vous préviens que je n'ai pas besoin de température. Il me suffit de prendre les valeurs sur chaque axe de l'accéléromètre et de les enregistrer chronologiquement afin de les exploiter plus tard. SI j'avais du DHT c'est parce que le programme originel devait enregistrer des données de température et d'humidité. Ce qui n'est pas mon cas. Je pense que vous aviez compris ce paragraphe à pour but d'éliminer les ambiguïtés.

De plus par rapport aux bauds élevé, il est vrai que je me suis mal exprimé. Je voulais souligner le fait que j'ai changé le programme originel en passant de 9600 bauds à 115200 bauds. Etant donné que 9600 bauds est environ égale à 9,6kHz et 115,200kHz pour l'autre paramètre si je ne me trompe pas. Donc je me suis dis que la cause venait de là. C'est peut-être faux, c'est une hypothèse.

Il en découle une question que je me pose : "Comment faire pour avoir le même nombre de baud dans tout le programme. Il suffit juste de remplacer et d'avoir le même nombre partout ou c'est plus compliqué ?"

Merci de votre compréhension.
Cordialement.
J.

La vitesse en baud dont vous parlez c’est pour le port série (la communication avec votre PC via USB), ça n’a rien à voir avec la RTC qui utilise un autre protocole, le I2C.

Votre RTC fonctionne donc - continuez avec cette bibliothèque