Go Down

Topic: Machine à état fonctionnel mais souci avec timer et Millis (Read 555 times) previous topic - next topic

goldoseb

bonjour a tous

comme promis je reviens avec un tout nouveau code après avoir appris a programmer une machine a état
avec l'aide de Zlika et mr hbachetti.

ma machine à état fonctionne bien il me reste juste quelques conditions à améliorer .

je voulais la poster quand j'étais sure que tout fonctionne bien , mais je coince sur la fonction Millis,

qui me donne pas les résultats attendue  surtout quand on plus un simple calcul arithmétique ne donne pas non plus les résultats attendue.

je vous donne le code si comme d'hab vous avez une idée pour me guider vers sa résolution.

je vais poster le code en trois parties:

voici la première :


Code: [Select]
/*
    Projet de contrôle de prise flacon et durée d'utilisation avec comptage des
    bons cycles et des mauvais, a l'aide d'une machine à état, avec utilisation d'un
    écran LCD d'un lecteur MP3 et un enregistrement des données sur carte sd
    
*/


//------------------- Déclaration des modules et bibliothèques  TFT LCD 3,2", OLED , MP3 ----------------------//

#include <SPI.h>
#include <SD.h>

//--------------- constantes qui ne changerons pas, pour association objets et broches arduino ----------------//    

const byte flacon_vertLED = 3 ;                     // déclaration de la broche led  VERTE flacon
const byte flacon_rougeLED = 4 ;                    // déclaration de la broche led  ROUGE flacon
const byte flacon_bleuLED  = 2 ;                    // déclaration de la broche led  BLEU flacon

const byte montage_vertLED = 6 ;                    // déclaration de la broche led  VERTE montage
const byte montage_rougeLED = 7 ;                   // déclaration de la broche led  ROUGE montage
const byte montage_bleuLED  = 5 ;                   // déclaration de la broche led  BLEU montage
 
int capteur_flacon    = 8;                          // création d'une constante pour la valeur du capteur flacon
int etat_capteur_flacon = 0;                        // création d'une constante etat pour la valeur du capteur flacon
int etat_Precedent_capteur_flacon = 0;              // création d'une constante etat_precedent pour la valeur du capteur flacon

int capteur_montage    = 9;                         // création d'une constante pour la valeur du capteur montage
int etat_capteur_montage = 0;                       // création d'une constante etat pour la valeur du capteur montage
int etat_Precedent_capteur_montage = 0;             // création d'une constante etat_precedent pour la valeur du capteur flacon

int compte_total = 0;                               // création d'une constante pour la valeur du compteur
int etatBouton = 0;                                 // création d'une constante etat pour la valeur du compteur
int etatPrecedent = 0;                              // création d'une constante etat_precedent pour la valeur du compteur

int compte_nok = 0;                                 // création d'une constante pour la valeur du compteur

File F4XRSLINE;
#define CS_PIN 10

unsigned long previousMillis = 0 ;
unsigned long temps_application ();                     // variable pour stocker  temps_ref_ech et mise a l'etat bas
unsigned long millis();                                 // variable pour stocker start

const unsigned long flacon_vertLEDinterval   = 200UL ;  //
const unsigned long flacon_rougeLEDinterval  = 200UL ;  //
const unsigned long flacon_bleuLEDinterval   = 200UL ;  //
                                                        //     variables pour stocker la durée d'un clignotement
const unsigned long montage_vertLEDinterval  = 200UL ;  //
const unsigned long montage_rougeLEDinterval = 200UL ;  //
const unsigned long montage_bleuLEDinterval  = 200UL ;  //

unsigned long flacon_vertLEDtimer   = 0 ;               //
unsigned long flacon_rougeLEDtimer  = 0 ;               //
unsigned long flacon_bleuLEDtimer   = 0 ;               //
                                                        //   variables pour stocker la valeur timer
unsigned long montage_vertLEDtimer  = 0 ;               //
unsigned long montage_rougeLEDtimer = 0 ;               //
unsigned long montage_bleuLEDtimer  = 0 ;               //

int flacon_vertLEDState  = LOW ;                        //
int flacon_rougeLEDState = LOW ;                        //
int flacon_bleuLEDState  = LOW ;                        //
                                                        //   variables pour stocker l'etat courant du State de leds
