Bonjour Je suis en train de réaliser une horloge avec afficheur 7 segments et un module DS1307. J'arrive correctement à récupérer l'heure du module et l'afficher sur les 7 segments, par contre je bloque pour pouvoir modifier l'heure manuellement avec 4 boutons poussoirs. Merci d'avance. Voici mon code #include #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; //periode 15 / 45 // 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 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 // 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 // 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 // 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 // Lecture du module RTC GetDateHeure(DateHeure); int Afficheur_minute = (DateHeure[0]); int Afficheur_heure = (DateHeure[1]); 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); } 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; } }

[image] ASSM: 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 En fait je comprends mal ta gestion des boutons : est-ce ton code ou bien tu l'as trouvé quelque part ? Moi je ferais comme ceci, en les déclarant en INPUT_PULLUP comme dit plus haut : state = digitalRead(btn_minute_plus); if (!state) { // bouton enfoncé Afficheur_minute += 1; if (Afficheur_minute < 0) Afficheur_minute += 10; // pas vraiment nécessaire pour le + (mais pour mémoire) Afficheur_minute = Afficheur_minute % 10; }

J'ai changé en pinMode(btn_minute_plus, INPUT_PULLUP); pinMode(btn_minute_moins, INPUT_PULLUP); pinMode(btn_heure_plus, INPUT_PULLUP); pinMode(btn_heure_moins, INPUT_PULLUP); et aussi state = digitalRead(btn_minute_plus); if (!state) { // bouton enfoncé Afficheur_minute += 1; if (Afficheur_minute < 0) Afficheur_minute += 10; // pas vraiment nécessaire pour le + (mais pour mémoire) Afficheur_minute = Afficheur_minute % 10; } Mais aucun changement

[image] ASSM: GetDateHeure(DateHeure); int Afficheur_minute = (DateHeure[0]); int Afficheur_heure = (DateHeure[1]); Pourquoi tu redéclare tes variables en plein milieu du code de la loop et après avoir l'avoir modifier en fonction de tes boutons. déjà déclare des variables au début de ta fonction si elles sont utilisées que dans celle-ci ou en dehors si elles sont utilisées par plusieurs fonctions. Peut tu aussi remettre ton code modifier car c'est difficile à suivre avec juste les modifications effectuées Tu n'a pas de warning d'ailleurs sur le scope de tes variables?

[image] ASSM: Mais aucun changement Normal. Tu prends en compte l'appui sur les boutons pour changer Afficheur_heure et Afficheur_minute mais avant d'afficher la nouvelle heure tu vas lire la RTC et tu remodifies les 2 variables donc tu affiches tout le temps l'heure de la RTC. En fait heures et minutes modifiées par les boutons ne sont jamais exploitées Il faudrait modifier la structure de ton code pour ne pas lire la RTC lorsqu'une modification de l'heure est en cours. Une fois que l'heure a été saisie (et validée, comment??) mettre à jour la RTC et se remettre à afficher l'heure de la RTC.

[image] ASSM: // Lecture du module RTC GetDateHeure(DateHeure); Afficheur_minute = DateHeure[0]; // enlever int ici et les parenthèses Afficheur_heure = DateHeure[1]; // ici aussi Donc, il faut déplacer ces lignes dans le setup. De plus, je me suis trompé : je pensais que les boutons servaient pour changer les chiffres (par exemple un bouton pour les dizaines et un pour les unités), mais il changent les heures et minutes, donc il faut modifier : if (Afficheur_minute < 0) Afficheur_minute += 60; Afficheur_minute = Afficheur_minute % 60; et if (Afficheur_heure < 0) Afficheur_heure += 60; Afficheur_heure = Afficheur_heure % 60;

Voici le code modifié avec l'erreur #include #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; //periode 15 / 45 // 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 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); // Lecture du module RTC GetDateHeure(DateHeure); int Afficheur_minute = (DateHeure[1]); int Afficheur_heure = (DateHeure[2]); } } 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) { // bouton enfoncé Afficheur_minute += 1; if (Afficheur_minute < 0) Afficheur_minute += 60; // pas vraiment nécessaire pour le + (mais pour mémoire) Afficheur_minute = Afficheur_minute % 60; // et maintenant pareil pour le bouton minute moins state = digitalRead(btn_minute_moins); if (!state) { // bouton enfoncé Afficheur_minute -= 1; if (Afficheur_minute < 0) Afficheur_minute += 60; Afficheur_minute = Afficheur_minute % 60; // et maintenant pareil pour le bouton heure plus state = digitalRead(btn_heure_plus); if (!state) { // bouton enfoncé Afficheur_heure += 1; if (Afficheur_heure < 0) Afficheur_heure += 60; Afficheur_heure = Afficheur_heure % 60; // et maintenant pareil pour le bouton heure moins state = digitalRead(btn_heure_plus); if (!state) { // bouton enfoncé Afficheur_heure -= 1; if (Afficheur_heure < 0) Afficheur_heure += 60; Afficheur_heure = Afficheur_heure % 60; 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); } 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; } }

[image] ASSM: 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 } Déplace ce bloc avant le setup. D'une manière générale, il vaut mieux mettre les fonctions avant l'endroit où elles sont appelées, parfois le compilateur ne les trouve pas si elles sont après...

Maintenant j'ai l'erreur 'disp1' was not declared in this scope

Même façon de faire, même sentence. Tu utilise la fonction disp1 avant de l'avoir déclarée. int Afficheur_minute; // Affichage des Afficheur_minutes à l'allumage int Afficheur_heure; // Affichage des Afficheur_heures à l'allumage ... void setup () { ... // Lecture du module RTC GetDateHeure(DateHeure); int Afficheur_minute = (DateHeure[1]); int Afficheur_heure = (DateHeure[2]); } } Comme je te l'ai indiqué dans un précédent message, tu déclare plusieurs fois Afficheur_minute et Afficheur_heure. Ce qui a pour effet d'écraser la portée de tes varaibles. en gros l'affectation de Afficheur_minute dans la fonction setup, ne sera visible que dans cette fonction. Donc quand tu fera ton +1, tu ne le ferra pas avec la valeur contenu dans DateHeure[1], mais avec la valeur par défaut de la déclaration globale. Je ne sais pas si je suis très claire?

HorlogeDS1307 7 segments

International Français

ASSM November 7, 2022, 11:34am 10

Bonjour Lesept

j'ai modifié le code comme préconisé.

Par contre en mettant la lecture du module RTC dans le setup j'ai l'erreur suivante

'GetDateHeure' was not declared in this scope

Topic		Replies	Views
Horloge RTC ne compte pas le temps Français	29	589	July 20, 2026
Need help adjusting time on Seven Segment Display clock Programming	46	841	June 26, 2026
Help with TM1637 6-digit And Button Programming	385	4667	January 7, 2026
Faire une horloge avec 4 7 segments displays Français	34	7019	February 21, 2018
Horloge Géante Français	348	39583	November 30, 2018

HorlogeDS1307 7 segments

Related topics