Déclenchement d'une temporisation et de l'allumage d'une e-match en fonction de l'altitude.

Salut à tous,
Suite au problème de carte électronique lors du séjour des Lycéens de Jean-Baptiste Say (Paris), qui ne donnait pas assez de puissance à l'e-match (choix du transistor,d'où les crash), j'ai réfléchi à pouvoir déclencher grâce à un capteur barométrique la temporisation puis l'allumage de l'e-match.
Le programme fait une première mesure (sur la rampe) qui sera l'altitude de départ du modèle (ou référence) puis tous les 100ms il prend à nouveau l'altitude et la compare à l'altitude de départ. Si la différence est inférieure à une valeur spécifiée par l'utilisateur, il ne se passe rien en revanche si la différence est plus grande, il démarre une temporisation définie par l'utilisateur(ici 5s). Une fois le délai écoulé, il alimente la sortie pyro pendant une seconde (réglable par l'utilisateur).
J'ai ajouté au programme un compteur, ainsi si la différence d'altitude a été atteinte une première fois, il n'y a pas de répétition de la tempo+allumage due à la fonction void loop() et une altitude du modèle qui progresse au-delà de la valeur spécifiée.
Le montage présenté dans la vidéo ne comprend pas l'interrupteur qui initialise l'arduino ni le transistor qui doit délivrer la puissance à l'e-match



De gauche à droite :
- 1ère LED rouge : allumée au démarrage, elle s'éteint lorsque le capteur (BMP180) est initialisé
- 2ème LED rouge : s'allume pour indiquer que l'altitude de référence a été mesurée
- 1ère LED verte : s'allume pour indiquer que la différence d'altitude a été atteinte et que la tempo démarre. Elle s'éteint à la fin de la tempo
- 2ème LED verte : s'allume pendant toute la durée d'alimentation de la sortie pyro

Voici le code ci-dessous :


/* SFE_BMP180 altitude example sketch

This sketch shows how to use the Bosch BMP180 pressure sensor
as an altimiter.
https://www.sparkfun.com/products/11824

Like most pressure sensors, the BMP180 measures absolute pressure.
Since absolute pressure varies with altitude, you can use the pressure
to determine your altitude.

Because pressure also varies with weather, you must first take a pressure
reading at a known baseline altitude. Then you can measure variations
from that pressure

Hardware connections:

- (GND) to GND
+ (VDD) to 3.3V

(WARNING: do not connect + to 5V or the sensor will be damaged!)

You will also need to connect the I2C pins (SCL and SDA) to your
Arduino. The pins are different on different Arduinos:

Any Arduino pins labeled:  SDA  SCL
Uno, Redboard, Pro:        A4   A5
Mega2560, Due:             20   21
Leonardo:                   2    3

Leave the IO (VDDIO) pin unconnected. This pin is for connecting
the BMP180 to systems with lower logic levels such as 1.8V

Have fun! -Your friends at SparkFun.

The SFE_BMP180 library uses floating-point equations developed by the
Weather Station Data Logger project: http://wmrx00.sourceforge.net/

Our example code uses the "beerware" license. You can do anything
you like with this code. No really, anything. If you find it useful,
buy me a beer someday.

V10 Mike Grusin, SparkFun Electronics 10/24/2013
V1.1.2 Updates for Arduino 1.6.4 5/2015
*/

// Your sketch must #include this library, and the Wire library.
// (Wire is a standard library included with Arduino.):

#include <SFE_BMP180.h>
#include <Wire.h>

// You will need to create an SFE_BMP180 object, here called "pressure":

SFE_BMP180 pressure;

double baseline; // baseline pressure

int L1 = 4;
int L2 = 5;
int L3 = 6;
int L4 = 7;

int count=0;

