J'ai reçu mes antennes dcf77 ( pollin.de )
J'ai fait le montage et lancé le programme et ça fonctionne.
Je n'arrive pas a comprendre comment mettre a jour l'heure du RTC avec la réception DCF.
Enfin si, je vois plus ou moins comment faire pour extraire les valeurs du récepteur et les intégrer mais pas comment le faire de façon journalière et surtout de le faire qu'en étant sur d'une bonne réception.
Si quelqu'un veut bien me mettre sur le chemin.
L'ARDUINO lui-même possède une heure interne que l'on peut régler avec la fonction setTime().
Un moyen consiste à utiliser setSyncProvider().
Voir cet exemple : SyncProvider.ino
La fonction fournie sera appelée à chaque appel de now().
Mais si tu veux absolument RTC + DCF77, tu devras mettre à l'heure la RTC dans la fonction getDCFTime() de l'exemple.
Cette mise à l'heure de la RTC se fera classiquement avec RTC.adjust() avec en paramètre une structure DateTime.
Je ne vois pas trop l'intérêt d'avoir du DCF77 et une RTC, sauf si l'on est absolument certain que la réception DCF77 est mauvaise.
Je ne vois pas trop l'intérêt d'avoir du DCF77 et une RTC, sauf si l'on est absolument certain que la réception DCF77 est mauvaise.
Le but final est de fabriquer des horloge intégrée a des enseignes publicitaires, donc par définition pas très accessibles.
Donc pas possible de les remettre a l'heure manuellement et la réception DCF peut effectivement être moyenne voire mauvaise.
Par facilité, j'ai refait un petit montage avec afficheur LCD, module RTC, capteur T/H et antenne DCF77.
Chaque module/fonction a été testé et fonctionne.
L’ensemble fonctionne et affiche toutes les infos sur le LCD.
La réception chez moi a l'interieur est très mauvaise ( 45 minutes pour avoir une trame valide )
voici mon code.
#include <dht11.h>
#define DHT11PIN 2 // broche DATA -> broche 2
dht11 DHT11;
#include <Wire.h> //librairie déjà sur arduino
#include <LiquidCrystal_I2C.h> //pour télécharger la librairie: croquis - include library - manage libraries - LiquidCrystal_I2C.h de Frank de Brabander
#include <RTClib.h> //librairie à télécharger en ZIP sur https://github.com/jcw/rtclib
const uint8_t PIN_DCF77 = 3;
#if defined(ARDUINO) && ARDUINO >= 100
#define printByte(args) write(args);
#else
#define printByte(args) print(args,BYTE);
#endif
uint8_t clock[8] = {0x0,0xe,0x15,0x17,0x11,0xe,0x0};
RTC_DS1307 RTC;
LiquidCrystal_I2C lcd(0x27,16,2); // Adresse du LCD 0x27 avec 16 colonnes et 2 lignes
void setup()
{
lcd.init(); // initialisation du LCD
lcd.backlight();
lcd.print("Initialising..."); //afficher un message sur l'afficheur LCD
//lcd.createChar(2, clock);
Wire.begin();
RTC.begin();
RTC.adjust(DateTime(2010,1,1,12,0,0)); //Ajuster la clock avec l'heure et la date de l'ordinateur
}
void loop()
{ DHT11.read(DHT11PIN);
lcd.clear(); //code pour afficher heure et date de la clock (du RTC) sur l'écran LCD
DateTime now = RTC.now();
lcd.printByte(2);
lcd.print(" ");
lcd.print(now.hour(), DEC);
lcd.print(':');
lcd.print(now.minute(), DEC);
lcd.print(':');
lcd.print(now.second(), DEC);
lcd.setCursor(11, 0);
lcd.print('H');
lcd.print(':');
lcd.setCursor(14, 0);
lcd.print(DHT11.humidity, DEC);
lcd.setCursor(0, 1);
lcd.print(now.day(), DEC);
lcd.print('/');
lcd.print(now.month(), DEC);
lcd.print('/');
lcd.print(now.year(), DEC);
lcd.setCursor(11, 1);
lcd.print('T');
lcd.print(':');
lcd.setCursor(14, 1);
lcd.print(DHT11.temperature, DEC);
delay(1000);
bool trame_decodee = decodeurDCF77.traiterSignal(digitalRead(PIN_DCF77), millis());
int annee = decodeurDCF77.annee();
int mois = decodeurDCF77.mois();
int jour = decodeurDCF77.jour();
int heure = decodeurDCF77.heure();
int minutes = decodeurDCF77.minutes();
if (trame_decodee) {
RTC.adjust(DateTime(annee,mois,jour,heure,minutes,0));
}
}
La partie DCF77 est a la fin :
bool trame_decodee = decodeurDCF77.traiterSignal(digitalRead(PIN_DCF77), millis());
int annee = decodeurDCF77.annee();
int mois = decodeurDCF77.mois();
int jour = decodeurDCF77.jour();
int heure = decodeurDCF77.heure();
int minutes = decodeurDCF77.minutes();
if (trame_decodee) {
RTC.adjust(DateTime(annee,mois,jour,heure,minutes,0));
}
J'ai voulu modifier la librairie avec notepad mais si je laisse le fichier modifié la compilation plante.
Que faut il utiliser pour modifier une librairie.
Merci
Que faut il utiliser pour modifier une librairie.
Un éditeur de texte "normal",
notepad étant une windowserie je n'ai pas d'avis dessus (désolé je ne suis pas fenêtres volantes mais manchot 
)
Notepad++ est reconnu dans le monde windaube pour être très bon .
PS : l'éditeur fait ce que tu lui demande de faire, la bonne question serait : que lui as tu demandé de modifier et où se trouve le fichier modifié ?
Merci,
J'ai modifié avec notepad dans, le fichier decodeurDCF77.h car il utilise une variable utilisée aussi dans la bibliothèque du rtc. Je crains donc un plantage ou une réaction aléatoire.
Si je tente de compiler avec le fichier modifié ça plante, alors qu'avec le fichier d'origine ça fonctionne.
je suppose un soucis de format de fichier vu que si je copie colle le contenu et je crée un nouveau fichier decodeurDCF77.h avec notepad ou le blocnote, ça plante aussi.
Marcototo:
J'ai modifié avec notepad dans, le fichier decodeurDCF77.h car il utilise une variable utilisée aussi dans la bibliothèque du rtc. Je crains donc un plantage ou une réaction aléatoire.
Si vraiment la même variable était définie dans les librairies DCF77 et rtc ça planterait à la compilation.
Tu ne peux pas modifier une variable dans le fichier.h sans modifier le .cpp correspondant.
Il serait pas mal d'être un peu plus précis :
Merci de vous intéresser a mon problème.
J'utilise une librairie rtc trouvée sur le net :
// A library for handling real-time clocks, dates, etc.
// 2010-02-04 <jc@wippler.nl> http://opensource.org/licenses/mit-license.php
// 2012-11-08 RAM methods - idreammicro.com
// 2012-11-14 SQW/OUT methods - idreammicro.com
// Simple general-purpose date/time class (no TZ / DST / leap second handling!)
class DateTime {
public:
DateTime (long t =0);
DateTime (uint16_t year, uint8_t month, uint8_t day,
uint8_t hour =0, uint8_t min =0, uint8_t sec =0);
DateTime (const char* date, const char* time);
uint16_t year() const { return 2000 + yOff; }
uint8_t month() const { return m; }
uint8_t day() const { return d; }
uint8_t hour() const { return hh; }
uint8_t minute() const { return mm; }
uint8_t second() const { return ss; }
uint8_t dayOfWeek() const;
// 32-bit times as seconds since 1/1/2000
long get() const;
protected:
uint8_t yOff, m, d, hh, mm, ss;
};
// RTC based on the DS1307 chip connected via I2C and the Wire library
class RTC_DS1307 {
public:
// SQW/OUT frequencies.
enum Frequencies
{
Frequency_1Hz,
Frequency_4096Hz,
Frequency_8192Hz,
Frequency_32768Hz
};
static void begin() {}
static void adjust(const DateTime& dt);
static DateTime now();
static uint8_t isrunning();
// SQW/OUT functions.
void setSqwOutLevel(uint8_t level);
void setSqwOutSignal(Frequencies frequency);
// RAM registers read/write functions. Address locations 08h to 3Fh.
// Max length = 56 bytes.
static uint8_t readByteInRam(uint8_t address);
static void readBytesInRam(uint8_t address, uint8_t length, uint8_t* p_data);
static void writeByteInRam(uint8_t address, uint8_t data);
static void writeBytesInRam(uint8_t address, uint8_t length, uint8_t* p_data);
// utility functions
static uint8_t bcd2bin (uint8_t val) { return val - 6 * (val >> 4); }
static uint8_t bin2bcd (uint8_t val) { return val + 6 * (val / 10); }
};
// DS1388 version
class RTC_DS1388 {
protected:
static uint8_t WDSeconds;
static uint8_t WDTSeconds;
public:
static void begin() {};
static void adjust(const DateTime& dt);
static DateTime now();
static uint8_t isrunning();
// EEPROM
static uint8_t getEEPROMBank(uint16_t pos);
static void EEPROMWrite(uint16_t pos, uint8_t c);
static uint8_t EEPROMRead(uint16_t pos);
static void EEPROMWritePage(uint8_t page, uint8_t* data);
static void EEPROMReadPage(uint8_t page, uint8_t* buffer);
//Watchdog
static void startWatchdogTimer(uint8_t Seconds, uint8_t TSeconds);
static void resetWatchdogTimer();
// utility functions
static uint8_t bcd2bin (uint8_t val) { return val - 6 * (val >> 4); }
static uint8_t bin2bcd (uint8_t val) { return val + 6 * (val / 10); }
};
// RTC based on the PCF8563 chip connected via I2C and the Wire library
// contributed by @mariusster, see http://forum.jeelabs.net/comment/1902
class RTC_PCF8563 {
public:
static void begin() {}
static void adjust(const DateTime& dt);
static DateTime now();
// utility functions
static uint8_t bcd2bin (uint8_t val) { return val - 6 * (val >> 4); }
static uint8_t bin2bcd (uint8_t val) { return val + 6 * (val / 10); }
};
// TI BQ32000 I2C RTC
class RTC_BQ32000 {
public:
static void begin() {}
static void adjust(const DateTime& dt);
static DateTime now();
static uint8_t isrunning();
static void setIRQ(uint8_t state);
/* Set IRQ output state: 0=disabled, 1=1Hz, 2=512Hz.
*/
static void setIRQLevel(uint8_t level);
/* Set IRQ output active state to LOW or HIGH.
*/
static void setCalibration(int8_t value);
/* Sets the calibration value to given value in the range -31 - 31, which
* corresponds to -126ppm - +63ppm; see table 13 in th BQ32000 datasheet.
*/
static void setCharger(int state);
/* If using a super capacitor instead of a battery for backup power, use this
method to set the state of the trickle charger: 0=disabled, 1=low-voltage
charge, 2=high-voltage charge. In low-voltage charge mode, the super cap is
charged through a diode with a voltage drop of about 0.5V, so it will charge
up to VCC-0.5V. In high-voltage charge mode the diode is bypassed and the super
cap will be charged up to VCC (make sure the charge voltage does not exceed your
super cap's voltage rating!!). */
// utility functions:
static uint8_t readRegister(uint8_t address);
static uint8_t writeRegister(uint8_t address, uint8_t value);
static uint8_t bcd2bin (uint8_t val) { return val - 6 * (val >> 4); }
static uint8_t bin2bcd (uint8_t val) { return val + 6 * (val / 10); }
};
// RTC using the internal millis() clock, has to be initialized before use
// NOTE: this clock won't be correct once the millis() timer rolls over (>49d?)
class RTC_Millis {
public:
static void begin(const DateTime& dt) { adjust(dt); }
static void adjust(const DateTime& dt);
static DateTime now();
protected:
static long offset;
};
Et les fichier donnés par bricoleau ICI
En fait je mélange tout je crois, c'est une fonction ( const uint8_t minute(); ) qui se retrouve dans les deux. Je m'inquiétais juste que quand je tape cette fonction le mot minute change de couleur ( rouge ) et je ne sais pas ce que ça veut dire.
Et au final mon code ne fonctionne pas 
Les fonctions minutes() ne font pas partie de la même class. Donc pas de problème.
Marcototo:
Et au final mon code ne fonctionne pas
Pourquoi tu n'utilises pas les librairies de bricoleu à la fois pour dcf77 et rtc? Comme ça tu seras sur qu'elles sont compatibles.
Parce que la librairie de bricoleu ne fonctionne pas avec les autres programmes que j'ai utilisé pour avoir un affichage de l'heure, la date et la température.
Je m'inquiétais juste que quand je tape cette fonction le mot minute change de couleur ( rouge ) et je ne sais pas ce que ça veut dire.
L'explication n'est valable QUE pour l'IDE arduino.
Une bibliothèque c'est plusieurs fichiers et dans le cas de l'IDE arduino il y a le fichier des mots clés pour qu'il apparaissent en rouge dans l'IDE.
Cela signifie que le mot "minute" est reconnu comme un nom de fonction déclarée.
Ce n'est bien sur valable QUE dans le cadre de l'utilisation de l'Ide Arduino.
Avec d'autres IDE seuls les mots clés officiels du C et C++ sont détectés.
La bibliothèque de Bricoleau pour la gestion d'une horloge RTC est très bien. Elle a un énorme avantage : elle contient tout ce qu'il faut et rien que ce qu'il faut, il n'y a rien d'inutile à l'intérieur, on ne peut pas en dire autant des autres bibliothèques.