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

Compare commits

base: laurent:453e6dbd2280a373f636624c0d0fa67b4a845099
Branches Tags
laurent:main
..
compare: laurent:main
Branches Tags
laurent:main

4 Commits
453e6dbd22 ... main

Author SHA1 Message Date
Laurent
4efdbb3d63 add OTA 2025-02-16 14:18:09 +01:00
Laurent Claude
471bfbe6ac +LEDs RGB, fix Brightness input 2023-10-13 14:40:47 +02:00
Laurent Claude
268be2953b ajout clignotement des secondes sur Nixie3 2023-08-04 21:10:41 +02:00
Laurent Claude
124b05be2d Avec 4 Nixies multiplexés 2023-07-28 12:35:54 +02:00
8 changed files with 68143 additions and 234 deletions
Expand all files Collapse all files

325
Horloge_Nixie_firmware.ino
View File

@ -8,21 +8,36 @@
*/ */
#include "hardware.h" #include "hardware.h"
#include "secrets.h" #include "secrets.h"
#include <WiFiManager.h> // https://github.com/tzapu/WiFiManager #include <WiFiManager.h> // https://github.com/tzapu/WiFiManager
#include <WiFiUdp.h> #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 <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
#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; RTC_DS1307 rtc;
char daysOfTheWeek[7][12] = {"Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi"}; char daysOfTheWeek[7][12] = { "Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi" };
int timeout = 120; // seconds to run for
bool wifiOK, ntpOK, rtcOK; bool wifiOK, ntpOK, rtcOK;
unsigned long LastRTCUpdate; // le temps de dernière MAJ de l'horloge interne RTC 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 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 const long intervalNixieUpdate = 1000; // 1000 = 1 seconde
WiFiUDP wifiUdp; WiFiUDP wifiUdp;
NTP ntp(wifiUdp); NTP ntp(wifiUdp);
@ -30,58 +45,59 @@ NTP ntp(wifiUdp);
///////////////////////////////////////////////////// /////////////////////////////////////////////////////
//////////// FONCTIONS //////////////// //////////// FONCTIONS ////////////////
///////////////////////////////////////////////////// /////////////////////////////////////////////////////
// //
bool initWIFI(){ bool initWIFI() {
// is configuration portal requested?
WiFiManager wm;
wm.setConfigPortalTimeout(60);
wm.setHostname("Horloge Nixie");
bool res; //WiFi.mode(WIFI_STA); // explicitly set mode, esp defaults to STA+AP
//reset settings on startup if switch pressed WiFiManager wm;
if (! digitalRead(Rotary_SW)) { bool reso;
Serial.println("RAZ");
wm.setConfigPortalTimeout(60);
wm.setHostname("HorlogeNixie");
//reset settings if switch pressed on startup
if (!digitalRead(Rotary_SW)) {
Serial.println("RAZ wifi");
wm.resetSettings(); 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
Serial.println("Failed to connect"); //reso = wm.autoConnect(SECRET_WIFI_SSID, SECRET_WIFI_PASS);
}
else { if (reso) {
//if you get here you have connected to the WiFi //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 //// Initialisation RTC
Serial.print("Initialisation de l'horloge interne RTC"); Serial.print("Initialisation de l'horloge interne RTC");
rtcOK = rtc.begin(); rtcOK = rtc.begin();
if (! rtcOK) { if (!rtcOK) {
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
delay(1000); delay(1000);
if (! rtc.begin()) { if (!rtc.begin()) {
Serial.println(" --> RTC introuvable !"); Serial.println(" --> RTC introuvable !");
return (false); return (false);
} } else {
else { Serial.println(" : OK");
Serial.println (" : OK");
return (true); return (true);
} }
} } else {
else {
Serial.println(" : déjà démarrée !"); Serial.println(" : déjà démarrée !");
return (true); return (true);
} }
} }
void printRTC(){ void printRTC() {
//// Affichage du temps RTC en console série pour débug //// Affichage du temps RTC en console série pour débug
DateTime now = rtc.now(); 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(daysOfTheWeek[now.dayOfTheWeek()]);
Serial.print(" "); Serial.print(" ");
Serial.print(now.day(), DEC); Serial.print(now.day(), DEC);
@ -97,84 +113,148 @@ void printRTC(){
Serial.println(now.second(), DEC); Serial.println(now.second(), DEC);
} }
void initNTP(){ void initNTP() {
// Paramétrage NTP avec prise en compte de l'heure d'été pour la France // Paramétrage NTP avec prise en compte de l'heure d'été pour la France
Serial.print("Initialisation NTP"); 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.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.ruleSTD("CET", Last, Sun, Oct, 3, 60); // last sunday in october 3:00, timezone +60min (+1 GMT)
ntp.begin(); ntp.begin();
Serial.println(" : OK"); Serial.println(" : OK");
//ntp.updateInterval(1000); // update every second //ntp.updateInterval(1000); // update every second
Serial.print("Le temps Internet (NTP) indique : "); Serial.print("Le temps Internet (NTP) indique : ");
ntp.update(); 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 //// Récupération du temps Internet par NTP
Serial.println ("Synchro temps NTP vers RTC :"); Serial.println("Synchro temps NTP vers RTC :");
Serial.print ("- récupération du temps Internet : "); Serial.print("- récupération du temps Internet : ");
ntp.update(); // récupération du temps NTP 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(ntp.formattedTime("%A %d/%m/%Y %T")); // www dd/mm/yyyy hh:mm:ss
//// Mise à jour du temps RTC de l'horloge locale //// 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())); rtc.adjust(DateTime(ntp.year(), ntp.month(), ntp.day(), ntp.hours(), ntp.minutes(), ntp.seconds()));
Serial.println ( " : OK." ); Serial.println(" : OK.");
LastRTCUpdate = millis(); LastRTCUpdate = millis();
} }
///////////////////////////////////////////////////// /////////////////////////////////////////////////////
/////////////////// setup //////////////////// /////////////////// setup ////////////////////
///////////////////////////////////////////////////// /////////////////////////////////////////////////////
// //
void setup () { void setup() {
//// Initialisation hardware //// Initialisation hardware
pinMode(Rotary_SW, INPUT_PULLUP); // Encodeur rotatif : switch pinMode(Rotary_SW, INPUT_PULLUP); // Encodeur rotatif : switch
pinMode(Rotary_A, INPUT_PULLUP); // Encodeur rotatif : voie A pinMode(Rotary_A, INPUT_PULLUP); // Encodeur rotatif : voie A
pinMode(Rotary_B, INPUT_PULLUP); // Encodeur rotatif : voie B 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_C, OUTPUT); // C
pinMode(BCD_B, OUTPUT);// B pinMode(BCD_B, OUTPUT); // B
pinMode(BCD_A, OUTPUT);// A pinMode(BCD_A, OUTPUT); // A
pinMode(BCD_D2, OUTPUT);// D Pour digits afficheurs nixie 2 pinMode(NX1A, OUTPUT); // Nixie 1
pinMode(BCD_C2, OUTPUT);// C pinMode(NX2A, OUTPUT); // Nixie 2
pinMode(BCD_B2, OUTPUT);// B pinMode(NX3A, OUTPUT); // Nixie 3
pinMode(BCD_A2, OUTPUT);// A pinMode(NX4A, OUTPUT); // Nixie 4
// Démarrage de l'I2C : // 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 //// Initialisation de la liaison série
Serial.begin(115200); Serial.begin(115200);
Serial.println (""); Serial.println("");
Serial.println ("Liaison série OK"); 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
wifiOK = initWIFI(); // initialisation du wifi
initNTP(); // récupération du temps Internet
rtcOK = initRTC(); // initialisation de l'horloge interne
if (wifiOK && rtcOK) { if (wifiOK && rtcOK) {
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 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
} }
// 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("Pour info, le temps de compil : ");
Serial.print(__DATE__); Serial.print(__DATE__);
Serial.print(" - ");
Serial.println(__TIME__); Serial.println(__TIME__);
Serial.println("Fin des initialisations."); 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("------------------------"); Serial.println("------------------------");
} }
///////////////////////////////////////////////////// /////////////////////////////////////////////////////
///////////////// loop ////////////////// ///////////////// loop //////////////////
///////////////////////////////////////////////////// /////////////////////////////////////////////////////
// //
void loop () { void loop() {
ArduinoOTA.handle();
unsigned long currentMillis = millis(); unsigned long currentMillis = millis();
// Mise à jour de l'affichage Nixie // Mise à jour de l'affichage Nixie
@ -182,39 +262,70 @@ void loop () {
LastNixieUpdate = currentMillis; LastNixieUpdate = currentMillis;
DateTime now = rtc.now(); DateTime now = rtc.now();
int heu_d = (now.hour())/10; heu_d = (now.hour()) / 10;
int heu_u = (now.hour())%10; heu_u = (now.hour()) % 10;
int min_d = (now.minute())/10; min_d = (now.minute()) / 10;
int min_u = (now.minute())%10; min_u = (now.minute()) % 10;
int sec_d = (now.second())/10; sec_d = (now.second()) / 10;
int sec_u = (now.second())%10; sec_u = (now.second()) % 10;
printNixie2(heu_d); // Si c'est la nuit alors réduire la luminosité des leds
printNixie(heu_u); if ((now.hour()> 21) || (now.hour() < 8)) {
Serial.print(heu_d); FastLED.setBrightness(10);
Serial.print(heu_u); } else {
delay(1200); brightnessInput = analogRead(IN_PHOTO_R); // read the input pin
FastLED.setBrightness(brightnessInput/2);
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'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 // Mise à jour de l'horloge interne RTC. Une fois par 24H
if ((currentMillis - LastRTCUpdate >= intervalRTCUpdate) || (currentMillis < LastRTCUpdate)) { if ((currentMillis - LastRTCUpdate >= intervalRTCUpdate) || (currentMillis < LastRTCUpdate)) {
LastRTCUpdate = currentMillis; LastRTCUpdate = currentMillis;
syncNTPtoRTC(); // Mise à l'heure de l'horloge RTC locale avec l'heure Internet 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
} }
} }

7
README.md
View File

@ -18,7 +18,7 @@ NTP - The NTP library allows you to receive time information from the In
## TODO : ## TODO :
Gestion des erreurs 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 - [X] RTC : en cas d'echec de récupération du temps Internet
- [ ] Pas/Perte de réseau - [ ] Pas/Perte de réseau
- [ ] - [ ]
@ -26,8 +26,9 @@ Gestion des erreurs
Fonctionnalités Fonctionnalités
- [X] Remise à zéro par pression d'un BP au démarrage : config Wifi, - [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é - [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 - [ ] 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)
- [ ] - [ ]
- [ ] - [ ]

14
debug.cfg Normal file
View File

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

67571
debug.svd Normal file
View File

File diff suppressed because it is too large Load Diff

17
debug_custom.json Normal file
View File

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

22
hardware.h
View File

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

415
nixie.cpp
View File

@ -1,145 +1,332 @@
#include "esp32-hal-gpio.h"
#include "nixie.h" #include "nixie.h"
#include "Arduino.h" #include "Arduino.h"
#include "hardware.h" #include "hardware.h"
void printNixie(int8_t a){ void printNixie1(int8_t a) {
switch (a) { switch (a) {
case 0: case 0:
digitalWrite(BCD_D, LOW); //D digitalWrite(BCD_D, LOW); //D
digitalWrite(BCD_C, LOW); //C digitalWrite(BCD_C, LOW); //C
digitalWrite(BCD_B, LOW); //B digitalWrite(BCD_B, LOW); //B
digitalWrite(BCD_A, LOW); //A digitalWrite(BCD_A, LOW); //A
break; digitalWrite(NX1A, 1); //Switch ON Anode Nixie 1
break;
case 1: case 1:
digitalWrite(BCD_D, LOW); //D digitalWrite(BCD_D, LOW); //D
digitalWrite(BCD_C, LOW); //C digitalWrite(BCD_C, LOW); //C
digitalWrite(BCD_B, LOW); //B digitalWrite(BCD_B, LOW); //B
digitalWrite(BCD_A, HIGH); //A digitalWrite(BCD_A, HIGH); //A
break; digitalWrite(NX1A, 1); //Switch ON Anode Nixie 1
break;
case 2: case 2:
digitalWrite(BCD_D, LOW); //D digitalWrite(BCD_D, LOW); //D
digitalWrite(BCD_C, LOW); //C digitalWrite(BCD_C, LOW); //C
digitalWrite(BCD_B, HIGH); //B digitalWrite(BCD_B, HIGH); //B
digitalWrite(BCD_A, LOW); //A digitalWrite(BCD_A, LOW); //A
break; digitalWrite(NX1A, 1); //Switch ON Anode Nixie 1
break;
case 3: case 3:
digitalWrite(BCD_D, LOW); //D digitalWrite(BCD_D, LOW); //D
digitalWrite(BCD_C, LOW); //C digitalWrite(BCD_C, LOW); //C
digitalWrite(BCD_B, HIGH); //B digitalWrite(BCD_B, HIGH); //B
digitalWrite(BCD_A, HIGH); //A digitalWrite(BCD_A, HIGH); //A
break; digitalWrite(NX1A, 1); //Switch ON Anode Nixie 1
break;
case 4: case 4:
digitalWrite(BCD_D, LOW); //D digitalWrite(BCD_D, LOW); //D
digitalWrite(BCD_C, HIGH); //C digitalWrite(BCD_C, HIGH); //C
digitalWrite(BCD_B, LOW); //B digitalWrite(BCD_B, LOW); //B
digitalWrite(BCD_A, LOW); //A digitalWrite(BCD_A, LOW); //A
break; digitalWrite(NX1A, 1); //Switch ON Anode Nixie 1
break;
case 5: case 5:
digitalWrite(BCD_D, LOW); //D digitalWrite(BCD_D, LOW); //D
digitalWrite(BCD_C, HIGH); //C digitalWrite(BCD_C, HIGH); //C
digitalWrite(BCD_B, LOW); //B digitalWrite(BCD_B, LOW); //B
digitalWrite(BCD_A, HIGH); //A digitalWrite(BCD_A, HIGH); //A
break; digitalWrite(NX1A, 1); //Switch ON Anode Nixie 1
break;
case 6: case 6:
digitalWrite(BCD_D, LOW); //D digitalWrite(BCD_D, LOW); //D
digitalWrite(BCD_C, HIGH); //C digitalWrite(BCD_C, HIGH); //C
digitalWrite(BCD_B, HIGH); //B digitalWrite(BCD_B, HIGH); //B
digitalWrite(BCD_A, LOW); //A digitalWrite(BCD_A, LOW); //A
break; digitalWrite(NX1A, 1); //Switch ON Anode Nixie 1
break;
case 7: case 7:
digitalWrite(BCD_D, LOW); //D digitalWrite(BCD_D, LOW); //D
digitalWrite(BCD_C, HIGH); //C digitalWrite(BCD_C, HIGH); //C
digitalWrite(BCD_B, HIGH); //B digitalWrite(BCD_B, HIGH); //B
digitalWrite(BCD_A, HIGH); //A digitalWrite(BCD_A, HIGH); //A
break; digitalWrite(NX1A, 1); //Switch ON Anode Nixie 1
break;
case 8: case 8:
digitalWrite(BCD_D, HIGH); //D digitalWrite(BCD_D, HIGH); //D
digitalWrite(BCD_C, LOW); //C digitalWrite(BCD_C, LOW); //C
digitalWrite(BCD_B, LOW); //B digitalWrite(BCD_B, LOW); //B
digitalWrite(BCD_A, LOW); //A digitalWrite(BCD_A, LOW); //A
break; digitalWrite(NX1A, 1); //Switch ON Anode Nixie 1
break;
case 9: case 9:
digitalWrite(BCD_D, HIGH); //D digitalWrite(BCD_D, HIGH); //D
digitalWrite(BCD_C, LOW); //C digitalWrite(BCD_C, LOW); //C
digitalWrite(BCD_B, LOW); //B digitalWrite(BCD_B, LOW); //B
digitalWrite(BCD_A, HIGH); //A digitalWrite(BCD_A, HIGH); //A
break; digitalWrite(NX1A, 1); //Switch ON Anode Nixie 1
case 99: break;
digitalWrite(BCD_D, HIGH); //D default:
digitalWrite(BCD_C, HIGH); //C digitalWrite(BCD_D, HIGH); //D
digitalWrite(BCD_B, HIGH); //B digitalWrite(BCD_C, HIGH); //C
digitalWrite(BCD_A, HIGH); //A digitalWrite(BCD_B, HIGH); //B
break; 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) { switch (a) {
case 0: case 0:
digitalWrite(BCD_D2, LOW); //D digitalWrite(BCD_D, LOW); //D
digitalWrite(BCD_C2, LOW); //C digitalWrite(BCD_C, LOW); //C
digitalWrite(BCD_B2, LOW); //B digitalWrite(BCD_B, LOW); //B
digitalWrite(BCD_A2, LOW); //A digitalWrite(BCD_A, LOW); //A
break; digitalWrite(NX2A, 1); //Switch ON Anode Nixie 2
break;
case 1: case 1:
digitalWrite(BCD_D2, LOW); //D digitalWrite(BCD_D, LOW); //D
digitalWrite(BCD_C2, LOW); //C digitalWrite(BCD_C, LOW); //C
digitalWrite(BCD_B2, LOW); //B digitalWrite(BCD_B, LOW); //B
digitalWrite(BCD_A2, HIGH); //A digitalWrite(BCD_A, HIGH); //A
break; digitalWrite(NX2A, 1); //Switch ON Anode Nixie 2
break;
case 2: case 2:
digitalWrite(BCD_D2, LOW); //D digitalWrite(BCD_D, LOW); //D
digitalWrite(BCD_C2, LOW); //C digitalWrite(BCD_C, LOW); //C
digitalWrite(BCD_B2, HIGH); //B digitalWrite(BCD_B, HIGH); //B
digitalWrite(BCD_A2, LOW); //A digitalWrite(BCD_A, LOW); //A
break; digitalWrite(NX2A, 1); //Switch ON Anode Nixie 2
break;
case 3: case 3:
digitalWrite(BCD_D2, LOW); //D digitalWrite(BCD_D, LOW); //D
digitalWrite(BCD_C2, LOW); //C digitalWrite(BCD_C, LOW); //C
digitalWrite(BCD_B2, HIGH); //B digitalWrite(BCD_B, HIGH); //B
digitalWrite(BCD_A2, HIGH); //A digitalWrite(BCD_A, HIGH); //A
break; digitalWrite(NX2A, 1); //Switch ON Anode Nixie 2
break;
case 4: case 4:
digitalWrite(BCD_D2, LOW); //D digitalWrite(BCD_D, LOW); //D
digitalWrite(BCD_C2, HIGH); //C digitalWrite(BCD_C, HIGH); //C
digitalWrite(BCD_B2, LOW); //B digitalWrite(BCD_B, LOW); //B
digitalWrite(BCD_A2, LOW); //A digitalWrite(BCD_A, LOW); //A
break; digitalWrite(NX2A, 1); //Switch ON Anode Nixie 2
break;
case 5: case 5:
digitalWrite(BCD_D2, LOW); //D digitalWrite(BCD_D, LOW); //D
digitalWrite(BCD_C2, HIGH); //C digitalWrite(BCD_C, HIGH); //C
digitalWrite(BCD_B2, LOW); //B digitalWrite(BCD_B, LOW); //B
digitalWrite(BCD_A2, HIGH); //A digitalWrite(BCD_A, HIGH); //A
break; digitalWrite(NX2A, 1); //Switch ON Anode Nixie 2
break;
case 6: case 6:
digitalWrite(BCD_D2, LOW); //D digitalWrite(BCD_D, LOW); //D
digitalWrite(BCD_C2, HIGH); //C digitalWrite(BCD_C, HIGH); //C
digitalWrite(BCD_B2, HIGH); //B digitalWrite(BCD_B, HIGH); //B
digitalWrite(BCD_A2, LOW); //A digitalWrite(BCD_A, LOW); //A
break; digitalWrite(NX2A, 1); //Switch ON Anode Nixie 2
break;
case 7: case 7:
digitalWrite(BCD_D2, LOW); //D digitalWrite(BCD_D, LOW); //D
digitalWrite(BCD_C2, HIGH); //C digitalWrite(BCD_C, HIGH); //C
digitalWrite(BCD_B2, HIGH); //B digitalWrite(BCD_B, HIGH); //B
digitalWrite(BCD_A2, HIGH); //A digitalWrite(BCD_A, HIGH); //A
break; digitalWrite(NX2A, 1); //Switch ON Anode Nixie 2
break;
case 8: case 8:
digitalWrite(BCD_D2, HIGH); //D digitalWrite(BCD_D, HIGH); //D
digitalWrite(BCD_C2, LOW); //C digitalWrite(BCD_C, LOW); //C
digitalWrite(BCD_B2, LOW); //B digitalWrite(BCD_B, LOW); //B
digitalWrite(BCD_A2, LOW); //A digitalWrite(BCD_A, LOW); //A
break; digitalWrite(NX2A, 1); //Switch ON Anode Nixie 2
break;
case 9: case 9:
digitalWrite(BCD_D2, HIGH); //D digitalWrite(BCD_D, HIGH); //D
digitalWrite(BCD_C2, LOW); //C digitalWrite(BCD_C, LOW); //C
digitalWrite(BCD_B2, LOW); //B digitalWrite(BCD_B, LOW); //B
digitalWrite(BCD_A2, HIGH); //A digitalWrite(BCD_A, HIGH); //A
break; digitalWrite(NX2A, 1); //Switch ON Anode Nixie 2
case 99: break;
digitalWrite(BCD_D2, HIGH); //D default:
digitalWrite(BCD_C2, HIGH); //C digitalWrite(BCD_D, HIGH); //D
digitalWrite(BCD_B2, HIGH); //B digitalWrite(BCD_C, HIGH); //C
digitalWrite(BCD_A2, HIGH); //A digitalWrite(BCD_B, HIGH); //B
break; 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;
} }
} }

6
nixie.h
View File

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