void setup()
{
   pinMode(L1,OUTPUT);
 pinMode(L2,OUTPUT);
 pinMode(L3,OUTPUT);
   pinMode(L4,OUTPUT);
 digitalWrite(L1,HIGH);
 Serial.begin(9600);
 Serial.println("REBOOT");
delay(1000);
 // Initialize the sensor (it is important to get calibration values stored on the device).

 if (pressure.begin()){
   Serial.println("BMP180 init success");
 digitalWrite(L1,LOW);
 delay (1000);
 }
   
 else
 {
   // Oops, something went wrong, this is usually a connection problem,
   // see the comments at the top of this sketch for the proper connections.

   Serial.println("BMP180 init fail (disconnected?)\n\n");
   while(1); // Pause forever.
 }

 // Get the baseline pressure:
 
 baseline = getPressure();
 float a=baseline/1013;
 float b=pow(a,0.19);
 float c=1-b;
 float d=44330*c;
 Serial.print("baseline pressure: ");
 Serial.print(baseline);
 Serial.println(" mb");
 Serial.print(d);
 Serial.println(" m");  
 digitalWrite(L2,HIGH);
}

void loop()
{
 double a,P;
 
 // Get a new pressure reading:

 P = getPressure();

 // Show the relative altitude difference between
 // the new reading and the baseline reading:

 a = pressure.altitude(P,baseline);
 Serial.println(count);  
 Serial.print("relative altitude: ");
 if (a >= 0.0) Serial.print(" "); // add a space for positive numbers
 Serial.print(a,1);
 Serial.println(" meters, ");
 if (a >= 0.0) Serial.print(" "); // add a space for positive numbers
if(a>1 && count<1){
 count=count+1;
 digitalWrite(L3,HIGH);
 Serial.println("Demarrage temporisation");
 delay(5000);
 Serial.println("Fin de la temporisation");
 digitalWrite(L3,LOW);
 digitalWrite(L4,HIGH);
 delay(1000);
 digitalWrite(L4,LOW);  
 }
 
 delay(100);
}


double getPressure()
{
 char status;
 double T,P,p0,a;

 // You must first get a temperature measurement to perform a pressure reading.
 
 // Start a temperature measurement:
 // If request is successful, the number of ms to wait is returned.
 // If request is unsuccessful, 0 is returned.

 status = pressure.startTemperature();
 if (status != 0)
 {
   // Wait for the measurement to complete:

   delay(status);

   // Retrieve the completed temperature measurement:
   // Note that the measurement is stored in the variable T.
   // Use '&T' to provide the address of T to the function.
   // Function returns 1 if successful, 0 if failure.

   status = pressure.getTemperature(T);
   if (status != 0)
   {
     // Start a pressure measurement:
     // The parameter is the oversampling setting, from 0 to 3 (highest res, longest wait).
     // If request is successful, the number of ms to wait is returned.
     // If request is unsuccessful, 0 is returned.

     status = pressure.startPressure(3);
     if (status != 0)
     {
       // Wait for the measurement to complete:
       delay(status);

       // Retrieve the completed pressure measurement:
       // Note that the measurement is stored in the variable P.
       // Use '&P' to provide the address of P.
       // Note also that the function requires the previous temperature measurement (T).
       // (If temperature is stable, you can do one temperature measurement for a number of pressure measurements.)
       // Function returns 1 if successful, 0 if failure.

       status = pressure.getPressure(P,T);
       if (status != 0)
       {
         return(P);
       }
       else Serial.println("error retrieving pressure measurement\n");
     }
     else Serial.println("error starting pressure measurement\n");
   }
   else Serial.println("error retrieving temperature measurement\n");
 }
 else Serial.println("error starting temperature measurement\n");
}


Je nettoierai le code notamment en retirant les infos inutiles et en commentant ce qui est nécessaire.
Bonne lecture
Amicalement,
Romuald

Salut , intéressant merci pour le partage.
Je ne connaissais pas les e-matchs, ca ressemble fort a un allumage electrique classique comme ceux la: http://www.sierrafoxhobbies.com/fr/motor-igniters/469-starters-estes-0047776023024.html, ou bien j'ai pas tout compris... ?  

Pour le déclenchement du délai, j'avais pensé a une methode utilisant plutot la vitesse que la position, par un calcul dx/dt. A l'apogée  la  vitesse devrait etre reduite voisine de 0, ce qui permettrait de declencher le parachute, ou une tempo.
Par securité, j'y ajouterais  un calcul par rapport  a la pression de depart, de facon a declencher  le parachute aussi sur la perte d'altitude et même si la vitesse de la fusée ne se réduit pas suffisamment (parabole écrasée)

