Contador Regresivo Arduino: Reloj de Año Nuevo con ESP32
Haz un contador regresivo con Arduino: ESP32 con NTP y matriz MAX7219 8x32 muestra días, horas y minutos; en Año Nuevo, texto y melodía. Con Uno + RTC.
Un contador regresivo con Arduino muestra en días, horas, minutos y segundos cuánto falta para un momento concreto (la medianoche de Año Nuevo, un cumpleaños, un examen) y es uno de los proyectos de temporada más divertidos para quien trabaja con electrónica. En esta guía conectarás el ESP32 por Wi-Fi a servidores NTP para obtener la hora de internet con precisión de segundo y mostrarás el tiempo restante en una matriz LED MAX7219 8x32 de cuatro módulos. Cuando el reloj marque las 00:00, en la pantalla correrá un mensaje de felicitación y un zumbador pasivo tocará una melodía.
Si estás en un lugar sin internet o solo tienes un Arduino Uno, montaremos el mismo proyecto con un módulo RTC (reloj en tiempo real); al final del artículo también encontrarás la versión en MicroPython para la Raspberry Pi Pico W y cómo adaptar el contador a fechas distintas de Año Nuevo. Los códigos están listos: solo cambia el nombre de tu Wi-Fi, la contraseña y la fecha objetivo y súbelos. Aun así explicamos qué hace cada línea para que puedas diseñar tu propio contador.

