car tu n'a pas assez lu les commentaires que j'ai mis dans le code:
// Mon bouton est a l'etat bas quand j'appuie et quand j'appuie pas il est a l'etat haut
// il faudra adapter le test a l'etat du bonton en question
Donc peut être qu'il te faut changer le test en HIGH?
En tout cas supprime les delay dans ta boucle sinon tes boutons ne seront pas détectés
]
Après 3h passé dessus j'ai l'honneur de t'annoncer QUE SA MARCHE !!!!!
Merci infiniment pour tout le temps que tu as pris...
J'aurais une dernière question. Je ne peux pas avoir de bouton "changer LED" alors je ne vois pas comment faire...
Tant mieux si ça fonctionne.
SGRmetrage:
J'aurais une dernière question. Je ne peux pas avoir de bouton "changer LED" alors je ne vois pas comment faire...
Je comprends pas la question? Tu n'a pas le droit d'avoir un deuxième bouton pour ton projet c'est ça? Mais tu n'a pas le droit parce que le prof te l'a dit ou parce que il n'y en a plus physiquement?
Si tu as la possibilité d'avoir 2 boutons ce n'est pas fini, il te faut également sauvegarder en mémoire eeprom l'état de la variable "buse_changee" sinon si tu es dan sla partie buse à changer et que tu redémarre la carte arduino, comme la variable s'initialise à true, le programme pensera que tu as changé la buse alors que ce sera pas le cas, car tu auras juste redémarré.
Donc je pense qu'il faut que tu sauvegarde en mémoire eeprom l'état de la variable pour que le programme soit quasi parfait
Si tu n'as le droit qu'à 1 seul bouton dans ce cas pas la peine, la réinitialisation de la carte reprendra à 0
Bonjour;
Je viens poster ici car je suis un face à un petit problème. Nous sommes dans les dernières période pour terminer nos projet. Aujourd'hui nous étions entrain de regrouper nos programmes (RTC + Programme du Thermocouple + Réglages des seuils etc) et nous avons eu un petit problème ou nous avons plonger pendant plus de deux heures sans trouver la réponse...
Je m'explique, le problème viens plus précisément du programme de la RTC (Pour lequel je remercie encore énormément toutes les personnes qui on pu m'aider ici, surtout certain).
Dans ce programme lorsque j'appuie la première fois sur le bouton ça fait une capture de ce temps (que l'on appellera t1) et lorsque que je rappuie ça fait une seconde capture (que l'on nomme t2).
Ensuite le programme fait t2 - t1 pour connaitre le temps totale d'utilisation.
Le problème vient du fait que le programme détecte l'appuie de t1 ou t2 que lorsqu'il viens d'afficher le l'heure sur le moniteur série. Je voudrais qu'on puisse faire l'image de ce temps n'importe quand et pas seulement lorsque l'heure s'affiche, de plus l'utilisateur lui ne verras pas le moniteur série.
Je vous met mon programme (Ou pas celui ou on a regroupé plusieurs programme pour éviter que ce soit trop le cafouillage, mais si besoin est je le mettrais. Mais le problème est le mème sur ce programme) :
#include "EEPROMAnything.h"
#include <EEPROM.h>
#include <TinkerKit.h>
#include <Wire.h>
#include "DS1307.h"
#define BOUTON_ENREGISTREMENT 7 // bouton poussoir pour démarrer et arreter l'enregistrement
#define BOUTON_CHANGER_BUSE 10 // bouton poussoir pour dire qu'on a changé la buse (sinon la led reste allumée) et on n'enregistre rien
// #define LED_ENREGISTREMENT 9 // led qui s'allume dès qu'on enregistre et s'éteint quand on enregistre pas
#define LED_CHANGER_BUSE 14 // led qui s'allume dès qu'on doit changer la buse
boolean buse_changee = true;
double SEC;
// const int buttonPin = A2;
int buttonState = 0;
double result1;
double result2;
int comptage=0;
unsigned int resultfinal;
byte dueeprom,mceeprom;
double current_sec = 0;
double starting_sec = 0;
double final_sec = 0;
double current_delta_sec = 0;
int test;
double final_delta_sec;
#define adr_eprom_test 200 // For the test for 1st time init of the Arduino (First power on)
#define adresse_eeprom_compteur 0
const int adresse_epromdu= 0;
const int adresse_eprommc= 1;
DS1307 clock;//define a object of DS1307 class
const unsigned long DISPLAY_INTERVAL = 5000; // in ms
static unsigned long lastTime=0; // in ms
unsigned long time=millis(); // in ms
void setup()
{
Serial.begin(9600);
clock.begin();
clock.fillByYMD(2014,3,27);// 06 Fevrier,2014
clock.fillByHMS(17,50,30);//13:53 30"
clock.fillDayOfWeek(THU);//Jeudi
clock.setTime();//write time to the RTC chip
pinMode(BOUTON_ENREGISTREMENT,INPUT);
pinMode(BOUTON_CHANGER_BUSE,INPUT);
// pinMode(LED_ENREGISTREMENT,OUTPUT);
pinMode(LED_CHANGER_BUSE,OUTPUT);
// Test pour le premier lancement avec une EEPROM vide
EEPROM_readAnything(adr_eprom_test, test);
if (test != 12345)
{
EEPROM_writeAnything(adr_eprom_test,12345); // marqueur pour dire qu'on a déjà initialisé
delay(5); // ça prends 3,3 ms d'écrire dans l'eeprom donc on attend 5ms pour etre sur d'avoir les valeurs
EEPROM_writeAnything(adresse_eeprom_compteur, 0); // met à 0 la variable d'utilisation du stylo pour la 1ere utilisation
delay(5); // ça prends 3,3 ms d'écrire dans l'eeprom donc on attend 5ms pour etre sur d'avoir les valeurs
Serial.print("Premiere init OK! test=");
Serial.println(test);
Serial.print("temps d'utilisation du stylo precedemment enregistre:");
EEPROM_readAnything(adresse_eeprom_compteur, final_delta_sec);
delay(5);
Serial.println(final_delta_sec);
}
// affiche l'heure courante avant de démarrer
else
{
// si on a deja init. alors
// Lit les valeurs sauvées en EEPROM
EEPROM_readAnything(adresse_eeprom_compteur, final_delta_sec);
delay(5);
Serial.print("temps d'utilisation precedemment enregistre:");
Serial.println(final_delta_sec);
}
}
void loop()
{
// affiche l'heure toute les 5 sec
time=millis();
if (time-lastTime>DISPLAY_INTERVAL) // if at least DISPLAY_INTERVAL ms have passed
{
printTime();
lastTime=time; // reset timer
}
enregistrement_temps();
changement_buse();
}
void backup_eeprom()
{
final_delta_sec = current_delta_sec + final_delta_sec; // on calcule le delta final en ajoutant à l'ancienne valeur la valeur courante
Serial.println("temps totale d'utilisation");
Serial.println(final_delta_sec, DEC);
if (final_delta_sec < 3600000) // Si delta secondes final est inférieur à la durée d'utilisation de la buse
{
// alors on enregistre en memoire la duree d'utilisation du stylo
EEPROM_writeAnything(adresse_eeprom_compteur, final_delta_sec);
delay(5); // ça prends 3,3 ms d'écrire dans l'eeprom donc on attend 5ms pour etre sur d'avoir les valeurs
}
else // sinon
{
// on allume la led de suivi pour dire qu'on doit changer la buse
digitalWrite(LED_CHANGER_BUSE,HIGH);
Serial.println("BUSE A CHANGER!");
// on met l'état de la variable de changement de buse à FALSE
// qui ne changera pas tant qu'on aura pas appuyé sur le bouton "buse changée"
buse_changee = false;
}
}
/*--------------------------------------------------*
* Fonction: Affiche le temps sur le moniteur série *
*--------------------------------------------------*/
void printTime()
{
clock.getTime();
Affiche_HMS();
Serial.println(" ");
delay(500);
}
void Affiche_HMS()
{
Serial.print(clock.hour, DEC);
Serial.print(":");
Serial.print(clock.minute, DEC);
Serial.print(":");
Serial.print(clock.second, DEC);
}
void enregistrement_temps()
{
// DEBUT ENREGISTREMENT
// détecte appui sur bouton d'enregistrement et commence le décompte
if (digitalRead(BOUTON_ENREGISTREMENT)==HIGH)
// Mon bouton est a l'etat bas quand j'appuie et quand j'appuie pas il est a l'etat haut
// il faudra adapter le test a l'etat du bonton en question
// ATTENTION: on ne peut pas rentrer dans cette partie si la buse n'a pas ete changee
// c'est à dire si la variable buse_changee est à l'état 'FALSE' !!
{
delay(300); // délai anti rebond pour éviter de rentrer plusieur fois dans la boucle
current_sec=((clock.hour)*36E2)+((clock.minute)*60)+ (clock.second);
Serial.print("temps courant:");
Serial.println(current_sec);
comptage++; // 1st give starting, 2nd give final
if (comptage==1) // 1st give starting
{
starting_sec = current_sec;
Serial.print("debut de l'enregistrement a t1=");
Serial.println(starting_sec);
// digitalWrite(LED_ENREGISTREMENT,HIGH); // on passe en mode enregistrement
}
if (comptage==2) // 2nd give final status and storage
{
// 1/4
// calcul de la fin du comptage
final_sec = current_sec;
Serial.print("fin de l'enregistrement a t2=");
Serial.println(final_sec);
current_delta_sec=(final_sec-starting_sec)+3599990;
Serial.print("delta temps t2-t1=");
Serial.println(current_delta_sec);
// 2/4
// stockage de la fin dans l'eeprom
backup_eeprom();
// 3/4
// réinitialisation du bouton
comptage=0; // reset comptage
Serial.print("temps total d'utilisation du stylo:");
Serial.println(final_delta_sec);
// 4/4
// On éteint la led pour dire qu'on a fini d'enregistrer
// digitalWrite(LED_ENREGISTREMENT,LOW);
// et du coup on repasse en mode écoute en sortant du if
}
}// FIN ENREGISTREMENT
}
void changement_buse()
{
// DEBUT CHANGEMENT BUSE
// Détecte si appui sur le bouton de changement de buse
if (digitalRead(BOUTON_CHANGER_BUSE)==HIGH && buse_changee == false)
{
delay(300); // délai anti rebond pour éviter de rentrer plusieur fois dans la boucle
// si appui sur le bouton alors
// on met l'état de changement de buse à l'état VRAI
buse_changee = true;
// on réinitialise la variable à 0
final_delta_sec = 0;
EEPROM_writeAnything(adresse_eeprom_compteur, final_delta_sec);
delay(5); //
// et on éteint la led de suivi pour dire qu'on a changé la buse
digitalWrite(LED_CHANGER_BUSE,LOW);
Serial.println("BUSE CHANGEE!");
Serial.print("temps d'utilisation réinitialisé à :");
Serial.println(final_delta_sec);
}// FIN CHANGEMENT BUSE
}
Voila si quelqu'un à une idée ou pourrait m'orienter ce serait vraiment bien. Je vous en remercie d'avance.
ps : Merci pour la réponse sur mon autre post j'ai déplace le sujet maintenant que j'ai retrouvé ce post 
désolé pour le dérangement !
L'enchaînement des fonctions est correct et le bouton est bien lu à chaque itération de loop().
La lecture du bouton n'est pas conditionné par l'affichage du temps dans le moniteur série.
Par contre tu as placé des delay un peu partout et à mon sens ils ne sont pas indispensables.
Particulièrement il y en a un dans printTime() qui est inutile. Il ne fait que ralentir la réactivité du programme puisqu'il met 500mS de délai à chaque appel.
Il y en a un aussi au début de enregistrement_temps() pour gérer les rebonds. Là aussi utilité douteuse. Il serait préférable de mettre 50ms de délai et de tester le relâché du bouton à la fin de la fonction.
Oui il a fait des modifs de mon prog d'origine et maintenant ça fait plus ce que ça devait faire, donc à lui de corriger pour rétablir.
Bonsoir;
Tout d'abord merci pour vos réponses.
Oui j'ai fait des modifs sur ton programme d'origine pour l'adapter à mon utilisation et répondre à mon cahier des charges; Je te remercie une fois encore pour ce que tu m'as donné.
j'ai supprimé les delay en question mais pourtant rien n'y fait... de plus je n'ai pas le matériel à partir d'aujourd'hui (c'est les vacances scolaire).
Bonjour;
Je viens re poster de nouveau étant toujours bloqué sur le même problème...
Voici mon programme :
/*--------------------------------------------------*
* Fonction: Librairies *
*--------------------------------------------------*/
#include "EEPROMAnything.h"
#include <EEPROM.h>
#include <TinkerKit.h>
#include <Wire.h>
#include "DS1307.h"
/*--------------------------------------------------*
* Fonction: Déclaration des variables *
*--------------------------------------------------*/
#define BOUTON_ENREGISTREMENT 7 // bouton poussoir pour démarrer et arreter l'enregistrement
#define BOUTON_CHANGER_BUSE 10 // bouton poussoir pour dire qu'on a changé la buse (sinon la led reste allumée) et on n'enregistre rien
#define LED_CHANGER_BUSE 14 // led qui s'allume dès qu'on doit changer la buse
boolean buse_changee = true;
double SEC;
int buttonState = 0;
double result1;
double result2;
int comptage=0;
unsigned int resultfinal;
double current_sec = 0;
double starting_sec = 0;
double final_sec = 0;
double current_delta_sec = 0;
int test;
double final_delta_sec;
#define adr_eprom_test 200
#define adresse_eeprom_compteur 0
DS1307 clock;//define a object of DS1307 class
const unsigned long DISPLAY_INTERVAL = 1000; // en ms
static unsigned long lastTime=0; // en ms
unsigned long time=millis(); // en ms
void setup()
{
Serial.begin(9600);
clock.begin();
clock.fillByYMD(2014,3,27);// 06 Fevrier,2014
clock.fillByHMS(17,50,30);//13:53 30"
clock.fillDayOfWeek(THU);//Jeudi
clock.setTime();//write time to the RTC chip
pinMode(BOUTON_ENREGISTREMENT,INPUT);
pinMode(BOUTON_CHANGER_BUSE,INPUT);
pinMode(LED_CHANGER_BUSE,OUTPUT);
/*--------------------------------------------------*
*Test pour le premier lancement avec une EEPROM vide*
*--------------------------------------------------*/
EEPROM_readAnything(adr_eprom_test, test);
if (test != 12345)
{
EEPROM_writeAnything(adr_eprom_test,12345); // marqueur pour dire qu'on a déjà initialisé
delay(5); // ça prends 3,3 ms d'écrire dans l'eeprom donc on attend 5ms pour etre sur d'avoir les valeurs
EEPROM_writeAnything(adresse_eeprom_compteur, 0); // met à 0 la variable d'utilisation du stylo pour la 1ere utilisation
delay(5); // ça prends 3,3 ms d'écrire dans l'eeprom donc on attend 5ms pour etre sur d'avoir les valeurs
Serial.print("Premiere init OK! test=");
Serial.println(test);
Serial.print("temps d'utilisation du stylo precedemment enregistre:");
EEPROM_readAnything(adresse_eeprom_compteur, final_delta_sec);
delay(5);
Serial.println(final_delta_sec);
}
// affiche l'heure courante avant de démarrer
else
{
// si on a deja init. alors
// Lit les valeurs sauvées en EEPROM
EEPROM_readAnything(adresse_eeprom_compteur, final_delta_sec);
delay(5);
Serial.print("temps d'utilisation precedemment enregistre:");
Serial.println(final_delta_sec);
}
}
void loop()
{
// affiche l'heure toute les 5 sec
time=millis();
if (time-lastTime>DISPLAY_INTERVAL) // if at least DISPLAY_INTERVAL ms have passed
{
printTime();
lastTime=time; // reset timer
}
enregistrement_temps();
changement_buse();
}
/*--------------------------------------------------*
* Fonction: Affiche le temps sur le moniteur série *
*--------------------------------------------------*/
void printTime()
{
clock.getTime();
Affiche_HMS();
Serial.println(" ");
delay(500);
}
void Affiche_HMS()
{
Serial.print(clock.hour, DEC);
Serial.print(":");
Serial.print(clock.minute, DEC);
Serial.print(":");
Serial.print(clock.second, DEC);
}
/*--------------------------------------------------*
*Fonction : Enregistrement du temps d'utilisation*
*--------------------------------------------------*/
void enregistrement_temps()
{
// DEBUT ENREGISTREMENT
// détecte appui sur bouton d'enregistrement et commence le décompte
if (digitalRead(BOUTON_ENREGISTREMENT)==HIGH)
// ATTENTION: on ne peut pas rentrer dans cette partie si la buse n'a pas ete changee
// c'est à dire si la variable buse_changee est à l'état 'FALSE' !!
{
delay(300); // délai anti rebond pour éviter de rentrer plusieur fois dans la boucle
current_sec=((clock.hour)*36E2)+((clock.minute)*60)+ (clock.second);
Serial.print("temps courant:");
Serial.println(current_sec);
comptage++; // 1st give starting, 2nd give final
if (comptage==1) // 1st give starting
{
starting_sec = current_sec;
Serial.print("debut de l'enregistrement a t1=");
Serial.println(starting_sec);
}
if (comptage==2) // 2nd give final status and storage
{
// 1/3
// calcul de la fin du comptage
final_sec = current_sec;
Serial.print("fin de l'enregistrement a t2=");
Serial.println(final_sec);
current_delta_sec=(final_sec-starting_sec)+3599990;
Serial.print("delta temps t2-t1=");
Serial.println(current_delta_sec);
// 2/3
// stockage de la fin dans l'eeprom
backup_eeprom();
// 3/3
// réinitialisation du bouton
comptage=0; // reset comptage
Serial.print("temps total d'utilisation du stylo:");
Serial.println(final_delta_sec);
}
}// FIN ENREGISTREMENT
}
/*--------------------------------------------------*
*Fonction : Changement de la buse => Maitenance*
*--------------------------------------------------*/
void changement_buse()
{
// DEBUT CHANGEMENT BUSE
// Détecte si appui sur le bouton de changement de buse
if (digitalRead(BOUTON_CHANGER_BUSE)==HIGH && buse_changee == false)
{
delay(300); // délai anti rebond pour éviter de rentrer plusieur fois dans la boucle
// si appui sur le bouton alors
// on met l'état de changement de buse à l'état VRAI
buse_changee = true;
// on réinitialise la variable à 0
final_delta_sec = 0;
EEPROM_writeAnything(adresse_eeprom_compteur, final_delta_sec);
delay(5); //
// et on éteint la led de suivi pour dire qu'on a changé la buse
digitalWrite(LED_CHANGER_BUSE,LOW);
Serial.println("BUSE CHANGEE!");
Serial.print("temps d'utilisation réinitialisé à :");
Serial.println(final_delta_sec);
}// FIN CHANGEMENT BUSE
}
/*--------------------------------------------------*
*Fonction : Sauvegarde*
*--------------------------------------------------*/
void backup_eeprom()
{
final_delta_sec = current_delta_sec + final_delta_sec; // on calcule le delta final en ajoutant à l'ancienne valeur la valeur courante
Serial.println("temps totale d'utilisation");
Serial.println(final_delta_sec, DEC);
if (final_delta_sec < 3600000) // Si delta secondes final est inférieur à la durée d'utilisation de la buse
{
// alors on enregistre en memoire la duree d'utilisation du stylo
EEPROM_writeAnything(adresse_eeprom_compteur, final_delta_sec);
delay(5); // ça prends 3,3 ms d'écrire dans l'eeprom donc on attend 5ms pour etre sur d'avoir les valeurs
}
else // sinon
{
// on allume la led de suivi pour dire qu'on doit changer la buse
digitalWrite(LED_CHANGER_BUSE,HIGH);
Serial.println("BUSE A CHANGER!");
// on met l'état de la variable de changement de buse à FALSE
// qui ne changera pas tant qu'on aura pas appuyé sur le bouton "buse changée"
buse_changee = false;
}
}
Et je repose mon problème :
Je m'explique, le problème viens plus précisément du programme de la RTC (Pour lequel je remercie encore énormément toutes les personnes qui on pu m'aider ici, surtout certain).
Dans ce programme lorsque j'appuie la première fois sur le bouton ça fait une capture de ce temps (que l'on appellera t1) et lorsque que je r appuie ça fait une seconde capture (que l'on nomme t2).
Ensuite le programme fait t2 - t1 pour connaitre le temps totale d'utilisation.Le problème vient du fait que le programme détecte l'appuie de t1 ou t2 que lorsqu'il viens d'afficher le l'heure sur le moniteur série. Je voudrais qu'on puisse faire l'image de ce temps n'importe quand et pas seulement lorsque l'heure s'affiche, de plus l'utilisateur lui ne verras pas le moniteur série.
j'ai enlevé les delay() en trop comme on me le précisé mais rien n'a changé... pourtant l’enchaînement est le même que celui du programme que l'on m'a donné. Je ne comprends vraiment pas...
je vous remercie d'avance.
Perso je n'ai pas compris ce que tu veux tu devrais reformuler.
Pour moi dans le programme que j'avais fais on pouvait appuyer à n'importe quel moment sans problème.
Peu importe l'affichage de l'heure ou pas sur le moniteur série.
Au pire si l'affichage de l'heure te gène tu commente tous les serial.print liés à l'heure, ou carrément ta fonction heure
Oui oui justement c'est ça qui était bien on peut appuyer à n'importe qu'elle moment!!
Le soucis dans mon programme, c'est qu'on ne peut pas appuyé n'importe quand... seulement à certain moment. Je comprends pas pourquoi..
Augmente la valeur de DISPLAY_INTERVAL car là tu l'as mis à 1seconde donc t'a entre 0 et 1 seconde pour détecter ton bouton.
N'affiche l'heure que toutes les 5 secondes par exemple donc mets
const unsigned long DISPLAY_INTERVAL = 5000; // en ms
Et dans ta fonction setup commente la mise à l'heure de ta RTC, tu le fais une fois après avec la pile de sauvegarde c'est à l'heure donc inutile de le refaire:
//clock.fillByYMD(2014,3,27);// 06 Fevrier,2014
// clock.fillByHMS(17,50,30);//13:53 30"
// clock.fillDayOfWeek(THU);//Jeudi
// clock.setTime();//write time to the RTC chip
Il me semble que avant c'était à 5000 ms et que ça ne marchait pas non plus.
Ah oui c'est vrai merci.
Je vais réessayer demain lorsque je l'aurais le matériel on verra ce que ça donne. Ce qui va compliqué la chose c'est que la prochaine étape sera de remplacer le bouton par un capteur ILS mais bon on verra bien^^
SGRmetrage:
Il me semble que avant c'était à 5000 ms et que ça ne marchait pas non plus.
Oui mais avant tu avais aussi laissé les delay() donc ça risquait pas de marcher... 
void loop()
{
// affiche l'heure toute les 5 sec
time=millis();
if (time-lastTime>DISPLAY_INTERVAL) // if at least DISPLAY_INTERVAL ms have passed
{
printTime();
lastTime=time; // reset timer
}
enregistrement_temps();
changement_buse();
}
Le bouton est lu tout le temps. On ne passe dans la boucle d'affichage qu'une fois toutes les DISPLAY_INTERVAL secondes.
Rien ne bloque la lecture. La seule chose qui pourrait bloquer la lecture serait si la fonction printTime() durait 1 seconde ou plus auquel cas on passerait à chaque itération de loop dans la fonction d'affichage de l'heure. C'est facile à mettre en évidence en augmentant significativement DISPLAY_INTERVAL.
Par contre, si on tient le bouton trop longtemps on passe 2 fois de suite dans enregistrement_temps. Mais ça normalement tu devrais le voir sur ta console puisque tu affiches des messages. Cependant je préconise les modifications suivantes qui à mon sens rendront le programme plus efficace et plus sûr.
void enregistrement_temps()
{
// DEBUT ENREGISTREMENT
// détecte appui sur bouton d'enregistrement et commence le décompte
if (digitalRead(BOUTON_ENREGISTREMENT)==HIGH)
// ATTENTION: on ne peut pas rentrer dans cette partie si la buse n'a pas ete changee
// c'est à dire si la variable buse_changee est à l'état 'FALSE' !!
{
delay(50); // délai anti rebond pour éviter de rentrer plusieur fois dans la boucle 50ms sont largement suffisantes
current_sec=((clock.hour)*36E2)+((clock.minute)*60)+ (clock.second);
Serial.print("temps courant:");
Serial.println(current_sec);
comptage++; // 1st give starting, 2nd give final
if (comptage==1) // 1st give starting
{
starting_sec = current_sec;
Serial.print("debut de l'enregistrement a t1=");
Serial.println(starting_sec);
}
if (comptage==2) // 2nd give final status and storage
{
// 1/3
// calcul de la fin du comptage
final_sec = current_sec;
Serial.print("fin de l'enregistrement a t2=");
Serial.println(final_sec);
current_delta_sec=(final_sec-starting_sec)+3599990;
Serial.print("delta temps t2-t1=");
Serial.println(current_delta_sec);
// 2/3
// stockage de la fin dans l'eeprom
backup_eeprom();
// 3/3
// réinitialisation du bouton
comptage=0; // reset comptage
Serial.print("temps total d'utilisation du stylo:");
Serial.println(final_delta_sec);
}
while (digitalRead(BOUTON_ENREGISTREMENT)==HIGH) ; // Attente du relâché du bouton
}// FIN ENREGISTREMENT
}
Ah oui et puis il y a une erreur ici:
if (time-lastTime>DISPLAY_INTERVAL) // if at least DISPLAY_INTERVAL ms have passed
qu'il faudrait écrire comme ça:
if (time >(lastTime + DISPLAY_INTERVAL)) // if at least DISPLAY_INTERVAL ms have passed
C'est la même chose d'un point de vue purement logique. Mais cela prend en compte le fait que millis() repasse périodiquement à 0. Cela dit, dans ton cas, je ne pense pas que tu le verras mais c'est une bonne habitude à prendre que de le coder comme ça.
Merci fdufnews
Je connaissais pas le test à l’envers pour le cas du 0 
Et l'attente de relaché du bouton c'est bien aussi, je vais l'utiliser maintenant
@SGRmetrage:
Amélioration à appliquer dans les autres cas d'utilisation d'un bouton par exemple dans void changement_buse()
Par ailleurs je me rend compte que tu as supprimé une condition importante ici:
// détecte appui sur bouton d'enregistrement et commence le décompte
if (digitalRead(BOUTON_ENREGISTREMENT)==HIGH)
// ATTENTION: on ne peut pas rentrer dans cette partie si la buse n'a pas ete changee
// c'est à dire si la variable buse_changee est à l'état 'FALSE' !!
Tu m'a supprimé la condition && buse_changee == true donc le code ne fonctionnera pas comme il devra et mes commentaires ne veulent plus rien dire par rapport au code
Merci fdufnews
Je connaissais pas l'attente de relaché du bouton c'est vraiment pas bête je n'y avais pas pensé.
je vais applique tout cela, et je vous tiendrais au courant demain si ça marche car je n'aurais le matériel que demain.
Par ailleurs je me rend compte que tu as supprimé une condition importante ici:
// détecte appui sur bouton d'enregistrement et commence le décompte
if (digitalRead(BOUTON_ENREGISTREMENT)==HIGH)
// ATTENTION: on ne peut pas rentrer dans cette partie si la buse n'a pas ete changee
// c'est à dire si la variable buse_changee est à l'état 'FALSE' !!
Tu m'a supprimé la condition&& buse_changee == true
donc le code ne fonctionnera pas comme il devra et mes commentaires ne veulent plus rien dire par rapport au code
Alors oui excuse moi, en fait c'était un jour quand je venais de finir d'adapter le programme pour mon utilisation ça ne marchait pas (je sais plus vraiment pourquoi) mon prof est venu m'aider et m'a dit d'enlever ça et POUFF ça à marché ^^ Je voulais comprendre pourquoi et j'ai totalement zapé après. Je vais donc réessayer des demain !
Merci en tout qu'a pour toutes votre aide.