voici la methode que j'utilise
https://github.com/bdureau/AltiUno
je fais du filtrage nuémérique pour dégager tous les parasites
Je detecte un décolage lorsque l'altitude est supérieure à 20 m par rapport à l'altitude au sol puis je calcule l'apogée lorsque 5 ou 10 mesures concecutives sont inférieures à l'altitude max
C'est sur ce principe que fonctionnent tous mes altimetres

@obor : non les e-match dont je parle sont de ce type http://www.sierrafoxhobbies.com/fr/e-matches-pour-charge-d-expulsion/1398-e-match-chip-type.html.

@boris : mon objectif était de réaliser un système simple à base d'une tempo pour Pablo du Lycée Jean-Baptiste Say car comme il te l'a dit il ne se sent pas les capacités de refaire ce que tu as réalisé avec tes altis. C'est d'ailleurs pour cela qu'avec son collègue ils avaient proposé une carte avec une temporisation lors du séjour de février. Je vais essayer d'inclure le filtre Kalman dans mon programme.

Bien que l’électronique ne me passionne pas du tout, je suis toujours en admiration.
Bravo Romu

Après un échange téléphonique fructueux avec Boris, j'ai pu intégrer un filtre de Karman à mon programme Arduino.
Je vous livre ci-dessous le nouveau code et en français !!!

/* Exemple de programme de mesure d'altitude utlilisant la librairie SFE_BMP180

Ce programme montre comment utiliser le capteur de pression Bosch BMP180
en tant qu'altimètre.
https://www.sparkfun.com/products/11824

Comme la pluspart des capteurs de pression, le BMP180 mesure la pression absolue.
Sachant que la presssion absolue varie avec l'altitude, vous pouvez utiliser la pression
pour déterminer l'altitude.

Etant donné que la pression varie avec la météo, vous devez d'abord faire une première mesure de la pression
à l'altitude initiale. Ensuite vous pouvez mesurer des variations à partir de cette mesure initiale.

Connections matérielles:

- (GND) à GND
+ (VDD) à 3.3V

(ATTENTION: ne pas connecter le + au 5V ou bien le capteur pourrait être endommagé!)

Vous allez aussi devoir connecter les broches I2C (SCL et SDA) à votre Arduino.
Les broches diffèrent selon l'Arduino :

                         SDA  SCL
Uno, Redboard, Pro:        A4   A5
Mega2560, Due:             20   21
Leonardo:                   2    3

Ne pas connecter la broche IO (VDDIO). Cette broche est utilisée pour connecter le BMP180 à des systèmes avec des
niveaux logiques plus bas tel que 1.8V

Amusez-vous! -Vos amis de SparkFun.

La librairie SFE_BMP180 utilise des équations à virgules flottantes développées par
Weather Station Data Logger project: http://wmrx00.sourceforge.net/

Notre exemple de code utilise la "beerware" license. Vous pouvez faire ce que vous voulez avec ce code.
Non vraiment, ce que vous voulez. Si vous le trouvez utile, offrez-moi une bière un jour.

V10 Mike Grusin, SparkFun Electronics 10/24/2013
V1.1.2 Mis à jour pour Arduino 1.6.4 en mai 2015
*/

// Votre programme doit inclure cette librairie et la librairie Wire.
// (Wire est une libraiie standard intégrée à Arduino.):

#include
#include

// Création de l'objet SFE_BMP180, appelé pressure:

SFE_BMP180 pressure;

double baseline; // pression initiale

int L1 = 4; // Définition de la broche de la LED indiquant l'initialisation. S'éteint lorsque le BMP180 est initialisé.
int L2 = 5; // Définition de la broche de la LED indiquant que la mesure de pression de base est réalisée
int L3 = 6; // Définition de la broche de la LED de la temporisation. S'allume lorsque la temporisation débute puis s'éteint en fin de temporisation.
int L4 = 7; // Définition de la broche de la LED de sortie pyro. Reste allumée pendant la durée d'alimentation de la sortie pyro.

