Construire une horloge Numitron rétro avec Arduino : simple, fiable et économe en énergie

Composants et fournitures

Composant	Quantité
Arduino Nano R3	1
Maxim Integrated DS3231M – ±5 ppm, RTC I²C	1
Registre à décalage TPIC6C595 (driver haut courant)	4
Tube Numitron IV9 (afficheur 4 digits)	4
LED générique (indicateur secondes)	2
Condensateur 100 nF (découplage)	4
Diode 1N4007 – Haute tension, haut courant	2
Interrupteur glissière (Alimentation / Intensité affichage)	1
Résistance 1 kΩ (limitation courant)	1

Outils et machines nécessaires

• Fer à souder (générique)
• Fil à souder, sans plomb

Applications et services en ligne

• Arduino IDE (Environnement de développement intégré)

À propos de ce projet

Ce guide vous explique comment construire une élégante horloge à tubes Numitron alimentée par un Arduino Nano, un module temps réel DS3231 et des registres à décalage TPIC6C595. Le résultat est un affichage à faible chauffe, fiable, qui affiche l'heure, la date, l'année et la température ambiante toutes les 30 secondes.

Le concept original provient de ce dépôt GitHub. Lors de ma première construction, j'ai rencontré plusieurs problèmes : les registres à décalage 74HC595 surchauffaient car le courant total consommé dépassait leur limite de 70 mA, et le programme utilisait des délais bloquants qui ne permettaient la lecture du RTC qu'une fois par minute.

En passant aux drivers haut courant TPIC6C595 et en refactorisant le firmware pour utiliser un timing non-bloquant avec millis(), l'horloge se met maintenant à jour en temps réel, maintient les tubes Numitron au frais, et offre même un mode économie d'énergie qui éclaire faiblement l'affichage.

Points forts :

• Seuls quatre tubes Numitron IV9 et quatre drivers TPIC6C595 sont nécessaires.
• Le DS3231 fournit une heure précise et un capteur de température, éliminant le besoin d'un thermomètre externe.
• Un interrupteur glissière bascule l'indicateur de secondes piloté par LED et permet de régler la luminosité de l'affichage.
• Tous les composants sont peu coûteux et facilement disponibles, ce qui en fait un excellent projet DIY pour les passionnés.

Après avoir assemblé le circuit et téléversé le code, montez simplement l'horloge dans un boîtier décoratif. Elle sera un excellent sujet de conversation dans tout atelier ou vitrine.

Code

• Code Arduino

Code Arduino (C/C++)

#include <RTClib.h> // RTC avec température pour DS3231
RTC_DS3231 rtc; // instancier DS3231
#include <Wire.h> // câblage I2C
#include <TimeLib.h> // fonctions temps
#include <Time.h> // bibliothèque temps
#include <DS1307RTC.h> // support RTC additionnel
#include <SPI.h>
#define led 7
const int latchPin = 13; // broche latch pour TPIC6C595
const int clockPin = 10; // broche clock
const int dataPin = 11; // broche data
unsigned long previousMillis = 0; // dernière mise à jour affichage
unsigned long previousMillisDiode = 0; // dernier clignotement LED
const long interval = 30000; // intervalle rafraîchissement affichage (30 s)
const long intervalDiode = 500; // intervalle clignotement LED
const int nums[12] = {
  0b10111110, // 0
  0b00000110, // 1
  0b01111010, // 2
  0b01101110, // 3
  0b11000110, // 4
  0b11101100, // 5
  0b11111100, // 6
  0b00001110, // 7
  0b11111110, // 8
  0b11101110, // 9
  0b11001010, // indicateur °C
  0b10111000  // point décimal °C
};
// Variables pour stocker les chiffres analysés
int hour1, hour2, minute1, minute2, day1, day2, month1, month2, year1, year2, year3, year4, temp1, temp2;
int hourDecimal, minuteDecimal, dayDecimal, monthDecimal, year70, tempDecimal;

void setup() {
  pinMode(led, OUTPUT);
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  Serial.begin(9600);
  SPI.begin();
  digitalWrite(clockPin, LOW); // assurer clock bas au départ
}