¿Cómo funciona un contador regresivo?
Una cuenta atrás es en realidad una sola resta: tiempo restante = momento objetivo − momento actual. Los ordenadores suelen guardar el tiempo como marca de tiempo Unix (epoch), es decir, los segundos transcurridos desde el 1 de enero de 1970. Si conviertes el momento objetivo al mismo formato, restas los dos números y obtienes el resultado en segundos; después lo divides en días, horas, minutos y segundos. Por ejemplo, el 27 de diciembre a las 18:30 faltan 365.400 segundos para Año Nuevo, es decir, 4 días, 5 horas y 30 minutos. La dificultad real no es el cálculo, sino conocer bien la hora actual: el contador millis() de Arduino se pone a cero en cada reinicio y, por el resonador cerámico del Uno, puede desviarse varios minutos al día. Por eso obtenemos la hora de internet (NTP) o de un chip RTC con pila.
| Paso | Operación | Ejemplo (365400 s) |
|---|---|---|
| Días | restante / 86400 | 4 |
| Horas | (restante % 86400) / 3600 | 5 |
| Minutos | (restante % 3600) / 60 | 30 |
| Segundos | restante % 60 | 0 |
Lista de materiales
| Material | Función | Nota |
|---|---|---|
| Placa de desarrollo ESP32 | Obtiene la hora NTP por Wi-Fi, calcula el tiempo restante y maneja la pantalla | En la versión Uno se usa Arduino Uno + RTC en su lugar |
| Matriz de puntos MAX7219 8x32 (tipo FC16) | Muestra el tiempo restante y el texto en movimiento | Viene con 4 matrices de 8x8 encadenadas |
| Zumbador pasivo | Toca la melodía de medianoche | El zumbador activo no puede tocar melodías, solo da un pitido fijo |
| Módulo RTC DS1307 o DS3231 | Mantiene la hora en la versión sin internet | Gracias a la pila de botón sigue contando aunque se corte la corriente |
| Adaptador de 5 V 2 A (recomendado) | Alimenta la matriz | Con poco brillo basta la alimentación por USB |
| Cables jumper y protoboard | Conexiones | Para los pines del módulo son cómodos los cables hembra-macho |
Esquema de conexión: MAX7219, zumbador y RTC
| Conexión | Arduino Uno | ESP32 | Pico W |
|---|---|---|---|
| MAX7219 VCC | 5V | 5V (VIN) | VBUS (5 V) |
| MAX7219 GND | GND | GND | GND |
| MAX7219 DIN | D11 (MOSI) | GPIO 23 | GP19 |
| MAX7219 CS | D10 | GPIO 5 | GP17 |
| MAX7219 CLK | D13 (SCK) | GPIO 18 | GP18 |
| Zumbador pasivo (+) | D6 | GPIO 25 | GP15 |
| Zumbador pasivo (−) | GND | GND | GND |
| RTC SDA / SCL | A4 / A5 | No hace falta (NTP) | No hace falta (NTP) |
El ESP32 y la Pico funcionan con lógica de 3,3 V. Según la hoja de datos del MAX7219, con alimentación de 5 V la entrada necesita al menos 3,5 V para leerse como 1 lógico; 3,3 V queda un poco por debajo, pero en la práctica la gran mayoría de los módulos funciona sin problemas. Si ves puntos aleatorios, parpadeos o bloqueos en la pantalla, acorta los cables y añade un conversor de nivel lógico en las líneas DIN, CLK y CS. Además, el cableado interno de los módulos del mercado varía: si el texto sale invertido, en espejo o con cada letra girada 90 grados, prueba a cambiar el valor FC16_HW del código por PAROLA_HW, GENERIC_HW o ICSTATION_HW. El funcionamiento del chip lo explicamos en detalle en el artículo Matriz LED MAX7219.
Instalar las bibliotecas
- En el IDE de Arduino abre el Gestor de bibliotecas, busca MD_Parola e instala la biblioteca de MajicDesigns; como dependencia también se instala MD_MAX72XX, y si no, instálala por separado.
- Para la versión Uno + RTC instala la biblioteca RTClib de Adafruit; cuando te lo pregunte, acepta también la dependencia Adafruit BusIO.
- Para el ESP32 instala desde el Gestor de placas el paquete esp32 de Espressif; las funciones de Wi-Fi y NTP vienen con ese paquete y no hace falta ninguna biblioteca adicional. Los detalles de la instalación están en el artículo ¿Qué es el ESP32?.
- Primero abre el ejemplo Parola_HelloWorld de MD_Parola, ajusta el pin CS y el tipo de hardware; si ves un "Hello" correcto en la pantalla, el cableado y el tipo de módulo son los adecuados.
Código del contador con la hora NTP del ESP32
El código siguiente conecta el ESP32 a la red Wi-Fi, obtiene la hora de un servidor NTP con configTzTime() y ajusta la zona horaria de Turquía (UTC+3). Después calcula el próximo Año Nuevo y en cada ciclo escribe el tiempo restante en la pantalla. Mientras los días sean mayores que cero, la pantalla alterna cada tres segundos entre "4g" (días, de "gün") y "05:30" (horas:minutos); el último día muestra horas:minutos, la última hora minutos:segundos y los últimos 10 segundos una sola cifra. Al llegar al objetivo, durante 60 segundos corre el texto y suena la melodía, y luego el contador pasa solo al objetivo del año siguiente.
1#include <WiFi.h>
2#include <time.h>
3#include <SPI.h>
4#include <MD_Parola.h>
5#include <MD_MAX72xx.h>
6
7#define HARDWARE_TYPE MD_MAX72XX::FC16_HW // modül tipi / module type
8#define MAX_DEVICES 4 // 4 adet 8x8 = 8x32 / 4 x 8x8 = 8x32
9#define CS_PIN 5 // DIN=GPIO23, CLK=GPIO18
10#define BUZZER_PIN 25 // pasif buzzer / passive buzzer
11
12const char* WIFI_SSID = "WIFI_ADIN"; // Wi-Fi adın / your Wi-Fi name
13const char* WIFI_PASS = "WIFI_SIFREN"; // Wi-Fi şifren / your Wi-Fi password
14const char* TZ_INFO = "TRT-3"; // Türkiye UTC+3 / Turkey UTC+3
15
16const int TARGET_MONTH = 1; // hedef ay / target month
17const int TARGET_DAY = 1; // hedef gün / target day
18const int TARGET_HOUR = 0; // hedef saat / target hour
19const char* MESSAGE = "Mutlu Yillar"; // kutlama yazısı / celebration text
20const long CELEBRATE_SEC = 60; // kutlama süresi (s) / celebration length (s)
21
22MD_Parola P = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
23
24// Jingle Bells nakaratı (Hz, ms) / Jingle Bells chorus (Hz, ms)
25const int notes[] = {659, 659, 659, 659, 659, 659, 659, 784, 523, 587, 659,
26 698, 698, 698, 698, 698, 659, 659, 659, 659,
27 659, 587, 587, 659, 587, 784};
28const int durs[] = {250, 250, 500, 250, 250, 500, 250, 250, 375, 125, 1000,
29 250, 250, 375, 125, 250, 250, 250, 125, 125,
30 250, 250, 250, 250, 500, 500};
31const int NOTE_COUNT = sizeof(notes) / sizeof(notes[0]);
32
33time_t target = 0;
34bool celebrating = false;
35char text[16];
36char lastText[16] = "";
37char msg[40];
38
39int noteIndex = 0;
40unsigned long lastNoteMs = 0;
41unsigned long waitMs = 0;
42bool melodyOn = false;
43
44time_t makeTarget(int year) {
45 struct tm t = {};
46 t.tm_year = year - 1900;
47 t.tm_mon = TARGET_MONTH - 1;
48 t.tm_mday = TARGET_DAY;
49 t.tm_hour = TARGET_HOUR;
50 t.tm_isdst = -1; // yaz saatini sistem belirlesin / let the system decide DST
51 return mktime(&t); // yerel saat -> epoch / local time -> epoch
52}
53
54void chooseTarget() {
55 time_t now = time(nullptr);
56 struct tm n;
57 localtime_r(&now, &n);
58 int year = n.tm_year + 1900;
59 target = makeTarget(year);
60 if (now - target >= CELEBRATE_SEC) target = makeTarget(year + 1); // bu yılki geçti / this year's has passed
61}
62
63void showText(const char* t) {
64 if (strcmp(t, lastText) != 0) { // yalnız değişince yaz / write only on change
65 strncpy(lastText, t, sizeof(lastText) - 1);
66 lastText[sizeof(lastText) - 1] = '\0';
67 P.print(lastText);
68 }
69}
70
71void startCelebration() {
72 celebrating = true;
73 time_t now = time(nullptr);
74 struct tm n;
75 localtime_r(&now, &n);
76 snprintf(msg, sizeof(msg), "%s %d", MESSAGE, n.tm_year + 1900);
77 P.displayClear();
78 P.displayText(msg, PA_CENTER, 40, 500, PA_SCROLL_LEFT, PA_SCROLL_LEFT);
79 noteIndex = 0;
80 waitMs = 0;
81 lastNoteMs = millis();
82 melodyOn = true;
83}
84
85void playMelody() {
86 if (!melodyOn || millis() - lastNoteMs < waitMs) return;
87 if (noteIndex >= NOTE_COUNT) { // melodi bitti / melody finished
88 melodyOn = false;
89 noTone(BUZZER_PIN);
90 return;
91 }
92 tone(BUZZER_PIN, notes[noteIndex], durs[noteIndex] * 9 / 10); // %90 çal, %10 sus / play 90%, rest 10%
93 lastNoteMs = millis();
94 waitMs = durs[noteIndex];
95 noteIndex++;
96}
97
98void setup() {
99 P.begin();
100 P.setIntensity(2); // parlaklık 0-15 / brightness 0-15
101 P.setTextAlignment(PA_CENTER);
102 P.print("WiFi");
103
104 WiFi.mode(WIFI_STA);
105 WiFi.begin(WIFI_SSID, WIFI_PASS);
106 while (WiFi.status() != WL_CONNECTED) delay(300);
107
108 P.print("NTP");
109 configTzTime(TZ_INFO, "pool.ntp.org", "time.google.com");
110 struct tm ti;
111 while (!getLocalTime(&ti, 5000)) {} // saat gelene kadar bekle / wait for the time
112 chooseTarget();
113}
114
115void loop() {
116 time_t now = time(nullptr);
117 long remaining = (long)(target - now);
118
119 if (remaining <= 0) {
120 if (remaining > -CELEBRATE_SEC) { // kutlama anı / celebration time
121 if (!celebrating) startCelebration();
122 if (P.displayAnimate()) P.displayReset(); // yazıyı sürekli kaydır / keep scrolling
123 playMelody();
124 return;
125 }
126 celebrating = false; // kutlama bitti / celebration over
127 noTone(BUZZER_PIN);
128 chooseTarget(); // sonraki yıla kur / set for next year
129 lastText[0] = '\0';
130 P.displayClear();
131 return;
132 }
133
134 long d = remaining / 86400;
135 long h = (remaining % 86400) / 3600;
136 long m = (remaining % 3600) / 60;
137 long s = remaining % 60;
138
139 if (d > 0) {
140 if ((now / 3) % 2 == 0) snprintf(text, sizeof(text), "%ldg", d); // gün / days
141 else snprintf(text, sizeof(text), "%02ld:%02ld", h, m); // saat:dakika / hh:mm
142 } else if (h > 0) {
143 snprintf(text, sizeof(text), "%02ld:%02ld", h, m); // saat:dakika / hh:mm
144 } else if (m > 0 || s > 10) {
145 snprintf(text, sizeof(text), "%02ld:%02ld", m, s); // dakika:saniye / mm:ss
146 } else {
147 snprintf(text, sizeof(text), "%ld", s); // son 10 sn / last 10 s
148 }
149 showText(text);
150 delay(20);
151}| Fragmento de código | ¿Qué hace? |
|---|---|
| configTzTime(TZ_INFO, ...) | Se conecta al servidor NTP, obtiene la hora en UTC y la convierte a hora local con la cadena TZ; por defecto el ESP32 vuelve a sincronizar la hora automáticamente cada hora. |
| makeTarget(year) | Rellena la fecha objetivo en la estructura struct tm y la convierte con mktime() a segundos epoch según la hora local. |
| chooseTarget() | Si el objetivo de este año ya pasó hace más que la duración de la celebración, elige el del año siguiente. |
| remaining / 86400 ... | Divide los segundos restantes en días, horas, minutos y segundos. |
| showText() | Escribe en pantalla con P.print() solo si el texto cambió; al no reenviar el mismo texto evita el parpadeo. |
| displayAnimate() | Dibuja el siguiente fotograma del texto en movimiento; al no ser bloqueante, hay que llamarla con frecuencia dentro del bucle. |
| playMelody() | Toca las notas en orden con la diferencia de millis(); como no usa delay(), el texto en movimiento no se traba. |
¿Por qué la pantalla alterna la información? La matriz 8x32 tiene solo 32 píxeles de ancho y, con la fuente predeterminada de MD_Parola, un dígito mide 5 píxeles y con su espacio de 1 píxel ocupa 6. "05:30", con cuatro dígitos y dos puntos, cabe cómodamente en unos 26 píxeles, pero una presentación de seis dígitos como "04:05:30" supera los 40. Por eso repartimos la información en el tiempo: cuando falta mucho importa el número de días, el último día las horas y los minutos, y en la última hora los segundos dan emoción. Si quieres mostrar más información a la vez, puedes encadenar un segundo módulo 8x32 y poner MAX_DEVICES a 8, o definir una fuente propia de dígitos estrechos.
Medianoche: texto en movimiento y melodía del zumbador
Cuando el contador llega a cero entra en acción la función startCelebration(): une el mensaje con el año, forma el texto "Mutlu Yillar 2027" y lo desplaza de derecha a izquierda con el efecto PA_SCROLL_LEFT. Como melodía se usan las 26 notas del estribillo de "Jingle Bells"; para cada nota se llama a tone(pin, frecuencia, duración) y se pasa a la siguiente con la diferencia de millis(). Solo se toca el 90 % de la duración de cada nota; ese breve silencio hace que las notas iguales consecutivas (mi-mi-mi) se oigan separadas. Como la fuente predeterminada no tiene caracteres turcos, en el mensaje escribimos i en lugar de ı; si prefieres español, cambia el texto de MESSAGE por algo como "Feliz Ano Nuevo" (sin ñ). Para cambiar la melodía basta con editar los arreglos notes y durs; las frecuencias de las notas y la lógica del zumbador pasivo las encuentras en el artículo ¿Qué es un zumbador (buzzer)?.
Versión con Arduino Uno + módulo RTC
Si vas a poner el contador en un aula sin internet, en el pasillo de un colegio o en un escaparate, es más seguro no depender del Wi-Fi. En ese caso un módulo RTC mantiene la hora: el chip DS1307 o DS3231 cuenta segundos con su propio cristal y, gracias a la pila de botón, sigue contando aunque Arduino se quede sin corriente. El DS1307 usa un cristal externo de 32,768 kHz sensible a la temperatura, por lo que puede desviarse cerca de un minuto al mes; el DS3231, con compensación de temperatura, se equivoca aproximadamente un minuto al año. En el código puedes pasar de uno a otro escribiendo RTC_DS3231 en lugar de RTC_DS1307. Para más detalles del módulo, echa un vistazo al artículo Módulo de reloj RTC.