int count=0; // déclaration d'une variable pour le compteur

//Variables du filtre Kalman
float f_1=1.00000;  //déclarée comme flottante
float kalman_x;
float kalman_x_last;
float kalman_p;
float kalman_p_last;
float kalman_k;
float kalman_q;
float kalman_r;
float kalman_x_temp;
float kalman_p_temp;
//Fin de déclaration des variables du filtre Kalman

void setup()
{
   pinMode(L1,OUTPUT);
   pinMode(L2,OUTPUT);
   pinMode(L3,OUTPUT);
   pinMode(L4,OUTPUT);
   digitalWrite(L1,HIGH); // Allumage de la LED d'initialisation du BMP180
   Serial.begin(9600);
   Serial.println("REBOOT");
   delay(1000);

 // Initialise le capteur (Il est important d'avoir des valeurs de calibration stockées).

 if (pressure.begin()){
   Serial.println("Succès de l'initialisation du BMP180");
   digitalWrite(L1,LOW); // Extinction de la LED d'initialisation du BMP180
   delay (1000);
 }
   
   else
 {
   // Oups, quelque chose ne s'est pas correctement déroulé, il s'agit souvent d'un problème de connection,
   // Voire les commentaires plus haut relatifs aux bonne connections.

   Serial.println("Echec d'initialisation du BMP180 (déconnecté?)\n\n");
   while(1); // Pause inifinie.
 }

//Initialisation du filtre Kalman
 KalmanInit();
 
  // Réalisons quelques mesures d'altitude
 // afin d'initialiser le filtre Kalman
 for (int i=0; i<50; i++){
   KalmanCalc(getPressure());
  }
 //Obtention de l'altitude du site de lancement
 long sum = 0;
 for (int i=0; i<10; i++){
     sum += KalmanCalc(getPressure());
 delay(50); }
 baseline = (sum / 10.0);

 float a=baseline/1013;
 float b=pow(a,0.19);
 float c=1-b;
 float d=44330*c;
 Serial.print("Pression initiale : ");
 Serial.print(baseline);
 Serial.print(" mb     ");
 Serial.print("Altitude initiale : ");
 Serial.print(d);
 Serial.println(" m");  
 digitalWrite(L2,HIGH); // Allumage de la LED indiquant que la mesure d'altitude initiale a été réalisée.
}

void loop()
{
 double a,P;
 
 // Mesure de la pression pendant le vol:

 P = KalmanCalc(getPressure());

 // Calcule de la différence relative entre
 // la nouvelle mesure et la mesure initiale:

 a = pressure.altitude(P,baseline);
 float b=a+5; // addition d'un offset pour obtenir une altitude relative inférieure à 1 quand le modèle est sur la rampe
 Serial.print("Etat du compteur : ");
 Serial.println(count);  
 Serial.print("Altitude relative : ");
//  if (b >= 0.0) Serial.print(" "); // ajoute un espace pour les nombres positifs
 Serial.print(b,1);
 Serial.println(" m");
//  if (b >= 0.0) Serial.print(" "); // ajoute un espace pour les nombres positifs
 
// Si l'altitude relative est supérieure à 1m et cela pour la première fois,
// count=count+1 sert à ce que l'allumage pyro n'ait lieu qu'une seule fois, sur la rampe et non
// pendant toute la durée du vol, alors il y a alimentation de la sortie pyro.
if(b>1 && count<1){
 count=count+1;
 digitalWrite(L3,HIGH); // Allumage de la LED indiquant le démarrage de la temporisation.
 Serial.println("Demarrage temporisation");
 delay(5000); // Durée de la temporisation à modifier selon besoin.
 Serial.println("Fin de la temporisation");
 digitalWrite(L3,LOW); // Extinction de la LED indiquant la fin de la temporisation.
 digitalWrite(L4,HIGH); // Alimentation de la sortie pyro et Allumage de la LED correspondante.
 delay(2000); // Durée de l'alimentation de la sortie pyro à modifier selon besoin.
 digitalWrite(L4,LOW); // Fin d'alimentation de la sortie pyro et extinction de la LED correspondante.
 }
 
 delay(100);
}


