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

Salut Pat

Citation:

---

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

Citation:

---

Envoyé par Pat42

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

---

Autrement il y a d'autres solutions:yaisse2:!
Quelle est la durée de la maintenance?

Cordialement
jpbbricole

Salut et bonne année 2021!

Citation:

---

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:

---

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:

---

1 2	#define bitDonneesMoisStart 45 #define bitDonneesMoisNbr 5

---

Un dessin vaut mieux qu'un long discours, donc en gros ça ressemble à cela:
Pièce jointe 588105

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:

---

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:

---

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.

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

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 :applo: 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

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:

---

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:

---

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

Code:

---

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:

---

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

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:

---

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

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:bug:, 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

Je suis déja de retour lol.

En fait , il était tard hier et j'ai omis un GROS :oops: 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:

---

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

Pièce jointe 609345

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:

---

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:

---

1 2 3 4 5

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

---

Bonjour Pat42

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

Code:

---

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:

---

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:

---

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:

---

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

petite amélioration éventuelle:

au lieu de

Code:

---

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:

---

1 2 3 4

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

---

voire

Code:

---

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:

---

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

---

on peut mettre

Code:

---

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:

---

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)

Bonjour Jay M

Citation:

---

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

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.

Bonjour a tous les deux,

Toujours aussi prompt à donner un coup de main :bravo: 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 :D .


Bonne fin de week-end à vous

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

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:

---

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 :D)


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

Code:

---

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:

---

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:

---

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.

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:

---

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)

Bonjour,

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

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

Citation:

---

bool validerParite(byte indexDepart, byte nombreDeBits)

---

Citation:

---

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

Bonjour,

Citation:

---

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:

---

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