int montage_vertLEDState  = LOW ;                       //
int montage_rougeLEDState = LOW ;                       //
int montage_bleuLEDState  = LOW ;                       //


 enum      // ---------------      enumeration des differents etats   -------------------------------------------//
 
    {
        initialisation,                   //     case 0   allumage et extinction de certaines led au depart
        presence_piece_sur_montage,       //     case 1   si une piece est presente sur le montage
        presence_flacon_sur_sa_base,      //     case 2   si un flacon est present sur sa base
        prise_flacon,                     //     case 3   si on se sert du flacon
        compteur_de_cycle_total,          //     case 4   on compte le nombre de cycle totale
        depose_flacon,                    //     case 5   si on repose le flacon
        retrait_de_la_piece_du_montage,   //     case 6   si on retire la piece du montage
        remplissage_tableau_carte_sd,     //     case 7   on ecrit sur la carte sd
        fin
      
        
    } etat = initialisation;     //  mise a l'etat initialisation pour le départ


//------------------------------------------- DEBUT DU PROGRAMME -----------------------------------------------//


goldoseb

voici la seconde partie :


Code: [Select]



void setup() // ---------- Partie du programme qui ne sera éxécuté qu'une seule fois ---------------------------//     
 {

Serial.begin(9600);                                                     // Démarage du port de communication Serie à la vitesse de 9600 bauds.

Serial.println("Initialisation de la carte SD...");                               // affichage moniteur " "

  Serial.print("Initialisation de la carte SD en cours...");                      // affichage moniteur " "
  if (SD.begin(10))                                                               // test pour pour verifier l'initialisation lecteur de carte sd
  {
    Serial.println(" Terminée.");                                                 // affichage moniteur " "
  } else
  {
    Serial.println(" Echec.");                                                    // affichage moniteur " "
    return;
  } 
  F4XRSLINE = SD.open("F4X_RS_L.csv", FILE_WRITE);                                // creation du fichier F4X_RS_L.CSV sur carte sd
  if (F4XRSLINE)
  {   
 
    F4XRSLINE.println("cycle_total,Cycle_NOK,Application_primaire");              // creation du tableau carte sd au format .CSV
    Serial.println("");
    Serial.println("   cycle_total  |  Cycle_NOK  |  Application_primaire  | ");  // affichage moniteur " "
    F4XRSLINE.close();                                                            // fermeture du fichier carte sd
  }


 
pinMode (flacon_rougeLED, OUTPUT);   //
pinMode (flacon_vertLED, OUTPUT);    //
pinMode (flacon_bleuLED ,OUTPUT);    //
                                     //          pin mode des broches LED
pinMode (montage_rougeLED, OUTPUT);  //
pinMode (montage_vertLED, OUTPUT);   //
pinMode (montage_bleuLED, OUTPUT);   //


pinMode(capteur_montage, INPUT);      //         initialisé la broche du capteur montage en input
pinMode(capteur_flacon,  INPUT);      //         initialisé la broche du capteur flacon en input     
               

montage_vertLEDtimer  = millis() ;  //
montage_rougeLEDtimer = millis() ;  //
montage_bleuLEDtimer  = millis() ;  //
                                    //           initialisation des millis des timers led
flacon_vertLEDtimer  = millis() ;   //
flacon_rougeLEDtimer = millis() ;   //
flacon_bleuLEDtimer  = millis() ;   //                         

 
digitalWrite (montage_rougeLED, HIGH);     // 
digitalWrite (montage_vertLED, HIGH);      // 
digitalWrite  (montage_bleuLED, HIGH);     // 
                                           //     mise au niveau bas des leds
digitalWrite (flacon_rougeLED, HIGH);      // 
digitalWrite (flacon_vertLED, HIGH);       // 
digitalWrite  (flacon_bleuLED, HIGH);      // 




 }





//.................................BOUCLE PRINCIPALE.........................................


