Contador regressivo com Arduino: relógio de Ano Novo com ESP32 e MAX7219
Monte um contador regressivo com Arduino: o horário NTP do ESP32 mostra dias, horas e minutos numa matriz MAX7219 8x32, com texto rolante e melodia à meia-noite. Também há versão com Uno + RTC.
Um contador regressivo com Arduino mostra quanto tempo falta para um momento-alvo (a meia-noite do Ano Novo, um aniversário, o dia de uma prova) em dias, horas, minutos e segundos, e é um dos projetos sazonais mais divertidos para quem curte eletrônica. Neste guia, você vai conectar um ESP32 a servidores NTP pelo Wi-Fi para obter o horário da internet com precisão de segundos e mostrar o tempo restante numa matriz de LED MAX7219 8x32 formada por quatro módulos. Quando o relógio marcar 00:00, “Feliz Ano Novo” vai rolar pela tela e um buzzer passivo vai tocar uma melodia.
Se você estiver num lugar sem internet ou só tiver um Arduino Uno, vamos montar o mesmo projeto com um módulo RTC (relógio de tempo real); no final, você também encontra uma versão em MicroPython para o Raspberry Pi Pico W e dicas para adaptar o contador a outras datas além do Ano Novo. O código está pronto: basta trocar o nome da rede Wi-Fi, sua senha e a data-alvo e carregar. Também vamos explicar o que cada linha faz, para que você possa criar o seu próprio contador.

