Détection de top synchro sur FI sur 162kh (fréquence étalon).

**jpbbricole** · 08/01/2021, 09h58

Salut Pat

Envoyé par Pat42

Auriez vous connaissance de littérature(d'un cours ou d'un bouquin) expliquant l' indexation en détail (telle que vous l'avez utilisé dans le prg ).

Quentends-tu par indexation, si c'est l'usage de cette syntaxe infoDonnees[compteurSeconde] = donneeBit; par exemple, soit des tableaux, tu peux regarder ici ou là-bas

Envoyé par Pat42

Du coup, je n'ai plus l'heure exacte et ça me stress

Autrement il y a d'autres solutions

!
Quelle est la durée de la maintenance?

Cordialement
jpbbricole

**Jay M** · 08/01/2021, 11h45

Salut et bonne année 2021!

Je n'ai malheureusement pas encore toutes les compétences en programmation pour comprendre vos modifs (je les comprends en surface, mais pas en détail)

Je vais essayer d'expliquer - peut-être ce sera utile: vous avez un tableau, infoDonnees qui contient 59 cases

Code :

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

1
2
 #define nombreDeSeconde 59
 byte infoDonnees[ nombreDeSeconde];

dans lequel le code de @JP stocke les 'bits' (0 ou 1) pertinents au fur et à mesure de leur arrivée chaque seconde.