1#include <SPI.h>
2#include <Wire.h>
3#include <MD_Parola.h>
4#include <MD_MAX72xx.h>
5#include <RTClib.h>
6
7#define HARDWARE_TYPE MD_MAX72XX::FC16_HW // modül tipi / module type
8#define MAX_DEVICES 4
9#define CS_PIN 10 // DIN=D11, CLK=D13
10#define BUZZER_PIN 6 // pasif buzzer / passive buzzer
11
12MD_Parola P = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
13RTC_DS1307 rtc; // DS3231 için RTC_DS3231 / use RTC_DS3231 for DS3231
14
15DateTime target(2027, 1, 1, 0, 0, 0); // yıl, ay, gün, saat, dk, sn / year, month, day, h, m, s
16const long CELEBRATE_SEC = 60; // kutlama süresi (s) / celebration length (s)
17
18const int notes[] = {659, 659, 659, 659, 659, 659, 659, 784, 523, 587, 659,
19 698, 698, 698, 698, 698, 659, 659, 659, 659,
20 659, 587, 587, 659, 587, 784};
21const int durs[] = {250, 250, 500, 250, 250, 500, 250, 250, 375, 125, 1000,
22 250, 250, 375, 125, 250, 250, 250, 125, 125,
23 250, 250, 250, 250, 500, 500};
24const int NOTE_COUNT = sizeof(notes) / sizeof(notes[0]);
25
26bool celebrating = false;
27char text[12];
28char lastText[12] = "";
29char msg[24];
30int noteIndex = 0;
31unsigned long lastNoteMs = 0;
32unsigned long waitMs = 0;
33bool melodyOn = false;
34
35void showText(const char* t) {
36 if (strcmp(t, lastText) != 0) { // yalnız değişince yaz / write only on change
37 strncpy(lastText, t, sizeof(lastText) - 1);
38 lastText[sizeof(lastText) - 1] = '\0';
39 P.print(lastText);
40 }
41}
42
43void startCelebration() {
44 celebrating = true;
45 snprintf(msg, sizeof(msg), "Mutlu Yillar %d", (int)target.year());
46 P.displayClear();
47 P.displayText(msg, PA_CENTER, 40, 500, PA_SCROLL_LEFT, PA_SCROLL_LEFT);
48 noteIndex = 0;
49 waitMs = 0;
50 lastNoteMs = millis();
51 melodyOn = true;
52}
53
54void playMelody() {
55 if (!melodyOn || millis() - lastNoteMs < waitMs) return;
56 if (noteIndex >= NOTE_COUNT) { // melodi bitti / melody finished
57 melodyOn = false;
58 noTone(BUZZER_PIN);
59 return;
60 }
61 tone(BUZZER_PIN, notes[noteIndex], durs[noteIndex] * 9 / 10);
62 lastNoteMs = millis();
63 waitMs = durs[noteIndex];
64 noteIndex++;
65}
66
67void setup() {
68 P.begin();
69 P.setIntensity(2); // parlaklık 0-15 / brightness 0-15
70 P.setTextAlignment(PA_CENTER);
71 if (!rtc.begin()) { // RTC bulunamadı / RTC not found
72 P.print("RTC?");
73 while (true) {}
74 }
75 if (!rtc.isrunning()) { // ilk kurulum: derleme saati / first setup: compile time
76 rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
77 }
78}
79
80void loop() {
81 DateTime now = rtc.now();
82 long remaining = (target - now).totalseconds();
83
84 if (remaining <= 0) {
85 if (remaining > -CELEBRATE_SEC) { // kutlama anı / celebration time
86 if (!celebrating) startCelebration();
87 if (P.displayAnimate()) P.displayReset();
88 playMelody();
89 return;
90 }
91 celebrating = false; // kutlama bitti, hedef +1 yıl / done, target +1 year
92 noTone(BUZZER_PIN);
93 target = DateTime(target.year() + 1, target.month(), target.day(),
94 target.hour(), target.minute(), target.second());
95 lastText[0] = '\0';
96 P.displayClear();
97 return;
98 }
99
100 long d = remaining / 86400;
101 long h = (remaining % 86400) / 3600;
102 long m = (remaining % 3600) / 60;
103 long s = remaining % 60;
104
105 if (d > 0) {
106 if ((now.unixtime() / 3) % 2 == 0) snprintf(text, sizeof(text), "%ldg", d);
107 else snprintf(text, sizeof(text), "%02ld:%02ld", h, m);
108 } else if (h > 0) {
109 snprintf(text, sizeof(text), "%02ld:%02ld", h, m);
110 } else if (m > 0 || s > 10) {
111 snprintf(text, sizeof(text), "%02ld:%02ld", m, s);
112 } else {
113 snprintf(text, sizeof(text), "%ld", s);
114 }
115 showText(text);
116 delay(20);
117}El código del Uno sigue la misma lógica que la versión ESP32; la única diferencia es que lee la hora con rtc.now() en lugar de NTP. En RTClib, la resta entre dos objetos DateTime devuelve un TimeSpan, y con totalseconds() se obtiene el tiempo restante en segundos. Si en la primera carga el RTC no estaba configurado, rtc.adjust() pone la hora del momento de compilación del ordenador; puede quedar atrasado lo que tarda entre compilar y cargar, es decir, 10–20 segundos. Para cerrar esa diferencia puedes añadir + TimeSpan(15) a la línea adjust. Cuando el objetivo pasa y termina la celebración, el código adelanta el objetivo un año automáticamente, así que el contador vuelve a funcionar cada Año Nuevo.
Versión en MicroPython con Raspberry Pi Pico W
En la Pico W puedes aplicar la misma idea con MicroPython. El módulo ntptime ajusta el reloj de la Pico en UTC; por eso convertimos el objetivo a UTC restando 3 horas a la hora local. Para la pantalla debes copiar a la Pico el controlador max7219.py de la comunidad MicroPython. Este controlador se basa en framebuf y usa una fuente de 8x8 píxeles, es decir, en 32 píxeles caben como máximo 4 caracteres; por eso omitimos los dos puntos y mostramos el formato "0530". Como el reloj interno de la Pico se desvía con el tiempo, si el dispositivo va a estar encendido durante días conviene repetir la llamada a ntptime.settime() una vez al día. Si eres nuevo en MicroPython, puedes empezar por el artículo Fundamentos de MicroPython.
1import network, ntptime, time
2from machine import Pin, SPI, PWM
3import max7219 # max7219.py Pico'da olmalı / must be on the Pico
4
5SSID = "WIFI_ADIN"
6PASS = "WIFI_SIFREN"
7UTC_OFFSET = 3 * 3600 # Türkiye UTC+3 / Turkey UTC+3
8# yerel 1 Ocak 00:00 -> UTC / local Jan 1 00:00 -> UTC
9TARGET = time.mktime((2027, 1, 1, 0, 0, 0, 0, 0)) - UTC_OFFSET
10
11spi = SPI(0, baudrate=10_000_000, polarity=0, phase=0, sck=Pin(18), mosi=Pin(19))
12disp = max7219.Matrix8x8(spi, Pin(17, Pin.OUT), 4)
13disp.brightness(2) # parlaklık 0-15 / brightness 0-15
14buz = PWM(Pin(15))
15
16def show(txt):
17 disp.fill(0)
18 x = max(0, (32 - len(txt) * 8) // 2) # ortala / center
19 disp.text(txt, x, 0, 1)
20 disp.show()
21
22wlan = network.WLAN(network.STA_IF)
23wlan.active(True)
24wlan.connect(SSID, PASS)
25show("WiFi")
26while not wlan.isconnected():
27 time.sleep(0.5)
28
29show("NTP")
30while True:
31 try:
32 ntptime.settime() # saati UTC'ye ayarla / set the clock to UTC
33 break
34 except OSError:
35 time.sleep(2)
36
37while True:
38 kalan = TARGET - time.time()
39 if kalan <= 0: # kutlama / celebration
40 buz.freq(784)
41 buz.duty_u16(30000)
42 time.sleep(0.4)
43 buz.duty_u16(0)
44 msg = "MUTLU YILLAR 2027"
45 for x in range(32, -len(msg) * 8, -1): # kayan yazı / scrolling text
46 disp.fill(0)
47 disp.text(msg, x, 0, 1)
48 disp.show()
49 time.sleep(0.03)
50 continue
51 d, r = divmod(kalan, 86400)
52 h, r = divmod(r, 3600)
53 m, s = divmod(r, 60)
54 if d > 0:
55 show("%dg" % d if (time.time() // 3) % 2 == 0 else "%02d%02d" % (h, m))
56 elif h > 0:
57 show("%02d%02d" % (h, m)) # saat dakika / hours minutes
58 else:
59 show("%02d%02d" % (m, s)) # dakika saniye / minutes seconds
60 time.sleep(0.2)Adaptarlo a otras fechas
Usar el contador para un cumpleaños, las vacaciones de mitad de curso, un examen o una boda es muy fácil. En el código del ESP32 basta con cambiar las constantes TARGET_MONTH, TARGET_DAY y TARGET_HOUR y actualizar el texto de MESSAGE; el año se calcula solo y, cuando pasa el objetivo, el contador se programa para el año siguiente. Si no quieres que se añada el año al texto de celebración, quita la parte %d de la línea snprintf dentro de startCelebration(). Para un evento único, por ejemplo un examen, usa en setup() un año fijo como target = makeTarget(2027) en lugar de chooseTarget(). En la versión Uno cambias los valores de DateTime en la línea target. Para fiestas cuya fecha cambia cada año, escribir a mano la fecha de ese año es lo más seguro.
| Evento | Ajustes (ESP32) | Mensaje sugerido |
|---|---|---|
| Año Nuevo | TARGET_MONTH 1, TARGET_DAY 1, TARGET_HOUR 0 | Mutlu Yillar (o Feliz Ano Nuevo) |
| Cumpleaños (p. ej. 14 de marzo) | 3, 14, 0 | Feliz cumple |
| Vacaciones de mitad de curso (día de las notas) | Mes y día según el calendario, hora 15 | Vacaciones |
| Día del examen | Año fijo: target = makeTarget(2027); mes, día y hora 10 | Suerte |
| 29 de octubre, Día de la República (Turquía) | 10, 29, 0 | Cumhuriyet Bayrami |
Ideas de proyectos con el contador regresivo
- Panel de clase: un contador grande colgado en el pasillo del colegio que muestre los días que faltan para la selectividad o un examen; encadena dos módulos 8x32 para llegar a 64 píxeles de ancho.
- Decoración automática: cuando el contador llegue a cero, enciende solo las luces del árbol de Navidad con un módulo de relé.
- Versión en color: sustituye la matriz por una matriz LED WS2812B y haz pasar los colores de rojo a verde en los últimos 10 segundos.
- Reloj de escritorio: cuando acabe la cuenta atrás, convierte la pantalla en un reloj normal; los detalles de NTP están en el artículo Reloj NTP con ESP32.
- Cambiar el objetivo desde el móvil: para introducir la fecha objetivo desde el navegador, ejecuta en el ESP32 un pequeño servidor web.
- Contador que no olvida el ajuste: guarda la fecha objetivo en la EEPROM; así el ajuste no se pierde aunque se vaya la luz.
Errores comunes y cómo solucionarlos
| Síntoma | Causa probable | Solución |
|---|---|---|
| El texto sale invertido, en espejo o con las letras giradas | Tipo de hardware incorrecto | Prueba PAROLA_HW, GENERIC_HW o ICSTATION_HW en lugar de FC16_HW |
| La pantalla muestra "NTP" todo el rato | No se obtiene la hora | Asegúrate de que la red no bloquee el puerto UDP 123 y prueba otro servidor NTP |
| La pantalla muestra "WiFi" todo el rato | Nombre o contraseña de la red incorrectos, o red de 5 GHz | El ESP32 solo se conecta a redes de 2,4 GHz; revisa el SSID y la contraseña |
| La hora va 3 horas adelantada o atrasada | Cadena de zona horaria incorrecta | Pon TZ_INFO en "TRT-3" (o la de tu zona); recuerda que el signo va al revés |
| El zumbador da un solo tono en lugar de melodía | Se usó un zumbador activo | Usa un zumbador pasivo, cuya frecuencia se puede cambiar |
| En el Uno la hora es incorrecta en cada encendido | El RTC no tiene pila o está agotada | Comprueba la pila; la línea adjust solo se ejecuta cuando isrunning() es false |
| El ESP32 se reinicia y la pantalla parpadea | La matriz consume demasiada corriente | Baja el brillo, alimenta la matriz con un adaptador de 5 V aparte y une las masas (GND) |
El contador regresivo reúne en un solo proyecto divertido muchas habilidades básicas: cálculo de tiempo, sincronización de la hora por red, manejo de una matriz LED y escritura de código no bloqueante. En la aplicación BlueGrays encontrarás, paso a paso y con esquemas y códigos listos, proyectos de reloj y calendario con matriz de puntos MAX7219, reloj NTP con ESP32, reloj digital con RTC DS1307 y melodías con zumbador, y podrás construir este contador sobre ellos.
Preguntas frecuentes
¿Cómo se hace un contador regresivo con Arduino?
Tomas la fecha objetivo y la hora actual en segundos y las restas; luego divides el resultado entre 86400, 3600 y 60 para obtener días, horas, minutos y segundos. La hora actual se lee de internet con NTP en el ESP32 y de un módulo RTC como el DS1307 o el DS3231 en el Arduino Uno. El resultado lo muestras en una matriz LED MAX7219, un display de 7 segmentos o un LCD.
¿Se puede usar millis() para una cuenta atrás?
Para temporizadores de unos minutos millis() basta, pero no sirve para una cuenta atrás de varios días. Por el resonador cerámico del Arduino Uno, millis() puede desviarse minutos al día y se pone a cero cada vez que la placa se reinicia. Para cuentas largas usa NTP o un módulo RTC con pila.
¿Si se cae internet, la hora NTP del ESP32 se detiene?
No. Una vez obtenida la hora, el ESP32 sigue contando con su propio cristal y la desviación suele ser de menos de unos segundos al día. Cuando vuelve la conexión, el cliente SNTP vuelve a sincronizar la hora cada hora por defecto; pero si se corta la corriente y la placa se reinicia, la hora se desconoce hasta que se obtiene de nuevo.
¿Cuánta corriente consume una matriz LED MAX7219 8x32?
Depende del brillo y del número de LED encendidos. Con poco brillo (setIntensity 0–3) y mostrando unas cifras se queda en unos 100–200 mA; con los 256 LED al máximo brillo puede superar 1 A. Para un contador que funcionará mucho tiempo, lo más seguro es alimentar la matriz con un adaptador de 5 V 2 A aparte.
¿Es más preciso el DS1307 o el DS3231?
El DS3231 es claramente más preciso: gracias a su cristal interno con compensación de temperatura se desvía aproximadamente un minuto al año. El DS1307 usa un cristal externo y puede desviarse entre medio minuto y un minuto al mes. Para un momento en el que importa el segundo, como Año Nuevo, conviene elegir el DS3231 o reajustar de vez en cuando el DS1307.
¿Se pueden mostrar caracteres como la ñ en una matriz LED?
La fuente predeterminada de MD_Parola no tiene letras como ñ, ı, ş o ğ; por eso en el ejemplo escribimos "Mutlu Yillar". Puedes definir tu propia fuente y cargarla con setFont(), dibujando esas letras en códigos de carácter que no uses. La vía más fácil es elegir en los mensajes cortos palabras que no necesiten esos caracteres.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Himno nacional turco con zumbador
Pulsas el botón y un pequeño zumbador empieza a tocar el himno nacional de Turquía, nota a nota.

Reloj y calendario de matriz de puntos (MAX7219, DS1307)
Un panel luminoso para tu mesa o tu pared que muestra la hora y la fecha con texto en movimiento.

Reloj matricial, calendario y estación meteorológica (MAX7219, DS1307)
Un panel de texto en movimiento para tu mesa o tu pared que muestra por turnos la hora, la fecha y el clima de la habitación.

4x 32x8 Matriz LED Animación Y Texto
Si apilas cuatro módulos largos de matriz LED, obtienes una pantalla cuadrada con más de mil puntos de luz.

Matriz 4x 32x8 LED - Pack de 6 animaciones
Cuatro paneles LED de 32x8 colocados uno encima de otro forman una pantalla cuadrada donde se suceden seis animaciones: lluvia digital que cae, una espiral que crece, células que nacen y mueren por…

ESP32: hora real desde Internet con NTP
El ESP32 se conecta al Wi-Fi y obtiene la hora real de servidores NTP (Network Time Protocol) con precisión de milisegundos. Gracias a configTzTime(), se aplica automáticamente la zona horaria de Turquía (TRT, UTC+3), y en los países con horario de verano el cambio (DST) se gestiona solo mediante una cadena POSIX TZ. La hora se muestra en el Serial Monitor y en una LCD I2C opcional.

Reloj digital con ESP32 y RTC DS1307 (I2C + LCD)
En este proyecto, mostramos la hora y la fecha en una pantalla LCD I2C de 16x2 mediante el módulo de reloj en tiempo real (RTC) DS1307. El DS1307 es un RTC con batería de respaldo que conserva la hora incluso si el ESP32 se apaga. Ambos módulos comparten la misma línea I2C (SDA/SCL), por lo que aprendemos a controlar varios dispositivos con solo dos cables de señal. Con este proyecto conocerás el protocolo I2C, el funcionamiento de los módulos RTC y la visualización dinámica en pantallas LCD.

Reloj digital con display de 7 segmentos de 4 dígitos
Un reloj digital luminoso de cuatro cifras, parecido al del horno de la cocina. El módulo de reloj DS1302 guarda la hora y cada segundo el Arduino lee las horas y los minutos y los muestra en el…
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