Como funciona um contador regressivo?
Uma contagem regressiva é, na verdade, uma única subtração: tempo restante = horário-alvo − horário atual. Os computadores normalmente guardam o tempo como timestamp Unix (epoch), o número de segundos desde 1º de janeiro de 1970. Depois de converter o momento-alvo para o mesmo formato, você subtrai os dois números, obtém o resultado em segundos e então divide isso em dias, horas, minutos e segundos. Por exemplo, às 18:30 de 27 de dezembro faltam 365.400 segundos para o Ano Novo, o que dá 4 dias, 5 horas e 30 minutos. O verdadeiro desafio não é a matemática, é saber o horário atual com precisão: o contador millis() do Arduino zera a cada reinicialização e, por causa do ressonador cerâmico do Uno, pode atrasar ou adiantar minutos por dia. Por isso pegamos o horário da internet (NTP) ou de um chip RTC com bateria.
| Passo | Operação | Exemplo (365400 s) |
|---|---|---|
| Dias | restante / 86400 | 4 |
| Horas | (restante % 86400) / 3600 | 5 |
| Minutos | (restante % 3600) / 60 | 30 |
| Segundos | restante % 60 | 0 |
Lista de materiais
| Componente | Função | Observação |
|---|---|---|
| Placa de desenvolvimento ESP32 | Obtém o horário NTP pelo Wi-Fi, calcula o tempo restante e controla o display | Na versão com Uno, usa-se um Arduino Uno + RTC no lugar |
| Matriz de pontos MAX7219 8x32 (tipo FC16) | Mostra o tempo restante e o texto rolante | Vem com 4 matrizes 8x8 já ligadas em cascata |
| Buzzer passivo | Toca a melodia da meia-noite | Um buzzer ativo não toca melodia, só um bipe fixo |
| Módulo RTC DS1307 ou DS3231 | Mantém o horário na versão sem internet | A bateria de botão faz ele continuar contando mesmo sem energia |
| Fonte de 5 V 2 A (recomendada) | Alimenta a matriz | Com brilho baixo, a alimentação pela USB é suficiente |
| Jumpers e protoboard | Ligações | Jumpers fêmea-macho são práticos para os pinos do módulo |
Esquema de ligação: MAX7219, buzzer e RTC
| Ligação | 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 |
| Buzzer passivo (+) | D6 | GPIO 25 | GP15 |
| Buzzer passivo (−) | GND | GND | GND |
| RTC SDA / SCL | A4 / A5 | Não é necessário (NTP) | Não é necessário (NTP) |
O ESP32 e o Pico trabalham com lógica de 3,3 V. Segundo o datasheet do MAX7219, com alimentação de 5 V a entrada precisa de pelo menos 3,5 V para ser considerada nível lógico alto; 3,3 V fica um pouco abaixo disso, mas na prática a maioria dos módulos funciona sem problemas. Se aparecerem pontos aleatórios, cintilação ou travamentos, encurte os fios e coloque um conversor de nível lógico nas linhas DIN, CLK e CS. Além disso, a fiação interna dos módulos do mercado varia: se o texto aparecer invertido, espelhado ou com cada letra girada 90 graus, tente trocar FC16_HW no código por PAROLA_HW, GENERIC_HW ou ICSTATION_HW. Explicamos em detalhes como o chip funciona no artigo Matriz de LED MAX7219.
Instalando as bibliotecas
- No Arduino IDE, abra o Gerenciador de Bibliotecas, busque MD_Parola e instale a biblioteca da MajicDesigns; a MD_MAX72XX é instalada como dependência e, se não for, instale-a separadamente.
- Para a versão com Uno + RTC, instale a biblioteca RTClib da Adafruit; quando for perguntado, aceite também a dependência Adafruit BusIO.
- Para o ESP32, instale o pacote esp32 da Espressif pelo Gerenciador de Placas; as funções de Wi-Fi e NTP vêm com esse pacote, então não é preciso biblioteca extra. Os detalhes da instalação estão em O que é o ESP32?.
- Primeiro abra o exemplo Parola_HelloWorld da MD_Parola e ajuste o pino CS e o tipo de hardware; se aparecer um “Hello” limpo na tela, a fiação e o tipo de módulo estão corretos.
Código da contagem regressiva com horário NTP no ESP32
O código abaixo conecta o ESP32 à sua rede Wi-Fi, obtém o horário de um servidor NTP com configTzTime() e define o fuso horário da Turquia (UTC+3). Depois, calcula o próximo Ano Novo e escreve o tempo restante no display a cada ciclo do loop. Enquanto o número de dias for maior que zero, o display alterna a cada três segundos entre “4g” (dias) e “05:30” (horas:minutos); no último dia mostra horas:minutos, na última hora minutos:segundos e, nos últimos 10 segundos, um único dígito. Quando o alvo é atingido, o texto rolante e a melodia tocam por 60 segundos e depois o contador passa automaticamente para o alvo do ano seguinte.
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}| Trecho do código | O que faz |
|---|---|
| configTzTime(TZ_INFO, ...) (sincroniza o horário) | Conecta ao servidor NTP, obtém o horário em UTC e converte para o horário local com a string TZ; por padrão, o ESP32 ressincroniza o horário automaticamente uma vez por hora. |
| makeTarget(year) (cria o alvo) | Preenche a data-alvo numa struct tm e a converte em segundos epoch no horário local com mktime(). |
| chooseTarget() (escolhe o alvo) | Se o alvo deste ano já passou há mais tempo que a duração da comemoração, escolhe o alvo do ano seguinte. |
| remaining / 86400 ... (divisão do tempo) | Divide os segundos restantes em dias, horas, minutos e segundos. |
| showText() (mostra o texto) | Escreve no display com P.print() só se o texto mudou; não reenviar o mesmo texto evita cintilação. |
| displayAnimate() (animação) | Desenha o próximo quadro do texto rolante; como não é bloqueante, precisa ser chamada com frequência no loop. |
| playMelody() (melodia) | Toca as notas em sequência usando diferenças de millis(); como não usa delay(), o texto rolante não trava. |
Mas por que o display alterna? A matriz 8x32 tem só 32 pixels de largura e, na fonte padrão da MD_Parola, um dígito tem 5 pixels de largura, ocupando 6 pixels com o espaço de 1 pixel ao lado. “05:30”, com quatro dígitos e dois-pontos, cabe com folga em cerca de 26 pixels, mas uma exibição de seis dígitos como “04:05:30” passa de 40 pixels. Por isso distribuímos a informação no tempo: quando o alvo está longe, o número de dias é o que importa; no último dia, horas e minutos; e, na última hora, os segundos criam a expectativa. Se quiser mostrar mais informação ao mesmo tempo, você pode acrescentar um segundo módulo 8x32 à cascata e definir MAX_DEVICES como 8, ou criar uma fonte personalizada com dígitos estreitos.
Meia-noite: texto rolante e melodia no buzzer
Quando o contador chega a zero, entra em ação a função startCelebration(): ela junta a mensagem com o ano para formar o texto “Mutlu Yillar 2027” (Feliz Ano Novo em turco) e o faz rolar da direita para a esquerda com o efeito PA_SCROLL_LEFT. A melodia usa as 26 notas do refrão de “Jingle Bells”; tone(pino, frequência, duração) é chamada para cada nota, e a próxima nota começa com base na diferença de millis(). Só 90 por cento da duração de cada nota é tocada; o breve silêncio que sobra faz as notas iguais repetidas (mi-mi-mi) serem ouvidas separadamente. A fonte padrão não tem caracteres turcos, por isso escrevemos i em vez de ı na mensagem. Para mudar a melodia, basta editar os arrays notes e durs; as frequências das notas e o funcionamento do buzzer passivo estão em O que é buzzer?.
Versão com Arduino Uno + módulo RTC
Se você vai colocar o contador numa sala de aula, num corredor da escola ou numa vitrine sem internet, é mais seguro não depender do Wi-Fi. Nesse caso, quem mantém o horário é um módulo RTC: o chip DS1307 ou DS3231 conta os segundos com seu próprio cristal e, graças à bateria de botão do módulo, continua contando mesmo se o Arduino ficar sem energia. O DS1307 usa um cristal externo de 32,768 kHz sensível à temperatura, por isso pode desviar perto de um minuto por mês; o DS3231, com compensação de temperatura, erra só cerca de um minuto por ano. Para trocar, basta escrever RTC_DS3231 no lugar de RTC_DS1307 no código. Para detalhes do módulo, dê uma olhada no artigo Módulo 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}O código do Uno segue a mesma lógica da versão com ESP32; a única diferença é que ele lê o horário com rtc.now() em vez de NTP. Na RTClib, subtrair dois objetos DateTime retorna um TimeSpan, e totalseconds() dá o tempo restante em segundos. Se o RTC nunca foi ajustado, no primeiro carregamento rtc.adjust() acerta o relógio com o horário de compilação do computador; ele pode ficar atrasado pelo tempo entre compilar e carregar, ou seja, 10–20 segundos. Para compensar essa diferença, você pode acrescentar + TimeSpan(15) na linha do adjust. Quando o alvo passa e a comemoração termina, o código adianta automaticamente o alvo em um ano, então o contador recomeça a cada Ano Novo.
Versão em MicroPython com o Raspberry Pi Pico W
Você pode aplicar a mesma ideia no Pico W com MicroPython. O módulo ntptime acerta o relógio do Pico em UTC, então convertemos o alvo para UTC subtraindo 3 horas do horário local. Para o display, é preciso copiar para o Pico o driver max7219.py da comunidade MicroPython. Esse driver é baseado em framebuf e usa uma fonte de 8x8 pixels, então cabem no máximo 4 caracteres em 32 pixels; por isso tiramos os dois-pontos e mostramos “0530”. Como o relógio interno do Pico desvia com o tempo, se o aparelho for ficar ligado por dias é uma boa ideia repetir a chamada ntptime.settime() uma vez por dia. Se você é novo no MicroPython, pode começar por 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)Adaptando para outras datas
Usar o contador para um aniversário, as férias do meio do ano, o dia de uma prova ou um casamento é muito fácil. No código do ESP32, basta mudar as constantes TARGET_MONTH, TARGET_DAY e TARGET_HOUR e atualizar o texto de MESSAGE; o ano é calculado automaticamente e, quando o alvo passa, o contador é ajustado para o ano seguinte. Se não quiser que o ano apareça no texto da comemoração, remova a parte %d da linha snprintf em startCelebration(). Para um evento único, como uma prova, use um ano fixo como target = makeTarget(2027) em vez de chooseTarget() no setup(). Na versão com Uno, você muda os valores de DateTime na linha do target. Para datas que mudam todo ano, como feriados religiosos, escrever à mão a data daquele ano é o jeito mais confiável.
| Evento | Configurações (ESP32) | Mensagem sugerida |
|---|---|---|
| Ano Novo | TARGET_MONTH 1, TARGET_DAY 1, TARGET_HOUR 0 | Mutlu Yillar (Feliz Ano Novo) |
| Aniversário (ex.: 14 de março) | 3, 14, 0 | Iyi ki dogdun (Feliz aniversário) |
| Férias do meio do ano letivo (dia do boletim) | Mês e dia conforme o calendário, hora 15 | Tatil basladi (As férias começaram) |
| Dia da prova | Ano fixo: target = makeTarget(2027); mês, dia e hora 10 | Basarilar (Boa sorte) |
| 29 de outubro, Dia da República (Turquia) | 10, 29, 0 | Cumhuriyet Bayrami (Dia da República) |
Ideias de projetos com contador regressivo
- Painel da sala: um contador grande pendurado no corredor da escola mostrando os dias que faltam para o vestibular; ligue dois módulos 8x32 em cascata para chegar a 64 pixels de largura.
- Decoração automática: quando o contador zerar, acenda automaticamente as luzes da árvore de Natal com um módulo relé.
- Versão colorida: troque a matriz por uma matriz de LED WS2812B e faça as cores passarem do vermelho ao verde nos últimos 10 segundos.
- Relógio de mesa: transforme o display num relógio comum quando a contagem acabar; os detalhes do NTP estão em Relógio NTP com ESP32.
- Mudar o alvo pelo celular: rode um pequeno servidor web no ESP32 para digitar a data-alvo pelo navegador.
- Contador que não esquece o ajuste: salve a data-alvo na EEPROM para que a configuração não se perca quando a energia cair e voltar.
Erros comuns e como resolver
| Sintoma | Causa provável | Solução |
|---|---|---|
| Texto invertido, espelhado ou com letras giradas | Tipo de hardware errado | Tente PAROLA_HW, GENERIC_HW ou ICSTATION_HW em vez de FC16_HW |
| O display fica mostrando “NTP” | Não foi possível obter o horário | Verifique se a rede não bloqueia a porta UDP 123 e tente outro servidor NTP |
| O display fica mostrando “WiFi” | Nome da rede ou senha errados, ou rede de 5 GHz | O ESP32 só se conecta a redes de 2,4 GHz; confira o SSID e a senha |
| Horário 3 horas adiantado ou atrasado | String de fuso horário errada | Defina TZ_INFO como "TRT-3"; lembre-se de que o sinal é invertido |
| O buzzer dá um único tom em vez da melodia | Foi usado um buzzer ativo | Use um buzzer passivo, cuja frequência pode ser alterada |
| No Uno, o horário está errado toda vez que liga | A bateria do RTC está ausente ou descarregada | Verifique a bateria; a linha do adjust só roda quando isrunning() é false |
| O ESP32 reinicia e o display cintila | A matriz consome corrente demais | Diminua o brilho, alimente a matriz com uma fonte separada de 5 V e una os GNDs |
Um contador regressivo reúne várias habilidades fundamentais num único projeto divertido: cálculo de tempo, sincronização do horário pela rede, controle de uma matriz de LED e código não bloqueante. No app BlueGrays, você encontra os projetos de relógio e calendário em matriz de pontos com MAX7219, relógio NTP com ESP32, relógio digital com RTC DS1307 e melodias no buzzer, passo a passo, com esquema do circuito e código pronto, e pode montar este contador a partir deles.
Perguntas frequentes
Como fazer um contador regressivo com Arduino?
Você pega a data-alvo e o horário atual em segundos e subtrai um do outro; depois divide o resultado por 86400, 3600 e 60 para obter dias, horas, minutos e segundos. O horário atual é lido da internet via NTP no ESP32, ou de um módulo RTC como o DS1307 ou o DS3231 no Arduino Uno. Em seguida, você mostra o resultado num display como uma matriz de LED MAX7219, um display de 7 segmentos ou um LCD.
Dá para usar millis() numa contagem regressiva?
millis() serve para temporizadores de alguns minutos, mas não é adequado para uma contagem que dura dias. Por causa do ressonador cerâmico do Arduino Uno, millis() pode desviar minutos por dia, e zera toda vez que a placa reinicia. Para contagens longas, use NTP ou um módulo RTC com bateria.
O relógio NTP do ESP32 para se a internet cair?
Não. Depois de obter o horário uma vez, o ESP32 continua contando com seu próprio cristal, e o desvio costuma ficar abaixo de alguns segundos por dia. Quando a conexão volta, o cliente SNTP ressincroniza o horário uma vez por hora por padrão; mas, se a energia cair e a placa reiniciar, o horário fica desconhecido até ser obtido de novo.
Quanta corrente consome uma matriz de LED MAX7219 8x32?
Depende do brilho e da quantidade de LEDs acesos. Com brilho baixo (setIntensity 0–3), fica em torno de 100–200 mA mostrando alguns dígitos; com os 256 LEDs acesos no brilho máximo, pode passar de 1 A. Para um contador que vai funcionar por muito tempo, alimentar a matriz com uma fonte separada de 5 V 2 A é o jeito mais seguro.
Qual é mais preciso, o DS1307 ou o DS3231?
O DS3231 é claramente mais preciso: graças ao cristal interno com compensação de temperatura, desvia cerca de um minuto por ano. O DS1307 usa um cristal externo e pode desviar entre meio minuto e um minuto por mês. Para um momento em que o segundo importa, como o Ano Novo, escolha o DS3231 ou reajuste o DS1307 de vez em quando.
Uma matriz de LED consegue mostrar caracteres turcos?
A fonte padrão da MD_Parola não tem letras como ı, ş ou ğ, por isso escrevemos “Mutlu Yillar” no exemplo. Você pode criar sua própria fonte, carregá-la com setFont() e desenhar as letras turcas em códigos de caractere não usados. O jeito mais fácil é escolher, para mensagens curtas, palavras que não precisem de letras turcas.
Projetos para montar depois desta leitura
Ver todos os projetos
Hino nacional da Turquia com buzzer
Pressione o botão e um pequeno buzzer começa a tocar o hino nacional da Turquia, nota por nota.

