+LEDs RGB, fix Brightness input

2023-10-13 14:40:47 +02:00 · 2023-10-13 14:40:47 +02:00 · 471bfbe6ac
commit 471bfbe6ac
parent 268be2953b
7 changed files with 68000 additions and 366 deletions
--- a/Horloge_Nixie_firmware.ino
+++ b/Horloge_Nixie_firmware.ino
@ -8,22 +8,30 @@
 */
 #include "hardware.h"
 #include "secrets.h"
-#include <WiFiManager.h> // https://github.com/tzapu/WiFiManager
+#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. 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
+#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
+#include <FastLED.h>
+
+// Number of leds in your strip
+#define NUM_LEDS 4
+#define LEDS_PIN 43
+// Define the array of leds
+CRGB leds[NUM_LEDS];

 RTC_DS1307 rtc;
-char daysOfTheWeek[7][12] = {"Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi"};
-int timeout = 120; // seconds to run for trying wifi connexion
+char daysOfTheWeek[7][12] = { "Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi" };
 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
+unsigned long LastDotUpdate;    // le temps de dernière MAJ de l'affichage du point des secondes
 int heu_d, heu_u, min_d, min_u, sec_d, sec_u;
+int brightnessInput, brightnessLeds ; //for RGB led brightness

-const long intervalRTCUpdate = 3600000;   // 86400000 = 24 heures / 3600000 = 1 heure
-const long intervalNixieUpdate = 2000;  //     1000 =  1 seconde
+const long intervalRTCUpdate = 3600000;  // 86400000 = 24 heures / 3600000 = 1 heure
+const long intervalNixieUpdate = 1000;   //     1000 =  1 seconde

 WiFiUDP wifiUdp;
 NTP ntp(wifiUdp);
@ -31,58 +39,59 @@ NTP ntp(wifiUdp);
 /////////////////////////////////////////////////////
 ////////////       FONCTIONS         ////////////////
 /////////////////////////////////////////////////////
