Bonjour terwal
Oui, tout à fait.
Dans son sketch du post #1, il a simplement oublié de reporter l'action de ses boutons, sur la mise à l'heure de sa RTC. par
rtc.adjust(DateTime(2022, 11, 07, Afficheur_heure, Afficheur_minute, 0));
Cordialement
jpbbricole
Non, c'est de la SRAM avec une batterie de sauvegarde
Au temps pour moi...
Bonsoir tous le monde.
Je vais essayé de vous expliquer clairement ce que je veux
Le but est de récupérer l'heure et les minutes du rtc et de l'afficher sur les 7 segments.(cette partie fonctionne)
lorsqu'il y a une coupure de courant la pile du RTC garde l'heure en memoire.(cette partie fonctionne)
Mais je veux que par exemple je puisse changer les heures et les minutes manuellement et l'enregistrer dans le RTC pour que si il y a une coupure de courant les heures et les minutes modifiées soient sauvegarder.
Ou par exemple passer de l'heure d'hiver a l'heure d'été ou vis vers ca et que celle ci soit sauvegardé dans le RTC.
Je suis en train d'essayer se que tu m'as preconisé.
j' ai ajouté comme preconisé
state = digitalRead(btn_minute_plus);
if ((state != mem_minute_plus) && (state == LOW))
Afficheur_minute += 1;
rtc.adjust(DateTime(2022, 11, 07, Afficheur_heure, Afficheur_minute, 0));
mem_minute_plus = state; // on enregistre l'état du bouton pour le tour suivant
Mais du coup je n'ai plus l'heure réelle au démarrage mais 00h15
Met le code complet. 2 lignes sorties de leur contexte ça ne veut pas dire grand chose.
Bonsoir ASSM
Au départ, il faut initialiser tes variables:
Afficheur_heure
Afficheur_minute
avec l'heure et minutes de ta RTC
Je regarde ça et te redis.
A+
Cordialement
jpbbricole
Merci d'avance jpbbricole
voici le code actuel
#include <Wire.h>
#include "RTClib.h"
RTC_DS1307 rtc;
word DateHeure[6] = {0, 0, 0, 0, 0};
// définition des broches du décodeur 7 segments des Unités des Afficheur_minutes
const int bit_A1 = 2;
const int bit_B1 = 3;
const int bit_C1 = 4;
const int bit_D1 = 5;
// définition des broches du décodeur 7 segments des Dizaines des Afficheur_minutes
const int bit_A2 = 6;
const int bit_B2 = 7;
const int bit_C2 = 8;
const int bit_D2 = 9;
// définition des broches du décodeur 7 segments des Unités des Afficheur_heures
const int bit_A3 = 10;
const int bit_B3 = 11;
const int bit_C3 = 12;
const int bit_D3 = 13;
// définition des broches du décodeur 7 segments des Dizaines des Afficheur_heures
const int bit_A4 = 14;
const int bit_B4 = 15;
const int bit_C4 = 16;
const int bit_D4 = 17;
int d1; //afficheur Unités des Afficheur_minutes
int d2; //afficheur Dizaines des Afficheur_minutes
int d3; //afficheur Unités des Afficheur_heures
int d4; //afficheur Dizaines des Afficheur_heures
int Afficheur_minute; // Affichage des Afficheur_minutes à l'allumage
int Afficheur_heure; // Affichage des Afficheur_heures à l'allumage
// les broches des boutons
int btn_minute_plus = A1;
int btn_minute_moins = A2;
int btn_heure_plus = A3;
int btn_heure_moins = A4;
// les mémoires d'état des boutons
int mem_minute_plus = HIGH;
int mem_minute_moins = HIGH;
int mem_heure_plus = HIGH;
int mem_heure_moins = HIGH;
int state = HIGH;
void GetDateHeure(word *DateHeure)
{
// Lecture du module RTC
DateTime now = rtc.now();
// Récupérration de l'heure
DateHeure[2] = now.hour(); // Heures
DateHeure[1] = now.minute(); // Minutes
DateHeure[0] = now.second(); // Secondes
}
void setup ()
{
Serial.begin(115200);
if (! rtc.begin())
{
Serial.println("Le module RTC non disponible");
while (1); // Attente RESET
}
else
{
Serial.println("Le module RTC est OK");
rtc.writeSqwPinMode(DS1307_SquareWave4kHz);
rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); // Date du PC
//rtc.adjust(DateTime(2020,1,24,10,10,10)); // Ajustement manuelle
// Ex: 10 Janvier 2020 à 10:00:00:
// rtc.adjust(DateTime(2020, 1, 10, 10, 0, 0));
// Les broches sont toutes des sorties
pinMode(bit_A1, OUTPUT);
pinMode(bit_B1, OUTPUT);
pinMode(bit_C1, OUTPUT);
pinMode(bit_D1, OUTPUT);
pinMode(bit_A2, OUTPUT);
pinMode(bit_B2, OUTPUT);
pinMode(bit_C2, OUTPUT);
pinMode(bit_D2, OUTPUT);
pinMode(bit_A3, OUTPUT);
pinMode(bit_B3, OUTPUT);
pinMode(bit_C3, OUTPUT);
pinMode(bit_D3, OUTPUT);
pinMode(bit_A4, OUTPUT);
pinMode(bit_B4, OUTPUT);
pinMode(bit_C4, OUTPUT);
pinMode(bit_D4, OUTPUT);
// Les broches sont toutes des entrées
pinMode(btn_minute_plus, INPUT);
pinMode(btn_minute_moins, INPUT);
pinMode(btn_heure_plus, INPUT);
pinMode(btn_heure_moins, INPUT);
// Les broches sont toutes mises à l'état bas
digitalWrite(bit_A1, LOW);
digitalWrite(bit_B1, LOW);
digitalWrite(bit_C1, LOW);
digitalWrite(bit_D1, LOW);
digitalWrite(bit_A2, LOW);
digitalWrite(bit_B2, LOW);
digitalWrite(bit_C2, LOW);
digitalWrite(bit_D2, LOW);
digitalWrite(bit_A3, LOW);
digitalWrite(bit_B3, LOW);
digitalWrite(bit_C3, LOW);
digitalWrite(bit_D3, LOW);
digitalWrite(bit_A4, LOW);
digitalWrite(bit_B4, LOW);
digitalWrite(bit_C4, LOW);
digitalWrite(bit_D4, LOW);
}
}
void loop ()
{
// on test maintenant si les boutons ont subi un appui (ou pas)
// d'abord le bouton minute plus
state = digitalRead(btn_minute_plus);
if ((state != mem_minute_plus) && (state == LOW))
Afficheur_minute += 1;
mem_minute_plus = state; // on enregistre l'état du bouton pour le tour suivant
rtc.adjust(DateTime(2022, 11, 07, Afficheur_heure, Afficheur_minute, 0));
// et maintenant pareil pour le bouton minute moins
state = digitalRead(btn_minute_moins);
if ((state != mem_minute_moins) && (state == LOW))
Afficheur_minute -= 1;
mem_minute_moins = state; // on enregistre l'état du bouton pour le tour suivant
rtc.adjust(DateTime(2022, 11, 07, Afficheur_heure, Afficheur_minute, 0));
// et maintenant pareil pour le bouton heure plus
state = digitalRead(btn_heure_plus);
if ((state != mem_heure_plus) && (state == LOW))
Afficheur_heure += 1;
mem_heure_plus = state; // on enregistre l'état du bouton pour le tour suivant
rtc.adjust(DateTime(2022, 11, 07, Afficheur_heure, Afficheur_minute, 0));
// et maintenant pareil pour le bouton heure moins
state = digitalRead(btn_heure_moins);
if ((state != mem_heure_moins) && (state == LOW))
Afficheur_minute -= 1;
mem_heure_moins = state; // on enregistre l'état du bouton pour le tour suivant
rtc.adjust(DateTime(2022, 11, 07, Afficheur_heure, Afficheur_minute, 0));
// Lecture du module RTC
GetDateHeure(DateHeure);
int Afficheur_minute = (DateHeure[1]);
int Afficheur_heure = (DateHeure[2]);
d1=Afficheur_minute%10;
d2=Afficheur_minute/10;
d3=Afficheur_heure%10;
d4=Afficheur_heure/10;
disp1(d1);
disp2(d2);
disp3(d3);
disp4(d4);
// Affichage de l'heure
Serial.print(DateHeure[2]), DEC; //Affichage Heures
Serial.print(':');
Serial.print(DateHeure[1], DEC); //Affichage Minutes
Serial.print(':');
Serial.print(DateHeure[0], DEC); //Affichage Secondes
Serial.println();
// Délai
delay(1000);
}
// fonction permettant d'afficher un nombre sur deux afficheurs
void disp1(int Afficheur_minute)
{
// on met à zéro tout les bits du décodeur
digitalWrite(bit_A1, LOW);
digitalWrite(bit_B1, LOW);
digitalWrite(bit_C1, LOW);
digitalWrite(bit_D1, LOW);
// On allume les bits nécessaires
if (Afficheur_minute >= 8)
{
digitalWrite(bit_D1, HIGH);
Afficheur_minute = Afficheur_minute - 8;
}
if (Afficheur_minute >= 4)
{
digitalWrite(bit_C1, HIGH);
Afficheur_minute = Afficheur_minute - 4;
}
if (Afficheur_minute >= 2)
{
digitalWrite(bit_B1, HIGH);
Afficheur_minute = Afficheur_minute - 2;
}
if (Afficheur_minute >= 1)
{
digitalWrite(bit_A1, HIGH);
Afficheur_minute = Afficheur_minute - 1;
}
}
void disp2(int Afficheur_minute)
{
// on met à zéro tout les bits du décodeur
digitalWrite(bit_A2, LOW);
digitalWrite(bit_B2, LOW);
digitalWrite(bit_C2, LOW);
digitalWrite(bit_D2, LOW);
// On allume les bits nécessaires
if (Afficheur_minute >= 8)
{
digitalWrite(bit_D2, HIGH);
Afficheur_minute = Afficheur_minute - 8;
}
if (Afficheur_minute >= 4)
{
digitalWrite(bit_C2, HIGH);
Afficheur_minute = Afficheur_minute - 4;
}
if (Afficheur_minute >= 2)
{
digitalWrite(bit_B2, HIGH);
Afficheur_minute = Afficheur_minute - 2;
}
if (Afficheur_minute >= 1)
{
digitalWrite(bit_A2, HIGH);
Afficheur_minute = Afficheur_minute - 1;
}
}
void disp3(int Afficheur_heure)
{
// on met à zéro tout les bits du décodeur
digitalWrite(bit_A3, LOW);
digitalWrite(bit_B3, LOW);
digitalWrite(bit_C3, LOW);
digitalWrite(bit_D3, LOW);
// On allume les bits nécessaires
if (Afficheur_heure >= 8)
{
digitalWrite(bit_D3, HIGH);
Afficheur_heure = Afficheur_heure - 8;
}
if (Afficheur_heure >= 4)
{
digitalWrite(bit_C3, HIGH);
Afficheur_heure = Afficheur_heure - 4;
}
if (Afficheur_heure >= 2)
{
digitalWrite(bit_B3, HIGH);
Afficheur_heure = Afficheur_heure - 2;
}
if (Afficheur_heure >= 1)
{
digitalWrite(bit_A3, HIGH);
Afficheur_heure = Afficheur_heure - 1;
}
}
void disp4(int Afficheur_heure)
{
// on met à zéro tout les bits du décodeur
digitalWrite(bit_A4, LOW);
digitalWrite(bit_B4, LOW);
digitalWrite(bit_C4, LOW);
digitalWrite(bit_D4, LOW);
// On allume les bits nécessaires
if (Afficheur_heure >= 8)
{
digitalWrite(bit_D4, HIGH);
Afficheur_heure = Afficheur_heure - 8;
}
if (Afficheur_heure >= 4)
{
digitalWrite(bit_C4, HIGH);
Afficheur_heure = Afficheur_heure - 4;
}
if (Afficheur_heure >= 2)
{
digitalWrite(bit_B4, HIGH);
Afficheur_heure = Afficheur_heure - 2;
}
if (Afficheur_heure >= 1)
{
digitalWrite(bit_A4, HIGH);
Afficheur_heure = Afficheur_heure - 1;
}
}
Bonsoir ASSM
Donc il faut mettre cette ligne:
rtc.adjust(DateTime(2022, 11, 07, Afficheur_heure, Afficheur_minute, 0));
Après chacune de ces lignes:
Afficheur_minute += 1;
Afficheur_minute -= 1;
Afficheur_heure += 1;
Afficheur_heure -= 1;
Entre parenthèse, il y a une erreur ici:
state = digitalRead(btn_heure_moins);
if ((state != mem_heure_moins) && (state == LOW))
Afficheur_minute -= 1;
c'est
Afficheur_heure -= 1;
qu'il faut.
Essaies de mettre ces ligne à la fin de setup()
DateTime now = rtc.now();
Afficheur_heure = now.hour(); // Heures
Afficheur_minute = now.minute(); // Minutes
Pour initialiser, au départ, les 2 variables.
Je n'ai pas essayé "en vrai"
A+
Cordialement
jpbbricole
Je n'ai pas vérifier, mais comme tu n'a toujours pas corriger tes problèmes de déclaration de variable, la valeur que tu incrémente, n'est pas la même que celle que tu lis dans le RTC 
, il me semble ?
Bonsoir terwal
On est reparti avec le sketch du post #1 où ces variables sont globales et au post #31, au départ je synchronise ces variables avec la RTC.
Cordialement
jpbbricole
Désolé je ne comprend pas ce que tu veux dire, tu veux garder la redéclarassions des variables globaux au milieu de la Loop?
Bonsoir terwal
Pour moi, une variable globale ne peut pa être déclarée dans loop?
Les variables qui nous intéressent sont déclarées au tout début du sketch:
int Afficheur_minute; // Affichage des Afficheur_minutes à l'allumage
int Afficheur_heure; // Affichage des Afficheur_heures à l'allumage
Cordialement
jpbbricole
Pour moi, une variable globale ne peut pa être déclarée dans loop?
Les variables qui nous intéressent sont déclarées au tout début du sketch:
Ce n'est pas ce que j'ai dit.
Je pense que l'on parle de la même chose?
les variables déclarées au début du sketch sont effectivement global et ont une certaine valeur.
Lorsque @ASSM les redéclares au milieu de la loop, deux instances de ces variables existes avec deux portées différentes, donc après la redéclarassions toutes utilisations ou affectation de ces nouvelles variables locales n'auront pas d'influence sur les variables global portant le même nom.
un petit exemple
int a;
void setup() {
Serial.begin(115200);
a = 0;
}
void loop() {
a++;
Serial.print("global:");Serial.println(a);
int a;
a++;
Serial.print("local:");Serial.println(a);
delay(1000);
}
output:
global:1
local:1
global:2
local:1
global:3
local:1
global:4
local:1
Après ce n'est pas forcément l'origine de son problème, mais cela peut donner à des erreurs dans l'avenir.
Je pense que le compilateur doit d'ailleurs générer un warning?
Bonjour ASSM
En reprenant ton programme du post #1, je me suis aperçu que tu utilisai A4:
int btn_heure_moins = A4;
Pour un bouton, or A4 fait partie, avec A5 du bus i2C qui connecte ta RTC.
A chaque pression sur le bouton tu "influence" le bus i2C.
C'est un Mega.
Dans le programme du post #1, mets en remarque cette ligne:
//rtc.adjust(DateTime(F(DATE), F(TIME))); // Date du PC
Ainsi que ces 2 lignes dans loop();
//int Afficheur_minute = (DateHeure[0]);
//int Afficheur_heure = (DateHeure[1]);
et appliques mes propositions du post #31 et tu as un début de solution.
Je reviendrai sur ton sujet en fin de matinée, aujourd'hui, ici, c'est la foire 
A+
Cordialement
jpbbricole
Bonjour jpbbricole
j'ai suivi tes conseilles et maintenant j'arrive a modifier l'heure et les minutes mais par contre si je regle l'heure a 11h22 et bien elle restera toujours à 11h22.
Je te joins mon code actuel
#include <Wire.h>
#include "RTClib.h"
RTC_DS1307 rtc;
word DateHeure[6] = {0, 0, 0, 0, 0};
//rtc.adjust(DateTime(F(DATE), F(TIME))); Date du PC
// définition des broches du décodeur 7 segments des Unités des Afficheur_minutes
const int bit_A1 = 2;
const int bit_B1 = 3;
const int bit_C1 = 4;
const int bit_D1 = 5;
// définition des broches du décodeur 7 segments des Dizaines des Afficheur_minutes
const int bit_A2 = 6;
const int bit_B2 = 7;
const int bit_C2 = 8;
const int bit_D2 = 9;
// définition des broches du décodeur 7 segments des Unités des Afficheur_heures
const int bit_A3 = 10;
const int bit_B3 = 11;
const int bit_C3 = 12;
const int bit_D3 = 13;
// définition des broches du décodeur 7 segments des Dizaines des Afficheur_heures
const int bit_A4 = 14;
const int bit_B4 = 15;
const int bit_C4 = 16;
const int bit_D4 = 17;
int d1; //afficheur Unités des Afficheur_minutes
int d2; //afficheur Dizaines des Afficheur_minutes
int d3; //afficheur Unités des Afficheur_heures
int d4; //afficheur Dizaines des Afficheur_heures
int Afficheur_minute; // Affichage des Afficheur_minutes à l'allumage
int Afficheur_heure; // Affichage des Afficheur_heures à l'allumage
// les broches des boutons
int btn_minute_plus = A1;
int btn_minute_moins = A2;
int btn_heure_plus = A3;
int btn_heure_moins = A4;
// les mémoires d'état des boutons
int mem_minute_plus = HIGH;
int mem_minute_moins = HIGH;
int mem_heure_plus = HIGH;
int mem_heure_moins = HIGH;
int state = HIGH;
void GetDateHeure(word *DateHeure)
{
// Lecture du module RTC
DateTime now = rtc.now();
// Récupérration de l'heure
DateHeure[2] = now.hour(); // Heures
DateHeure[1] = now.minute(); // Minutes
DateHeure[0] = now.second(); // Secondes
}
void setup ()
{
Serial.begin(115200);
if (! rtc.begin())
{
Serial.println("Le module RTC non disponible");
while (1); // Attente RESET
}
else
{
Serial.println("Le module RTC est OK");
rtc.writeSqwPinMode(DS1307_SquareWave4kHz);
rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); // Date du PC
//rtc.adjust(DateTime(2020,1,24,10,10,10)); // Ajustement manuelle
// Ex: 10 Janvier 2020 à 10:00:00:
// rtc.adjust(DateTime(2020, 1, 10, 10, 0, 0));
// Les broches sont toutes des sorties
pinMode(bit_A1, OUTPUT);
pinMode(bit_B1, OUTPUT);
pinMode(bit_C1, OUTPUT);
pinMode(bit_D1, OUTPUT);
pinMode(bit_A2, OUTPUT);
pinMode(bit_B2, OUTPUT);
pinMode(bit_C2, OUTPUT);
pinMode(bit_D2, OUTPUT);
pinMode(bit_A3, OUTPUT);
pinMode(bit_B3, OUTPUT);
pinMode(bit_C3, OUTPUT);
pinMode(bit_D3, OUTPUT);
pinMode(bit_A4, OUTPUT);
pinMode(bit_B4, OUTPUT);
pinMode(bit_C4, OUTPUT);
pinMode(bit_D4, OUTPUT);
// Les broches sont toutes des entrées
pinMode(btn_minute_plus, INPUT);
pinMode(btn_minute_moins, INPUT);
pinMode(btn_heure_plus, INPUT);
pinMode(btn_heure_moins, INPUT);
// Les broches sont toutes mises à l'état bas
digitalWrite(bit_A1, LOW);
digitalWrite(bit_B1, LOW);
digitalWrite(bit_C1, LOW);
digitalWrite(bit_D1, LOW);
digitalWrite(bit_A2, LOW);
digitalWrite(bit_B2, LOW);
digitalWrite(bit_C2, LOW);
digitalWrite(bit_D2, LOW);
digitalWrite(bit_A3, LOW);
digitalWrite(bit_B3, LOW);
digitalWrite(bit_C3, LOW);
digitalWrite(bit_D3, LOW);
digitalWrite(bit_A4, LOW);
digitalWrite(bit_B4, LOW);
digitalWrite(bit_C4, LOW);
digitalWrite(bit_D4, LOW);
DateTime now = rtc.now();
Afficheur_heure = now.hour(); // Heures
Afficheur_minute = now.minute(); // Minutes
}
}
void loop ()
{
// on test maintenant si les boutons ont subi un appui (ou pas)
// d'abord le bouton minute plus
state = digitalRead(btn_minute_plus);
if ((state != mem_minute_plus) && (state == LOW))
Afficheur_minute += 1;
rtc.adjust(DateTime(2022, 11, 07, Afficheur_heure, Afficheur_minute, 0));
mem_minute_plus = state; // on enregistre l'état du bouton pour le tour suivant
// et maintenant pareil pour le bouton minute moins
state = digitalRead(btn_minute_moins);
if ((state != mem_minute_moins) && (state == LOW))
Afficheur_minute -= 1;
rtc.adjust(DateTime(2022, 11, 07, Afficheur_heure, Afficheur_minute, 0));
mem_minute_moins = state; // on enregistre l'état du bouton pour le tour suivant
// et maintenant pareil pour le bouton heure plus
state = digitalRead(btn_heure_plus);
if ((state != mem_heure_plus) && (state == LOW))
Afficheur_heure += 1;
rtc.adjust(DateTime(2022, 11, 07, Afficheur_heure, Afficheur_minute, 0));
mem_heure_plus = state; // on enregistre l'état du bouton pour le tour suivant
// et maintenant pareil pour le bouton heure moins
state = digitalRead(btn_heure_moins);
if ((state != mem_heure_moins) && (state == LOW))
Afficheur_heure -= 1;
rtc.adjust(DateTime(2022, 11, 07, Afficheur_heure, Afficheur_minute, 0));
mem_heure_moins = state; // on enregistre l'état du bouton pour le tour suivant
// Lecture du module RTC
GetDateHeure(DateHeure);
// int Afficheur_minute = (DateHeure[1]);
// int Afficheur_heure = (DateHeure[2]);
d1=Afficheur_minute%10;
d2=Afficheur_minute/10;
d3=Afficheur_heure%10;
d4=Afficheur_heure/10;
disp1(d1);
disp2(d2);
disp3(d3);
disp4(d4);
// Affichage de l'heure
Serial.print(DateHeure[2]), DEC; //Affichage Heures
Serial.print(':');
Serial.print(DateHeure[1], DEC); //Affichage Minutes
Serial.print(':');
Serial.print(DateHeure[0], DEC); //Affichage Secondes
Serial.println();
// Délai
delay(100);
}
// fonction permettant d'afficher un nombre sur deux afficheurs
void disp1(int Afficheur_minute)
{
// on met à zéro tout les bits du décodeur
digitalWrite(bit_A1, LOW);
digitalWrite(bit_B1, LOW);
digitalWrite(bit_C1, LOW);
digitalWrite(bit_D1, LOW);
// On allume les bits nécessaires
if (Afficheur_minute >= 8)
{
digitalWrite(bit_D1, HIGH);
Afficheur_minute = Afficheur_minute - 8;
}
if (Afficheur_minute >= 4)
{
digitalWrite(bit_C1, HIGH);
Afficheur_minute = Afficheur_minute - 4;
}
if (Afficheur_minute >= 2)
{
digitalWrite(bit_B1, HIGH);
Afficheur_minute = Afficheur_minute - 2;
}
if (Afficheur_minute >= 1)
{
digitalWrite(bit_A1, HIGH);
Afficheur_minute = Afficheur_minute - 1;
}
}
void disp2(int Afficheur_minute)
{
// on met à zéro tout les bits du décodeur
digitalWrite(bit_A2, LOW);
digitalWrite(bit_B2, LOW);
digitalWrite(bit_C2, LOW);
digitalWrite(bit_D2, LOW);
// On allume les bits nécessaires
if (Afficheur_minute >= 8)
{
digitalWrite(bit_D2, HIGH);
Afficheur_minute = Afficheur_minute - 8;
}
if (Afficheur_minute >= 4)
{
digitalWrite(bit_C2, HIGH);
Afficheur_minute = Afficheur_minute - 4;
}
if (Afficheur_minute >= 2)
{
digitalWrite(bit_B2, HIGH);
Afficheur_minute = Afficheur_minute - 2;
}
if (Afficheur_minute >= 1)
{
digitalWrite(bit_A2, HIGH);
Afficheur_minute = Afficheur_minute - 1;
}
}
void disp3(int Afficheur_heure)
{
// on met à zéro tout les bits du décodeur
digitalWrite(bit_A3, LOW);
digitalWrite(bit_B3, LOW);
digitalWrite(bit_C3, LOW);
digitalWrite(bit_D3, LOW);
// On allume les bits nécessaires
if (Afficheur_heure >= 8)
{
digitalWrite(bit_D3, HIGH);
Afficheur_heure = Afficheur_heure - 8;
}
if (Afficheur_heure >= 4)
{
digitalWrite(bit_C3, HIGH);
Afficheur_heure = Afficheur_heure - 4;
}
if (Afficheur_heure >= 2)
{
digitalWrite(bit_B3, HIGH);
Afficheur_heure = Afficheur_heure - 2;
}
if (Afficheur_heure >= 1)
{
digitalWrite(bit_A3, HIGH);
Afficheur_heure = Afficheur_heure - 1;
}
}
void disp4(int Afficheur_heure)
{
// on met à zéro tout les bits du décodeur
digitalWrite(bit_A4, LOW);
digitalWrite(bit_B4, LOW);
digitalWrite(bit_C4, LOW);
digitalWrite(bit_D4, LOW);
// On allume les bits nécessaires
if (Afficheur_heure >= 8)
{
digitalWrite(bit_D4, HIGH);
Afficheur_heure = Afficheur_heure - 8;
}
if (Afficheur_heure >= 4)
{
digitalWrite(bit_C4, HIGH);
Afficheur_heure = Afficheur_heure - 4;
}
if (Afficheur_heure >= 2)
{
digitalWrite(bit_B4, HIGH);
Afficheur_heure = Afficheur_heure - 2;
}
if (Afficheur_heure >= 1)
{
digitalWrite(bit_A4, HIGH);
Afficheur_heure = Afficheur_heure - 1;
}
}
c'est normal, la récupération des variables de l'heure sont en commentaire pour l'instant.
d1=Afficheur_minute%10;
d2=Afficheur_minute/10;
d3=Afficheur_heure%10;
d4=Afficheur_heure/10;
tu peux remplacer par
d1=DateHeure[1]%10;
d2=DateHeure[1]/10;
d3=DateHeure[2]%10;
d4=DateHeure[2]/10;
ou bien enlever c'est satané déclaration par simplement ça 
Afficheur_minute = (DateHeure[1]);
Afficheur_heure = (DateHeure[2]);
Comme je l'ai indiqué dans mon précédent message, il n'y aucune raison de faire une déclaration de variable à ce moment du code
Bonjour ASSM,
Mes conseils ne vont, pas forcément agir selon mes prévisions. En effet, la technique qui consiste à ne pas mettre d'accolade avec les if est piégeuse!
if ((state != mem_minute_moins) && (state == LOW))
Afficheur_minute -= 1;
rtc.adjust(DateTime(2022, 11, 07, Afficheur_heure, Afficheur_minute, 0));
Je t'ai fait rajouter rtc.adjust(DateTime....cette instruction est tout le temps exécutée vu que, sans accolades, seul l'instruction suivant le if est dépendant de ce if.
C'est mieux d'écrire:
if ((state != mem_minute_moins) && (state == LOW))
{
Afficheur_minute -= 1;
rtc.adjust(DateTime(2022, 11, 07, Afficheur_heure, Afficheur_minute, 0));
}
Je te livre le résultat de mes cogitations, je n'ai pas le temps, cet après midi, de te détailler mes modifications, mais essaies, chez moi ça fonctionne.
Les principales modifications, sont la lecture des boutons, pour ça, il serait meilleur d'en confier la gestion à une bibliothèque comme Button.h, ça simplifie nettement la chose.
Assures toi que tes boutons sont d'un côté à GND et de l'autre sur la pin de l'Arduino (PULL_UP)
J'ai, aussi, remplacé
delay(1000);
Par une temporisation avec millis, non bloquante. Ainsi, tes boutons agissent immédiatement.
Le programme:
#include <Wire.h>
#include "RTClib.h"
RTC_DS1307 rtc;
word DateHeure[6] = {0, 0, 0, 0, 0};
// définition des broches du décodeur 7 segments des Unités des Afficheur_minutes
const int bit_A1 = 2;
const int bit_B1 = 3;
const int bit_C1 = 4;
const int bit_D1 = 5;
// définition des broches du décodeur 7 segments des Dizaines des Afficheur_minutes
const int bit_A2 = 6;
const int bit_B2 = 7;
const int bit_C2 = 8;
const int bit_D2 = 9;
// définition des broches du décodeur 7 segments des Unités des Afficheur_heures
const int bit_A3 = 10;
const int bit_B3 = 11;
const int bit_C3 = 12;
const int bit_D3 = 13;
// définition des broches du décodeur 7 segments des Dizaines des Afficheur_heures
const int bit_A4 = 14;
const int bit_B4 = 15;
const int bit_C4 = 16;
const int bit_D4 = 17;
int d1; //afficheur Unités des Afficheur_minutes
int d2; //afficheur Dizaines des Afficheur_minutes
int d3; //afficheur Unités des Afficheur_heures
int d4; //afficheur Dizaines des Afficheur_heures
int Afficheur_minute; // Affichage des Afficheur_minutes à l'allumage
int Afficheur_heure; // Affichage des Afficheur_heures à l'allumage
// les broches des boutons
int btn_minute_plus = A1;
int btn_minute_moins = A2;
int btn_heure_plus = A3;
int btn_heure_moins = A4;
// les mémoires d'état des boutons
//int mem_minute_plus = HIGH;
//int mem_minute_moins = HIGH;
//int mem_heure_plus = HIGH;
//int mem_heure_moins = HIGH;
//int state = HIGH;
int rtcAnneeParDefaut = 2022;
int rtcMoisParDefaut = 11;
int rtcJourParDefaut = 2022;
unsigned long affichageTempo = 1000; // Affichage toutes les secondes
unsigned long affichageMillis = millis(); // Affichage chrono
void setup ()
{
Serial.begin(115200);
if (! rtc.begin())
{
Serial.println("Le module RTC non disponible");
while (1); // Attente RESET
}
else
{
Serial.println("Le module RTC est OK");
//rtc.writeSqwPinMode(DS1307_SquareWave4kHz);
//rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); // Date du PC
//rtc.adjust(DateTime(2020,1,24,10,10,10)); // Ajustement manuelle
// Ex: 10 Janvier 2020 à 10:00:00:
// rtc.adjust(DateTime(2020, 1, 10, 10, 0, 0));
// Les broches sont toutes des sorties
pinMode(bit_A1, OUTPUT);
pinMode(bit_B1, OUTPUT);
pinMode(bit_C1, OUTPUT);
pinMode(bit_D1, OUTPUT);
pinMode(bit_A2, OUTPUT);
pinMode(bit_B2, OUTPUT);
pinMode(bit_C2, OUTPUT);
pinMode(bit_D2, OUTPUT);
pinMode(bit_A3, OUTPUT);
pinMode(bit_B3, OUTPUT);
pinMode(bit_C3, OUTPUT);
pinMode(bit_D3, OUTPUT);
pinMode(bit_A4, OUTPUT);
pinMode(bit_B4, OUTPUT);
pinMode(bit_C4, OUTPUT);
pinMode(bit_D4, OUTPUT);
// Les broches sont toutes des entrées
pinMode(btn_minute_plus, INPUT_PULLUP);
pinMode(btn_minute_moins, INPUT_PULLUP);
pinMode(btn_heure_plus, INPUT_PULLUP);
pinMode(btn_heure_moins, INPUT_PULLUP);
// Les broches sont toutes mises à l'état bas
digitalWrite(bit_A1, LOW);
digitalWrite(bit_B1, LOW);
digitalWrite(bit_C1, LOW);
digitalWrite(bit_D1, LOW);
digitalWrite(bit_A2, LOW);
digitalWrite(bit_B2, LOW);
digitalWrite(bit_C2, LOW);
digitalWrite(bit_D2, LOW);
digitalWrite(bit_A3, LOW);
digitalWrite(bit_B3, LOW);
digitalWrite(bit_C3, LOW);
digitalWrite(bit_D3, LOW);
digitalWrite(bit_A4, LOW);
digitalWrite(bit_B4, LOW);
digitalWrite(bit_C4, LOW);
digitalWrite(bit_D4, LOW);
}
DateTime now = rtc.now();
rtcAnneeParDefaut = now.year();
rtcMoisParDefaut = now.month();
rtcJourParDefaut = now.day();
Afficheur_heure = now.hour(); // Heures
Afficheur_minute = now.minute(); // Minutes
}
void loop ()
{
// on test maintenant si les boutons ont subi un appui (ou pas)
// d'abord le bouton minute plus
//state = digitalRead(btn_minute_plus);
//--------------------------------- Minures plus
if (digitalRead(btn_minute_plus) == LOW)
{
Serial.println("btn_minute_plus");
DateTime now = rtc.now();
Afficheur_minute = now.minute(); // Minutes
Afficheur_minute += 1;
rtc.adjust(DateTime(rtcAnneeParDefaut, rtcMoisParDefaut, rtcJourParDefaut, Afficheur_heure, Afficheur_minute, 0));
delay(20);
while(digitalRead(btn_minute_plus) == LOW){} // Attendre le relâchement du bouton
}
//--------------------------------- Minutes moins
if (digitalRead(btn_minute_moins) == LOW)
{
Serial.println("btn_minute_moins");
DateTime now = rtc.now();
Afficheur_minute = now.minute(); // Minutes
Afficheur_minute -= 1;
rtc.adjust(DateTime(rtcAnneeParDefaut, rtcMoisParDefaut, rtcJourParDefaut, Afficheur_heure, Afficheur_minute, 0));
delay(20);
while(digitalRead(btn_minute_moins) == LOW){} // Attendre le relâchement du bouton
}
//--------------------------------- Heures plus
if (digitalRead(btn_heure_plus) == LOW)
{
Serial.println("btn_heure_plus");
DateTime now = rtc.now();
Afficheur_heure = now.hour(); // Heures
Afficheur_heure += 1;
rtc.adjust(DateTime(rtcAnneeParDefaut, rtcMoisParDefaut, rtcJourParDefaut, Afficheur_heure, Afficheur_minute, 0));
delay(20);
while(digitalRead(btn_heure_plus) == LOW){} // Attendre le relâchement du bouton
}
//--------------------------------- Heures moins
if (digitalRead(btn_heure_moins) == LOW)
{
Serial.println("btn_heure_moins");
DateTime now = rtc.now();
Afficheur_heure = now.hour(); // Heures
Afficheur_heure -= 1;
rtc.adjust(DateTime(rtcAnneeParDefaut, rtcMoisParDefaut, rtcJourParDefaut, Afficheur_heure, Afficheur_minute, 0));
delay(20);
while(digitalRead(btn_heure_moins) == LOW){} // Attendre le relâchement du bouton
}
//int Afficheur_minute = (DateHeure[0]);
//int Afficheur_heure = (DateHeure[1]);
// Affichage de l'heure
if (millis() - affichageMillis >= affichageTempo)
{
// Lecture du module RTC
GetDateHeure(DateHeure);
d1=Afficheur_minute%10;
d2=Afficheur_minute/10;
d3=Afficheur_heure%10;
d4=Afficheur_heure/10;
disp1(d1);
disp2(d2);
disp3(d3);
disp4(d4);
Serial.print(DateHeure[2]), DEC; //Affichage Heures
Serial.print(':');
Serial.print(DateHeure[1], DEC); //Affichage Minutes
Serial.print(':');
Serial.print(DateHeure[0], DEC); //Affichage Secondes
Serial.println();
affichageMillis = millis();
}
// Délai
//delay(1000);
}
void GetDateHeure(word *DateHeure)
{
// Lecture du module RTC
DateTime now = rtc.now();
// Récupérration de l'heure
DateHeure[2] = now.hour(); // Heures
DateHeure[1] = now.minute(); // Minutes
DateHeure[0] = now.second(); // Secondes
}
// fonction permettant d'afficher un nombre sur deux afficheurs
void disp1(int Afficheur_minute)
{
// on met à zéro tout les bits du décodeur
digitalWrite(bit_A1, LOW);
digitalWrite(bit_B1, LOW);
digitalWrite(bit_C1, LOW);
digitalWrite(bit_D1, LOW);
// On allume les bits nécessaires
if (Afficheur_minute >= 8)
{
digitalWrite(bit_D1, HIGH);
Afficheur_minute = Afficheur_minute - 8;
}
if (Afficheur_minute >= 4)
{
digitalWrite(bit_C1, HIGH);
Afficheur_minute = Afficheur_minute - 4;
}
if (Afficheur_minute >= 2)
{
digitalWrite(bit_B1, HIGH);
Afficheur_minute = Afficheur_minute - 2;
}
if (Afficheur_minute >= 1)
{
digitalWrite(bit_A1, HIGH);
Afficheur_minute = Afficheur_minute - 1;
}
}
void disp2(int Afficheur_minute)
{
// on met à zéro tout les bits du décodeur
digitalWrite(bit_A2, LOW);
digitalWrite(bit_B2, LOW);
digitalWrite(bit_C2, LOW);
digitalWrite(bit_D2, LOW);
// On allume les bits nécessaires
if (Afficheur_minute >= 8)
{
digitalWrite(bit_D2, HIGH);
Afficheur_minute = Afficheur_minute - 8;
}
if (Afficheur_minute >= 4)
{
digitalWrite(bit_C2, HIGH);
Afficheur_minute = Afficheur_minute - 4;
}
if (Afficheur_minute >= 2)
{
digitalWrite(bit_B2, HIGH);
Afficheur_minute = Afficheur_minute - 2;
}
if (Afficheur_minute >= 1)
{
digitalWrite(bit_A2, HIGH);
Afficheur_minute = Afficheur_minute - 1;
}
}
void disp3(int Afficheur_heure)
{
// on met à zéro tout les bits du décodeur
digitalWrite(bit_A3, LOW);
digitalWrite(bit_B3, LOW);
digitalWrite(bit_C3, LOW);
digitalWrite(bit_D3, LOW);
// On allume les bits nécessaires
if (Afficheur_heure >= 8)
{
digitalWrite(bit_D3, HIGH);
Afficheur_heure = Afficheur_heure - 8;
}
if (Afficheur_heure >= 4)
{
digitalWrite(bit_C3, HIGH);
Afficheur_heure = Afficheur_heure - 4;
}
if (Afficheur_heure >= 2)
{
digitalWrite(bit_B3, HIGH);
Afficheur_heure = Afficheur_heure - 2;
}
if (Afficheur_heure >= 1)
{
digitalWrite(bit_A3, HIGH);
Afficheur_heure = Afficheur_heure - 1;
}
}
void disp4(int Afficheur_heure)
{
// on met à zéro tout les bits du décodeur
digitalWrite(bit_A4, LOW);
digitalWrite(bit_B4, LOW);
digitalWrite(bit_C4, LOW);
digitalWrite(bit_D4, LOW);
// On allume les bits nécessaires
if (Afficheur_heure >= 8)
{
digitalWrite(bit_D4, HIGH);
Afficheur_heure = Afficheur_heure - 8;
}
if (Afficheur_heure >= 4)
{
digitalWrite(bit_C4, HIGH);
Afficheur_heure = Afficheur_heure - 4;
}
if (Afficheur_heure >= 2)
{
digitalWrite(bit_B4, HIGH);
Afficheur_heure = Afficheur_heure - 2;
}
if (Afficheur_heure >= 1)
{
digitalWrite(bit_A4, HIGH);
Afficheur_heure = Afficheur_heure - 1;
}
}
A ta disposition pour toutes questions.
PS: Regardes du côté des tableaux, ils simplifieraient l'écriture et la gestion de ton programme.
A+
Cordialement
jpbbricole