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 :
/*
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 -----------------------------------------------//
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;
}
}
//-----------------------------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
}
}
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
}
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();
}
}
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.
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 exempleconst 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#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ôtconst 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
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 rienSerial.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
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 bonfloat 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)
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
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.
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 ?
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
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
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.
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??
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
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
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?
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.
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 :
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