-// 
-bool initWIFI(){
- // is configuration portal requested?
-  WiFiManager wm;
-  wm.setConfigPortalTimeout(60);
-  wm.setHostname("Horloge Nixie");
+//
+bool initWIFI() {

-  bool res;
-  //reset settings on startup if switch pressed
-  if (! digitalRead(Rotary_SW)) {
-    Serial.println("RAZ");
+  //WiFi.mode(WIFI_STA); // explicitly set mode, esp defaults to STA+AP
+  WiFiManager wm;
+  bool reso;
+
+  wm.setConfigPortalTimeout(60);
+  wm.setHostname("HorlogeNixie");
+
+  //reset settings if switch pressed on startup
+  if (!digitalRead(Rotary_SW)) {
+    Serial.println("RAZ wifi");
    wm.resetSettings();
  }
-  res = wm.autoConnect("NixieClockAP"); // Création d'un AP ou connexion mémorisée

-  if(!res) {
-    Serial.println("Failed to connect");
-  } 
-  else {
+  reso = wm.autoConnect("NixieClockAP");  // Création d'un AP ou connexion mémorisée
+  //reso = wm.autoConnect(SECRET_WIFI_SSID, SECRET_WIFI_PASS);
+
+  if (reso) {
    //if you get here you have connected to the WiFi
-    Serial.println("connected...yeey :)");
+    Serial.println("Connected...yeey :)");
+  } else {
+    Serial.println("Failed to connect");
  }

-  return(res);
+  return (reso);
 }

-bool initRTC(){
+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
+  if (!rtcOK) {
+    Wire.begin(I2C_SDA, I2C_SCL);  // Broches (SDA,SCL) de l'I2C pour la RTC
    delay(1000);
-    if (! rtc.begin()) {
+    if (!rtc.begin()) {
      Serial.println(" --> RTC introuvable !");
      return (false);
-    }
-    else {
-      Serial.println (" : OK");
+    } else {
+      Serial.println(" : OK");
      return (true);
    }
-  }
-  else {
+  } else {
    Serial.println(" : déjà démarrée !");
    return (true);
  }
 }

-void printRTC(){
-    //// Affichage du temps RTC en console série pour débug
+void printRTC() {
+  //// Affichage du temps RTC en console série pour débug
  DateTime now = rtc.now();
-  Serial.print ( " Heure de l'horloge interne (RTC) : " );
+  Serial.print("Heure de l'horloge interne (RTC) : ");
  Serial.print(daysOfTheWeek[now.dayOfTheWeek()]);
  Serial.print(" ");
  Serial.print(now.day(), DEC);
@ -98,84 +107,90 @@ void printRTC(){
  Serial.println(now.second(), DEC);
 }

-void initNTP(){
+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.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
+  Serial.println(ntp.formattedTime("%A %d/%m/%Y %T"));  // www dd/mm/yyyy hh:mm:ss
 }

-void syncNTPtoRTC(){
+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
+  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" );
+  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." );
+  Serial.println(" : OK.");
  LastRTCUpdate = millis();
 }

 /////////////////////////////////////////////////////
 ///////////////////   setup      ////////////////////
 /////////////////////////////////////////////////////
-// 
-void setup () {
-  //// Initialisation hardware 
+//
+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
-  pinMode(BCD_C, OUTPUT);// C
-  pinMode(BCD_B, OUTPUT);// B
-  pinMode(BCD_A, OUTPUT);// A
+  pinMode(BCD_D, OUTPUT);  // D      Pour digits afficheurs Nixie
+  pinMode(BCD_C, OUTPUT);  // C
+  pinMode(BCD_B, OUTPUT);  // B
+  pinMode(BCD_A, OUTPUT);  // A

-  pinMode(NX1A, OUTPUT);// Nixie 1
-  pinMode(NX2A, OUTPUT);// Nixie 2
-  pinMode(NX3A, OUTPUT);// Nixie 3
-  pinMode(NX4A, OUTPUT);// Nixie 4
+  pinMode(NX1A, OUTPUT);  // Nixie 1
+  pinMode(NX2A, OUTPUT);  // Nixie 2
+  pinMode(NX3A, OUTPUT);  // Nixie 3
+  pinMode(NX4A, OUTPUT);  // Nixie 4

  // Démarrage de l'I2C :
-  Wire.begin(I2C_SDA,I2C_SCL); // Broches (SDA,SCL) de l'I2C pour la RTC
+  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");
+  Serial.println("");
+  Serial.println("Liaison série OK");
+
+  //// Initialisation des LEDs RGB
+  FastLED.addLeds<WS2812B, LEDS_PIN, RGB>(leds, NUM_LEDS);  // GRB ordering is typical
+  FastLED.setBrightness(16);
+  leds[0] = CRGB::Black;
+  FastLED.show();
+
+  wifiOK = initWIFI();  // initialisation du wifi
+  initNTP();            // récupération du temps Internet
+  rtcOK = initRTC();    // initialisation de l'horloge interne

-  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
+    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.print("Pour info, le temps de compil : ");
  Serial.print(__DATE__);
+  Serial.print(" - ");
  Serial.println(__TIME__);
  Serial.println("Fin des initialisations.");
-  printRTC();       // Affichage du temps RTC en console série
+  printRTC();  // Affichage du temps RTC en console série
  Serial.println("------------------------");
-
 }

 /////////////////////////////////////////////////////
 /////////////////     loop         //////////////////
 /////////////////////////////////////////////////////
-// 
-void loop () {
+//
+void loop() {
  unsigned long currentMillis = millis();

  // Mise à jour de l'affichage Nixie
@ -183,47 +198,61 @@ void loop () {
    LastNixieUpdate = currentMillis;

    DateTime now = rtc.now();
-    heu_d = (now.hour())/10;
-    heu_u = (now.hour())%10;
-    min_d = (now.minute())/10;
-    min_u = (now.minute())%10;
-    sec_d = (now.second())/10;
-    sec_u = (now.second())%10;
+    heu_d = (now.hour()) / 10;
+    heu_u = (now.hour()) % 10;
+    min_d = (now.minute()) / 10;
+    min_u = (now.minute()) % 10;
+    sec_d = (now.second()) / 10;
+    sec_u = (now.second()) % 10;
+
+    printRTC();
+
+    brightnessInput = analogRead(IN_PHOTO_R);  // read the input pin
+    FastLED.setBrightness(brightnessInput/16);
+
+    int aupif = random(0, 4);
+    int randomR = random(255);
+    int randomG = random(255);
+    int randomB = random(255);
+    leds[aupif] = CRGB(randomR, randomG, randomB);
+    FastLED.show();
  }

-  // allumage du point une demi-seconde par seconde
+  // allumage du point une seconde puis éteint une seconde
  // utilisation du digit "9" du Nixie 3 (dizaines de minutes)
-  if (currentMillis - LastNixieUpdate < 1000) {
+  if ((currentMillis - LastDotUpdate < 1000) || (currentMillis < LastDotUpdate)) {
    printNixie3(9);
    delay(5);
-    digitalWrite(NX3A, 0);      //Switch OFF Anode Nixie 1
+    digitalWrite(NX3A, 0);  //Switch OFF Anode Nixie 1
  } else {
-    delay(5);
+    if ((currentMillis - LastDotUpdate < 2000) || (currentMillis < LastDotUpdate)) {
+      delay(5);
+    } else {
+      LastDotUpdate = currentMillis;
+    }
  }

  printNixie1(heu_d);
  delay(5);
-  digitalWrite(NX1A, 0);      //Switch OFF Anode Nixie 1
+  digitalWrite(NX1A, 0);  //Switch OFF Anode Nixie 1

  printNixie2(heu_u);
  delay(5);
-  digitalWrite(NX2A, 0);      //Switch OFF Anode Nixie 1
+  digitalWrite(NX2A, 0);  //Switch OFF Anode Nixie 1

  printNixie3(min_d);
  delay(5);
-  digitalWrite(NX3A, 0);      //Switch OFF Anode Nixie 1
+  digitalWrite(NX3A, 0);  //Switch OFF Anode Nixie 1

  printNixie4(min_u);
  delay(5);
-  digitalWrite(NX4A, 0);      //Switch OFF Anode Nixie 1
-
-
+  digitalWrite(NX4A, 0);  //Switch OFF Anode Nixie 1

  // 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
+    syncNTPtoRTC();  // Mise à l'heure de l'horloge RTC locale avec l'heure Internet
+    printRTC();      // Affichage du temps RTC en console série
  }
 }
--- a/README.md
+++ b/README.md
@ -18,7 +18,7 @@ NTP         - The NTP library allows you to receive time information from the In

 ## TODO :
 Gestion des erreurs
- [X] WiFi : utiliser le Wifi Manager https://github.com/tzapu/WiFiManager
+- [En cours] 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
 - [ ]
@ -26,8 +26,9 @@ Gestion des erreurs
 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
+- [X] affichage de l'heure sur Nixie
+- [En cours] Effets lumineux sur leds RGB
 - [ ] ajustement de l'heure par encodeur rotatif
- [ ] alarme réveil par buzer/HP ?
+- [ ] Traitement parallélisé (synchro NTP via réso // affichage de l'heure)
 - [ ]
 - [ ]
--- a/debug.cfg
+++ b/debug.cfg
@ -0,0 +1,14 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+#
+# Example OpenOCD configuration file for ESP32-S3 connected via builtin USB-JTAG adapter.
+#
+# For example, OpenOCD can be started for ESP32-S3 debugging on
+#
+#   openocd -f board/esp32s3-builtin.cfg
+#
+
+# Source the JTAG interface configuration file
+source [find interface/esp_usb_jtag.cfg]
+# Source the ESP32-S3 configuration file
+source [find target/esp32s3.cfg]
+
--- a/debug.svd
+++ b/debug.svd
--- a/debug_custom.json
+++ b/debug_custom.json
@ -0,0 +1,17 @@
+{
+	"name":"Arduino on ESP32-S3",
+	"toolchainPrefix":"xtensa-esp32s3-elf",
+	"svdFile":"debug.svd",
+	"request":"attach",
+	"overrideAttachCommands":[
+		"set remote hardware-watchpoint-limit 2",
+		"monitor reset halt",
+		"monitor gdb_sync",
+		"thb setup",
+		"c"
+	],
+	"overrideRestartCommands":[
+		"monitor reset halt",
+		"monitor gdb_sync"
+	]
+}
--- a/hardware.h
+++ b/hardware.h
@ -18,6 +18,8 @@
 // sortie pilotage des LEDs WS2812B placées sous les Nixies
  #define OUT_LEDs 43

+// Entrée photo-résistance
+  #define IN_PHOTO_R 10

 // Touches
  #define Rotary_A 35
--- a/nixie.cpp
+++ b/nixie.cpp
@ -3,330 +3,330 @@
 #include "Arduino.h"
 #include "hardware.h"

-void printNixie1(int8_t a){
+void printNixie1(int8_t a) {
  switch (a) {
    case 0:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, LOW);  //A
-    digitalWrite(NX1A, 1);      //Switch on Anode Nixie 1
-    break;
+      digitalWrite(BCD_D, LOW);  //D
+      digitalWrite(BCD_C, LOW);  //C
+      digitalWrite(BCD_B, LOW);  //B
+      digitalWrite(BCD_A, LOW);  //A
+      digitalWrite(NX1A, 1);     //Switch ON Anode Nixie 1
+      break;
    case 1:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX1A, 1);      //Switch on Anode Nixie 1
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, LOW);   //C
+      digitalWrite(BCD_B, LOW);   //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX1A, 1);      //Switch ON Anode Nixie 1
+      break;
    case 2:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, HIGH); //B
-    digitalWrite(BCD_A, LOW);  //A
-    digitalWrite(NX1A, 1);      //Switch on Anode Nixie 1
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, LOW);   //C
+      digitalWrite(BCD_B, HIGH);  //B
+      digitalWrite(BCD_A, LOW);   //A
+      digitalWrite(NX1A, 1);      //Switch ON Anode Nixie 1
+      break;
    case 3:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, HIGH); //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX1A, 1);      //Switch on Anode Nixie 1
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, LOW);   //C
+      digitalWrite(BCD_B, HIGH);  //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX1A, 1);      //Switch ON Anode Nixie 1
+      break;
    case 4:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, HIGH); //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, LOW);  //A
-    digitalWrite(NX1A, 1);      //Switch on Anode Nixie 1
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, HIGH);  //C
+      digitalWrite(BCD_B, LOW);   //B
+      digitalWrite(BCD_A, LOW);   //A
+      digitalWrite(NX1A, 1);      //Switch ON Anode Nixie 1
+      break;
    case 5:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, HIGH); //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX1A, 1);      //Switch on Anode Nixie 1
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, HIGH);  //C
+      digitalWrite(BCD_B, LOW);   //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX1A, 1);      //Switch ON Anode Nixie 1
+      break;
    case 6:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, HIGH); //C