void loop () {     // partie du programme contenant la boucle qui sera joué a l'infinie




    switch(etat) {                 //             machine a etat



                  case initialisation:                             // action pour l'étape 0
             
                               preparation_montage();                 // fonction allumage et extinction de certaines led au depart
                         
                          break;


                   
                   
                  case presence_piece_sur_montage:                         // action pour l'étape 0
             
                               controle_montage();                 // fonction detection de la presence ou pas d'une piece sur le montage
                         
                          break;

                         


                  case compteur_de_cycle_total:                                       // action pour l'étape 2
                   
                                compteur1();                        // fonction comptage du nombre de cycle total
                           
                     
                          break;
                         
             
                         
             
                  case presence_flacon_sur_sa_base:                        // action pour l'étape 1
             
                                controle_flacon();                 // fonction detection de la presence ou pas d'un flacon sur sa base
                           
                          break;
                         
             
                         
             
                  case prise_flacon:                                       // action pour l'étape 2
                   
                                utilisation_flacon();               // fonction detection de l'utilisation du flacon
                           
                     
                          break;



                   
                         
             
                         
             
                  case depose_flacon:                                      // action pour l'étape 4

                                 fin_utilisation_flacon();           // fonction detection de l'utilisation du flacon
             
                           
                   
                       
                          break;




                  case retrait_de_la_piece_du_montage:                     // action pour l'étape 5

                                 retrait_piece();                    // fonction detection du retrait de la piece du montage
             
                           
                   
                       
                          break;





                  case remplissage_tableau_carte_sd:                     // action pour l'étape 6

                                 carte_sd();                    // fonction d'ecriture des différents parametres sur le carte sd en .csv
             
                           
                   
                       
                          break;




                                 

    }




}

goldoseb

Code: [Select]

//-----------------------------Partie du programme contenant les differentes fonction -------------------





              void preparation_montage(){   //---------------Fonction pour la preparation du montage -----

                

                          digitalWrite(montage_rougeLED, LOW);                     //  mettre la led RGB A rouge à l'etat haut
                          digitalWrite(montage_vertLED, HIGH);                     //  mettre la led RGB A vert à l'etat bas
                          digitalWrite(montage_bleuLED, HIGH);                     //  mettre la led RGB A bleu à l'etat bas
                      
          
                          digitalWrite(flacon_rougeLED, LOW);                      //  mettre la led RGB M rouge à l'etat haut
                          digitalWrite(flacon_vertLED, HIGH);                      //  mettre la led RGB M vert à l'etat bas
                          digitalWrite(flacon_bleuLED, HIGH);                      //  mettre la led RGB M bleu à l'etat bas

                          delay(100);

                         Serial.println(" " + String(compte_total) + " | " + String(compte_nok) + " | " + String(( millis() - previousMillis)) );

                          etat = presence_piece_sur_montage;                       // activation étape suivante
  

                        }




              
               void controle_montage(){   //---------------Fonction pour verifier qu'une piece se trouve sur le montage -----





                        if (digitalRead(capteur_montage)  != 0) {                    // si la lecture de la valeur de la photodiode de présence pièce est haute
                                              
                            digitalWrite(montage_rougeLED, HIGH);                    // etein la led RGB rouge du montage.
                            
                            clignotement_montage_vertLED();                          // fonction clignotement de la led verte du montage
                            
    
                            Serial.println("");                                      // affichage moniteur " "
                            Serial.println("déposez une piéce sur le montage");      // affichage moniteur " "
                            
                        }

                  
                        
                        if (digitalRead(capteur_montage)  != 1) {                    // si la lecture de la valeur de la photodiode de présence pièce est basse

                            digitalWrite(montage_rougeLED, HIGH);                    // Etein la led RGB rouge du montage.
                            digitalWrite(montage_vertLED, LOW);                      // Allume la led RGB vert du montage

                            Serial.println("");                                      // affichage moniteur " "
                            Serial.println("montage pret");                          // affichage moniteur " "
                            
                            etat = compteur_de_cycle_total ;                         // activation étape suivante
                            
                        }
 
               }





                void compteur1(){           // ************ Fonction permettant de compter le nombre de cycles ************ //

  

                              etatBouton = digitalRead(capteur_montage);                   // lecture l'etat actuel du capteur de presence et
                                                                                           // memorise le dans la variable etat bouton
                              
                                   delay(100);                                             // delai pour eviter un comportement eratique

                                   if (etatBouton == 0) {                                  // et si l'etat du capteur est haut

                                        compte_total++;                                    // on incrémente le compteur de 1

                                        
                                        Serial.print("Nombre de cycle total : ");          // affichage moniteur
                                        Serial.println(compte_total);                      // affiche le nombre de cycle total
    
                                        Serial.print("Nombre de cycle NOK : ");            // affichage moniteur
                                        Serial.println(compte_nok);                        // affiche la valeur de compte
                                      
                                }

                        etat = presence_flacon_sur_sa_base ;                               // activation étape suivante
                  }






                 void controle_flacon(){   //---------------Fonction pour verifier que le flacon est sur sa base -----

                  
 
                        digitalWrite(montage_vertLED, LOW);                                                  // Allume la led RGB vert du montage
                        digitalWrite(montage_rougeLED, HIGH);                                                // Allume la led RGB vert du montage
                        
                      
                        if (digitalRead(capteur_flacon)  != 1)  {                                            // si la lecture de la valeur de la photodiode de présence pièce est basse
                                              
                            digitalWrite(flacon_rougeLED, HIGH);                                             // Allume la led RGB rouge du montage.
                            
                            clignotement_flacon_vertLED();                                                   // fonction clignotement de la verte du flacon
    
                            Serial.println("");                                                              // affichage moniteur " "
                            Serial.println("déposez le flacon sur sa base");                                 // affichage moniteur " "
                            
                        }
                        
                        
                        if (digitalRead(capteur_flacon)  != 0) {    // si la lecture de la valeur de présence pièce est haute

                            if (digitalRead(capteur_montage)  != 1) {
                                                                                                             //et si et seulement si la valeur de présence pièce est basse
                            digitalWrite(montage_rougeLED, HIGH);                                            // Etein la led RGB rouge du montage.
                            digitalWrite(montage_vertLED, LOW);                                              // Allume la led RGB vert du montage

                            Serial.println("");                                                              // affichage moniteur " "
                            Serial.println("flacon pret");                                                   // affichage moniteur " "
                            
                            etat = prise_flacon ;                                                            // activation étape suivante

                            
                        }
                        
                         else

                            etat = presence_piece_sur_montage;                                               // retour a l'etat controle piece sur montage

                  
               }
         }    