void loop() {
  tmElements_t tm; // structure de la bibliothèque DS1307RTC
  RTC.read(tm); // lire heure et température actuelles
  // Analyser les chiffres
  hourDecimal = tm.Hour / 10;
  hour1 = hourDecimal;
  hour2 = tm.Hour - 10 * hourDecimal;
  minuteDecimal = tm.Minute / 10;
  minute1 = minuteDecimal;
  minute2 = tm.Minute - 10 * minuteDecimal;
  dayDecimal = tm.Day / 10;
  day1 = dayDecimal;
  day2 = tm.Day - 10 * dayDecimal;
  monthDecimal = tm.Month / 10;
  month1 = monthDecimal;
  month2 = tm.Month - 10 * monthDecimal;
  year70 = tm.Year - 30;
  year1 = 2;
  year2 = 0;
  year3 = year70 / 10;
  year4 = year70 - 10 * year3;
  tempDecimal = rtc.getTemperature() / 10;
  temp1 = tempDecimal;
  temp2 = rtc.getTemperature() - 10 * tempDecimal;

  // Clignotement LED secondes
  if (millis() - previousMillisDiode >= intervalDiode) {
    previousMillisDiode = millis();
    digitalWrite(led, !digitalRead(led));
  }

  // Rafraîchissement affichage toutes les 30 s
  if (millis() - previousMillis >= interval) {
    previousMillis = millis();
    // Effacer affichage (effet respiration)
    digitalWrite(clockPin, LOW);
    SPI.transfer(0b00000000);
    SPI.transfer(0b00000000);
    SPI.transfer(0b00000000);
    SPI.transfer(0b00000000);
    digitalWrite(clockPin, HIGH);
    delay(500);
    // Afficher date (mois/jour)
    digitalWrite(clockPin, LOW);
    SPI.transfer(nums[month2]);
    SPI.transfer(nums[month1]);
    SPI.transfer(nums[day2]);
    SPI.transfer(nums[day1]);
    digitalWrite(clockPin, HIGH);
    delay(1500);
    // Effacer à nouveau
    digitalWrite(clockPin, LOW);
    SPI.transfer(0b00000000);
    SPI.transfer(0b00000000);
    SPI.transfer(0b00000000);
    SPI.transfer(0b00000000);
    digitalWrite(clockPin, HIGH);
    delay(500);
    // Afficher année (AA)
    digitalWrite(clockPin, LOW);
    SPI.transfer(nums[year4]);
    SPI.transfer(nums[year3]);
    SPI.transfer(nums[year2]);
    SPI.transfer(nums[year1]);
    digitalWrite(clockPin, HIGH);
    delay(1500);
    // Effacer à nouveau
    digitalWrite(clockPin, LOW);
    SPI.transfer(0b00000000);
    SPI.transfer(0b00000000);
    SPI.transfer(0b00000000);
    SPI.transfer(0b00000000);
    digitalWrite(clockPin, HIGH);
    delay(500);
    // Afficher température (°C)
    digitalWrite(clockPin, LOW);
    SPI.transfer(0b10111000); // point décimal
    SPI.transfer(0b11001010); // symbole °C
    SPI.transfer(nums[temp2]);
    SPI.transfer(nums[temp1]);
    digitalWrite(clockPin, HIGH);
    delay(1500);
    // Effacement final
    digitalWrite(clockPin, LOW);
    SPI.transfer(0b00000000);
    SPI.transfer(0b00000000);
    SPI.transfer(0b00000000);
    SPI.transfer(0b00000000);
    digitalWrite(clockPin, HIGH);
    delay(500);
  } else {
    // Affichage horaire régulier (HH:MM)
    digitalWrite(clockPin, LOW);
    SPI.transfer(nums[minute2]);
    SPI.transfer(nums[minute1]);
    SPI.transfer(nums[hour2]);
    SPI.transfer(nums[hour1]);
    digitalWrite(clockPin, HIGH);
  }
}

Schémas