-    digitalWrite(BCD_B, HIGH); //B
-    digitalWrite(BCD_A, LOW);  //A
-    digitalWrite(NX1A, 1);      //Switch on Anode Nixie 1
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, HIGH);  //C
+      digitalWrite(BCD_B, HIGH);  //B
+      digitalWrite(BCD_A, LOW);   //A
+      digitalWrite(NX1A, 1);      //Switch ON Anode Nixie 1
+      break;
    case 7:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, HIGH); //C
-    digitalWrite(BCD_B, HIGH); //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX1A, 1);      //Switch on Anode Nixie 1
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, HIGH);  //C
+      digitalWrite(BCD_B, HIGH);  //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX1A, 1);      //Switch ON Anode Nixie 1
+      break;
    case 8:
-    digitalWrite(BCD_D, HIGH); //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, LOW);  //A
-    digitalWrite(NX1A, 1);      //Switch on Anode Nixie 1
-    break;
+      digitalWrite(BCD_D, HIGH);  //D
+      digitalWrite(BCD_C, LOW);   //C
+      digitalWrite(BCD_B, LOW);   //B
+      digitalWrite(BCD_A, LOW);   //A
+      digitalWrite(NX1A, 1);      //Switch ON Anode Nixie 1
+      break;
    case 9:
-    digitalWrite(BCD_D, HIGH); //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX1A, 1);      //Switch on Anode Nixie 1
-    break;
-    case 99:
-    digitalWrite(BCD_D, HIGH); //D
-    digitalWrite(BCD_C, HIGH);  //C
-    digitalWrite(BCD_B, HIGH);  //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX1A, 0);      //Switch OFF Anode Nixie 2
-    break;
+      digitalWrite(BCD_D, HIGH);  //D
+      digitalWrite(BCD_C, LOW);   //C
+      digitalWrite(BCD_B, LOW);   //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX1A, 1);      //Switch ON Anode Nixie 1
+      break;
+    default:
+      digitalWrite(BCD_D, HIGH);  //D
+      digitalWrite(BCD_C, HIGH);  //C
+      digitalWrite(BCD_B, HIGH);  //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX1A, 0);      //Switch OFF Anode Nixie 2
+      break;
  }
 }

-void printNixie2(int8_t a){
+void printNixie2(int8_t a) {
  switch (a) {
    case 0:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, LOW);  //A
-    digitalWrite(NX2A, 1);      //Switch on Anode Nixie 2
-    break;
+      digitalWrite(BCD_D, LOW);  //D
+      digitalWrite(BCD_C, LOW);  //C
+      digitalWrite(BCD_B, LOW);  //B
+      digitalWrite(BCD_A, LOW);  //A
+      digitalWrite(NX2A, 1);     //Switch ON Anode Nixie 2
+      break;
    case 1:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX2A, 1);      //Switch on Anode Nixie 2
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, LOW);   //C
+      digitalWrite(BCD_B, LOW);   //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX2A, 1);      //Switch ON Anode Nixie 2
+      break;
    case 2:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, HIGH); //B