goldoseb

Code: [Select]


                   void utilisation_flacon(){   //---------------Fonction pour verifier l'utilisation du flacon -----
                    


                           digitalWrite(montage_vertLED, LOW);                                        // Allume la led RGB vert du montage
                           digitalWrite(montage_rougeLED, HIGH);                                      // Allume la led RGB vert du montage
                           digitalWrite(flacon_vertLED, LOW);                                         // Allume la led RGB vert du montage
                           digitalWrite(flacon_rougeLED, HIGH);                                       // Allume la led RGB vert du montage

                          

                        
 
                      
                        if (digitalRead(capteur_flacon)  != 0)  {        // si la lecture de la valeur de la photodiode de présence pièce est basse

                                 if (digitalRead(capteur_montage)  != 1) {

                                                                                        
                                  
                                                    
                                  digitalWrite(flacon_vertLED, HIGH);                                  // Allume la led RGB vert du montage
                                  
                                  clignotement_flacon_bleuLED();                                       // fonction clignotement de la led bleu du flacon
          
                                  Serial.println("");                                                  // affichage moniteur " "
                                  Serial.println("veuillez utilisez le flacon");                       // affichage moniteur " "

                                 }
                                 else
      
                                     etat = presence_piece_sur_montage;                                // retour a l'etat controle piece sur montage

                        }
                            

                        

                        
                        if (digitalRead(capteur_flacon)  != 1) {                                      // si la lecture de la valeur de la photodiode de présence pièce est haute
 
                            digitalWrite(flacon_bleuLED, LOW);                                        // Allume la led RGB vert du montage

                            previousMillis = millis();                                           // on initialise le chronomètre

                            Serial.println("");                                                       // affichage moniteur " "
                            Serial.println("flacon en cours d'utilisation");                          // affichage moniteur " "

                            etat = depose_flacon;                                                     // activation étape suivante

                            
                        }
                          

                  
               }


                    


                      void fin_utilisation_flacon(){   //---------------Fonction pour verifier la depose du flacon apres utilisation -----


                           digitalWrite(montage_vertLED, HIGH);                                 // Allume la led RGB vert du montage
                           digitalWrite(montage_rougeLED, LOW);                                 // Allume la led RGB vert du montage

                           digitalWrite(flacon_bleuLED, HIGH);                                  // Allume la led RGB vert du montage

                        if (digitalRead(capteur_flacon)  != 1) {                                // si la lecture de la valeur de la photodiode de présence pièce est basse
                                              
                            clignotement_flacon_vertLED() ;                                     // fonction clignotement de la led verte du flacon
    
                            Serial.println("");                                                 // affichage moniteur " "
                            Serial.println("veuillez reposez le flacon");                       // affichage moniteur " "
                            
                        }

                        
                        if (digitalRead(capteur_flacon)  != 0) {                                // si la lecture de la valeur de la photodiode de présence pièce est haute

                            digitalWrite(montage_rougeLED, HIGH);                               // Etein la led RGB rouge du montage.
                            digitalWrite(montage_vertLED, LOW);                                 // Allume la led RGB vert du montage
                            
                            digitalWrite(flacon_rougeLED, HIGH);                                // Allume la led RGB rouge du montage.
                            digitalWrite(flacon_vertLED, LOW);                                  // Allume la led RGB vert du montage


                            Serial.println("");                                                 // affichage moniteur " "
                            Serial.println("le flacon est bien de retour sur sa base");         // affichage moniteur " "

                            

                            if (( millis() - previousMillis) <= 5000 ) {

                                    compte_nok++;                                               // on incrémente le compteur de 1
                                    
                                    
                                    
                                    
                            }

                            
                            etat = retrait_de_la_piece_du_montage;                              // action pour l'étape 5
                        }
                          
                            
                  
               }




                      void retrait_piece() {                                                   // fonction detection du retrait de la piece du montage



                            if (digitalRead(capteur_montage)  != 1) {                          // si la lecture de la valeur de la photodiode de présence pièce est haute
                                              
                            digitalWrite(montage_vertLED, HIGH);                               // Allume la led RGB vert du montage
                            
                            clignotement_montage_rougeLED() ;                                  // fonction clignotement de la led verte du montage                
  
    
                            Serial.println("");                                                // affichage moniteur " "
                            Serial.println("retirez la piéce du montage");                     // affichage moniteur " "
 
                        }

                        else

                            etat = remplissage_tableau_carte_sd;                                             //  mise a l'etat initialisation pour le départ

    
                            
                      }