double getPressure()
{
 char status;
 double T,P,p0,a;

 // Vous obtenez d'abord une mesure de la température afin d'effectuer une mesure de pression.
 
 // Débute une mesure de température :
 // Si la requête aboutit, le nombre de ms à attendre est retournée.
 // Si la requête échoue, 0 est retourné.

 status = pressure.startTemperature();
 if (status != 0)
 {
   // Attend que la mesure soit achevée :

   delay(status);

   // Récupère la mesure de température :
   // Remarquez que cette valeur est stockée dans la variable T.
   // Utilise '&T' pour fournir l'adresse de T à la fonction.
   // La Fonction retourne 1 si réussie, 0 si échec.

   status = pressure.getTemperature(T);
   if (status != 0)
   {
     // Débute une meure de pression :
     // Le paramètre est le réglage du sur-échantillonnage, de 0 à 3 (haute résolution = longue attente).
     // Si la requête aboutit, le nombre de ms à attendre est retournée.
     // Si la requête échoue, 0 est retourné.

     status = pressure.startPressure(3);
     if (status != 0)
     {
       // Attend que la mesure soit achevée :
       delay(status);
       // Récupère la mesure de pression :
       // Remarquez que cette valeur est stockée dans la variable P.
       // Utilise '&P' pour fournir l'adresse de P.
       // Remarquez que la fonction requiert la mesure de température (T) précédemment obtenue.
       // (Si la température est stable, vous pouvez ne faire qu'une seule mesure de température pour vos mesures de pression)
       // La fonction retourne 1 si réussie, 0 si échec.

       status = pressure.getPressure(P,T);
       if (status != 0)
       {
         return(P);
       }
       else Serial.println("Mesure de pression impossible\n");
     }
     else Serial.println("Impossible de démarrer la mesure de pression\n");
   }
   else Serial.println("Mesure de température impossible\n");
 }
 else Serial.println("Impossible de démarrer la mesure de température\n");
}

//================================================================
// Fonctions de Kalman
//================================================================

//Appelle  KalmanInit() un fois.  

//KalmanInit() - Appel avant toute itération de  KalmanCalc()
void KalmanInit()
{
  kalman_q=4.0001;  //paramètres du filtre, vous pouvez les modifier.
  kalman_r=.20001;  // mais ces valeurs semblent optimales

  kalman_x = 0;
  kalman_p = 0;
  kalman_x_temp = 0;
  kalman_p_temp = 0;
 
  kalman_x_last = 0;
  kalman_p_last = 0;
 
}

//KalmanCalc() - Calcule les nouvelles valeurs du filtre Kalman à partir de la valeur flottante "altitude".
// Ceci sera l'altitude ASL pendant le vol et l'altitude AGL pendant le dépôt.
float KalmanCalc (float altitude)
{
 
  //Prédit kalman_x_temp, kalman_p_temp
  kalman_x_temp = kalman_x_last;
  kalman_p_temp = kalman_p_last + kalman_r;
 
  //Actualise les valeurs du filtre Kalman
  kalman_k = (f_1/(kalman_p_temp + kalman_q)) * kalman_p_temp;
  kalman_x = kalman_x_temp + (kalman_k * (altitude - kalman_x_temp));
  kalman_p = (f_1 - kalman_k) * kalman_p_temp;
 
  //Sauvegarde cet état pour la suite
  kalman_x_last = kalman_x;
  kalman_p_last = kalman_p;
 
  //Affecte l'altitude courante filtrée Kalman aux variables en cours.
 return kalman_x;
}  

Avec et sans le Kalman (à préciser que le BMP180 est donné avec une résolution de 25cm):

Romu c'est nickel
Très bonne analyse ta courbe

Prochaine étape il faut que tu developpe un kit. Tu sais router un PCB?

Sympa, bravo.
Pour publier le code, il y a github, c'est tres pratique et ca garde l'historique. Suffit de se crer un compte: github

bdureau a écrit:Prochaine étape il faut que tu developpe un kit. Tu sais router un PCB?

Non je ne sais pas faire mais j'avais dans l'idée d'apprendre. J'ai vu des tutos sur Youtube, notamment avec EasyEDA.

