LM555 vs ESP32: Entenda a Diferença entre CLOCK e TIMER na Prática
CLOCK e TIMER: Entenda a diferença e aprenda a usar o Timer de hardware do ESP32
Introdução
Em eletrônica, controlar o tempo é uma necessidade muito comum. Relógios digitais, contadores, temporizadores, sistemas de automação e microcontroladores precisam utilizar referências de tempo para executar suas tarefas.
Uma maneira tradicional de gerar pulsos é utilizar o conhecido CI 555. Com ele, podemos construir um oscilador capaz de gerar um sinal de clock, por exemplo, com frequência próxima de 1 Hz, ou seja, aproximadamente um ciclo por segundo.
Mas como fazer a mesma coisa utilizando um ESP32? Será que precisamos de um CI 555 externo para controlar o tempo?
Neste artigo, vamos entender a diferença entre CLOCK e TIMER, conhecer o funcionamento do LM555 e aprender como utilizar o Timer de hardware do ESP32 para realizar uma contagem automática de 0 a 9, atualizando um display de sete segmentos a cada segundo.
1. O que é CLOCK?
CLOCK, ou sinal de relógio, é uma sequência periódica de pulsos elétricos utilizada para sincronizar o funcionamento de circuitos digitais.
Esse sinal normalmente alterna entre dois níveis lógicos:
Nível alto (HIGH): representa o nível lógico 1.
Nível baixo (LOW): representa o nível lógico 0.
Cada ciclo completo corresponde a um período, formado por uma parte em nível alto e outra em nível baixo.
A frequência do clock é medida em Hertz (Hz) e indica quantos ciclos completos acontecem por segundo.
Por exemplo:
1 Hz: um ciclo completo por segundo.
2 Hz: dois ciclos completos por segundo.
10 Hz: dez ciclos completos por segundo.
1 kHz: mil ciclos completos por segundo.
Um clock de 1 Hz é bastante interessante para projetos didáticos, pois permite visualizar facilmente a passagem do tempo em um contador digital.
2. O que é TIMER?
TIMER significa temporizador. É um recurso utilizado para medir intervalos de tempo e executar determinadas ações quando um período programado é atingido.
Imagine que queremos atualizar um display a cada segundo. Podemos configurar um temporizador para gerar um evento sempre que esse intervalo terminar.
O TIMER não precisa necessariamente produzir um sinal elétrico de clock em um pino externo. Ele pode simplesmente gerar um evento interno para avisar ao microcontrolador que o tempo programado passou.
Essa é uma diferença importante:
CLOCK: é um sinal periódico de pulsos utilizado para sincronizar circuitos.
TIMER: é um recurso que mede intervalos de tempo e pode gerar eventos programados.
Os dois conceitos estão relacionados, mas não significam a mesma coisa.
3. Gerando um CLOCK de 1 Hz com o LM555
Uma maneira tradicional de construir um gerador de clock é utilizar o CI LM555 configurado no modo astável.
Nesse modo de funcionamento, o circuito gera pulsos continuamente, sem precisar de um comando externo para iniciar cada ciclo.
O funcionamento depende principalmente de dois resistores e um capacitor.
Para nossa demonstração, utilizamos:
| Componente | Valor |
|---|---|
| CI | LM555 |
| R1 | 10 kΩ |
| R2 | 68 kΩ |
| C1 | 10 µF / 16 V |
| Capacitor de desacoplamento | 10 nF |
| Alimentação | 5 V |
Como funciona o circuito?
O capacitor realiza ciclos de carga e descarga através dos resistores.
Durante a carga, sua tensão aumenta até atingir aproximadamente 2/3 da tensão de alimentação. Nesse momento, o LM555 altera o estado da saída e inicia o processo de descarga.
Durante a descarga, a tensão diminui até aproximadamente 1/3 da alimentação. Quando esse nível é atingido, o processo de carga começa novamente.
Essa alternância produz os pulsos na saída do CI, localizada no pino 3.
Fórmula para calcular a frequência
Vamos utilizar os valores da nossa montagem:
R1 = 10.000 Ω
R2 = 68.000 Ω
C = 0,00001 F
Substituindo na fórmula:
f = 1,44 / [(10.000 + 2 × 68.000) × 0,00001]
Primeiro, resolvemos a soma:
10.000 + 136.000 = 146.000
Depois, multiplicamos pelo capacitor:
146.000 × 0,00001 = 1,46
Finalmente:
f = 1,44 / 1,46
f ≈ 0,986 Hz
Portanto, temos uma frequência próxima de 1 Hz.
Para descobrir o período, utilizamos:
T = 1 / f
T = 1 / 0,986
T ≈ 1,014 segundo
Isso significa que o circuito completa aproximadamente um ciclo a cada segundo.
É importante lembrar que o resultado real pode variar conforme a tolerância dos resistores, do capacitor e as características do CI.
4. Utilizando o CLOCK do LM555 com o CD4026
![]() |
| O LM555 trabalha no modo astável, gerando pulsos periódicos com frequência próxima de 1 Hz. Os resistores de 10 kΩ e 68 kΩ, juntamente com o capacitor de 10 µF, determinam a frequência de oscilação. |
Agora que temos um gerador de clock, podemos utilizá-lo para controlar um contador digital.
Uma aplicação interessante é conectar a saída do LM555 ao pino CLOCK do CI CD4026.
O CD4026 é um contador decimal que também possui decodificador para display de sete segmentos de cátodo comum.
Seu funcionamento é simples:
O LM555 gera um pulso aproximadamente a cada segundo.
O pulso chega à entrada CLOCK do CD4026.
O CD4026 identifica a transição positiva do pulso e incrementa a contagem.
O display apresenta o número correspondente.
Ao chegar ao número 9, o contador retorna automaticamente para zero.
Assim, construímos um contador digital utilizando eletrônica analógica e digital, sem precisar de programação.
Essa montagem permite visualizar claramente como um sinal de clock controla a contagem de um circuito digital.
5. Como o ESP32 controla o tempo?
O ESP32 possui temporizadores internos chamados de Hardware Timers.
Esses temporizadores utilizam o sistema de relógio interno do microcontrolador para realizar contagens de tempo e gerar eventos programados.
Dessa maneira, podemos criar um temporizador de um segundo sem utilizar um LM555 externo.
Na versão Arduino-ESP32 3.3.12, utilizamos três funções principais:
timerBegin()
timerAttachInterrupt()
timerAlarm()
Vamos entender cada uma delas.
5.1. timerBegin() – Inicializando o temporizador
A primeira função é responsável por inicializar o Timer de hardware.
Exemplo:
timer = timerBegin(1000000);
O valor 1000000 representa a frequência de contagem configurada para o temporizador: 1 MHz.
Isso significa que o contador do timer avança um milhão de vezes por segundo, ou seja, um incremento a cada microssegundo.
Podemos entender essa configuração como a definição da velocidade de funcionamento do nosso cronômetro interno.
5.2. timerAttachInterrupt() – Associando uma interrupção
Depois de inicializar o timer, precisamos associar uma função que será executada quando o alarme for atingido.
Exemplo:
timerAttachInterrupt(timer, &onTimer);
Essa função associa o temporizador à função chamada onTimer().
Mas o que é uma interrupção?
Uma interrupção é um mecanismo que permite ao microcontrolador responder a um evento específico sem precisar ficar verificando continuamente se ele aconteceu.
No nosso projeto, quando o temporizador atingir o intervalo programado, a função onTimer() será executada.
Ela apenas sinalizará que passou um segundo.
5.3. timerAlarm() – Programando o intervalo
A terceira função configura o alarme do temporizador.
Exemplo:
timerAlarm(timer, 1000000, true, 0);
Vamos entender seus parâmetros:
| Parâmetro | Significado |
|---|---|
| timer | Temporizador utilizado |
| 1000000 | Quantidade de incrementos até o alarme |
| true | Repetição automática do alarme |
| 0 | Sem limite de repetições |
Como configuramos o timer para contar a 1 MHz, um milhão de incrementos corresponde a um segundo.
Com a repetição automática ativada, o temporizador continuará gerando eventos a cada segundo.
6. Fazendo a contagem de 0 a 9 com o ESP32
Agora vamos aplicar o que aprendemos.
No circuito com LM555 e CD4026, o CI 555 gera o clock e o CD4026 realiza a contagem.
Com o ESP32, podemos fazer as duas funções utilizando os recursos internos do microcontrolador e um programa.
O funcionamento será:
O Timer de hardware é configurado para gerar um evento a cada segundo.
Quando o intervalo termina, ocorre uma interrupção.
A interrupção sinaliza que passou um segundo.
O programa incrementa a variável do contador.
O ESP32 atualiza os segmentos do display.
Quando chega ao número 9, a contagem retorna a zero.
Uma vantagem é que podemos modificar o intervalo de tempo diretamente no programa, sem precisar trocar resistores ou capacitores.
7. Código completo – Contador com Timer de hardware do ESP32
O exemplo abaixo utiliza um display de sete segmentos de cátodo comum e a versão Arduino-ESP32 3.3.11.
O display inicia no número zero e avança automaticamente a cada segundo, até chegar ao número nove. Depois, retorna ao zero e repete a sequência.
/*
============================================================
Projeto : RodRobot - Contador com Timer de Hardware
Placa : ESP32
Display : 7 segmentos - Catodo comum
Funcao : Contagem automatica de 0 a 9
Timer : Intervalo de 1 segundo
IDE : Arduino-ESP32 3.3.12
============================================================
*/
// -------------------- PINOS DO DISPLAY ----------------------
const int SEG_A = 23; // Segmento A
const int SEG_B = 22; // Segmento B
const int SEG_C = 21; // Segmento C
const int SEG_D = 19; // Segmento D
const int SEG_E = 18; // Segmento E
const int SEG_F = 17; // Segmento F
const int SEG_G = 16; // Segmento G
// -------------------- VARIAVEIS DO TIMER --------------------
hw_timer_t *timer = NULL; // Ponteiro do timer
volatile bool novoSegundo = false; // Sinaliza novo segundo
int contador = 0; // Contagem de 0 a 9
// -------------------- TABELA DOS NUMEROS --------------------
// Ordem dos segmentos: A, B, C, D, E, F, G
// HIGH acende o segmento no catodo comum.
const byte numeros[10][7] = {
{1, 1, 1, 1, 1, 1, 0}, // 0
{0, 1, 1, 0, 0, 0, 0}, // 1
{1, 1, 0, 1, 1, 0, 1}, // 2
{1, 1, 1, 1, 0, 0, 1}, // 3
{0, 1, 1, 0, 0, 1, 1}, // 4
{1, 0, 1, 1, 0, 1, 1}, // 5
{1, 0, 1, 1, 1, 1, 1}, // 6
{1, 1, 1, 0, 0, 0, 0}, // 7
{1, 1, 1, 1, 1, 1, 1}, // 8
{1, 1, 1, 1, 0, 1, 1} // 9
};
// -------------------- VETOR DOS PINOS -----------------------
const int segmentos[7] = {
SEG_A, SEG_B, SEG_C, SEG_D,
SEG_E, SEG_F, SEG_G
};
// -------------------- INTERRUPCAO DO TIMER ------------------
// Executada automaticamente a cada segundo
void ARDUINO_ISR_ATTR onTimer() {
novoSegundo = true; // Sinaliza o evento
}
// -------------------- MOSTRAR NUMERO ------------------------
void mostrarNumero(int numero) {
for (int i = 0; i < 7; i++) {
digitalWrite(segmentos[i], numeros[numero][i]);
}
}
// -------------------- CONFIGURACAO --------------------------
void setup() {
// Configura os segmentos como saidas
for (int i = 0; i < 7; i++) {
pinMode(segmentos[i], OUTPUT);
}
// Inicia mostrando zero
mostrarNumero(contador);
// Inicializa timer com frequencia de 1 MHz
timer = timerBegin(1000000);
// Associa a interrupcao ao timer
timerAttachInterrupt(timer, &onTimer);
// Configura alarme para cada 1 segundo
// 1000000 incrementos = 1 segundo
// true = repeticao automatica
timerAlarm(timer, 1000000, true, 0);
}
// -------------------- LOOP PRINCIPAL ------------------------
void loop() {
// Verifica se o timer sinalizou novo segundo
if (novoSegundo) {
novoSegundo = false; // Limpa o sinal
contador++; // Incrementa a contagem
if (contador > 9) {
contador = 0; // Retorna para zero
}
mostrarNumero(contador); // Atualiza o display
}
}
Observação: a interrupção executa apenas uma sinalização. A contagem e a atualização do display acontecem no loop principal, evitando colocar operações mais demoradas dentro da interrupção.
8. Comparação: LM555 + CD4026 versus ESP32
Agora podemos entender melhor as diferenças entre as duas soluções.
| Característica | LM555 + CD4026 | ESP32 |
|---|---|---|
| Geração do tempo | Oscilador LM555 | Timer de hardware |
| Referência de tempo | Resistores e capacitor | Relógio interno do chip |
| Contagem | CD4026 | Programa |
| Controle do display | CD4026 | GPIO do ESP32 |
| Alteração do intervalo | Troca de componentes | Alteração do código |
| Programação | Não necessita | Necessita |
| Flexibilidade | Circuito dedicado | Alta flexibilidade |
Uma diferença importante é que o LM555 produz um sinal elétrico de clock em sua saída, que é enviado fisicamente ao CD4026.
Já o Timer de hardware do ESP32 gera um evento interno. Esse evento aciona uma interrupção que sinaliza ao programa que o intervalo de tempo terminou.
Portanto, o ESP32 não precisa gerar um clock externo para realizar essa contagem.
É possível, entretanto, programar uma saída GPIO para produzir pulsos elétricos de 1 Hz, caso seja necessário controlar outro circuito digital externamente.
9. Conclusão
Com essa experiência, conseguimos entender dois caminhos diferentes para controlar o tempo em projetos eletrônicos.
O primeiro utiliza componentes dedicados: o LM555 gera os pulsos de clock e o CD4026 realiza a contagem e controla o display.
O segundo utiliza os recursos internos do ESP32. Seu Timer de hardware controla os intervalos, enquanto o programa realiza a contagem e atualiza o display.
Isso mostra como a eletrônica tradicional e a programação de microcontroladores podem resolver problemas semelhantes, mas utilizando princípios e recursos diferentes.
Entender essa diferença é importante para quem deseja aprender eletrônica digital, programação embarcada e automação.
No próximo passo, podemos ampliar esse projeto para construir um contador de segundos e minutos, evoluindo para um relógio digital utilizando o ESP32.
RodRobot – Eletrônica, ESP32, IoT e Robótica na prática.
🔧 Acompanhe o RodRobot
Projetos maker com ESP32, Arduino, eletrônica e programação.
RodRobot – Projetos maker, eletrônica e programação na prática.





Comentários
Postar um comentário