add OTA

Horloge_Nixie_firmware.ino

@@ -13,15 +13,30 @@
 #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> // https://github.com/FastLED/FastLED
+
+#include <ESPmDNS.h>
+#include <NetworkUdp.h>
+#include <ArduinoOTA.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
 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
+unsigned long LastLedUpdate;    // le temps de dernière MAJ des leds RGB
+int heu_d, heu_u, min_d, min_u, sec_d, sec_u;
+byte brightnessInput, brightnessLeds ; //for RGB led brightness
+byte randomR, randomG, randomB; // for RGB led random colors
 
-const long intervalRTCUpdate = 17000;   // 86400000 = 24 heures
+const long intervalRTCUpdate = 600000;  // 86400000 = 24 heures / 3600000 = 1 heure / 600000 = 10 minutes
 const long intervalNixieUpdate = 1000;   //     1000 =  1 seconde
 
 WiFiUDP wifiUdp;
@@ -32,28 +47,31 @@ NTP ntp(wifiUdp);
 /////////////////////////////////////////////////////
 //
 bool initWIFI() {
- // is configuration portal requested?
+
+  //WiFi.mode(WIFI_STA); // explicitly set mode, esp defaults to STA+AP
   WiFiManager wm;
+  bool reso;
+
   wm.setConfigPortalTimeout(60);
   wm.setHostname("HorlogeNixie");
 
-  bool res;
-  //reset settings on startup if switch pressed
+  //reset settings if switch pressed on startup
   if (!digitalRead(Rotary_SW)) {
-    Serial.println("RAZ");
+    Serial.println("RAZ wifi");
     wm.resetSettings();
   }
-  res = wm.autoConnect("NixieClockAP"); // Création d'un AP ou connexion mémorisée
 
-  if(!res) {
+  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 :)");
+  } else {
     Serial.println("Failed to connect");
   }
-  else {
-    //if you get here you have connected to the WiFi
-    Serial.println("connected...yeey :)");
-  }
 