Un groupe consécutif de ces 0 et 1 constitue (lorsqu'on les regroupe) une information pertinente. Par exemple, le protocole nous dit que les informations concernant le N° du mois en cours sont stockées sur 5 bits consécutifs en format DCB (Décimal codé binaire) et sont reçus lors des 5 secondes N° 45, 46, 47, 48 et 49. C'est ce que @JP a mémorisé dans le code par

Code :

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

1
2
 #define bitDonneesMoisStart 45
 #define bitDonneesMoisNbr 5

Un dessin vaut mieux qu'un long discours, donc en gros ça ressemble à cela:
Nom : BCD.png
Affichages : 153
Taille : 139,1 Ko

Donc lorsque l'on veut aller chercher le N° du mois, il faut calculer la valeur d'un "octet fictif" (à droite sur le schéma) dont les 5 bits de poids faibles (bitNombre) seraient remplis à partir des cases du tableau, en commençant à la ligne 45 (bitStart).

Un octet dispose de 8 bits, et est codé en base 2. On définit donc sa valeur comme une somme pondéré par la valeur des bits (un 1 on prend la valeur, un 0 on ne la prend pas):
Le bit le plus à droite (bit #0) compte pour 1 (2⁰),
et en allant vers la gauche le bit #1 pour 2 (2¹),
le bit #2 pour 4 (2²)
...
et le dernier bit #7 vaut 128 (2⁷).

Le code de @JP propose une fonction qui va effectuer ce travail: aller chercher dans le tableau une succession de valeurs (bitNombre) à partir d'une certaine place (bitStart) et effectuer cette somme pondérée.

C'est codé dans cette boucle for

Code :

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

1
2
3
4
	for (int bitIndex = 0; bitIndex < bitNombre; bitIndex ++)
	{
		extrait += infoDonnees[(bitStart+0) + bitIndex] << bitIndex;
	}

La "magie" des puissances de 2 se fait en informatique avec un décalage à gauche (opérateur arithmétique << dit bitwise left shift) << bitIndex.

Si vous prenez un 1, en binaire représenté 00000001, et que vous le décalez de 3 positions à gauche par exemple, vous obtenez 00001000 ce qui vaut 8, soit 2³. Si par contre vous avez décalé 3 fois un octet valant 0 (en binaire 00000000) il reste bien sûr à zéro.

Donc la boucle prend les 0 ou 1 aux bonnes cases du tableau et effectue un décalage croissant (donc puissance de 2 croissante) et la somme avec le += pour arriver à former le bon octet avec des 0 et 1 aux bons endroits.

En sortie de cette boucle, la variable extrait contient donc la valeur de notre octet.
Comme on sait que c'est un codage BCD, les chiffres de 0 à 9 sont codé sur quatre bits

Chiffre Bits
0.........0000
1.........0001
2.........0010
3.........0011
4.........0100
5.........0101
6.........0110
7.........0111
8.........1000
9.........1001

On a la représentation du N° du mois en deux bouts, les 4 bits de poids forts sont la dizaine et les 4 bits de poids faible sont les unités

il faut donc faire un peu de cuisine pour prendre les 4 bits du haut d'un côté et les 4 bits du bas de l'autre. Soit on le fait avec des opérateurs qui travaillent sur les bits (masques et décalage) soit on fait la même chose avec des division et modulo par 16 (2⁴). C'est ce qu'à choisi de faire @JP dans son code:

Code :

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

	extrait = (extrait/16*10) + (extrait%16);                         // Transformer du BCD en decimal

Comme tout le tableau contient des informations codées en BCD (DCB en français

) la fonction de @JP est générique et peut s'appliquer à d'autres parties du tableau.

**Guesset** · 09/01/2021, 16h11

Bonjour Pat42,

Juste pour mettre mon grain de sel. Le SIGLENT sait sauvegarder des copies d'écran, entre autres, en BMP et PNG sur une clé USB. C'est pratique et de bonne qualité. J'ai abandonné les photos d'écran car j'avais toujours des reflets et une horizontalité améliorable. Si ça peut aider...

Salutations

**Pat42** · 12/01/2021, 15h12

Bonjour , désolé de n'avoir pu vous répondre plus rapidement , mais les 8 jours derniers m'ont beaucoup occupé.
Merci a vous JP et J may pour le coup de main que vous me donnez à chaque fois que "j'attaque la falaise".

Avec tes liens sur les tableaux et la super explication de J MAY

j'espère que cela va rentrer mais pas trop, sinon, je n'aurais plus le plaisir de "converser" avec vous.

Concernant la mise en panne de l'émetteur , l'horaire est d'environ 8h à environ 11h30. En fait j'aimerais installer cette horloge, ce qui me permet au fil de ce projet (à rallonge) d'en apprendre un peu plus.

Merci aussi à Guesset de s'être inséré dans la discussion . C'est un Siglent SDS 1202X-E et je vais tester...

Bon! j'ai de la lecture qui m'attend...

A+
Cordialement

Pat

**Pat42** · 26/11/2021, 23h49

Bonjour à tous, en particulier à jpbbricole et Jay M .

Je reviens à nouveau avec mon projet (horloge étalon) qui me sert de fil conducteur pour apprendre.

Rappelez vous…

Vous m’avez donné un bon coup de main pour créer ce prg qui me permet d’afficher les données de l’émetteur d’Allouis sur 162 khz, émetteur qui est puissant et modulé en phase. Avec Allouis, je n’ai pas de pb et je fais simplement un test sur l’année pour accepter l’affichage des données.

Pour en apprendre un peu plus sur la programmation , je me suis fabriqué un récepteur pour DCF 77 sur 77,5Khz ( j’aurais pu acheter un module tout fait, mais... c'est un plaisir de se tapper la tête contre les murs quand cela ne fonctionne pas comme on le veut ).

Du coup, j’ai modifié légèrement le pgr pour l’adapter à la réception de DCF77 ( au niveau du timing de la récupérations des données et du top synchro,
et j'ai aussi supprimé le niveau du signal reçu).

DCF étant modulé en Amplitude, la réception est agrémentée d’évanouissements , de phading, de parasites en tout genre ect… De plus, le signal est de quelques centaines de µV/m , alors qu’Allouis c’est quelques mV/m. du coup , il y a souvent des pertes de synchronisation

Et j’en arrive à mon pb.

1) Il faudrait pour le fonctionnement fiable de l’horloge avec DCF77, que je teste les bits de donnée avec le bit de parité sur tous les champs : minutes, heures, mois, ect… et autoriser l’affichage que si tous les tests sont bons.
2) plus tard, piloter une horloge en temps réelle qui prend la relève, puis recaler cette horloge une fois toutes les 72 heures.

Voici un exemple avec les secondes qui supportent les données des minutes (pour rafraîchir les mémoires, pas celle du pc lol ).

Encodage pour affichage 29 mns

Code :

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

1
2
3
4
5
6
7
8
9
       Sec                   Bin                       Déc             affichage 29 minutes
       21                    1                          1      -------       1
       22                    2                          2                    0
       23                    4                          4                    0      on utilise 7 bits pour les minutes le 8° est le bit de parité
       24                    8                          8      -------       1
       25                   16                         10                    0                  
       26                   32                         20      -------       1
       27                   64                         40                    0          
       28                  --                          --      -------       1        Bit de parité à 1 ou 0

Par exemple pour 29 minutes : Seconde 21, 24, 26 à 1
Le nb de bit à 1 plus le bit de parité doit toujours être pair . Si le nb de bits de donnée à 1 est pair, le bit de parité est à 0. Si le nb de bit de donnée à 1 est impair, le bit de parité est à 1.

Alors ! comment compter les 7 bits de données et le bit de parité qui sont à 1 sachant que dans le pg, on utilise que les 7 bits de données.

J'ai eu quelques idées par ex.

Ici je rajoute le bit à lire en plus

Code :

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

1
2
#define bitDonneesMinutesStart 21   
#define bitDonneesMinutesNbr 8 // normalement 7

et là, je retire le bit pour que l'affichage soit correct et je fais ma sauce entre les deux actions, mais se sont des usines à gaz..

Code :

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

nouvelleMin = donneesExtraire(bitDonneesMinutesStart, bitDonneesMinutesNbr-1);

pourriez vous me donner la bonne méthode à employer pour gérer cela sans trop modifier le prg.

Merci à vous.

Voici le prg

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
#include <Wire.h>                    //inclusion d'une bibliothéque permettant d'utiliser un afficheur liquide Crystal à 2 ou 4 alignes I2c.
 #include <LiquidCrystal_I2C.h>
 
 //----- Adressage matériel -----
 LiquidCrystal_I2C lcd(0x27, 20, 4); // adresse de l'afficheur 4 lignes I2c.
 //LiquidCrystal_I2C lcd(0x26, 20,4); // adresse de l'afficheur 2 lignes I2c
 //------------------------------
 #define interruptPin 2              // on définit la pin 2 comme la pin qui déclenchera les intéerruptions sur les fronts montants ou descendants 
 #define ledSeconde 13               // on definit la pin 13 comme la pin qui marquera les secondes avec une led, la led indquera aussi si les secondes contienne un bit de donné.
                                     // elle clignotera deux fois si la seconde contient un bit de donné.
 
 #define bitdonneesEteHiver   17         //definit 'heure d'été et d'hiver: si bit17 à 0 et bit 18 à 1 ,c'est l'heure d'hiver. 1h de plus que l'heure UTC
 #define bitdonneesEteHiverNbr  2       // si bit 17 à 1 et bit 18 à 0 , c'est l'heure d'été, 2h de plus que l'heure UTC
 
 #define bitDonneesMinutesStart 21   
 #define bitDonneesMinutesNbr 7     //8 //définit le début des secondes qui contiennent des bits de donnés pour les minutes (seconde 21 à 28).
 
 #define bitDonneesHeuresStart 29
 #define bitDonneesHeuresNbr 7      //définit le début des secondes qui contiennent des bits de donnés pour les heures (seconde 29 à 35).
 
 #define bitDonneesJourStart 36     //définit le début des secondes qui contiennent des bits de donnés pour les jours (seconde 36 à 41).
 #define bitDonneesJourNbr 6
 
 #define bitDonneesJourSemaineStart 42   //définit le début des secondes qui contiennent des bits de donnés pour les jours de semaine (seconde 42 à 44).
 #define bitDonneesJourSemaineNbr 3
 const char* jourSemaineNom[] = {"--","Lun", "Mar", "Mer", "Jeu", "Ven", "Sam", "Dim"};
 
 #define bitDonneesMoisStart 45          //définit le début des secondes qui contiennent des bits de donnés pour les jours des mois(seconde 45 à 49).
 #define bitDonneesMoisNbr 5
 const char* moisNom[] = {"--", "Jan", "Fev", "Mars", "Avr", "Mai", "Juin", "Juil", "Aout", "Sept", "Oct", "Nov", "Dec"};
 
 #define bitDonneesAnneesStart 50       //définit le début des secondes qui contiennent des bits de donnés pour les années dizaines et unités(seconde 50 à 55).
 #define bitDonneesAnneesNbr 6
 
 #define nombreDeSeconde 59             //définit le nb d'octet pour mettre les valeurs associés aux secondes 0 à 58 soit 59 octets.
 byte infoDonnees[ nombreDeSeconde];
 byte donneeBit = 0;
 
 volatile boolean mesureEnCours = false;    //déclaration de mesureEnCours
 volatile boolean mesureNouvelle = false;   // déclaration de mesureNouvelle,ces deux délarations servent à la machine à état pour repérer le début de la premièrev seconde
                                                  // qui est le top synchro.
 
 volatile unsigned long tempoDepart = millis();        //Déclaration sur deux octets non signé
 volatile unsigned long topSyncMilliSec = millis();    //Déclaration sur deux octets non signé
 volatile unsigned long departMesure = millis();      //Déclaration sur deux octets non signé
 const unsigned int topSyncMinimum = 800;             // Déclaration du temps mini pour le repérage du top synchro , seconde 59 sans bit ni top seconde
 
 int unsigned  compteurSeconde = 0;                       //déclaration de un octet pour le compteur des secondes
 
 int nouvelleMin;
 int nouvelleHeure;
 String nouveauJourSemaineNom;
 int nouveauJour;                                         //Déclaration des octets qui vont contenir les résultats 
 String nouveauMois;
 int nouvelleAnnee;
 int testNouvelleAnnee;
 int passageEteHiver;
 int heureUtc;
 
 boolean top = false;
 boolean top1 = false;                                //déclaration pour les machines à état
 boolean top2 = false;
 boolean top3 = true;                                 //pour indiquer "attente donnée"
 boolean top4 = true;
 boolean top5 = false;
 
 
 float tension = 0;
 int valeur =0;
 
 void setup()
 {
   lcd.backlight(); lcd.init(); // initialisation de l'afficheur 4 lignes
 
    for (byte s = 0; s <= nombreDeSeconde ; s++)   // Initialisation des bits de données
    {                                             // A faire avant chaque cycle de minute
     infoDonnees[s] = 0;
    }
 
   Serial.begin (115200);
   pinMode(interruptPin, INPUT_PULLUP);    // entrée interruption avec pull up
   pinMode(ledSeconde, OUTPUT);            //
   digitalWrite(ledSeconde, LOW);
   attachInterrupt(digitalPinToInterrupt(interruptPin), impulsion_Interruption, CHANGE); //interruption pour rechercher
 
 
   lcd.setCursor(0,0);
   lcd.print("Attente synchro");
 
 
   LiquidCrystal_I2C lcd(0x26, 16,2); lcd.init(); // initialisation de l'afficheur 2 lignes
 
  }
 
 //-----------------------------------------------------------------------
 void loop()
 {
   if (mesureNouvelle == true)
   {                                                                    // appel de la fonction "topSyncAction" si le top synchro est détecté
     mesureNouvelle = false;
     topSyncAction();
   }
 
   topSeconde();
   ecriture_Bit_Importante();                                            //appelle des fonctions
   affichage_I2c();
 
   niveauSignal();
 
 }
 
 //------------------------------------------------------------------------
 void impulsion_Interruption()
 {
   if (digitalRead(interruptPin) == LOW && !mesureEnCours)
   {
     tempoDepart = millis();                                                           // machine à état pour récupérer le top synchro (début de la 1° seconde)
     mesureEnCours = true;
   }
 
   if (digitalRead(interruptPin) == HIGH && mesureEnCours)
   {
     topSyncMilliSec = millis() - tempoDepart;
     mesureEnCours = false;
     mesureNouvelle = true;
 
   }
 }
 //-------------------------------------------------------------------------
 void topSyncAction()
 {
 
   if (topSyncMilliSec >= topSyncMinimum )
   {
     digitalWrite (ledSeconde, HIGH);
     compteurSeconde = 0;
     departMesure = millis();
     //Serial.println (millis());
     //Serial.print (compteurSeconde);
     //Serial.println ("Syncro_seconde----->0");                                           // top debut de la 1° seconde (synchro)
     delay (5);
     //Serial.println (millis());
     digitalWrite (ledSeconde, LOW);
     top1 = true;                            // permet de rentrer dans la fonction topSeconde qu'au top synchro, a un reset ou la mise en marche du pgr.
     top2 = true ;                          // permet d'attendre le top synchro, l'affichage des secondes demarre avec la seconde 0
     lcd.clear();                          //efface les donneeés sur l'ecran   au top synchro
 
   }
   top5 = true;                          //on indique le niveau du signal à chaque interruption
 }
 //-------------------------------------------------------------------------
 
 void topSeconde()
 {
   if(millis()- departMesure >= 950 && digitalRead (interruptPin)== HIGH &&( compteurSeconde < 59) && top1 ) //<59 empeche le compteur d'indiquer 60 par un nouveau passage dans cette routine
   {                                                                                                                // avant le top Synchro ainsi que le top1 qui permet de renter dans le
     digitalWrite (ledSeconde, HIGH);                                                                                // topSeconde uniquement au top syncrho
     compteurSeconde++;
     //Serial.println (compteurSeconde);
     departMesure = millis();
     delay (5);                                                                 //génère à partir des interrupts les tops seconde sauf la 59°s
     digitalWrite (ledSeconde, LOW);
     //Serial.println (millis());
     delay (105);
     //Serial.println (millis());
     lectureBit();
   }
 
 
   if(compteurSeconde == 58 && (millis() - departMesure >= 1000))
   {
     digitalWrite (ledSeconde, HIGH);
 
     compteurSeconde++;
     departMesure = millis();
     delay (5);                                                                   //génère  le top 59°s manquant dans la réception
     digitalWrite (ledSeconde, LOW);
     //Serial.println (compteurSeconde);
     lectureBit();
 
   }
 
 }
 //---------------------------------------------------------------------------
 
 void lectureBit()
 {
   if( digitalRead (interruptPin) == HIGH)
   {
     digitalWrite(ledSeconde, HIGH);
     delay (5);                                           //lit le bit 105 ms aprés le top seconde. Si le bit est à 1, il y a une donnée valide.
     digitalWrite (ledSeconde, LOW);
     donneeBit = 1;
     top = true;
   }
 
   else
   {
     donneeBit = 0;
     top = true;                                       // si pas de bit lue aprés 105 ms, le bit est égal à 0 .
   }
 
 }
 //---------------------------------------------------------------------------
 
 void ecriture_Bit_Importante()
 {
   if(top)
   {
     //Serial.print ("seconde----->");Serial.print (compteurSeconde );Serial.print("    ");   Serial.print("Donnée------>"); Serial.println(donneeBit);
     infoDonnees[compteurSeconde] = donneeBit;
     top = false;
     top2 = true;
   }
 }
 
 
/*------------------------------------------------------------------------------
  Extraction de donnees dans le tableau infoDonnees
  les donnees en BCD sont converties en decimal
'*------------------------------------------------------------------------------
*/
int donneesExtraire(int bitStart, int bitNombre)
{
  int extrait = 0;
 
  for (int bitIndex = 0; bitIndex < bitNombre; bitIndex ++)
  {
    extrait += infoDonnees[(bitStart+0) + bitIndex] << bitIndex;   
  }
 
  extrait = (extrait/16*10) + (extrait%16);                         // Transformer du BCD en decimal
  return extrait;
}
 
 
 
 
 //----------------------------------------------------------------------------------
 
 void affichage_I2c()
 {
 
   if(compteurSeconde == 59)
   {
 
 
     nouvelleMin = donneesExtraire(bitDonneesMinutesStart, bitDonneesMinutesNbr); //-1
     nouvelleHeure = donneesExtraire(bitDonneesHeuresStart, bitDonneesHeuresNbr);
     nouveauJour = donneesExtraire(bitDonneesJourStart, bitDonneesJourNbr);
     nouveauJourSemaineNom = jourSemaineNom[donneesExtraire(bitDonneesJourSemaineStart, bitDonneesJourSemaineNbr)];
     nouveauMois = moisNom[donneesExtraire(bitDonneesMoisStart, bitDonneesMoisNbr)];
     nouvelleAnnee = donneesExtraire(bitDonneesAnneesStart, bitDonneesAnneesNbr);
     passageEteHiver = donneesExtraire(bitdonneesEteHiver,bitdonneesEteHiverNbr);
     testNouvelleAnnee = nouvelleAnnee /10 % 10;    // permet d'avoir toujours  le "2" des dizaines d'années , fonctionne jusqu' à l'année 2030
 
     top4 = true;                                       // autorise l 'affichage des données une seule fois par minute pour éviter des multitudes d'affichages 
                                                        //qui ne servent à rien et qui creer des pb de timing si l'affichage n'est pasterminé avant l'interruption pour le top synchro.
   }                                                
 
   if (top2)
   {
 
     lcd.setCursor(17,1);
     if (compteurSeconde<10){lcd.print("0");}
     lcd.print( compteurSeconde);  //affichage des secondes
     lcd.setCursor(19,1);
     lcd.print("s");
 
     lcd.setCursor(17,2);
     if (compteurSeconde<10){lcd.print("0");}
     lcd.print( compteurSeconde);  //affichage des secondes
     lcd.setCursor(19,2);
     lcd.print("s");
 
 //-----------------------------------------------------------------------------------
     if( testNouvelleAnnee != 2) // si different de 2 , "affichage attente données"
     {
       lcd.setCursor(0,0);
       lcd.print("Attente donnees");
     }
 
     top2 = false;
   }
 
 
   if (compteurSeconde == 0 && (testNouvelleAnnee == 2) &&( top4 == true)) //si 2, alors affichage les données une seule autorisation d'écriture est donné pa la fonction
   {
 
     lcd.setCursor(0,0);
     lcd.print(nouveauJourSemaineNom);
    //---------------------------- 
     lcd.print(" ");
     if (nouveauJour<10){lcd.print("0");}
     lcd.print(nouveauJour);
   //-----------------------------
     lcd.print(" ");
     lcd.print(nouveauMois);
   //-----------------------------
     lcd.print("  ");
     lcd.print("20");
     lcd.print(nouvelleAnnee);
   //-----------------------------
     lcd.setCursor(0,1); 
     lcd.print("PARIS ");   
     if (nouvelleHeure<10){lcd.print("0");}                                                                 //affiche les données si les dizaines et unités de l'année sont 20 21 ou 22
     lcd.print(nouvelleHeure);
     lcd.print("hr");
    //-----------------------------
     lcd.print(" ");  
     if (nouvelleMin<10){lcd.print("0");}         //void affichagei2c, si non on est sans arret dans l'ecriture des données sur l'afficheur et quand arrive l'interruption
     lcd.print(nouvelleMin);                    // à la seconde 0 pour le top synchro, l'interruption laisse finir le travail. du coup, se sera la prochaine                                             // interruption qui sera prise en compte et toute les mesures sont décalées et l'affichage est incorrect.
     lcd.print("min ");                         //void affichagei2c, si non on est sans arret dans l'ecriture des données sur l'afficheur et quand arrive l'interruption
                                               // à la seconde 0 pour le top synchro, l'interruption laisse finir le travail. du coup, se sera la prochaine
                                               // interruption qui sera prise en compte et toute les mesures sont décalées et l'affichage est incorrect
 
    //----------------------------- 
 
   if ( passageEteHiver == 2)
   {
    heureUtc = nouvelleHeure - 1;       //hiver bit sur seconde 18
     if(nouvelleHeure == 0){heureUtc = 23;}
 
   }  
 
 
   if ( passageEteHiver == 1)
   {
    heureUtc = nouvelleHeure - 2;       // été  bit sur seconde 17
     if(nouvelleHeure == 0){heureUtc = 22;} 
     if(nouvelleHeure == 1){heureUtc = 23;}     
   }
 
      lcd.setCursor(0,2);
      lcd.print("UTC   ");
      if (heureUtc<10){lcd.print("0");}
      lcd.print(heureUtc);
      lcd.print("hr ");
 
         if (nouvelleMin<10){lcd.print("0");}                  //void affichagei2c, si non on est sans arret dans l'ecriture des données sur l'afficheur et quand arrive l'interruption
      lcd.print(nouvelleMin);                               // à la seconde 0 pour le top synchro, l'interruption laisse finir le travail. du coup, se sera la prochaine                                             // interruption qui sera prise en compte et toute les mesures sont décalées et l'affichage est incorrect.
      lcd.print("min ");
 
      top4 = false;
   }
 
 }
 
 //-----------------------------------------------------------------------
 
 void niveauSignal()
 {
   if(top5)
   {
     valeur = analogRead(A7);
     tension = valeur * (5.0 / 1023.0);
     lcd.setCursor(0,3);
     lcd.print("Niv.Signal");
     lcd.setCursor(11,3);
     lcd.print(tension);
 
     top5 = false;
   }
 }

Une petite photo de la réception DCF77 ( pas terrible ce soir, les données sont perdues dans " un brouillard électronique " à couper au couteau ,mais le récepteur fait son job ).
On repère bien les bits de 100ms et celui de 200 ms

**jpbbricole** · 27/11/2021, 11h35

Bonjour Pat42

Ca fait plaisir de te relire.
Tu as fait ton propre récepteur, donc tu as bobiné l'antenne?
En tout cas, joli travail!
Pour ton problème de parité, remplaces int donneesExtraire par ça:

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
/*------------------------------------------------------------------------------
  Extraction de donnees dans le tableau infoDonnees
  les donnees en BCD sont converties en decimal
  Retourne -1 si la parité n'est pas bonne
'*------------------------------------------------------------------------------
*/
int donneesExtraire(int bitStart, int bitNombre)
{
  int extrait = 0;
  byte bits1count = 0;     // Compteur de bits à 1
 
  for (int bitIndex = 0; bitIndex < bitNombre; bitIndex ++)
  {
    extrait += infoDonnees[bitStart + bitIndex] << bitIndex; 
	if (infoDonnees[bitStart + bitIndex] == 1) {bits1count ++;}     // On compte les bit à 1
  }
  bits1count += infoDonnees[bitStart + bitNombre];     // Ajout du bit de parité
 
 
  if (bits1count % 2 == 0)     // Si bits1count paire donc parité bonne
  {
	extrait = (extrait/16*10) + (extrait%16);     // Transformer du BCD en decimal
  } 
  else
  {
	extrait = -1;
  }
 
  return extrait;
}

int donneesExtraire te retournes -1 si la parité n'est pas bonne, autrement la valeur lue.

A+
Cordialement
jpbbricole

**Pat42** · 27/11/2021, 21h20

Bonsoir Jpbbricole,

J'aimerais venir plus souvent et intervenir régulièrement pour aider les personnes en difficultés comme tu le fais, mais mes connaissances étant ce qu'elles sont en programmation

, je ne peux que prendre des leçons et laisser aux pros. le soin de donner les solutions...
Du coup, je viens quand j'ai besoin d'un coup de main, ce qui n'empêche que je viens faire mon petit tour de temps en temps.

Pour mon récepteur, je n'ai pas fabriqué la bobine, j'ai récupéré un bobinage GO sur un vieux récepteur PO GO ainsi que les transfo FI, mais il est beaucoup plus simple que mon premier récepteur qui fonctionne avec une pll pour récupérer les données modulées en phase ( émetteur d'Allouis).

Je vais décortiquer ton bout de programme et le tester .

Merci et bonne soirée.

pat

**Pat42** · 27/11/2021, 23h03

Je suis déja de retour lol.

En fait , il était tard hier et j'ai omis un GROS

détail.

Pour les minutes, se sont les secondes 21 à 27 qui contiennent les données et le bit de parité est transmis à la 28° seconde
Pour les heures , se sont les secondes 29 à 34 qui contiennent les données et le bit de parité est transmis à la 35° seconde

Mais pour les jours du mois, le jour de la semaine, le N° du mois et l'année, les bits de données sont transmis de la seconde 36 à 57 et le bit de parité est commun et est transmis à la seconde 58.

Je t'ai mis un petit tableau récupéré sur wikipédia (https://fr.wikipedia.org/wiki/DCF77)

Du coup pourrais tu m'aider simplement à faire la partie minute.
C'est a dire ( je me répète) compter les bits à 1 des secondes 21 à 27 qui servent pour les données, plus le bit de parité de la seconde 28 et mettre cela dans un compteur

Code :

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

  byte bits1count

pour que je puisse le visualiser sur mon écran série.

J'essaierai de faire le reste et le test qui va bien pour savoir si le nbr bit à 1 est pair ou impair.

Bonne fin de soirée

pat

Nom : Capture.PNG
Affichages : 127
Taille : 55,1 Ko

Nom : Capture.PNG
Affichages : 127
Taille : 55,1 Ko

**Jay M** · 28/11/2021, 10h57

Salut

ça veut dire qu'on ne peut pas réellement extraire le BCD puisque plusieurs champs peuvent être groupés.
On note cependant que le bit de parité suit toujours la zone concernée
On peut donc reprendre la bonne idée de @jpbricole et faire une fonction qui détermine si la parité est OK

Code :

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

1
2
3
4
5
6
bool validerParite(byte indexDepart, byte nombreDeBits) {
  byte nombreDeBitsNonNuls = 0;                                           // Compteur de bits non nuls
  for (byte index = 0; index <= nombreDeBits; index++)                     // On parcourt la zone concernée du tableau
    if (infoDonnees[indexDepart + index] != 0) nombreDeBitsNonNuls++;     //      et compte les bits non nuls (y compris le bit de parité qui doit suivre dans le tableau)
  return (nombreDeBitsNonNuls & 0x1) == 0;                                // retourne vrai si le nombre est pair (bit de poids faible nul)
}

à appeler pour la zone des minutes (21,7) puis des heures (29,6) puis du reste qui est groupé (36, 22) pour valider les 3 zones (si j'ai bien compté)

Code :

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

1
2
3
4
5
if (validerParite(21,7) && validerParite(29,6) && validerParite(36,22)) {
  // parité OK
} else {
  // parité incorrecte
}

**jpbbricole** · 28/11/2021, 11h12

Bonjour Pat42

Voilà, j'ai revu le tout en fonction du tableau.
Tu reprends la fonction int donneesExtraire originale:

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
/*------------------------------------------------------------------------------
  Extraction de donnees dans le tableau infoDonnees
  les donnees en BCD sont converties en decimal
'*------------------------------------------------------------------------------
*/
int donneesExtraire(int bitStart, int bitNombre)
{
  int extrait = 0;
 
  for (int bitIndex = 0; bitIndex < bitNombre; bitIndex ++)
  {
    extrait += infoDonnees[(bitStart+0) + bitIndex] << bitIndex;   
  }
 
  extrait = (extrait/16*10) + (extrait%16);                         // Transformer du BCD en decimal
  return extrait;
}

Dans l'initialisation des variables tu ajoutes:

Code :

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

1
2
3
4
5
6
7
8
9
 //------------------------------------- Parités P1, P2 et P3
 #define bitDonneesP1start bitDonneesMinutesStart
 #define bitDonneesP1nbr bitDonneesMinutesNbr
 
 #define bitDonneesP2start bitDonneesHeuresStart
 #define bitDonneesP2nbr bitDonneesHeuresStart
 
 #define bitDonneesP3start bitDonneesJourStart
 #define bitDonneesP3nbr bitDonneesJourNbr + bitDonneesJourSemaineNbr + bitDonneesMoisNbr + bitDonneesAnneesNbr

Tu ajotes la fonction:

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
 
/*----------------------------------------------------------------------------------
	Contrôle de la parité des données
	P1 = Minutes
	P2 = Heures
	P3 = Jour du mois, jour de la semaine, numéro du mois et année sans le sièclke
 
	Retourne true si parité juste
'*----------------------------------------------------------------------------------
*/
boolean donneesPariteTest(int bitStart, int bitNombre)
{
  byte bits1count = 0;     // Compteur de bits à 1
 
  for (int bitIndex = 0; bitIndex < bitNombre; bitIndex ++)
  {
	if (infoDonnees[bitStart + bitIndex] == 1) {bits1count ++;}     // On compte les bit à 1
  }
  bits1count += infoDonnees[bitStart + bitNombre];     // Ajout du bit de parité
 
 
  return (bits1count % 2 == 0) ? true : false;
}

Pour tester les parités P1 ou P2 ou P3:

Code :

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

1
2
3
4
5
6
7
   bool pariteTest = false;
   pariteTest = donneesPariteTest(bitDonneesP1start, bitDonneesP1nbr);
   Serial.println(pariteTest);
   pariteTest = donneesPariteTest(bitDonneesP2start, bitDonneesP2nbr);
   Serial.println(pariteTest);
   pariteTest = donneesPariteTest(bitDonneesP3start, bitDonneesP3nbr);
   Serial.println(pariteTest);

A+
Cordialement
jpbbricole

**Jay M** · 28/11/2021, 13h50

petite amélioration éventuelle:

au lieu de

Code :

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

1
2
3
4
5
 for (int bitIndex = 0; bitIndex < bitNombre; bitIndex ++)
  {
	if (infoDonnees[bitStart + bitIndex] == 1) {bits1count ++;}     // On compte les bit à 1
  }
  bits1count += infoDonnees[bitStart + bitNombre];     // Ajout du bit de parité

on peut faire simplement (puisque au final on ajoute aussi la valeur après la boucle)

Code :

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

1
2
3
4
 for (int bitIndex = 0; bitIndex <= bitNombre; bitIndex ++)
  {
	if (infoDonnees[bitStart + bitIndex] == 1) {bits1count ++;}     // On compte les bit à 1
  }

voire

Code :

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

1
2
3
4
 for (int bitIndex = 0; bitIndex <= bitNombre; bitIndex ++)
  {
	bits1count += infoDonnees[bitStart + bitIndex] ;     // On compte les bit à 1
  }

et sinon pour le return, un test est déjà une valeur de vérité, donc pas la peine de rajouter l'opération ternaire.

au lieu de

Code :

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

  return (bits1count % 2 == 0) ? true : false;

on peut mettre

Code :

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

  return (bits1count % 2 == 0);

un modulo étant couteux, pour savoir si un un nombre est pair il suffit de regarder son bit de poids faible (qui compte pour 1, le reste étant des puissances de 2 c'est pair), ce que l'on peut écrire ainsi avec un masque sur le bit 0

Code :

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

  return (bits1count & 1) == 0;

(cela dit, l'optimiseur va généralement détecter qu'on teste la parité et va remplacer le modulo par un test sur ce bit de poids faible)

**jpbbricole** · 28/11/2021, 14h07

Bonjour Jay M

Envoyé par Jay M

petite amélioration éventuelle:

Ouai! comme on dit chez nous, je suis ni pour, ni contre, bien au contraire.
Je pense qu'il faut quand même garder un petit fond "ludique" dans l'écriture des programmes et éviter de chercher trop de perfectionnisme.
Ce n'est que l'avis du papy bricoleur que je suis.

Cordialement
jpbbricole

**Jay M** · 28/11/2021, 14h12

je n'ai pas bien vu le côté ludique de rajouter du code pour rien - ça doit être un biais culturel

blague à part, ce n'étaient que des suggestions, comme d'habitude chacun fait ce qu'il veut, l'important c'est d'apprendre éventuellement quelque chose au passage.

**Pat42** · 28/11/2021, 15h37

Bonjour a tous les deux,

Toujours aussi prompt à donner un coup de main

et bien! je vais avoir de la lecture.

Le but du jeux est bien de compter les bits à 1 des données comme ils arrivent ( 8 secondes de la 21° sec à la 28°sec qui peuvent contenir des 1 et des 0. Le bit de parité à la 28° seconde est à 1 si le nbr de 1 des données est impair ce qui fait que la totalité des bits à 1 est toujours pair en sachant que seul les bits des secondes, 21 à 27 contiennent l'information à afficher (je me répète , mais c'est pour être certain de bien m'expliquer).

Bon ! j'attaquerai demain soir, pour l' instant on va se "taper"une petite coinche entre amis

.

Bonne fin de week-end à vous

**Jay M** · 28/11/2021, 15h44

le code proposé par @jpbricole doit répondre au besoin exprimé

**Pat42** · 03/12/2021, 23h09

Bonsoir,

Après un bon moment, je ne suis pas arrivé au résultat escompté avec la fonction que tu m'as écrit ( j'ai corrigé une petite coquille).

Code :

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

1
2
#define bitDonneesP2start bitDonneesHeuresStart
#define bitDonneesP2nbr bitDonneesHeuresStart

Du coup, je me suis dit " il faut que je me casse la tête". J'ai donc écrit trois petites fonctions qui font le boulot, en m'inspirant et de la fonction que tu m'as concocté Jpbbricole et des recommandations de M Jay.
Je n'arrive pas encore à jongler avec les subtilités de la programmation et comme cela, c'est beaucoup plus clair pour moi, et j'en comprends le déroulement.
C'est comme la boite à vitesse que j'ai ouverte dernièrement pour en comprendre le fonctionnement et la réparer ( je l'ai remonté, elle fonctionne impéccablement

)

Trois appels incluant bitstart et le nbr de secondes à prendre en compte.

Code :

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

1
2
3
     int testParite1 = extraireDonneeParite1( 21,8); //Données des minutes 
     int testParite2 = extraireDonneeParite2( 29,7); //Données des heures                             
     int testParite3 = extraireDonneeParite3( 36,23); //Données des jours, jour semaine, mois, année

Puis trois petites fonctions

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
 int extraireDonneeParite1(int bitStart1, int bitNombre1)
{                                                       
   bits1count = 0; 
   int extrait1 = 0;
     for (int bitIndex = 0; bitIndex < bitNombre1; bitIndex ++) 
   {                                                                              
    bits1count += infoDonnees[bitStart1 + bitIndex] ;        
 
                //Serial.println (bits1count);
   }
              //if(bits1count %2 == 0){Serial.println( "OK1" );}
 
}
 
//-----------------------------------------------------------------------------
 
 int extraireDonneeParite2(int bitStart2, int bitNombre2)
{                                                        
   bits2count = 0; 
   int extrait2 = 0;
     for (int bitIndex = 0; bitIndex < bitNombre2; bitIndex ++) 
   {                                                                                              
    bits2count += infoDonnees[bitStart2 + bitIndex] ;                             
   }
}
 
//---------------------------------------------------------------------------------
 
 int extraireDonneeParite3(int bitStart3, int bitNombre3)
{                                                         
   bits3count = 0; 
   int extrait3 = 0;
     for (int bitIndex = 0; bitIndex < bitNombre3; bitIndex ++) 
   {                                                                               
    bits3count += infoDonnees[bitStart3 + bitIndex] ;              
   }    
}

Puis le test de parité , j'ai additionné les parités puis modulo du total .

Code :

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

if (compteurSeconde == 0 && (bits1count + bits2count + bits3count )%2 == 0 && top4)

J'ai déclaré bits1count + bits2count + bits3count en global, car je l'ai utilise dans plusieurs fonctions.

Je vais me replonger dans la fonction de JPbbricole pour tenter de la faire tourner.

Bon week-end à vous.

**Jay M** · 04/12/2021, 09h50

bonjour

vos trois fonctions n'ont pas de return alors que vous dites au compilateur qu'elles doivent retourner un int. le compilateur doit vous mettre un warning

ça fonctionne pour les variables car vous avez déclaré les bits1count, bits2count et bits3count en global et vous les utilisez dans les fonctions.

En pratique vous dévoyez la notion de fonction. Il suffirait d'une fonction qui valide la parité entre 2 index et vous appelez cette fonction 3 fois, comme posté ci dessous la fonction:

Code :

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

1
2
3
4
5
6
bool validerParite(byte indexDepart, byte nombreDeBits) {
  byte nombreDeBitsNonNuls = 0;                                           // Compteur de bits non nuls
  for (byte index = 0; index <= nombreDeBits; index++)                     // On parcourt la zone concernée du tableau
    if (infoDonnees[indexDepart + index] != 0) nombreDeBitsNonNuls++;     //      et compte les bits non nuls (y compris le bit de parité qui doit suivre dans le tableau)
  return (nombreDeBitsNonNuls & 0x1) == 0;                                // retourne vrai si le nombre est pair (bit de poids faible nul)
}

va retourner vrai (true) si la parité est correcte et faux (false) si la parité est incorrecte (la comparaison (nombreDeBitsNonNuls & 0x1) == 0 dit si le nombre est pair)

**Pat42** · 07/12/2021, 14h44

Bonjour,

Bon! j'étais presque content de moi, ça casse le délire

Oui effectivement, je n'ai pas mis de return...et je n'ai aucun warning ...!
J'ai bien compris qu'il ne faut qu'une seule fonction et que celle-ci doit être appelée trois fois pour faire ce boulot répétitif (comme la fonction que m'a aussi écrit Jpbbricole)

Je vais essayer d'écrire les appels.

Je ne comprend pas vraiment pourquoi bool dans

bool validerParite(byte indexDepart, byte nombreDeBits)

**jpbbricole** · 07/12/2021, 16h27

Envoyé par Pat42

Je ne comprend pas vraiment pourquoi bool dans bool validerParite(byte indexDepart, byte nombreDeBits) ...

Parce que cette fonction retourne une valeur booléenne (false ou true) contrairement à une void qui ne retourne rien.

Le retour est true si la parité de la section entre les bits indexDepart et indexDepart +nombreDeBits est OK sinon false.

Cordialement
jpbbricole

**Jay M** · 07/12/2021, 16h42

Bonjour,

Envoyé par Pat42

Bon! j'étais presque content de moi, ça casse le délire

ça marchait, c'était déjà ça !

oui pour le bool c'est le type retourné (une valeur de vérité) true ou false qui va dire - comme le nom de la fonction l'indique - si la parité est valide.

comme ça on peut écrire

Code :

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

1
2
3
4
 
if (validerParite(21,8)) { // if (condition) ...
  // les minutes sont OK
}

bien sûr c'est encore mieux d'utiliser les constantes proposées par @jpbricole plutôt que les valeurs magiques 21 et 8 par exemple bitDonneesMinutesStart au lieu de 21

Détection de top synchro sur FI sur 162kh (fréquence étalon).

Arduino

Discussions similaires

Partager

Partager