Relógio e calendário de matriz de LEDs (MAX7219, DS1307)
Um painel luminoso para a mesa ou a parede que mostra a hora e a data em texto deslizante.

Relógio, calendário e estação meteorológica de matriz de pontos (MAX7219, DS1307)
Um painel com texto em rolagem para sua mesa ou parede que mostra, em sequência, a hora, a data e as condições do ambiente.

Animação e texto em 4 matrizes LED 32x8
Empilhe quatro módulos longos de matriz LED para formar um display quadrado com mais de mil pontos de luz. Primeiro, letras caem do alto como chuva, como nos filmes.

4x matriz de LED 32x8 - Pacote de 6 animações
Quatro painéis de LED 32x8 empilhados formam um display quadrado que exibe seis animações em sequência: chuva digital, uma espiral que cresce, células que nascem e morrem sozinhas, ondas circulares…

Hora exata pela internet com ESP32 e NTP
O ESP32 se conecta ao Wi-Fi e obtém a hora exata com precisão de milissegundos de servidores NTP (Network Time Protocol). Com a função configTzTime(), o fuso horário configurado (TRT, UTC+3 neste exemplo) é aplicado automaticamente, e as mudanças nos países que adotam horário de verão são gerenciadas automaticamente por uma string POSIX TZ. A hora é exibida tanto no Monitor Serial quanto em um LCD I2C opcional.

Relógio digital com ESP32 e RTC DS1307 (I2C + LCD)
Neste projeto, exibimos a hora e a data em um display LCD I2C 16x2 usando o módulo de relógio de tempo real (RTC) DS1307. O DS1307 é um RTC com bateria de reserva que mantém a hora mesmo quando o ESP32 é desligado. Os dois módulos compartilham o mesmo barramento I2C (SDA/SCL), permitindo aprender a controlar vários dispositivos com apenas dois fios de sinal. Você aprenderá na prática o protocolo de comunicação I2C, o funcionamento dos módulos RTC e a exibição de dados dinâmicos em um LCD.

Relógio digital com display de 7 segmentos de 4 dígitos
Um relógio digital luminoso de quatro dígitos, parecido com o de um forno de cozinha.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