Perso lorsque tu debutes TCI est pas mal
Ensuite il ya Eagle et KiCad qui est OpenSource
Peut importe lequel tu utilises, au final il faut produir des fichiers Gerber que tu peux envoyer en Chine pour qu'ils te fassent les cartes.
Bon evidement on en rate quelques une mais après ça donne un resultat sympa

Je confirme e que dit Boris.

Pour la réalisation du PCB, j'ai dans l'idée de tester cette méthode DIY :

Voici le tuto concernant EasyEDA :

tu peux dans un premier temps faire comme ça mais si tu voulais envisager une production de kit pour votre centre astro, pour moins de 10 euros port compris tu peux faire 10 cartes.

Voici la version du programme Arduino qui sera testé prochainement. A la version précédente (voir plus haut dans ce post), j'ai ajouté le fait d'enregistrer sur carte microSD l'altitude pendant le vol.

/* Programme de déclenchement d'une charge d'éjection pour fusée :
Ce programme utilise un capteur BMP180 et un circuit équipé d'un lecteur/enregistreur de carte microSD.
A la mise en route, le programme démmarre une série de 50 mesures barométriques afin de déterminer
l'altitude du site de lancement. Une fois celà fait, le programme continue les mesures de pressions
toutes les 100ms. Si l'altitude mesurée est supérieure à 1m par rapport à l'altitude du site, le
programme déclenche une temporisation réglée initialement par l'utilisateur (déterminée à partir
de la simulation OpenRocket ou Rocksim). A la fin de la temporisation, le programme active pendant
2s la sortie pyro.

Connections du capteur BMP180:

- (GND) à GND
+ (VDD) à 3.3V (ATTENTION: ne pas connecter le + au 5V ou bien le capteur pourrait être endommagé!)

Vous allez aussi devoir connecter les broches I2C (SCL et SDA) à votre Arduino.
Les broches diffèrent selon l'Arduino :

                         SDA  SCL
Uno, Redboard, Pro:        A4   A5
Mega2560, Due:             20   21
Leonardo:                   2    3

Connections du lecteur/enregistreur de carte microSD (Arduino Uno et Nano):

- (GND) à GND
+ (VDD) à 5V
MISO : D12
MOSI : D11
SCK  : D13
CS   : D10
*/


#include // librairie pour le capteur de pression
#include // librairie pour le capteur de pression

#include // librairie pour le lecteur/enregistreur de carte MicroSD
#include // librairie pour le lecteur/enregistreur de carte MicroSD


// Création de l'objet SFE_BMP180, appelé pressure:

SFE_BMP180 pressure;

double moyenne; // moyenne des mesures pour l'obtention de l'altitude du site
double baseline; // pression initiale

int L1 = 4; // Définition de la broche de la LED indiquant l'initialisation. S'éteint lorsque le BMP180 est initialisé.
int L2 = 5; // Définition de la broche de la LED indiquant que la mesure de pression de base est réalisée
int L3 = 6; // Définition de la broche de la LED de la temporisation. S'allume lorsque la temporisation débute puis s'éteint en fin de temporisation.
int L4 = 7; // Définition de la broche de la LED indiquant que les mesures sont effectuées et enregistrées
int pyro = 8; // Définition de la broche de la sortie pyro. Reste allumée pendant la durée d'alimentation de la sortie pyro.

int count=0; // déclaration d'une variable pour le compteur

// Variables du filtre Kalman
float f_1=1.00000;  // déclarée comme flottante
float kalman_x;
float kalman_x_last;
float kalman_p;
float kalman_p_last;
float kalman_k;
float kalman_q;
float kalman_r;
float kalman_x_temp;
float kalman_p_temp;
// Fin de déclaration des variables du filtre Kalman

File monFichier; // Déclaration de l'objet fichier

