Guías · 10 min de lectura

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.

Módulo LED matricial MAX7219 8x32
Módulo MAX7219 8x32 formado por cuatro matrices de 8x8: 256 LED y solo 5 cables (VCC, GND, DIN, CS, CLK).

¿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.

PasoOperaciónEjemplo (365400 s)
Díasrestante / 864004
Horas(restante % 86400) / 36005
Minutos(restante % 3600) / 6030
Segundosrestante % 600

Lista de materiales

MaterialFunciónNota
Placa de desarrollo ESP32Obtiene la hora NTP por Wi-Fi, calcula el tiempo restante y maneja la pantallaEn 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 movimientoViene con 4 matrices de 8x8 encadenadas
Zumbador pasivoToca la melodía de medianocheEl zumbador activo no puede tocar melodías, solo da un pitido fijo
Módulo RTC DS1307 o DS3231Mantiene la hora en la versión sin internetGracias a la pila de botón sigue contando aunque se corte la corriente
Adaptador de 5 V 2 A (recomendado)Alimenta la matrizCon poco brillo basta la alimentación por USB
Cables jumper y protoboardConexionesPara los pines del módulo son cómodos los cables hembra-macho

Esquema de conexión: MAX7219, zumbador y RTC

ConexiónArduino UnoESP32Pico W
MAX7219 VCC5V5V (VIN)VBUS (5 V)
MAX7219 GNDGNDGNDGND
MAX7219 DIND11 (MOSI)GPIO 23GP19
MAX7219 CSD10GPIO 5GP17
MAX7219 CLKD13 (SCK)GPIO 18GP18
Zumbador pasivo (+)D6GPIO 25GP15
Zumbador pasivo (−)GNDGNDGND
RTC SDA / SCLA4 / A5No hace falta (NTP)No hace falta (NTP)
Alimenta siempre la matriz con 5 V, pero no subestimes la corriente: con los 256 LED al máximo brillo el consumo puede superar 1 A, lo que fuerza el puerto USB y el diodo de protección de la placa. Si en el código mantienes el brillo entre 0 y 3, te quedas en unos 100–200 mA al mostrar cifras. Si lo quieres más brillante, alimenta la matriz con un adaptador independiente de 5 V 2 A y conecta obligatoriamente su GND a la placa.

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

  1. 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.
  2. Para la versión Uno + RTC instala la biblioteca RTClib de Adafruit; cuando te lo pregunte, acepta también la dependencia Adafruit BusIO.
  3. 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?.
  4. 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.

C++ (Arduino IDE)
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.
En la cadena TZ el signo va al revés: en formato POSIX "TRT-3" significa UTC+3. Como Turquía no usa horario de verano desde 2016, con eso basta. Para Alemania, Francia, España e Italia puedes usar "CET-1CEST,M3.5.0,M10.5.0/3" y para el Reino Unido "GMT0BST,M3.5.0/1,M10.5.0"; con estas cadenas los cambios de horario de verano se calculan automáticamente.

¿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.

Módulo de reloj RTC DS1307
Módulo RTC DS1307: se conecta por I2C y, gracias a la pila de botón, conserva la hora aunque se corte la corriente.
C++ (Arduino IDE)
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.

Si la hora del módulo DS1307 no avanza o se reinicia en cada encendido, la pila puede estar agotada o no estar puesta. Algunos módulos DS1307 baratos tienen un circuito de carga, por lo que esperan una pila recargable LIR2032; poner una CR2032 normal en esos módulos puede hincharla. Antes de cambiar la pila, comprueba el esquema de tu módulo.

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.

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.

EventoAjustes (ESP32)Mensaje sugerido
Año NuevoTARGET_MONTH 1, TARGET_DAY 1, TARGET_HOUR 0Mutlu Yillar (o Feliz Ano Nuevo)
Cumpleaños (p. ej. 14 de marzo)3, 14, 0Feliz cumple
Vacaciones de mitad de curso (día de las notas)Mes y día según el calendario, hora 15Vacaciones
Día del examenAño fijo: target = makeTarget(2027); mes, día y hora 10Suerte
29 de octubre, Día de la República (Turquía)10, 29, 0Cumhuriyet 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íntomaCausa probableSolución
El texto sale invertido, en espejo o con las letras giradasTipo de hardware incorrectoPrueba PAROLA_HW, GENERIC_HW o ICSTATION_HW en lugar de FC16_HW
La pantalla muestra "NTP" todo el ratoNo se obtiene la horaAsegúrate de que la red no bloquee el puerto UDP 123 y prueba otro servidor NTP
La pantalla muestra "WiFi" todo el ratoNombre o contraseña de la red incorrectos, o red de 5 GHzEl ESP32 solo se conecta a redes de 2,4 GHz; revisa el SSID y la contraseña
La hora va 3 horas adelantada o atrasadaCadena de zona horaria incorrectaPon 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íaSe usó un zumbador activoUsa un zumbador pasivo, cuya frecuencia se puede cambiar
En el Uno la hora es incorrecta en cada encendidoEl RTC no tiene pila o está agotadaComprueba la pila; la línea adjust solo se ejecuta cuando isrunning() es false
El ESP32 se reinicia y la pantalla parpadeaLa matriz consume demasiada corrienteBaja el brillo, alimenta la matriz con un adaptador de 5 V aparte y une las masas (GND)
Para probar el contador días antes de Año Nuevo, ajusta la hora objetivo a unos minutos después; espera el momento de la celebración, mira el texto y escucha la melodía, y luego vuelve a la fecha real. Si el ESP32 se resetea constantemente, la causa suele ser la fuente de alimentación; los detalles están en el artículo Brownout y Guru Meditation del ESP32.

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.

Ver todos los proyectos
Himno nacional turco con zumbador
AR-15Intermedio

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.

4.8(114)
235
Reloj y calendario de matriz de puntos (MAX7219, DS1307)
AR-84Intermedio
Premium

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.

5.0(37)
59
Reloj matricial, calendario y estación meteorológica (MAX7219, DS1307)
AR-85Intermedio
Premium

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.

5.0(50)
66
4x 32x8 Matriz LED Animación Y Texto
AR-90Intermedio
Premium

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.

4.6(40)
66
Matriz 4x 32x8 LED - Pack de 6 animaciones
AR-91Intermedio
Premium

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…

4.5(35)
48
ESP32: hora real desde Internet con NTP
ES-26Avanzado
Premium

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.

4.5(13)
22
Reloj digital con ESP32 y RTC DS1307 (I2C + LCD)
ES-18Intermedio
Premium

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.

4.6(26)
40
Reloj digital con display de 7 segmentos de 4 dígitos
AR-48Intermedio
Premium

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…

4.8(56)
73