Guias · 10 min de leitura

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.

Módulo de LED matriz de pontos MAX7219 8x32
O módulo MAX7219 8x32 formado por quatro matrizes 8x8: 256 LEDs e apenas 5 fios (VCC, GND, DIN, CS, CLK).

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.

PassoOperaçãoExemplo (365400 s)
Diasrestante / 864004
Horas(restante % 86400) / 36005
Minutos(restante % 3600) / 6030
Segundosrestante % 600

Lista de materiais

ComponenteFunçãoObservação
Placa de desenvolvimento ESP32Obtém o horário NTP pelo Wi-Fi, calcula o tempo restante e controla o displayNa 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 rolanteVem com 4 matrizes 8x8 já ligadas em cascata
Buzzer passivoToca a melodia da meia-noiteUm buzzer ativo não toca melodia, só um bipe fixo
Módulo RTC DS1307 ou DS3231Mantém o horário na versão sem internetA bateria de botão faz ele continuar contando mesmo sem energia
Fonte de 5 V 2 A (recomendada)Alimenta a matrizCom brilho baixo, a alimentação pela USB é suficiente
Jumpers e protoboardLigaçõesJumpers fêmea-macho são práticos para os pinos do módulo

Esquema de ligação: MAX7219, buzzer e RTC

LigaçãoArduino UnoESP32Pico W
MAX7219 VCC5V5V (VIN)VBUS (5 V)
MAX7219 GNDGNDGNDGND
MAX7219 DIND11 (MOSI)GPIO 23GP19
MAX7219 CSD10GPIO 5GP17
MAX7219 CLKD13 (SCK)GPIO 18GP18
Buzzer passivo (+)D6GPIO 25GP15
Buzzer passivo (−)GNDGNDGND
RTC SDA / SCLA4 / A5Não é necessário (NTP)Não é necessário (NTP)
Alimente a matriz sempre com 5 V, mas não subestime a corrente: com os 256 LEDs acesos no brilho máximo, ela pode passar de 1 A, o que força a porta USB e o diodo de proteção da placa. Se você mantiver o brilho entre 0 e 3 no código, fica em torno de 100–200 mA mostrando dígitos. Se quiser mais brilho, alimente a matriz com uma fonte separada de 5 V 2 A e não deixe de ligar o GND da fonte à placa.

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

  1. 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.
  2. Para a versão com Uno + RTC, instale a biblioteca RTClib da Adafruit; quando for perguntado, aceite também a dependência Adafruit BusIO.
  3. 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?.
  4. 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.

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}
Trecho do códigoO 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.
O sinal na string TZ é invertido: no formato POSIX, "TRT-3" significa UTC+3. A Turquia não usa horário de verão desde 2016, então isso basta. Para Alemanha, França, Espanha e Itália você pode usar "CET-1CEST,M3.5.0,M10.5.0/3" e, para o Reino Unido, "GMT0BST,M3.5.0/1,M10.5.0"; com essas strings, as mudanças de horário de verão são calculadas automaticamente.

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.

Módulo relógio RTC DS1307
Módulo RTC DS1307: liga por I2C e mantém o horário mesmo sem energia, graças à bateria de botão.
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}

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.

Se o horário do módulo DS1307 nunca avança ou zera toda vez que é ligado, a bateria pode estar descarregada ou ausente. Alguns módulos DS1307 baratos têm circuito de carga e por isso esperam uma bateria recarregável LIR2032; colocar uma CR2032 comum nesses módulos pode fazer a bateria estufar. Confira o esquema do seu módulo antes de trocar a bateria.

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.

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.

EventoConfigurações (ESP32)Mensagem sugerida
Ano NovoTARGET_MONTH 1, TARGET_DAY 1, TARGET_HOUR 0Mutlu Yillar (Feliz Ano Novo)
Aniversário (ex.: 14 de março)3, 14, 0Iyi ki dogdun (Feliz aniversário)
Férias do meio do ano letivo (dia do boletim)Mês e dia conforme o calendário, hora 15Tatil basladi (As férias começaram)
Dia da provaAno fixo: target = makeTarget(2027); mês, dia e hora 10Basarilar (Boa sorte)
29 de outubro, Dia da República (Turquia)10, 29, 0Cumhuriyet 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

SintomaCausa provávelSolução
Texto invertido, espelhado ou com letras giradasTipo de hardware erradoTente 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árioVerifique 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 GHzO ESP32 só se conecta a redes de 2,4 GHz; confira o SSID e a senha
Horário 3 horas adiantado ou atrasadoString de fuso horário erradaDefina TZ_INFO como "TRT-3"; lembre-se de que o sinal é invertido
O buzzer dá um único tom em vez da melodiaFoi usado um buzzer ativoUse um buzzer passivo, cuja frequência pode ser alterada
No Uno, o horário está errado toda vez que ligaA bateria do RTC está ausente ou descarregadaVerifique a bateria; a linha do adjust só roda quando isrunning() é false
O ESP32 reinicia e o display cintilaA matriz consome corrente demaisDiminua o brilho, alimente a matriz com uma fonte separada de 5 V e una os GNDs
Para testar o contador dias antes do Ano Novo, ajuste o horário-alvo para alguns minutos à frente; espere o momento da comemoração, veja o texto rolante e ouça a melodia, depois volte para a data real. Se o ESP32 ficar reiniciando, a causa quase sempre é a alimentação; os detalhes estão em Brownout e Guru Meditation no ESP32.

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.

Ver todos os projetos
Hino nacional da Turquia com buzzer
AR-15Intermediário

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.

4.8(114)
235
Relógio e calendário de matriz de LEDs (MAX7219, DS1307)
AR-84Intermediário
Premium

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.

5.0(37)
59
Relógio, calendário e estação meteorológica de matriz de pontos (MAX7219, DS1307)
AR-85Intermediário
Premium

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.

5.0(50)
66
Animação e texto em 4 matrizes LED 32x8
AR-90Intermediário
Premium

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.

4.6(40)
66
4x matriz de LED 32x8 - Pacote de 6 animações
AR-91Intermediário
Premium

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…

4.5(35)
48
Hora exata pela internet com ESP32 e NTP
ES-26Avançado
Premium

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.

4.5(13)
22
Relógio digital com ESP32 e RTC DS1307 (I2C + LCD)
ES-18Intermediário
Premium

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.

4.6(26)
40
Relógio digital com display de 7 segmentos de 4 dígitos
AR-48Intermediário
Premium

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.

4.8(56)
73