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" );
// 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
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("------------------------");
//// 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
}
}

33
README.md
View File

@ -1,32 +1,33 @@
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
## Licence
Mon code est publié sous licence libre GNU GPL v3.
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)
## Librairies utilisées :
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
- [ ]
Gestion des erreurs
- [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
- [ ] alarme réveil par buzer/HP ?
- [ ]
- [ ]
- [ ]
- [ ]

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"