Meilleurs initialisations wifi/ntp/rtc

Horloge_Nixie_firmware.ino

@@ -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 <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 <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 "nixie.h"       // Mes routines de pilotage d'affichage Nixie
 
-const char *ssid     = SECRET_WIFI_SSID;
+RTC_DS1307 rtc;
-const char *password = SECRET_WIFI_PASS;
 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
+  bool res;
-  Serial.println ("Routine de synchro NTP vers RTC :");
+  //reset settings on startup if switch pressed
-  Serial.print ("- récupération du temps Internet : ");
+  if (! digitalRead(Rotary_SW)) {
-  ntp.update(); // récupération du temps NTP
+    Serial.println("RAZ");
-  Serial.println(ntp.formattedTime("%T")); // hh:mm:ss
+    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
+  if(!res) {
-  Serial.print ( "- enregistrement du temps Internet dans l'horlore RTC" );
+    Serial.println("Failed to connect");
-  rtc.adjust(DateTime(ntp.year(), ntp.month(), ntp.day(), ntp.hours(), ntp.minutes(), ntp.seconds()));
+  } 
-  Serial.println ( " : OK." );
+  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
+  wifiOK = initWIFI(); // initialisation du wifi
-  WiFi.begin(ssid, password);
+  initNTP();   // récupération du temps Internet
-  Serial.print ("Connexion au WiFi");
+  rtcOK = initRTC();   // initialisation de l'horloge interne
-  while ( WiFi.status() != WL_CONNECTED ) {
+    
-    delay ( 500 );
+  if (wifiOK && rtcOK) {
-    Serial.print ( "." );
+    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 ");
+  // Mise à jour de l'affichage Nixie
-  delay(10000);
+  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
+  }
 }

README.md

@@ -1,5 +1,4 @@
-Firmware pour ESP8266 pour mon horloge Nixie   
+Firmware pour mon horloge Nixie sur ESP32
-(sera migré sur ESP32 un jour)
 
 ## 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
+WiFiManager - https://github.com/tzapu/WiFiManager
-- WiFiUdp
+WiFiUdp     -
-- RTClib (https://github.com/adafruit/RTClib)
+RTClib      - Date and time functions using a DS1307 RTC connected via I2C and Wire lib. https://github.com/adafruit/RTClib
-- NTP (https://github.com/sstaub/NTP)
+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
+- [X] WiFi : utiliser le Wifi Manager https://github.com/tzapu/WiFiManager
-- [ ] NTP : en cas d'echec de récupération du temps Internet
+- [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

hardware.h

@@ -1,10 +1,21 @@
 #include "Arduino.h"
 
 // I2C (pour RTC)
-  #define I2C_SDA 2
+  #define I2C_SDA 42
-  #define I2C_SCL 14
+  #define I2C_SCL 41
+
 // Sorties BCD vers Nixie
-  #define BCD_A 16
+  #define BCD_A 15
-  #define BCD_B 5
+  #define BCD_B 16
-  #define BCD_C 4
+  #define BCD_C 17
-  #define BCD_D 0
+  #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)

nixie.cpp

@@ -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_B, LOW);  //B
-    digitalWrite(BCD_A, LOW);  //A
+    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;
   }
 }

nixie.h

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

secrets.h.default

@@ -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"