-  return(res);
+  return (reso);
 }
 
 bool initRTC() {
@@ -66,13 +84,11 @@ bool initRTC(){
     if (!rtc.begin()) {
       Serial.println(" --> RTC introuvable !");
       return (false);
-    }
-    else {
+    } else {
       Serial.println(" : OK");
       return (true);
     }
-  }
-  else {
+  } else {
     Serial.println(" : déjà démarrée !");
     return (true);
   }
@@ -134,15 +150,15 @@ void setup () {
   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_D, OUTPUT);  // D      Pour digits afficheurs Nixie
   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
+  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
@@ -152,6 +168,15 @@ void setup () {
   Serial.println("");
   Serial.println("Liaison série OK");
 
+  //// Initialisation des LEDs RGB
+  FastLED.addLeds<WS2812B, LEDS_PIN>(leds, NUM_LEDS);  // GRB ordering is typical - avant :   FastLED.addLeds<WS2812B, LEDS_PIN, RGB>(leds, NUM_LEDS);
+  FastLED.setBrightness(16);
+  leds[0] = CRGB::Black;
+  FastLED.show();
+  randomR = random(256);
+  randomG = random(256);
+  randomB = random(256);
+
   wifiOK = initWIFI();  // initialisation du wifi
   initNTP();            // récupération du temps Internet
   rtcOK = initRTC();    // initialisation de l'horloge interne
@@ -161,13 +186,66 @@ void setup () {
     syncNTPtoRTC();  // Mise à l'heure de l'horloge RTC locale avec l'heure Internet
     printRTC();      // Affichage du temps RTC en console série
   }
+
+  // Port defaults to 3232
+  // ArduinoOTA.setPort(3232);
+
+  // Hostname defaults to esp3232-[MAC]
+  // ArduinoOTA.setHostname("myesp32");
+
+  // No authentication by default
+  // ArduinoOTA.setPassword("admin");
+
+  // Password can be set with it's md5 value as well
+  // MD5(admin) = 21232f297a57a5a743894a0e4a801fc3
+  // ArduinoOTA.setPasswordHash("21232f297a57a5a743894a0e4a801fc3");
+
+  ArduinoOTA
+    .onStart([]() {
+      String type;
+      if (ArduinoOTA.getCommand() == U_FLASH) {
+        type = "sketch";
+      } else {  // U_SPIFFS
+        type = "filesystem";
+      }
+
+      // NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
+      Serial.println("Start updating " + type);
+    })
+    .onEnd([]() {
+      Serial.println("\nEnd");
+    })
+    .onProgress([](unsigned int progress, unsigned int total) {
+      Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
+    })
+    .onError([](ota_error_t error) {
+      Serial.printf("Error[%u]: ", error);
+      if (error == OTA_AUTH_ERROR) {
+        Serial.println("Auth Failed");
+      } else if (error == OTA_BEGIN_ERROR) {
+        Serial.println("Begin Failed");
+      } else if (error == OTA_CONNECT_ERROR) {
+        Serial.println("Connect Failed");
+      } else if (error == OTA_RECEIVE_ERROR) {
+        Serial.println("Receive Failed");
+      } else if (error == OTA_END_ERROR) {
+        Serial.println("End Failed");
+      }
+    });
+
+  ArduinoOTA.begin();
+
+  Serial.println("Ready");
+  Serial.print("IP address: ");
+  Serial.println(WiFi.localIP());
+
   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
   Serial.println("------------------------");
-
 }
 
 /////////////////////////////////////////////////////
@@ -175,6 +253,8 @@ void setup () {
 /////////////////////////////////////////////////////
 //
 void loop() {
+  ArduinoOTA.handle();
+
   unsigned long currentMillis = millis();
 
   // Mise à jour de l'affichage Nixie
@@ -182,33 +262,64 @@ void loop () {
     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;
+    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;
 
-    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);
+      // Si c'est la nuit alors réduire la luminosité des leds
+    if ((now.hour()> 21) || (now.hour() < 8)) {
+      FastLED.setBrightness(10);
+    } else {
+      brightnessInput = analogRead(IN_PHOTO_R);  // read the input pin
+      FastLED.setBrightness(brightnessInput/2);
     }
+  }
+
+
+  // Mise à jour de l'affichage des led RGB x fois par seconde
+  if ((currentMillis - LastLedUpdate > 50) || (currentMillis < LastLedUpdate)) {
+    LastLedUpdate = currentMillis;
+
+    randomR += random(3) - 1;
+    randomG += random(3) - 1;
+    randomB += random(3) - 1;
+    byte aupif = random(4);
+    leds[aupif] = CRGB(randomR, randomG, randomB);
+    FastLED.show();
+  }
+
+  // allumage du point x seconde puis éteint x seconde
+  // utilisation du digit "9" du Nixie 3 (dizaines de minutes)
+  if ((currentMillis - LastDotUpdate < 1000) || (currentMillis < LastDotUpdate)) {
+    printNixie3(9);
+    delay(5);
+    digitalWrite(NX3A, 0);  //Switch OFF Anode Nixie 3
+  } else {
+    if ((currentMillis - LastDotUpdate < 2000) || (currentMillis < LastDotUpdate)) {
+      delay(5);
+    } else {
+      LastDotUpdate = currentMillis;
+    }
+  }
+
+  printNixie1(heu_d);
+  delay(5);
+  digitalWrite(NX1A, 0);  //Switch OFF Anode Nixie 1
+
+  printNixie2(heu_u);
+  delay(5);
+  digitalWrite(NX2A, 0);  //Switch OFF Anode Nixie 2
+
+  printNixie3(min_d);
+  delay(5);
+  digitalWrite(NX3A, 0);  //Switch OFF Anode Nixie 3
+
+  printNixie4(min_u);
+  delay(5);
+  digitalWrite(NX4A, 0);  //Switch OFF Anode Nixie 4
 
   // Mise à jour de l'horloge interne RTC. Une fois par 24H
   if ((currentMillis - LastRTCUpdate >= intervalRTCUpdate) || (currentMillis < LastRTCUpdate)) {

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)
 - [ ]
 - [ ]

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]
+

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"
+	]
+}