-    digitalWrite(BCD_A, LOW);  //A
-    digitalWrite(NX2A, 1);      //Switch on Anode Nixie 2
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, LOW);   //C
+      digitalWrite(BCD_B, HIGH);  //B
+      digitalWrite(BCD_A, LOW);   //A
+      digitalWrite(NX2A, 1);      //Switch ON Anode Nixie 2
+      break;
    case 3:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, HIGH); //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX2A, 1);      //Switch on Anode Nixie 2
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, LOW);   //C
+      digitalWrite(BCD_B, HIGH);  //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX2A, 1);      //Switch ON Anode Nixie 2
+      break;
    case 4:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, HIGH); //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, LOW);  //A
-    digitalWrite(NX2A, 1);      //Switch on Anode Nixie 2
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, HIGH);  //C
+      digitalWrite(BCD_B, LOW);   //B
+      digitalWrite(BCD_A, LOW);   //A
+      digitalWrite(NX2A, 1);      //Switch ON Anode Nixie 2
+      break;
    case 5:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, HIGH); //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX2A, 1);      //Switch on Anode Nixie 2
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, HIGH);  //C
+      digitalWrite(BCD_B, LOW);   //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX2A, 1);      //Switch ON Anode Nixie 2
+      break;
    case 6:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, HIGH); //C
-    digitalWrite(BCD_B, HIGH); //B
-    digitalWrite(BCD_A, LOW);  //A
-    digitalWrite(NX2A, 1);      //Switch on Anode Nixie 2
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, HIGH);  //C
+      digitalWrite(BCD_B, HIGH);  //B
+      digitalWrite(BCD_A, LOW);   //A
+      digitalWrite(NX2A, 1);      //Switch ON Anode Nixie 2
+      break;
    case 7:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, HIGH); //C
-    digitalWrite(BCD_B, HIGH); //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX2A, 1);      //Switch on Anode Nixie 2
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, HIGH);  //C
+      digitalWrite(BCD_B, HIGH);  //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX2A, 1);      //Switch ON Anode Nixie 2
+      break;
    case 8:
-    digitalWrite(BCD_D, HIGH); //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, LOW);  //A
-    digitalWrite(NX2A, 1);      //Switch on Anode Nixie 2
-    break;
+      digitalWrite(BCD_D, HIGH);  //D
+      digitalWrite(BCD_C, LOW);   //C
+      digitalWrite(BCD_B, LOW);   //B
+      digitalWrite(BCD_A, LOW);   //A
+      digitalWrite(NX2A, 1);      //Switch ON Anode Nixie 2
+      break;
    case 9:
-    digitalWrite(BCD_D, HIGH); //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX2A, 1);      //Switch on Anode Nixie 2
-    break;
-    case 99:
-    digitalWrite(BCD_D, HIGH); //D
-    digitalWrite(BCD_C, HIGH);  //C
-    digitalWrite(BCD_B, HIGH);  //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX2A, 0);      //Switch off Anode Nixie 2
-    break;
+      digitalWrite(BCD_D, HIGH);  //D
+      digitalWrite(BCD_C, LOW);   //C
+      digitalWrite(BCD_B, LOW);   //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX2A, 1);      //Switch ON Anode Nixie 2
+      break;
+    default:
+      digitalWrite(BCD_D, HIGH);  //D
+      digitalWrite(BCD_C, HIGH);  //C
+      digitalWrite(BCD_B, HIGH);  //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX2A, 0);      //Switch off Anode Nixie 2
+      break;
  }
 }