goldoseb

Code: [Select]




                      void carte_sd() {                                         // fonction d'ecriture des différents parametres sur le carte sd en .csv


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

                                    float cycle_total = compte_total;                          // On lis le nombre de cycle ok.
                                    //float Durée_cycle_complet = monDHT.readTemperature();       // on lis la durée de chaque cycle complet.
                                   
                                    float Cycle_NOK = compte_nok;                               // On lis le nombre de cycle nok.
                                    //float Durée_cycle_primaire = monDHT.readTemperature();      // on lis la durée de chaque cycle primaire.

                                    float Application_primaire = ( millis() - previousMillis   );                               // On lis le nombre de cycle nok.
                                    //float Durée_cycle_primaire = monDHT.readTemperature();      // on lis la durée de chaque cycle primaire.

                                   


                                     
                                    // On met en forme la donnée au formar csv, c'est-à dire chaque paramètre séparé par une virgule.
                                    String F4X_RS_L = String(cycle_total) + "," + String(Cycle_NOK) + "," + String(Application_primaire) ;
                                 
                                    // On enregistre la donnée
                                    F4XRSLINE = SD.open("F4X_RS_L.csv", FILE_WRITE); //Maximum 8 caractères avant le .csv
                                    if (F4XRSLINE)
                                    {   
                                      F4XRSLINE.println(F4X_RS_L);
                                      Serial.println(" " + String(cycle_total) + " | " + String(Cycle_NOK) + " | " + String(Application_primaire)    );
                                      F4XRSLINE.close();   
                                    }
                                    else
                                    {
                                      Serial.println("Impossible d'ouvrir le fichier");
                                    } 
                                   
                                 


 

                            etat = initialisation;                                             //  mise a l'etat initialisation pour le départ

                       }
                           
                     






                     
             //-----------------------------------  fonction de clignotement led du montage   -------------------------------------------


                      void clignotement_montage_vertLED() {                         // fonction clignotement de la led verte du montage               


                        if ( (millis() - montage_vertLEDtimer) >= montage_vertLEDinterval ) {
                              if(montage_vertLEDState == LOW )
                                 montage_vertLEDState = HIGH;
                                 else
                                 montage_vertLEDState = LOW;
                                 digitalWrite(montage_vertLED , montage_vertLEDState);
                                 montage_vertLEDtimer = millis();
   
                        }
   
                      }



                      void clignotement_montage_rougeLED() {                   // fonction clignotement de la rouge verte du montage


                        if ( (millis() - montage_rougeLEDtimer) >= montage_rougeLEDinterval ) {
                              if(montage_rougeLEDState == LOW )
                                 montage_rougeLEDState = HIGH;
                                 else
                                 montage_rougeLEDState = LOW;
                                 digitalWrite(montage_rougeLED , montage_rougeLEDState);
                                 montage_rougeLEDtimer = millis();
   
                        }
   
                      }



                      void clignotement_montage_bleuLED() {                   // fonction clignotement de la led bleu du montage


                        if ( (millis() - montage_bleuLEDtimer) >= montage_bleuLEDinterval ) {
                              if(montage_bleuLEDState == LOW )
                                 montage_bleuLEDState = HIGH;
                                 else
                                 montage_bleuLEDState = LOW;
                                 digitalWrite(montage_bleuLED , montage_bleuLEDState);
                                 montage_bleuLEDtimer = millis();
   
                        }
   
                      }





         //  -----------------------------------  fonction de clignotement led du flacon   -------------------------------------------




                      void clignotement_flacon_rougeLED() {                   // fonction clignotement de la led rouge du flacon


                        if ( (millis() - flacon_rougeLEDtimer) >= flacon_rougeLEDinterval ) {
                              if(flacon_rougeLEDState == LOW )
                                 flacon_rougeLEDState = HIGH;
                                 else
                                 flacon_rougeLEDState = LOW;
                                 digitalWrite(flacon_rougeLED , flacon_rougeLEDState);
                                 flacon_rougeLEDtimer = millis();
   
                        }
   
                      }





                      void clignotement_flacon_vertLED() {                   // fonction clignotement de la led verte du flacon


                        if ( (millis() - flacon_vertLEDtimer) >= flacon_vertLEDinterval ) {
                              if(flacon_vertLEDState == LOW )
                                 flacon_vertLEDState = HIGH;
                                 else
                                 flacon_vertLEDState = LOW;
                                 digitalWrite(flacon_vertLED , flacon_vertLEDState);
                                 flacon_vertLEDtimer = millis();
   
                        }
   
                      }



                      void clignotement_flacon_bleuLED() {                   // fonction clignotement de la led bleu du flacon


                        if ( (millis() - flacon_bleuLEDtimer) >= flacon_bleuLEDinterval ) {
                              if(flacon_bleuLEDState == LOW )
                                 flacon_bleuLEDState = HIGH;
                                 else
                                 flacon_bleuLEDState = LOW;
                                 digitalWrite(flacon_bleuLED , flacon_bleuLEDState);
                                 flacon_bleuLEDtimer = millis();
   
                        }
   
                      }