void setup()
{
   pinMode(L1,OUTPUT); // Déclaration en tant que sortie de la broche
   pinMode(L2,OUTPUT); // Déclaration en tant que sortie de la broche
   pinMode(L3,OUTPUT); // Déclaration en tant que sortie de la broche
   pinMode(L4,OUTPUT); // Déclaration en tant que sortie de la broche
   pinMode(pyro,OUTPUT); // Déclaration en tant que sortie de la broche
   digitalWrite(L1,HIGH); // Allumage de la LED d'initialisation du BMP180
   
    Serial.begin(9600); // ouverture de la communication sérielle

    Serial.println("REBOOT");
    Serial.print("Initialisation de la carte SD...");

    if (!SD.begin(10)) {
    Serial.println("L'initialisation de la carte SD a echoue !");
    return;
 }
    Serial.println("L'initialisation de la carte SD a reussie !");
   
   

 // Initialise le capteur (Il est important d'avoir des valeurs de calibration stockées).

 if (pressure.begin()){
     delay(1000);
     Serial.println("Succes de l'initialisation du BMP180");
   digitalWrite(L1,LOW); // Extinction de la LED d'initialisation du BMP180
   delay (1000);
 }
   
   else
 {
   // Oups, quelque chose ne s'est pas correctement déroulé, il s'agit souvent d'un problème de connection,
   // Voire les commentaires plus haut relatifs aux bonne connections.

     Serial.println("Echec d'initialisation du BMP180 (deconnecte?)\n\n");
   while(1); // Pause inifinie.
 }



//Initialisation du filtre Kalman
 KalmanInit();
 
  // Réalisons quelques mesures d'altitude
 // afin d'initialiser le filtre Kalman
 for (int i=0; i<50; i++){
   KalmanCalc(getPressure());
  }
 //Obtention de l'altitude du site de lancement
       //Réalisation des 50 mesures de pression et calcul de la moyenne
 long sum = 0;
 for (int i=0; i<50; i++){
     sum += KalmanCalc(getPressure());
 delay(50); }
 moyenne = (sum / 50.0);
       //Calcul de l'altitude du site
 float a=moyenne/1013;
 float b=pow(a,0.19);
 float c=1-b;
 float d=44330*c;

 digitalWrite(L2,HIGH); // Allumage de la LED indiquant que la mesure d'altitude initiale a été réalisée.

   // Ecriture sur la carte SD de l'altitude du site.
   monFichier = SD.open("altitude.txt", FILE_WRITE); // crée et ouvre le fichier *.txt

   if (monFichier) {

   monFichier.print("Altitude du site : ");
   monFichier.print(d);
   monFichier.println("m");
   monFichier.close(); // referme le fichier *.txt
   }

   else {
   Serial.println("Erreur lors de l'ouverture de altitude.txt");
 }

 
}

void loop()
{
 double a,P;
 
 // Mesure de la pression pendant le vol:

 P = KalmanCalc(getPressure());

 // Calcule de la différence relative entre
 // la nouvelle mesure et la mesure initiale:

 a = pressure.altitude(P,baseline);

monFichier = SD.open("altitude.txt", FILE_WRITE); // Ecriture en continue de l'altitude du modèle

   if (monFichier) {

   monFichier.print("Altitude : ");
   monFichier.print((44330*(1-(pow((P/1013),0.19))))-(44330*(1-(pow((moyenne/1013),0.19)))));
   monFichier.println("m");
   monFichier.close();

   digitalWrite(L4,HIGH); // Allumage de la LED que les mesures sont effectuées et enregistrées

// Si l'altitude relative est supérieure à 1m et cela pour la première fois,
// count=count+1 sert à ce que l'allumage pyro n'ait lieu qu'une seule fois, sur la rampe et non
// pendant toute la durée du vol, alors il y a alimentation de la sortie pyro.
if(((44330*(1-(pow((P/1013),0.19))))-(44330*(1-(pow((moyenne/1013),0.19)))))>1 && count<1){
 count=count+1;
 digitalWrite(L3,HIGH); // Allumage de la LED indiquant le démarrage de la temporisation.
 delay(5000); // Durée de la temporisation à modifier selon besoin.
 digitalWrite(L3,LOW); // Extinction de la LED indiquant la fin de la temporisation.
 digitalWrite(pyro,HIGH); // Alimentation de la sortie pyro et Allumage de la LED correspondante.
 delay(2000); // Durée de l'alimentation de la sortie pyro à modifier selon besoin.
 digitalWrite(pyro,LOW); // Fin d'alimentation de la sortie pyro et extinction de la LED correspondante.
}
 delay(100);
}

   else {
   Serial.println("Erreur lors de l'ouverture de altitude.txt");
 }
}