-void printNixie3(int8_t a){
+void printNixie3(int8_t a) {
  switch (a) {
    case 0:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, LOW);  //A
-    digitalWrite(NX3A, 1);      //Switch on Anode Nixie 3
-    break;
+      digitalWrite(BCD_D, LOW);  //D
+      digitalWrite(BCD_C, LOW);  //C
+      digitalWrite(BCD_B, LOW);  //B
+      digitalWrite(BCD_A, LOW);  //A
+      digitalWrite(NX3A, 1);     //Switch ON Anode Nixie 3
+      break;
    case 1:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX3A, 1);      //Switch on Anode Nixie 3
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, LOW);   //C
+      digitalWrite(BCD_B, LOW);   //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX3A, 1);      //Switch ON Anode Nixie 3
+      break;
    case 2:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, HIGH); //B
-    digitalWrite(BCD_A, LOW);  //A
-    digitalWrite(NX3A, 1);      //Switch on Anode Nixie 3
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, LOW);   //C
+      digitalWrite(BCD_B, HIGH);  //B
+      digitalWrite(BCD_A, LOW);   //A
+      digitalWrite(NX3A, 1);      //Switch ON Anode Nixie 3
+      break;
    case 3:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, HIGH); //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX3A, 1);      //Switch on Anode Nixie 3
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, LOW);   //C
+      digitalWrite(BCD_B, HIGH);  //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX3A, 1);      //Switch ON Anode Nixie 3
+      break;
    case 4:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, HIGH); //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, LOW);  //A
-    digitalWrite(NX3A, 1);      //Switch on Anode Nixie 3
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, HIGH);  //C
+      digitalWrite(BCD_B, LOW);   //B
+      digitalWrite(BCD_A, LOW);   //A
+      digitalWrite(NX3A, 1);      //Switch ON Anode Nixie 3
+      break;
    case 5:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, HIGH); //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX3A, 1);      //Switch on Anode Nixie 3
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, HIGH);  //C
+      digitalWrite(BCD_B, LOW);   //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX3A, 1);      //Switch ON Anode Nixie 3
+      break;
    case 6:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, HIGH); //C
-    digitalWrite(BCD_B, HIGH); //B
-    digitalWrite(BCD_A, LOW);  //A
-    digitalWrite(NX3A, 1);      //Switch on Anode Nixie 3
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, HIGH);  //C
+      digitalWrite(BCD_B, HIGH);  //B
+      digitalWrite(BCD_A, LOW);   //A
+      digitalWrite(NX3A, 1);      //Switch ON Anode Nixie 3
+      break;
    case 7:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, HIGH); //C
-    digitalWrite(BCD_B, HIGH); //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX3A, 1);      //Switch on Anode Nixie 3
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, HIGH);  //C
+      digitalWrite(BCD_B, HIGH);  //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX3A, 1);      //Switch ON Anode Nixie 3
+      break;
    case 8:
-    digitalWrite(BCD_D, HIGH); //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, LOW);  //A
-    digitalWrite(NX3A, 1);      //Switch on Anode Nixie 3
-    break;
+      digitalWrite(BCD_D, HIGH);  //D
+      digitalWrite(BCD_C, LOW);   //C
+      digitalWrite(BCD_B, LOW);   //B
+      digitalWrite(BCD_A, LOW);   //A
+      digitalWrite(NX3A, 1);      //Switch ON Anode Nixie 3
+      break;
    case 9:
-    digitalWrite(BCD_D, HIGH); //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX3A, 1);      //Switch on Anode Nixie 3
-    break;
-    case 99:
-    digitalWrite(BCD_D, HIGH); //D
-    digitalWrite(BCD_C, HIGH); //C
-    digitalWrite(BCD_B, HIGH); //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX3A, 0);      //Switch off Anode Nixie 3
-    break;
+      digitalWrite(BCD_D, HIGH);  //D
+      digitalWrite(BCD_C, LOW);   //C
+      digitalWrite(BCD_B, LOW);   //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX3A, 1);      //Switch ON Anode Nixie 3
+      break;
+    default:
+      digitalWrite(BCD_D, HIGH);  //D
+      digitalWrite(BCD_C, HIGH);  //C
+      digitalWrite(BCD_B, HIGH);  //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX3A, 0);      //Switch off Anode Nixie 3
+      break;
  }
 }