goldoseb

bon en faite il y a 4 partie !!!!

donc mon souci se trouve en fin de programme dans la partie contenant les fonctions

dans les deux parties   "utilisation du flacon" et fin "d'utilisation du flacon"


dans la partie utilisation du flacon j'initialise millis et dans la partie. fin utilisation je
je fais un calcul soustractif  pour avoir un temps d'utilisation du flacon.

je trouve les résultats de millis pas très juste et quand j'incremante le compteur en fonction de chaque cycle inférieur a 5s. cela ne fonctionne pas toujours.

si quelqu'un a le pourquoi du comment ??

merci

au faite si vous avez des critiques sur ma première machine a état code seule je suis preneur.

J-M-L

Bonjour

La structure se lit c'est bien mais comme je suis sur mobile pas simple de regarder votre code en entier

Quelques  commentaires:

- dans les déclarations vos commentaires parlent de constantes, dans ce cas dites le au compilateur en mettant le mot clé const devant la déclaration, par exemple
Code: [Select]
const int capteur_flacon    = 8;                          // création d'une constante pour la valeur du capteur flacon

- utilisez des types appropriés pour ne pas manger trop de mémoire. Par exemple la constante ci dessus pourrait sans doute être un seul octet (byte), de même pour l'enum de vos états

- soyez consistant dans les déclarations. Au début toutes vos pins sont des const byte (bravo) mais ensuite vous avez un
Code: [Select]
#define CS_PIN 10Pourquoi pas un const byte et cette écriture qui n'est pas la convention que vous avez adoptée pour les autres pins. Utilisez plutôt
Code: [Select]
const byte ChipSelectCarteSDPin = 10; // ou juste CSPin

- utilisez Serial à 115200 bauds au moins, pourquoi aller lentement à 9600 bauds ?