double getPressure()
{
 char status;
 double T,P,p0,a;

 // Vous obtenez d'abord une mesure de la température afin d'effectuer une mesure de pression.
 
 // Débute une mesure de température :
 // Si la requête aboutit, le nombre de ms à attendre est retournée.
 // Si la requête échoue, 0 est retourné.

 status = pressure.startTemperature();
 if (status != 0)
 {
   // Attend que la mesure soit achevée :

   delay(status);

   // Récupère la mesure de température :
   // Remarquez que cette valeur est stockée dans la variable T.
   // Utilise '&T' pour fournir l'adresse de T à la fonction.
   // La Fonction retourne 1 si réussie, 0 si échec.

   status = pressure.getTemperature(T);
   if (status != 0)
   {
     // Débute une meure de pression :
     // Le paramètre est le réglage du sur-échantillonnage, de 0 à 3 (haute résolution = longue attente).
     // Si la requête aboutit, le nombre de ms à attendre est retournée.
     // Si la requête échoue, 0 est retourné.

     status = pressure.startPressure(3);
     if (status != 0)
     {
       // Attend que la mesure soit achevée :
       delay(status);
       // Récupère la mesure de pression :
       // Remarquez que cette valeur est stockée dans la variable P.
       // Utilise '&P' pour fournir l'adresse de P.
       // Remarquez que la fonction requiert la mesure de température (T) précédemment obtenue.
       // (Si la température est stable, vous pouvez ne faire qu'une seule mesure de température pour vos mesures de pression)
       // La fonction retourne 1 si réussie, 0 si échec.

       status = pressure.getPressure(P,T);
       if (status != 0)
       {
         return(P);
       }
       else Serial.println("Mesure de pression impossible\n");
     }
     else Serial.println("Impossible de démarrer la mesure de pression\n");
   }
   else Serial.println("Mesure de température impossible\n");
 }
 else Serial.println("Impossible de démarrer la mesure de température\n");
}

//================================================================
// Fonctions de Kalman
//================================================================

//Appelle  KalmanInit() un fois.  

//KalmanInit() - Appel avant toute itération de  KalmanCalc()
void KalmanInit()
{
  kalman_q=4.0001;  //paramètres du filtre, vous pouvez les modifier.
  kalman_r=.20001;  // mais ces valeurs semblent optimales

  kalman_x = 0;
  kalman_p = 0;
  kalman_x_temp = 0;
  kalman_p_temp = 0;
 
  kalman_x_last = 0;
  kalman_p_last = 0;
 
}

//KalmanCalc() - Calcule les nouvelles valeurs du filtre Kalman à partir de la valeur flottante "altitude".
// Ceci sera l'altitude ASL pendant le vol et l'altitude AGL pendant le dépôt.
float KalmanCalc (float altitude)
{
 
  //Prédit kalman_x_temp, kalman_p_temp
  kalman_x_temp = kalman_x_last;
  kalman_p_temp = kalman_p_last + kalman_r;
 
  //Actualise les valeurs du filtre Kalman
  kalman_k = (f_1/(kalman_p_temp + kalman_q)) * kalman_p_temp;
  kalman_x = kalman_x_temp + (kalman_k * (altitude - kalman_x_temp));
  kalman_p = (f_1 - kalman_k) * kalman_p_temp;
 
  //Sauvegarde cet état pour la suite
  kalman_x_last = kalman_x;
  kalman_p_last = kalman_p;
 
  //Affecte l'altitude courante filtrée Kalman aux variables en cours.
 return kalman_x;
}

tu testes ça le 24?

bravo Romuald

philippehuguenin a écrit:tu testes ça le 24?

Oui c'est prévu. Ce sera avec la Delta 0.

Maintenant je dois terminer la baie électronique et réaliser le circuit électronique. Cà va viendre! Cà va viendre !!!