-void printNixie4(int8_t a){
+void printNixie4(int8_t a) {
  switch (a) {
    case 0:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, LOW);  //A
-    digitalWrite(NX4A, 1);      //Switch on Anode Nixie 4
-    break;
+      digitalWrite(BCD_D, LOW);  //D
+      digitalWrite(BCD_C, LOW);  //C
+      digitalWrite(BCD_B, LOW);  //B
+      digitalWrite(BCD_A, LOW);  //A
+      digitalWrite(NX4A, 1);     //Switch ON Anode Nixie 4
+      break;
    case 1:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX4A, 1);      //Switch on Anode Nixie 4
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, LOW);   //C
+      digitalWrite(BCD_B, LOW);   //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX4A, 1);      //Switch ON Anode Nixie 4
+      break;
    case 2:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, HIGH); //B
-    digitalWrite(BCD_A, LOW);  //A
-    digitalWrite(NX4A, 1);      //Switch on Anode Nixie 4
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, LOW);   //C
+      digitalWrite(BCD_B, HIGH);  //B
+      digitalWrite(BCD_A, LOW);   //A
+      digitalWrite(NX4A, 1);      //Switch ON Anode Nixie 4
+      break;
    case 3:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, HIGH); //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX4A, 1);      //Switch on Anode Nixie 4
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, LOW);   //C
+      digitalWrite(BCD_B, HIGH);  //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX4A, 1);      //Switch ON Anode Nixie 4
+      break;
    case 4:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, HIGH); //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, LOW);  //A
-    digitalWrite(NX4A, 1);      //Switch on Anode Nixie 4
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, HIGH);  //C
+      digitalWrite(BCD_B, LOW);   //B
+      digitalWrite(BCD_A, LOW);   //A
+      digitalWrite(NX4A, 1);      //Switch ON Anode Nixie 4
+      break;
    case 5:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, HIGH); //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX4A, 1);      //Switch on Anode Nixie 4
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, HIGH);  //C
+      digitalWrite(BCD_B, LOW);   //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX4A, 1);      //Switch ON Anode Nixie 4
+      break;
    case 6:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, HIGH); //C
-    digitalWrite(BCD_B, HIGH); //B
-    digitalWrite(BCD_A, LOW);  //A
-    digitalWrite(NX4A, 1);      //Switch on Anode Nixie 4
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, HIGH);  //C
+      digitalWrite(BCD_B, HIGH);  //B
+      digitalWrite(BCD_A, LOW);   //A
+      digitalWrite(NX4A, 1);      //Switch ON Anode Nixie 4
+      break;
    case 7:
-    digitalWrite(BCD_D, LOW);  //D
-    digitalWrite(BCD_C, HIGH); //C
-    digitalWrite(BCD_B, HIGH); //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX4A, 1);      //Switch on Anode Nixie 4
-    break;
+      digitalWrite(BCD_D, LOW);   //D
+      digitalWrite(BCD_C, HIGH);  //C
+      digitalWrite(BCD_B, HIGH);  //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX4A, 1);      //Switch ON Anode Nixie 4
+      break;
    case 8:
-    digitalWrite(BCD_D, HIGH); //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, LOW);  //A
-    digitalWrite(NX4A, 1);      //Switch on Anode Nixie 4
-    break;
+      digitalWrite(BCD_D, HIGH);  //D
+      digitalWrite(BCD_C, LOW);   //C
+      digitalWrite(BCD_B, LOW);   //B
+      digitalWrite(BCD_A, LOW);   //A
+      digitalWrite(NX4A, 1);      //Switch ON Anode Nixie 4
+      break;
    case 9:
-    digitalWrite(BCD_D, HIGH); //D
-    digitalWrite(BCD_C, LOW);  //C
-    digitalWrite(BCD_B, LOW);  //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX4A, 1);      //Switch on Anode Nixie 4
-    break;
-    case 99:
-    digitalWrite(BCD_D, HIGH); //D
-    digitalWrite(BCD_C, HIGH); //C
-    digitalWrite(BCD_B, HIGH); //B
-    digitalWrite(BCD_A, HIGH); //A
-    digitalWrite(NX4A, 0);      //Switch off Anode Nixie 4
-    break;
+      digitalWrite(BCD_D, HIGH);  //D
+      digitalWrite(BCD_C, LOW);   //C
+      digitalWrite(BCD_B, LOW);   //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX4A, 1);      //Switch ON Anode Nixie 4
+      break;
+    default:
+      digitalWrite(BCD_D, HIGH);  //D
+      digitalWrite(BCD_C, HIGH);  //C
+      digitalWrite(BCD_B, HIGH);  //B
+      digitalWrite(BCD_A, HIGH);  //A
+      digitalWrite(NX4A, 0);      //Switch off Anode Nixie 4
+      break;
  }
 }