Modication en place d'un float

Bonjour à tous,

Je cherche à incrémenter (à chaque tour de mon loop) une variable af. Je l’initialise donc à 0 (dans mon setup), puis je l’incremente à chaque tour d’une valeur calculée.

Ma fonction me renvoie “nan” : pourquoi ? nan = not a number, mais encore ?

Voici le code complet :

#include "Wire.h" // Librairie Wire Arduino
#include "I2Cdev.h" // Librairie permettant les échanges par protocole I2C
#include "MPU6050.h" // Librairie propre à l'accéléromètre
#include "math.h" // Contient des fonctions mathématiques



// Definition des variables :

MPU6050 accel; // nom de l'accéléromètre
int16_t ax, ay, az, gx, gy, gz; // mesure brute des accélérations (sur 16bits)
int buzzer = 2; // Borne de sortie = borne 2
float alpha; // angle (x,g)
float beta; // angle (y,g)
float gamma; // angle (z,g)
bool booleen; // booléen !
float dt = 0.05; // intervalle de temps (en secondes) pour l'intégration
float accelx, accely, accelz; // accélérations calculées
float accelVerticale; // accélération verticale à t
float vitesseVerticale = 0; // vitesse verticale (obtenue par intégration)

float fc = 50; // fréquence d'échantillonnage (passe-bas)
float Tc = 1/(2*3.14*fc); // période d'échantillonage
float af = 0; // accélération filtrée


// Initialisation :

void setup() {
  Wire.begin(); // débute la communication I2C
  pinMode(buzzer, OUTPUT); // le buzzer est la sortie du montage
  
  Serial.begin(9600); // permet l'affichage des données lues
  Serial.println("Initialisation I2C...");
  accel.initialize(); // initialisation I2C
  Serial.println("Test de la connexion du dispositif...");
  Serial.println(accel.testConnection() ? "Echec de la connexion" : "Connexion réussie"); // test de la connexion à l'accéléromètre
  Serial.println("CLEARDATA");
  Serial.println("LABEL,time,az,azf");
  Serial.println("RESETTIMER");
    // L'objectif est ici de tester si le variomètre est vertical, cela avec une erreur de 4%.
    // On utilise pour cela la mesure de la gravité terrestre : si l'accélération suivant
    // l'axe z est supérieure à 0.96*9,81, on peut initialiser l'angle gamma à 0, les deux
    // autres à pi.
  accel.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
  while (abs(az) < 0.96*16384) {
    Serial.println("Calibrage...");
  }
  alpha, beta, gamma = PI, PI, 0;
}


void integrationAngles(float *angles){
    // Ici, on va mesurer les angles des axes x,y,z de l'accéléromètre avec l'axe vertical.
    // Pour cela, on intègre les vitesses angulaires délivrées par le gyroscope.
    // Les angles renvoyés sont en rad.
  accel.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
  alpha = alpha + (float(gx)*dt/131)*2*PI/360;
  beta = beta + (float(gy)*dt/131)*2*PI/360;
  gamma = gamma + (float(gy)*dt/131)*2*PI/360;
  angles[0] = alpha;
  angles[1] = beta;
  angles[2] = gamma;
}


float acceleration(){
    // Renvoie l'accélération à un instant t
  float angles[3];
  accel.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
  integrationAngles(angles);
  accelx = float(ax)*cos(angles[0])*9.81/16384;
  accely = float(ay)*cos(angles[1])*9.81/16384;
  accelz = float(az)*cos(angles[2])*9.81/16384;
  accelVerticale = sqrt(pow(accelx,2) + pow(accely,2) + pow(accelz,2)) - 9.81;
  return(accelVerticale);
}

//=========================================================== Filtrage de l'accélération =======================================================

// ===== Filtre passe-bas :

float passe_bas(float a){
  af = (dt/Tc)*(a-af)+af;
  return(af);
}

// ===== Moyenne glissante :

float moyenne_glissante(){
  
}

//=================================================================== Intégration ==============================================================

// ===== Méthode des trapèzes :

float trapeze(){
    //Renvoie la vitesse verticale par intégration de l'accélération (méthode des trapèzes)
  float accel1 = acceleration();
  vitesseVerticale = vitesseVerticale + accel1*dt;
  delay(50); // attente de 0.05 s
  return(vitesseVerticale);
}

// ===== 

void loop(){
  Serial.print("DATA,TIME");
  Serial.print(acceleration());
  float accel_non_filtre = acceleration();
  Serial.println(passe_bas(accel_non_filtre));
}

Merci d’avance !

Merci d’avance

Bonjour,

alpha, beta, gamma = PI, PI, 0;
ne fait certainement pas ce que tu veux.
C’est équivalent à
gamma=0;

Il faut couper l’initialisation en 3 (ou en deux mais je trouve que c’est moins clair)

alpha=beta=PI;
gamma=0;

Déjà une erreur de corrigée, merci ! Et quant à mon problème principal ?

Merci d'avance.

  while (abs(az) < 0.96 * 16384) {
    Serial.println("Calibrage...");
  }

ne doit pas fonctionner car az n’est pas modifié dans la boucle. Il faut relire les angles dans la boucle.

C'est modifié, merci. Et j'aimerais comprendre pourquoi ma fonction passe_bas retourne un nan. Sauriez vous me dire ?

Soit Tc est égal à 0 soit une des variables est à nan. Dans la fonction passe_bas, affiches les variables utilisées avant le calcul.

C'est donc Tc qui était trop petit, ie nul. Merci !