HorlogeDS1307 7 segments

ASSM · November 6, 2022, 6:40pm

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 <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; //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;
  }
}

lesept · November 6, 2022, 6:58pm

Il faudrait expliquer ce qui coince.
Je pense que le problème est lié au delay(1000). Le reste du code tourne très vite et le µC reste la majeure partie du temps dans ce delay donc il ne scrute pas les boutons et il manque les appuis.
Essaye déjà d'ôter cette ligne.

En parcourant rapidement le code, je vois que tu ne vérifies pas que les valeurs que tu modifies restent entre 0 et 9 : il faut ajouter ceci lorsque tu appliques un changement

if (Afficheur_minute  < 0) Afficheur_minute  += 10;
Afficheur_minute  = Afficheur_minute  % 10;

ou

if (Afficheur_heure  < 0) Afficheur_heure  += 10;
Afficheur_heure  = Afficheur_heure % 10;

Le % est l'opération modulo : ici il calcule le reste de la division par 10.

ASSM · November 6, 2022, 7:40pm

Bonsoir Lesept

j'ai supprimé le delay(1000) mais rien ne change.
Aucun changement de l'affichage lorsque j'appuie sur le bouton plus des minutes par exemple.

En ce qui concerne les conditions d'affichage pour rester entre 0 et 9 je pensai bien en mettre mais je voulais résoudre d'abord mon problème de boutons poussoirs.

lesept · November 6, 2022, 7:43pm

Essaye de changer 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);

lesept · November 6, 2022, 7:47pm

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;
}

ASSM · November 6, 2022, 8:00pm

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

terwal · November 6, 2022, 8:14pm

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?

fdufnews · November 7, 2022, 8:52am

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.

lesept · November 7, 2022, 10:18am

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;

ASSM · November 7, 2022, 11:34am

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

ASSM · November 7, 2022, 11:37am

Voici le code modifié avec l'erreur

#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; //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;
  }
}

lesept · November 7, 2022, 11:37am

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...

ASSM · November 7, 2022, 11:42am

Maintenant j'ai l'erreur

'disp1' was not declared in this scope

terwal · November 7, 2022, 12:00pm

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?

lesept · November 7, 2022, 12:56pm

Au besoin, relis mon message numéro 9

fdufnews · November 7, 2022, 1:00pm

Une fois que la compilation passera, l'heure ne s'incrémentera plus. Tu ne lis pas la RTC dans loop().
Loop devrait avoir une structure dans ce style

loop()
    Est-ce qu'un bouton est appuyé?
       si oui aller à regler_l_heure
       si non continuer
   lire_la_RTC
   afficher_l_heure

La fonction regler_l_heure devrait ressembler à ça,

tu testes les boutons appuyés,
tu affiches les valeurs modifiées
validation des changements
- si oui tu mets la RTC à jour
- si non tu ne changes pas la RTC
retour

jpbbricole · November 7, 2022, 1:16pm

Bonjour ASSM

Ce n'est pas qu'une "simple erreur", mais un problème de structure de ton programme. Je ne sais ce que tu as voulu faire entre le sketch du post #1 et celui du post #11, mais il semble que c'est le b....l , j'ai l'impression que tu as mis des fonctions dans loop(), mais impossible de redresser ça.
Qu'as tu voulu faire?

Dans quel environnement développes tu?

Cordialement
jpbbricole

lesept · November 7, 2022, 1:29pm

On peut peut-être mettre la RTC à l'heure, après manipulation des boutons, par la commande

DateTime now = rtc.now();
rtc.adjust(DateTime(now.year(), now.month(), now.day(), Afficheur_heure, Afficheur_minute, 0));

Comme la DS1317 a une EEPROM, il faut éviter de le faire trop souvent, pour ne pas la flinguer trop vite : donc il faut utiliser un booléen qui passe à true si un bouton est enfoncé. Et tu mets à l'heure si le booléen est à tue.

jpbbricole · November 7, 2022, 1:44pm

Bonjour lesept

lesept:

On peut peut-être mettre la RTC à l'heure, après manipulation des boutons, par la commande
DateTime now = rtc.now();
rtc.adjust(DateTime(now.year(), now.month(), now.day(), Afficheur_heure, Afficheur_minute, 0));

Ce n'est pas le serpent qui se mord la queue?

Il faudrait utiliser:
rtc.adjust(DateTime(2022, 11, 07, Afficheur_heure, Afficheur_minute, 0));

Cordialement
jpbbricole

terwal · November 7, 2022, 1:46pm

Il a juste appliqué le conseil de @lesept, sans forcément avoir une idée précise de ce que ça fait.

Il faudrait reprendre tout le code, mais peut être petit à petit, pour qu'il puisse appréhender ce qu'il fait.

Topic		Replies	Views
Help with TM1637 6-digit And Button Programming	385	1554	January 7, 2026
Affichage zéros non significatifs Français	35	256	December 23, 2025
Enregistrer et afficher la date et l' heure de démarrage Français	215	452	April 13, 2026
Faire une horloge avec 4 7 segments displays Français	35	6763	May 6, 2021
Horloge d'échecs tm1637 Français	88	649	July 16, 2025

HorlogeDS1307 7 segments

Related topics