LM555 vs ESP32: Entenda a Diferença entre CLOCK e TIMER na Prática

Como Gerar um Clock de 1 Segundo com LM555 e ESP32?
LM555 e ESP32: duas maneiras diferentes de controlar o tempo. Enquanto o LM555 gera pulsos elétricos periódicos por meio de um circuito RC, o ESP32 utiliza seu Timer de hardware para executar operações em intervalos programados.

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

LM555 em Modo Astável: Aprenda a Gerar Pulsos de Clock de 1 Hz

Circuito eletrônico utilizando o CI LM555 configurado como oscilador astável para gerar um sinal de clock com frequência aproximada de 1 Hz. A montagem utiliza resistores de 10 kΩ e 68 kΩ, capacitor eletrolítico de 10 µF e capacitor de desacoplamento de 10 nF, alimentados com 5 V. O sinal de saída é obtido pelo pino 3 do LM555 e pode ser utilizado para acionar contadores digitais, como o CD4026.

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:

ComponenteValor
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

LM555 em Modo Astável: Entenda a Fórmula, os Resistores R1 e R2 e o Capacitor

Infográfico explicativo da fórmula de frequência do CI LM555 configurado no modo astável. A imagem apresenta a equação utilizada para calcular a frequência de oscilação, identifica os resistores R1 e R2 e o capacitor C, além de demonstrar por que o resistor R2 aparece multiplicado por dois. O exemplo utiliza R1 de 10 kΩ, R2 de 68 kΩ e capacitor de 10 µF, resultando em uma frequência aproximada de 0,986 Hz, correspondente a um período de aproximadamente 1,014 segundo.

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

Como Fazer um Contador de 0 a 9 com LM555 e CD4026 – Circuito Completo
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:

  1. O LM555 gera um pulso aproximadamente a cada segundo.

  2. O pulso chega à entrada CLOCK do CD4026.

  3. O CD4026 identifica a transição positiva do pulso e incrementa a contagem.

  4. O display apresenta o número correspondente.

  5. 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?

Como Ligar um Display de 7 Segmentos de Cátodo Comum ao ESP32 – Circuito Completo
Diagrama de ligação de um display de sete segmentos de cátodo comum ao ESP32 DevKit V1. O circuito utiliza sete resistores de 330 Ω para limitar a corrente dos segmentos A, B, C, D, E, F e G. Cada segmento é controlado individualmente por uma saída GPIO do ESP32, permitindo formar os números de 0 a 9 por meio de programação na Arduino IDE.

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âmetroSignificado
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á:

  1. O Timer de hardware é configurado para gerar um evento a cada segundo.

  2. Quando o intervalo termina, ocorre uma interrupção.

  3. A interrupção sinaliza que passou um segundo.

  4. O programa incrementa a variável do contador.

  5. O ESP32 atualiza os segmentos do display.

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

ESP32 - CONTADOR COM TIMER DE HARDWARE
INÍCIO DO CÓDIGO
/*
  ============================================================
  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
  }
}
FIM DO CÓDIGO


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ísticaLM555 + CD4026ESP32
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

Postagens mais visitadas deste blog

ESP32 + RoboEyes: Como Criar Olhos Animados para seu Robô com Display OLED

ESP-NOW com ESP32-C3 e ESP32: Comunicação Sem Wi-Fi na Prática

ESP32-C3 Super Mini: Características, Vantagens, Pinagem, Matter.