Discussion :

[lololebricoleur]

Bonjour,

Je précise que je suis ultra débutant en Arduino et novice en électronique.
Je travail sur un petit projet qui doit tourner en boucle infinie et commencer par un paramétrage de l'heure et de la date
Pour ça, j'ai l'intention d'utiliser un module DS3231 pour mémoriser et d'un DCF77 pour initialiser et actualiser.

Au démarrage de mon projet j'ai donc besoin de lancer la mise à jour de l'heure et date et ensuite, mon intention est de le faire une fois pas jour.

Pour ça, je me disais qu'en début de loop, je pourrais utiliser un booléen quime permet de savoir si l'heure doit ou non être initialisée
Si elle doit l'être, je lance la fonction dédiée mais dans cette fonction, je dois intégrer une boucle qui va décoder la trame du DCF77
Et comme la réception n'est pas toujours optimale, j'avais l'intention de mettre une autre boucle pour gérer un nombre d'essai limité.

Voilà donc ma question est :
Quand je rentre dans une fonction, est il possible de reste dans cette fonction en y intégrant une boucle et de n'en ressortir que quand je l'ai décidé ?

Merci de votre aide

[jackk]

Quand je rentre dans une fonction, est il possible de reste dans cette fonction en y intégrant une boucle et de n'en ressortir que quand je l'ai décidé ?

Oui bien sûr: une fonction ne se termine (normalement) qu'avec l'exécution de l'instruction return ou de la dernière instruction (celle qui précède l'accolade fermante du code de la fonction).
Donc, c'est toi qui décides.

[lololebricoleur]

Merci de ta réponse Jackk,

Compte tenu la courte description de mon petit projet, est-ce que tu penses que c'est comme ça que je dois m'y prendre ?

Merci de ton aide

[jackk]

Mes connaissances sont limitées en Arduino.

Mais si je peux me permettre, j'intégrerais le décodage de la trame DCF77 dans une fonction qui renverrait un booléen renseignant si le décodage s'est bien effectué ou pas. Si oui, on met à l'heure et si non, on attend le prochain appel de la fonction.
Je ne sais pas si l'arduino utilise un watchdog qui vérifie si la boucle principale (la fonction loop) s'effectue en un temps donné, mais d'une manière générale, il n'est pas bon de bloquer cette boucle principale, ne serait-ce que pour exécuter le reste du code.

[Jay M]

salut

une idée de structure de code (tapée ici, non testée)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
const unsigned long deltaMAJ = 86400000UL;    // 24h en ms
unsigned long derniereMAJ = -deltaMAJ;        // pour forcer une MAJ au démarrage
 
bool lireDCF77(const unsigned long delaiMax = 1000) { // valeur du timeout par défaut 1s
  bool lectureCorrecte = false;
  unsigned long debut = millis();
  while (!lectureCorrecte && (millis() - debut <= delaiMax)) {
    // faire une lecture DCF77
    // si elle est réussie, mettre lectureCorrecte à true
    // *** à faire ***
  }
  return lectureCorrecte;
}
 
void actualiserDS3231() {
  // *** à faire ***
}
 
 
void miseAJourHeure() {
  if (millis() - derniereMAJ >= deltaMAJ) {   // on vérifie si c'est le moment de la MàJ
    if (lireDCF77()) {                        // on va lire l'heure DCF77, si ça s'est bien passé
      actualiserDS3231();                     // on met à jour la RTC (appel bloquant avec un délai qu'on peut passer en paramètre)
    }
    derniereMAJ = millis();                   // on se souvient avoir effectué la demande (même si elle n'a pas aboutie)
  }
}
 
void setup() {
  // *** à faire ***
}
 
void loop() {
  miseAJourHeure();
 
  // ici le reste du programme
  // *** à faire ***
 
}

dans la loop() on appelle constamment la fonction miseAJourHeure() qui ne fait rien sauf 1 fois par jour où elle va essayer de lire la DCF77 pendant un temps max que l'on peut préciser dans l'appel de la fonction lireDCF77() (si on ne met pas de paramètre, le paramètre par défaut de la déclaration de la fonction est pris, soit 1000ms)

Une alternative, comme vous avez une RTC DS3231, serait de déclencher une alarme toutes les 24h et c'est sur traitement de cette alarme que vous allez appeler la fonction lireDCF77()

Enfin, à noter qu'il existe une bibliothèque Time de Michael Margolis et Paul Stoffregen pour la gestion du temps avec une source externe de synchro (la doc mentionne même la DCF77)

je n'ai jamais joué DCF77, si le temps d'acquisition est long il faut sans doute dans ce cas rendre asynchrone sa lecture

[jackk]

je n'ai jamais joué DCF77, si le temps d'acquisition est long il faut sans doute dans ce cas rendre asynchrone sa lecture

Une trame dure une minute, à raison d'un bit par seconde.
En suivant ton lien, on arrive à une bibliothèque spécifique pour DCF77.

[Jay M]

Une trame dure une minute, à raison d'un bit par seconde.

Ok donc Il faut une petite machine à etat asynchrone pour écouter la trame de temps en temps

[jackk]

Pourquoi pas, mais il y a peut-être plus simple.
Il faut travailler en interruption: une sur chaque front pour mesurer la durée du bit et en déduire sa valeur.
Une fois la trame terminée, reste le choix de la stratégie:
- polling: un booléen est positionné dès que la trame est décodée et le programme scrute régulièrement si le flag est levé.
- événement, donc asynchrone comme tu le prévoyais: il faut trouver un moyen de lancer un événement et je ne pense pas qu'on puisse générer facilement une interruption logicielle. Une autre solution, s'il reste des I/O est de relier une sortie à une entrée programmée pour générer une interruption et du coup ça devient moins compliqué.

[Jay M]

Pourquoi pas, mais il y a peut-être plus simple, Il faut travailler en interruption: une sur chaque front.

oui c’est la bonne approche
( ça reste une machine à état dont les événements sont les interruptions )

il faut trouver un moyen de lancer un événement et je ne pense pas qu'on puisse générer facilement une interruption logicielle.

On peut avoir des interruptions logicielles avec les timers. Mais dans le cas présent le timing de mise à jour de l’horloge n’est pas à la ms près. Un drapeau mis lorsque l'heure est prête et on le lit au prochain tour de loop ou alors on met à jour la RTC dans l’interruption mais c’est un peu plus touchy car il faudra réactiver les interruptions.

A noter que si on a un moyen de se synchroniser de temps en temps alors on peut se passer de la RTC et donc ça enlève les soucis d’interruption bloquée