hardware.h

@@ -5,15 +5,21 @@
   #define I2C_SCL 41
 
 // Sorties BCD vers Nixie
-  #define BCD_A 15
-  #define BCD_B 16
-  #define BCD_C 17
-  #define BCD_D 18
+  #define BCD_A 11
+  #define BCD_B 12
+  #define BCD_C 13
+  #define BCD_D 14
 
-  #define BCD_A2 9
-  #define BCD_B2 10
-  #define BCD_C2 11
-  #define BCD_D2 12  
+  #define NX1A 4
+  #define NX2A 5
+  #define NX3A 6
+  #define NX4A 7
+
+// 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

nixie.cpp

@@ -1,74 +1,86 @@
+#include "esp32-hal-gpio.h"
 #include "nixie.h"
 #include "Arduino.h"
 #include "hardware.h"
 
-void printNixie(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;
     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;
     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;
     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;
     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;
     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;
     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;
     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;
     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;
     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:
+    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;
   }
 }
@@ -76,70 +88,245 @@ void printNixie(int8_t a){
 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
+      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_D2, LOW);  //D
-    digitalWrite(BCD_C2, LOW);  //C
-    digitalWrite(BCD_B2, LOW);  //B
-    digitalWrite(BCD_A2, HIGH); //A
+      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_D2, LOW);  //D
-    digitalWrite(BCD_C2, LOW);  //C
-    digitalWrite(BCD_B2, HIGH); //B
-    digitalWrite(BCD_A2, LOW);  //A
+      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_D2, LOW);  //D
-    digitalWrite(BCD_C2, LOW);  //C
-    digitalWrite(BCD_B2, HIGH); //B
-    digitalWrite(BCD_A2, HIGH); //A
+      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_D2, LOW);  //D
-    digitalWrite(BCD_C2, HIGH); //C
-    digitalWrite(BCD_B2, LOW);  //B
-    digitalWrite(BCD_A2, LOW);  //A
+      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_D2, LOW);  //D
-    digitalWrite(BCD_C2, HIGH); //C
-    digitalWrite(BCD_B2, LOW);  //B
-    digitalWrite(BCD_A2, HIGH); //A
+      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_D2, LOW);  //D
-    digitalWrite(BCD_C2, HIGH); //C
-    digitalWrite(BCD_B2, HIGH); //B
-    digitalWrite(BCD_A2, LOW);  //A
+      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_D2, LOW);  //D
-    digitalWrite(BCD_C2, HIGH); //C
-    digitalWrite(BCD_B2, HIGH); //B
-    digitalWrite(BCD_A2, HIGH); //A
+      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_D2, HIGH); //D
-    digitalWrite(BCD_C2, LOW);  //C
-    digitalWrite(BCD_B2, LOW);  //B
-    digitalWrite(BCD_A2, LOW);  //A
+      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_D2, HIGH); //D
-    digitalWrite(BCD_C2, LOW);  //C
-    digitalWrite(BCD_B2, LOW);  //B
-    digitalWrite(BCD_A2, HIGH); //A
+      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_D2, HIGH); //D
-    digitalWrite(BCD_C2, HIGH);  //C
-    digitalWrite(BCD_B2, HIGH);  //B
-    digitalWrite(BCD_A2, HIGH); //A
+    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) {
+  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;
+    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;
+    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;
+    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;
+    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;
+    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;
+    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;
+    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;
+    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;
+    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;
+    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) {
+  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;
+    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;
+    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;
+    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;
+    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;
+    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;
+    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;
+    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;
+    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;
+    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;
+    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;
   }
 }

nixie.h

@@ -2,5 +2,7 @@
 #include "Arduino.h"
 #include "hardware.h"
 
-void printNixie(int8_t a);
+void printNixie1(int8_t a);
 void printNixie2(int8_t a);
+void printNixie3(int8_t a);
+void printNixie4(int8_t a);