laurent/Horloge_Nixie_firmware
1
0
Fork 0
Code Issues Pull Requests Releases Activity

Meilleurs initialisations wifi/ntp/rtc

Browse Source
This commit is contained in:
Laurent Claude 2023-07-10 22:17:09 +02:00
parent daa915b5c7
commit 453e6dbd22
6 changed files with 281 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

217
Horloge_Nixie_firmware.ino
View File

@ -1,46 +1,87 @@
/*
* Created by Laurent CLaude
* https://www.laurentclaude.fr/
*
* This code is in license GPL v3
* My code is under license GPL v3
*
* Horloge Nixie basée sur ESP + module RTC-DS1307, avec fonctionnalités wifi pour synchro NTP
*/
#include "hardware.h"
#include "secrets.h"
#include <ESP8266WiFi.h>
#include <WiFiManager.h> // https://github.com/tzapu/WiFiManager
#include <WiFiUdp.h>
#include <RTClib.h> // Date and time functions using a DS1307 RTC connected via I2C and Wire lib
#include <NTP.h> // The NTP library allows you to receive time information from the Internet. https://github.com/sstaub/NTP
#include "nixie.h" // Mes routines de pilotage d'affichage Nixie
#include <RTClib.h> // Date and time functions using a DS1307 RTC connected via I2C and Wire lib. https://github.com/adafruit/RTClib
#include <NTP.h> // The NTP library allows you to receive time information from the Internet. https://github.com/sstaub/NTP
#include "nixie.h" // Mes routines de pilotage d'affichage Nixie
const char *ssid = SECRET_WIFI_SSID;
const char *password = SECRET_WIFI_PASS;
RTC_DS1307 rtc;
char daysOfTheWeek[7][12] = {"Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi"};
int timeout = 120; // seconds to run for
bool wifiOK, ntpOK, rtcOK;
unsigned long LastRTCUpdate; // le temps de dernière MAJ de l'horloge interne RTC
unsigned long LastNixieUpdate; // le temps de dernière MAJ affichage Nixie
const long intervalRTCUpdate = 17000; // 86400000 = 24 heures
const long intervalNixieUpdate = 1000; // 1000 = 1 seconde
WiFiUDP wifiUdp;
NTP ntp(wifiUdp);
RTC_DS1307 rtc;
/////////////////////////////////////////////////////
//////////// FONCTIONS ////////////////
/////////////////////////////////////////////////////
//
void syncNTPtoRTC(){
bool initWIFI(){
// is configuration portal requested?
WiFiManager wm;
wm.setConfigPortalTimeout(60);
wm.setHostname("Horloge Nixie");
//// Récupération du temps Internet par NTP
Serial.println ("Routine de synchro NTP vers RTC :");
Serial.print ("- récupération du temps Internet : ");
ntp.update(); // récupération du temps NTP
Serial.println(ntp.formattedTime("%T")); // hh:mm:ss
bool res;
//reset settings on startup if switch pressed
if (! digitalRead(Rotary_SW)) {
Serial.println("RAZ");
wm.resetSettings();
}
res = wm.autoConnect("NixieClockAP"); // Création d'un AP ou connexion mémorisée
//// Mise à jour du temps RTC de l'horloge locale
Serial.print ( "- enregistrement du temps Internet dans l'horlore RTC" );
rtc.adjust(DateTime(ntp.year(), ntp.month(), ntp.day(), ntp.hours(), ntp.minutes(), ntp.seconds()));
Serial.println ( " : OK." );
if(!res) {
Serial.println("Failed to connect");
}
else {
//if you get here you have connected to the WiFi
Serial.println("connected...yeey :)");
}
//// Affichage du temps RTC en console série pour débug
return(res);
}
bool initRTC(){
//// Initialisation RTC
Serial.print("Initialisation de l'horloge interne RTC");
rtcOK = rtc.begin();
if (! rtcOK) {
Wire.begin(I2C_SDA,I2C_SCL); // Broches (SDA,SCL) de l'I2C pour la RTC
delay(1000);
if (! rtc.begin()) {
Serial.println(" --> RTC introuvable !");
return (false);
}
else {
Serial.println (" : OK");
return (true);
}
}
else {
Serial.println(" : déjà démarrée !");
return (true);
}
}
void printRTC(){
//// Affichage du temps RTC en console série pour débug
DateTime now = rtc.now();
Serial.print ( "Maintenant l'horloge interne indique : " );
Serial.print ( " Heure de l'horloge interne (RTC) : " );
Serial.print(daysOfTheWeek[now.dayOfTheWeek()]);
Serial.print(" ");
Serial.print(now.day(), DEC);
@ -56,56 +97,124 @@ void syncNTPtoRTC(){
Serial.println(now.second(), DEC);
}
void initNTP(){
// Paramétrage NTP avec prise en compte de l'heure d'été pour la France
Serial.print("Initialisation NTP");
ntp.ruleDST("CEST", Last, Sun, Mar, 2, 120); // last sunday in march 2:00, timetone +120min (+1 GMT + 1h summertime offset)
ntp.ruleSTD("CET", Last, Sun, Oct, 3, 60); // last sunday in october 3:00, timezone +60min (+1 GMT)
ntp.begin();
Serial.println(" : OK");
//ntp.updateInterval(1000); // update every second
Serial.print("Le temps Internet (NTP) indique : ");
ntp.update();
Serial.println(ntp.formattedTime("%A %d/%m/%Y %T")); // www dd/mm/yyyy hh:mm:ss
}
void syncNTPtoRTC(){
//// Récupération du temps Internet par NTP
Serial.println ("Synchro temps NTP vers RTC :");
Serial.print ("- récupération du temps Internet : ");
ntp.update(); // récupération du temps NTP
Serial.println(ntp.formattedTime("%A %d/%m/%Y %T")); // www dd/mm/yyyy hh:mm:ss
//// Mise à jour du temps RTC de l'horloge locale
Serial.print ( "- enregistrement du temps Internet dans l'horlore RTC" );
rtc.adjust(DateTime(ntp.year(), ntp.month(), ntp.day(), ntp.hours(), ntp.minutes(), ntp.seconds()));
Serial.println ( " : OK." );
LastRTCUpdate = millis();
}
/////////////////////////////////////////////////////
//////////// setup et loop ////////////////
/////////////////// setup ////////////////////
/////////////////////////////////////////////////////
//
void setup () {
//// Initialisation hardware
pinMode(Rotary_SW, INPUT_PULLUP); // Encodeur rotatif : switch
pinMode(Rotary_A, INPUT_PULLUP); // Encodeur rotatif : voie A
pinMode(Rotary_B, INPUT_PULLUP); // Encodeur rotatif : voie B
pinMode(BCD_D, OUTPUT);// D Pour digits afficheurs nixie 1
pinMode(BCD_C, OUTPUT);// C
pinMode(BCD_B, OUTPUT);// B
pinMode(BCD_A, OUTPUT);// A
pinMode(BCD_D2, OUTPUT);// D Pour digits afficheurs nixie 2
pinMode(BCD_C2, OUTPUT);// C
pinMode(BCD_B2, OUTPUT);// B
pinMode(BCD_A2, OUTPUT);// A
// Démarrage de l'I2C :
Wire.begin(I2C_SDA,I2C_SCL); // Broches (SDA,SCL) de l'I2C pour la RTC
//// Initialisation de la liaison série
Serial.begin(115200);
Serial.println ("");
Serial.println ("Liaison série OK");
//// Connexion au WIFI
WiFi.begin(ssid, password);
Serial.print ("Connexion au WiFi");
while ( WiFi.status() != WL_CONNECTED ) {
delay ( 500 );
Serial.print ( "." );
wifiOK = initWIFI(); // initialisation du wifi
initNTP(); // récupération du temps Internet
rtcOK = initRTC(); // initialisation de l'horloge interne
if (wifiOK && rtcOK) {
printRTC(); // Affichage du temps RTC en console série
syncNTPtoRTC(); // Mise à l'heure de l'horloge RTC locale avec l'heure Internet
printRTC(); // Affichage du temps RTC en console série
}
Serial.println ( " OK" );
Serial.print("Pour info, le temps de compil : ");
Serial.print(__DATE__);
Serial.println(__TIME__);
Serial.println("Fin des initialisations.");
printRTC(); // Affichage du temps RTC en console série
Serial.println("------------------------");
// Récup du temps avec prise en compte de l'heure d'été pour la France
Serial.print("Initialisation NTP");
ntp.ruleDST("CEST", Last, Sun, Mar, 2, 120); // last sunday in march 2:00, timetone +120min (+1 GMT + 1h summertime offset)
ntp.ruleSTD("CET", Last, Sun, Oct, 3, 60); // last sunday in october 3:00, timezone +60min (+1 GMT)
ntp.begin();
Serial.println(" : OK");
Serial.print("- sur Internet, nous sommes le : ");
ntp.update();
Serial.println(ntp.formattedTime("%A %d/%m/%Y, il est : %T")); // www dd/mm/yyyy hh:mm:ss
//// Initialisation RTC
Serial.print("Initialisation RTC");
if (! rtc.begin()) {
Wire.begin(I2C_SDA,I2C_SCL); // Broches (SDA,SCL) de l'I2C pour la RTC
delay(1000);
if (! rtc.begin()) {
Serial.println(" --> RTC introuvable ! Fin.");
while (1);
}
}
Serial.println (" : OK");
syncNTPtoRTC(); // Mise à l'heure de l'horloge RTC locale avec l'heure Internet
}
/////////////////////////////////////////////////////
///////////////// loop //////////////////
/////////////////////////////////////////////////////
//
void loop () {
unsigned long currentMillis = millis();
Serial.print("Rien ");
delay(10000);
// Mise à jour de l'affichage Nixie
if ((currentMillis - LastNixieUpdate >= intervalNixieUpdate) || (currentMillis < LastNixieUpdate)) {
LastNixieUpdate = currentMillis;
DateTime now = rtc.now();
int heu_d = (now.hour())/10;
int heu_u = (now.hour())%10;
int min_d = (now.minute())/10;
int min_u = (now.minute())%10;
int sec_d = (now.second())/10;
int sec_u = (now.second())%10;
printNixie2(heu_d);
printNixie(heu_u);
Serial.print(heu_d);
Serial.print(heu_u);
delay(1200);
printNixie2(99);
printNixie(99);
delay(000);
printNixie2(min_d);
printNixie(min_u);
Serial.print(min_d);
Serial.print(min_u);
delay(1200);
printNixie2(99);
printNixie(99);
delay(1200);
}
// Mise à jour de l'horloge interne RTC. Une fois par 24H
if ((currentMillis - LastRTCUpdate >= intervalRTCUpdate) || (currentMillis < LastRTCUpdate)) {
LastRTCUpdate = currentMillis;
syncNTPtoRTC(); // Mise à l'heure de l'horloge RTC locale avec l'heure Internet
printRTC(); // Affichage du temps RTC en console série
}
}

21
README.md
View File

@ -1,5 +1,4 @@
Firmware pour ESP8266 pour mon horloge Nixie
(sera migré sur ESP32 un jour)
Firmware pour mon horloge Nixie sur ESP32
## Hardware utilisé
Voir mes schémas : https://code.laurentclaude.fr/laurent/Horloge_Nixie_Schematics
@ -9,21 +8,23 @@ Mon code est publié sous licence libre GNU GPL v3.
Mais tout n'est pas écrit par moi, consultez les licences correspondantes.
## Librairies utilisées :
- ESP8266WiFi
- WiFiUdp
- RTClib (https://github.com/adafruit/RTClib)
- NTP (https://github.com/sstaub/NTP)
WiFiManager - https://github.com/tzapu/WiFiManager
WiFiUdp -
RTClib - Date and time functions using a DS1307 RTC connected via I2C and Wire lib. https://github.com/adafruit/RTClib
NTP - The NTP library allows you to receive time information from the Internet. https://github.com/sstaub/NTP
## Personnalisation
Personnalisez le fichier 'secrets.h.default' avec vos identifiants de connexion WiFi (SSID et PASS)
et renommez-le en 'secrets.h'
## TODO :
Gestion des erreurs
- [ ] WiFi : utiliser le Wifi Manager https://github.com/tzapu/WiFiManager
- [ ] NTP : en cas d'echec de récupération du temps Internet
- [X] WiFi : utiliser le Wifi Manager https://github.com/tzapu/WiFiManager
- [X] RTC : en cas d'echec de récupération du temps Internet
- [ ] Pas/Perte de réseau
- [ ]
- [ ]
Fonctionnalités
- [X] Remise à zéro par pression d'un BP au démarrage : config Wifi,
- [X] Syncro de l'heure par internet et prise en compte heure d'été
- [ ] affichage de l'heure sur Nixie
- [ ] ajustement de l'heure par encodeur rotatif

23
hardware.h
View File

@ -1,10 +1,21 @@
#include "Arduino.h"
// I2C (pour RTC)
#define I2C_SDA 2
#define I2C_SCL 14
#define I2C_SDA 42
#define I2C_SCL 41
// Sorties BCD vers Nixie
#define BCD_A 16
#define BCD_B 5
#define BCD_C 4
#define BCD_D 0
#define BCD_A 15
#define BCD_B 16
#define BCD_C 17
#define BCD_D 18
#define BCD_A2 9
#define BCD_B2 10
#define BCD_C2 11
#define BCD_D2 12
// Touches
#define Rotary_A 35
#define Rotary_B 36
#define Rotary_SW 37 // switch vers la masse (R pullup interne) pour réinit du wifi au démarrage (choisi au pif)

85
nixie.cpp
View File

@ -2,9 +2,9 @@
#include "Arduino.h"
#include "hardware.h"
void printNixie(byte a){
void printNixie(int8_t a){
switch (a) {
case 0 :
case 0:
digitalWrite(BCD_D, LOW); //D
digitalWrite(BCD_C, LOW); //C
digitalWrite(BCD_B, LOW); //B
@ -61,8 +61,85 @@ void printNixie(byte a){
case 9:
digitalWrite(BCD_D, HIGH); //D
digitalWrite(BCD_C, LOW); //C
digitalWrite(BCD_B, HIGH); //B
digitalWrite(BCD_A, LOW); //A
digitalWrite(BCD_B, LOW); //B
digitalWrite(BCD_A, HIGH); //A
break;
case 99:
digitalWrite(BCD_D, HIGH); //D
digitalWrite(BCD_C, HIGH); //C
digitalWrite(BCD_B, HIGH); //B
digitalWrite(BCD_A, HIGH); //A
break;
}
}
void printNixie2(int8_t a){
switch (a) {
case 0:
digitalWrite(BCD_D2, LOW); //D
digitalWrite(BCD_C2, LOW); //C
digitalWrite(BCD_B2, LOW); //B
digitalWrite(BCD_A2, LOW); //A
break;
case 1:
digitalWrite(BCD_D2, LOW); //D
digitalWrite(BCD_C2, LOW); //C
digitalWrite(BCD_B2, LOW); //B
digitalWrite(BCD_A2, HIGH); //A
break;
case 2:
digitalWrite(BCD_D2, LOW); //D
digitalWrite(BCD_C2, LOW); //C
digitalWrite(BCD_B2, HIGH); //B
digitalWrite(BCD_A2, LOW); //A
break;
case 3:
digitalWrite(BCD_D2, LOW); //D
digitalWrite(BCD_C2, LOW); //C
digitalWrite(BCD_B2, HIGH); //B
digitalWrite(BCD_A2, HIGH); //A
break;
case 4:
digitalWrite(BCD_D2, LOW); //D
digitalWrite(BCD_C2, HIGH); //C
digitalWrite(BCD_B2, LOW); //B
digitalWrite(BCD_A2, LOW); //A
break;
case 5:
digitalWrite(BCD_D2, LOW); //D
digitalWrite(BCD_C2, HIGH); //C
digitalWrite(BCD_B2, LOW); //B
digitalWrite(BCD_A2, HIGH); //A
break;
case 6:
digitalWrite(BCD_D2, LOW); //D
digitalWrite(BCD_C2, HIGH); //C
digitalWrite(BCD_B2, HIGH); //B
digitalWrite(BCD_A2, LOW); //A
break;
case 7:
digitalWrite(BCD_D2, LOW); //D
digitalWrite(BCD_C2, HIGH); //C
digitalWrite(BCD_B2, HIGH); //B
digitalWrite(BCD_A2, HIGH); //A
break;
case 8:
digitalWrite(BCD_D2, HIGH); //D
digitalWrite(BCD_C2, LOW); //C
digitalWrite(BCD_B2, LOW); //B
digitalWrite(BCD_A2, LOW); //A
break;
case 9:
digitalWrite(BCD_D2, HIGH); //D
digitalWrite(BCD_C2, LOW); //C
digitalWrite(BCD_B2, LOW); //B
digitalWrite(BCD_A2, HIGH); //A
break;
case 99:
digitalWrite(BCD_D2, HIGH); //D
digitalWrite(BCD_C2, HIGH); //C
digitalWrite(BCD_B2, HIGH); //B
digitalWrite(BCD_A2, HIGH); //A
break;
}
}

3
nixie.h
View File

@ -2,4 +2,5 @@
#include "Arduino.h"
#include "hardware.h"
void printNixie(byte a);
void printNixie(int8_t a);
void printNixie2(int8_t a);

2
secrets.h.default
View File

@ -1,4 +1,4 @@
## Change with your credentials and rename this file in 'secrets.h'
// Change with your credentials and rename this file 'secrets.h'
#define SECRET_WIFI_SSID "YOUR_SSID"
#define SECRET_WIFI_PASS "YOUR_PASS"