decodeurDCF77.h
C'est la librairie principale, qui utilise les deux précédentes en y ajoutant les fameuses règles d'analyse du signal, pour déterminer si on a reçu un bit 1 ou à 0.
Le traitement du signal repose sur plusieurs points, dont une analyse statistique des fronts montants, pour repérer la pulsation principale du signal DCF77.
C'est là que se concentrent les macérations neuronales, avec très certainement des possibilités d'amélioration.
A noter que cette librairie est encore du cpp standard non lié à l'environnement arduino, pour une meilleure portabilité.
/***************************************************************************************************
/*
/* Décodeur DCF77
/*
/* Code générique multi-plateforme, non spécifique à Arduino.
/* (2015) Bricoleau
/*
/***************************************************************************************************/
#ifndef decodeurDCF77_h
#define decodeurDCF77_h
#include <stdint.h>
class decodeurDCF77_c
{
public :
decodeurDCF77_c();
bool traiterSignal(uint8_t signal_0_ou_1, uint32_t millis_signal);
//retourne true si une trame est décodée, false sinon
//Les donnees ci-dessous sont mises à jour par la fonction traiterSignal()
//Utilisation en lecture seule
//HORLOGE
const uint32_t millis_derniere_trame_ok();
const uint8_t annee();
const uint8_t mois();
const uint8_t jour();
const uint8_t joursem(); //1 = lundi, ... 7 = dimanche
const uint8_t heure();
const uint8_t minute();
const bool heure_ete();
//SIGNAL
const uint8_t qualiteReception(uint32_t millis_maintenant);
//valeurs renvoyées :
// 0 : signal inexistant
//1 à 4 : signal trop faible, pas de décodage possible
// 5 : signal parfait, décodage probable
// 6 : signal correct, décodage probable
//7 à 11 : signal parasité, décodage incertain
const uint8_t longueur_trame_en_cours(); //pour suivre la réception
const uint8_t bit_trame(uint8_t rang); //pour suivre la réception
private :
uint32_t _millis_derniere_trame_ok;
uint8_t _annee;
uint8_t _mois;
uint8_t _jour;
uint8_t _joursem;
uint8_t _heure;
uint8_t _minute;
bool _heure_ete;
uint32_t ref_synchro_pulsation;
void decalerPulsation(uint32_t millis_reference);
};
extern decodeurDCF77_c decodeurDCF77;
#endif
Les digitalRead() et millis() doivent être effectués en amont, et leurs valeurs fournies aux primitives d'entrée de la librairie
Le programme exemple demo_decodeurDCF77 montre une utilisation de cette librairie, avec visualisation de la trame en cours de réception :
Demo decodage signal DCF77
Recherche pulsation...
0000000
00000110101000
0011111101100010001011000110101000100001011100000110101000 Mercredi 28/10/2015 22:31 (heure d'hiver)
0110111100011010001010100110101000100001011100000110101000 Mercredi 28/10/2015 22:32 (heure d'hiver)
0111000111000000001011100110001000100001011100000110101000 Mercredi 28/10/2015 22:33 (heure d'hiver)
0011101100010010001010010110101000100001011100000110101000 Mercredi 28/10/2015 22:34 (heure d'hiver)
0010111010110010001011010110001000100001011100000110101000 Mercredi 28/10/2015 22:35 (heure d'hiver)
0101001000110000001010110110001000100001011100000110101000 Mercredi 28/10/2015 22:36 (heure d'hiver)
0000111100100000001011110110101000100001011100000110101000 Mercredi 28/10/2015 22:37 (heure d'hiver)
0001010000010010001010001110101000100001011100000110101000 Mercredi 28/10/2015 22:38 (heure d'hiver)
00100101000110100010110011100010
decodeurDCF1.h
Ca c'est le vrai driver hardware de module DCF1, pour arduino.
Cette librairie est une surcouche du decodeurDCF77.h
Elle met en place une interruption associée au changement d'état de la pin DATA du module DCF1.
La routine d'interruption lit l'état du signal et déclenche les primitives du decodeurDCF77.
Le programme exemple demo_decodeurDCF1 déjà évoqué au début du toto, montre une utilisation de cette librairie.
C'est cette librairie qu'il convient d'inclure dans vos programmes arduino
/***************************************************************************************************
/*
/* Driver de récepteur DCF77, modèle DCF1 (www.polllin.de)
/* Librairie spécifique Arduino
/*
/* (2015) Bricoleau
/*
/***************************************************************************************************/
#ifndef decodeurDCF1_h
#define decodeurDCF1_h
#include <Arduino.h>
class decodeurDCF1_c
{
public :
void begin(uint8_t pin); //obligatoirement une pin avec interruption
void start(); //activer le traitement de l'interruption (non inclus dans begin)
void stop(); //desactiver le traitement de l'interruption
//A partir de là, les donnees ci-dessous sont automatiquement mises à jour par l'interruption
//Utilisation en lecture seule
//HORLOGE
const uint32_t millis_derniere_trame_ok(); //Suivre la valeur de cette zone
//pour savoir si une nouvelle date/heure est disponible ci-dessous
const uint8_t annee();
const uint8_t mois();
const uint8_t jour();
const uint8_t joursem(); //1 = lundi, ... 7 = dimanche
const uint8_t heure();
const uint8_t minute();
const bool heure_ete();
//SIGNAL
const uint8_t qualiteReception();
//valeurs renvoyées :
// 0 : signal inexistant
//1 à 4 : signal trop faible, pas de décodage possible
// 5 : signal parfait, décodage probable
// 6 : signal correct, décodage probable
//7 à 11 : signal parasité, décodage incertain
const uint8_t longueur_trame_en_cours(); //pour suivre la réception
const uint8_t bit_trame(uint8_t rang); //pour suivre la réception
//DIVERS
const bool started(); //interruption activee
const uint8_t pin();
private :
uint8_t _pin;
};
extern decodeurDCF1_c decodeurDCF1;
#endif
Le programme principal ne se soucie alors plus du tout de la gestion du DCF1.
Il se contente de lire les variables d'état du décodeur, pour connaître la date exacte ou encore la qualité du signal reçu.
C'est uniquement cette librairie qu'il faudra adapter, pour gérer la réception DCF77 avec un module autre qu'un DCF1, ou sur un système autre qu'arduino.
Au vu des programmes exemples fournis, on pourrait penser qu'il y a peu de différences d'utilisation entre les librairies decodeurDCF77 et decodeurDCF1.
Pourtant, la différence est fondamentale.
Si vous essayez d'intégrer la librairie decodeurDCF77 dans un programme qui fait déjà autre chose, vous risquez de rater des impulsions du signal, dès lors qu'une partie annexe du programme dure plus de 50 ms.
La librairie decodeurDCF1 vous garantit de ne perdre aucune impulsion, même si votre programme principal fait déjà beaucoup de choses.
Elle a toutefois son inconvénient : la routine d'interruption est un poil lourde, puisqu'elle inclut l'exécution des fonctions de décodage du signal. Elle peut durer jusqu'à 600µs (temps moyen 80µs) sur une arduino standard à 16 Mhz. Votre programme principal doit dont être compatible avec ces petits freeze.
Si ce n'est pas le cas, il vous faudra envisager de restructurer le driver DCF1 (séparer acquisition et traitement du signal), ou bien de simplifier le traitement du signal dans le decodeurDCF77, quitte à perdre en capacité de filtrage des parasites.