- Ne pas utiliser la classe String, surtout si c'est juste pour imprimer sur le port série! Coupez votre Serial.print() en petits bouts. Par exemple ça c'est bien
Code: [Select]
Serial.print("Nombre de cycle total : ");          // affichage moniteur
Serial.println(compte_total);
alors que ça c'est pas bien et mange plein de mémoire pour rien
Code: [Select]
Serial.println(" " + String(cycle_total) + " | " + String(Cycle_NOK) + " | " + String(Application_primaire));idem bien sûr dans l'écriture sur SD.

- appuyez sur ctrl-T pour indenter le code proprement, vous avez de nombreux blocs illisibles par exemple
Code: [Select]
if ( (millis() - montage_vertLEDtimer) >= montage_vertLEDinterval ) {
                              if(montage_vertLEDState == LOW )
                                 montage_vertLEDState = HIGH;
                                 else
                                 montage_vertLEDState = LOW;
                                 digitalWrite(montage_vertLED , montage_vertLEDState);
                                 montage_vertLEDtimer = millis();
   
                        }
les 2 dernières lignes ne sont bien sûr pas dans le else (c'est correct) mais super moche... un adepte du python par exemple s'y perdrait (même si je déteste le fait que le formatage du texte définisse la structure des blocs en python)

- vous avec du code redondant (clignotement) avec juste deux ou trois variables liées qui changent. Apprenez à utiliser des structures pour regrouper ces variables et les tableaux pour en avoir plusieurs facilement adressables.

- respectez les «concepts » - utilisez LOW et HIGH au lieu de 0 et 1 quand vous jouez avec les pins.

- un délai de 100 est super long pour éviter le rebond des boutons. 15 devrait aller

- ce truc la intellectuellement ne sent pas bon
Code: [Select]
float Application_primaire = ( millis() - previousMillis   ); Pourquoi diable utiliser un float pour un truc qui semble être une durée en ms? Surtout avec un commentaire qui parle de nombre de cycles...

- en parlant de previousMillis vérifiez la cohérence de ce que vous comptez, je ne suis pas trop sûr de comprendre pourquoi vous regardez avec 5000ms. de plus compte_nok étant un int sa valeur Max sera de 32767... à la vitesse où pédale votre arduino vous allez sans doute déborder...

- dans vos fonctions qui testent l'état des boutons, faites de if (condition) {...} else {...} ne lisez pas deux fois la valeur de la pin en la comparant une fois à HIGH puis une fois à LOW (c'est là qu'il n'est pas beau d'utiliser 0 et 1)

Voilà j'espère que ces commentaires aideront
Hello - Please do not PM me for help,  others will benefit as well if you post your question publicly on the forums.
Bonjour Pas de messages privés SVP, postez dans le forum directement pour que ça profite à tous

goldoseb

merci pour tout ces commentaires.

je vais potasser tout cela et je reviendrais avec la correction des que possible.


seb

goldoseb



bonjour,

quelques information.

suite a
- ce truc la intellectuellement ne sent pas bon
Code: [Select]

float Application_primaire = ( millis() - previousMillis   );


Pourquoi diable utiliser un float pour un truc qui semble être une durée en ms? Surtout avec un commentaire qui parle de nombre de cycles...

- en parlant de previousMillis vérifiez la cohérence de ce que vous comptez, je ne suis pas trop sûr de comprendre pourquoi vous regardez avec 5000ms. de plus compte_nok étant un int sa valeur Max sera de 32767... à la vitesse où pédale votre arduino vous allez sans doute déborder...


donc je vais donc utiliser un unsigned long. comme cela je serais large a la place du int !!!


apres , j'utilise cette fonction pour incrémenter un compteur : en faite tous les cycles inférieur a 5000ms
sont a considérer comme nok  et donc doivent incrémenter le compteur nok.
et effectivement la je n'ai pas besoin de vigile flottante vu que se sera des entiers , donc a remplacer par un int

si je ne me trompe pas

Zlika

Bonsoir goldoseb,

Pourquoi créer une variable B pour y mettre la valeur de A pour ensuite sauvegarder B dans ton fichier.
Écris directement la valeur de A dans ton fichier.

Comme le dit J-M-L, on a du mal à comprendre ce que tu veux faire. Tes commentaires ne reflète pas ce que tu fais.

Code: [Select]
float Application_primaire = ( millis() - previousMillis   );  // On lis le nombre de cycle nok.

On ne peut pas deviner ce que tu veux faire dans ton programme donc un commentaire qui ne correspond pas c'est une erreur de code ou une erreur de commentaire ?
Si ça coince, forcez. Si ça casse, ça devait probablement être réparé, de toute façon.

goldoseb

je galère avec la fonction millis

car je ne trouve pas de bon tuto qui explique pas a pas chaque ligne donc je fais des déductions qui apparement ne sont pas juste.

j'ai modifié le code déjà avec un int

Code: [Select]
int Application_primaire = ( millis() - previousMillis   );  // On lis le nombre de cycle nok.

pour moi application primaire est le résultat de millis moins   previous millis

previous Millis pour moi  initialise le chrono au moment ou je veux qu'il commence

quant a lui millis démarre au début du programme et a chaque cycle je crée une nouvelle valeur de previous millis    avec  previous millis = millis

dans mon esprit de cette manière a chaque cycle j'arrive a calculer la durée d'utilisation de mon flacon

et donc si ce temps est inférieur a 5000ms j'incremente un compteur " nok "



bon je galère encore sur cette fonction  mais avoue que ma machine a état n'est pas si mal " juste pour me rassurer "  et entre temps j'ai appris a écrire sur une sd    bon il y as encore beaucoup de boulot mais dans trois ou quatre vies je serais bien

Zlika

Millis() retourne une valeur de type unsigned long et previousMillis est déclaré comme unsigned long.
Une addition /soustraction doit dans le pire des cas se ranger dans un unsigned long.

Code: [Select]
unsigned long temps_application ();                     // variable pour stocker  temps_ref_ech et mise a l'etat bas
unsigned long millis();   


Tu veux faire quoi ? Déclaration d'une variable, d'un prototype de fonction??
Si ça coince, forcez. Si ça casse, ça devait probablement être réparé, de toute façon.

goldoseb

OUPS. je n'avais pas vu que les commentaire de ces lignes n'étaient pas les bons je corrige cela  et le re-post
           car j'ai fais plusieurs essais avant de vous demander votre aide


Code: [Select]

unsigned long previousMillis = 0 ;                      // variable pour stocker la mise a jour de previousmillis()
unsigned long temps_application ();                     // variable pour stocker le temps d'utilisation du flacon
unsigned long millis();                                 // variable pour stocker millis()


donc lors de la prise du flacon j'initialise previousmillis  avec   previousMillis = millis();

puis lorsque le flacon est déposé sur sa base je peux calculer le temps d'application avec

Code: [Select]
if (( millis() - previousMillis) <= 5000 ) {   // calcule du temps d'application du flacon

          compte_nok++;                    // si infferieur a 5000ms on incrémente le compteur nokde 1


et donc si le temps d'application est inférieur a 5000ms incrémenter le compteur nok

j'ai utilisée des unsigned long car le chrono peux tourner entre 18 et 24 heures d'affilée donc je me suis dis que si millis s'incremente autant de temps il finirait par devenir très grand?




Zlika

Quote
unsigned long previousMillis = 0 ;                      // variable pour stocker la mise a jour de previousmillis()
unsigned long temps_application ();                     // variable pour stocker le temps d'utilisation du flacon
unsigned long millis();                                 // variable pour stocker millis()
Le problème est surtout que tu utilises des parenthèses pour temps_application (ce qui en fait une fonction) et que tu essayes, je pense, de déclarer une variable pour stocker millis() ce qui n'as aucun intérêt. Au moment où tu veux une référence de temps, tu appelles la fonction millis() et si tu veux mémoriser ce moment, tu mets le résultat dans une variable.
Prend le temps de relire ton code, tu ne devrais pas faire ces erreurs.
Si ça coince, forcez. Si ça casse, ça devait probablement être réparé, de toute façon.

goldoseb

Merci   pour ces infos.


je fais ce genre d'erreur quand j'essai plein de choses et quand je bloque sur quelque chose.

du coup je me perd et comme lorsque je compile il n'y as pas de souci , ça passe a l'as

et très honnêtement je n'avais même pas subodoré que j'avais passé cette ligne en fonction d'autant plus que c'est avant le setup et donc je me m'y rends pas souvent.

j'ai tout réécris

comme cela :

Code: [Select]
unsigned long previousMillis = 0 ;                      // variable pour stocker la mise a jour de millis()
unsigned long temps_application = 0;                     // variable pour stocker le temps d'utilisation du flacon


en supprimant la variable millis

je vais donc de ce pas faire des tests et voir si les changements apportés ont un effet

encore merci a tous.

Go Up