Contador Digital com CD4026 e ESP32: Aprenda a Contar de 0 a 9 com Display de 7 Segmentos
![]() |
Comparação entre o contador de décadas CD4026 e o ESP32, como realizar uma contagem de 0 a 9 utilizando um display de 7 segmentos de cátodo comum. Entenda a diferença entre contagem por hardware e por programação e conheça o conceito de contador e timer. |
Contador e Timer: Entenda a Diferença e Aprenda a Usar o CI CD4026 com Display de 7 Segmentos
Na eletrônica digital, encontramos circuitos capazes de contar eventos, medir intervalos de tempo e controlar dispositivos de acordo com determinadas condições. Entre essas funções, duas são muito importantes: o contador e o timer.
Embora estejam relacionados e possam trabalhar juntos, eles possuem funções diferentes.
Neste artigo, vamos entender a diferença entre contador e timer, conhecer o funcionamento do circuito integrado CD4026, um contador de décadas com decodificador para display de 7 segmentos, e aprender como funciona um display de cátodo comum.
Para tornar o aprendizado mais prático, vamos utilizar um circuito eletrônico capaz de realizar uma contagem de 0 a 9 utilizando um botão push button e um display de 7 segmentos.
1. Qual é a diferença entre contador e timer?
Antes de montar o circuito, precisamos compreender dois conceitos fundamentais da eletrônica digital.
O que é um contador?
Um contador é um circuito ou sistema responsável por registrar a quantidade de eventos que acontecem.
Por exemplo, imagine um botão conectado a um circuito eletrônico. Cada vez que pressionamos esse botão, geramos um pulso elétrico. O contador recebe esse pulso e incrementa seu valor em uma unidade.
Nesse exemplo, não importa se pressionamos o botão rapidamente ou se esperamos vários segundos entre uma pressão e outra. O contador registra os pulsos recebidos.
A principal pergunta de um contador é: quantas vezes determinado evento aconteceu?
O que é um timer?
O timer é um recurso utilizado para medir intervalos de tempo ou executar determinadas ações depois de um período definido.
Imagine um circuito que precisa executar uma ação a cada segundo. Nesse caso, podemos utilizar um timer para estabelecer esse intervalo.
Diferentemente do contador acionado por um botão, aqui a referência para executar a ação é a passagem do tempo.
A principal pergunta de um timer é: quanto tempo passou ou quando determinada ação deve acontecer?
Comparando contador e timer
| Contador | Timer |
|---|---|
| Conta eventos ou pulsos | Trabalha com intervalos de tempo |
| Pode contar pressionamentos de botão | Pode executar ações a cada segundo |
| Incrementa conforme recebe eventos | Utiliza uma referência temporal |
| Exemplo: contar peças | Exemplo: temporizar uma máquina |
É importante entender que um timer digital também pode utilizar circuitos contadores internamente. A diferença está na finalidade: contar eventos ou utilizar a contagem de ciclos de clock para controlar o tempo.
2. Conhecendo o CI CD4026
O CD4026 é um circuito integrado CMOS desenvolvido para realizar contagens decimais e controlar diretamente um display de 7 segmentos de cátodo comum.
Ele reúne duas funções importantes no mesmo componente:
Contador de décadas: realiza a contagem de 0 a 9.
Decodificador: transforma o valor contado nos sinais necessários para acionar os segmentos do display.
Isso significa que não precisamos utilizar um circuito integrado contador separado e outro decodificador para apresentar os números no display.
O próprio CD4026 executa essas duas funções.
O que significa contador de décadas?
Um contador de décadas é um circuito que trabalha com dez estados diferentes, representando os números de 0 a 9.
Quando recebe os pulsos de clock, sua contagem segue esta sequência:
0 → 1 → 2 → 3 → 4 → 5 → 6 → 7 → 8 → 9 → 0
Depois de chegar ao número 9, o próximo pulso faz o contador retornar ao zero, iniciando um novo ciclo.
Essa característica é muito utilizada em contadores digitais, relógios, temporizadores e equipamentos de medição.
Como o CD4026 realiza a contagem?
O funcionamento é relativamente simples.
O circuito integrado possui uma entrada chamada CLOCK. É nela que recebemos os pulsos responsáveis por avançar a contagem.
Cada pulso válido recebido na entrada CLOCK faz o contador avançar uma posição.
Por exemplo, quando pressionamos um botão conectado à entrada de clock, geramos um pulso elétrico que faz o número mudar no display.
Além da entrada de clock, o CD4026 possui outras funções importantes:
CLOCK: recebe os pulsos de contagem.
RESET: reinicia a contagem, retornando ao zero.
CLOCK INHIBIT: permite bloquear a contagem.
DISPLAY ENABLE IN: controla a habilitação das saídas do display.
CARRY OUT: fornece um sinal para encadear outro estágio de contagem.
O CD4026 também possui saídas próprias para controlar os segmentos A, B, C, D, E, F e G.
Assim, ele recebe o pulso, atualiza a contagem, decodifica o número e aciona o display automaticamente.
3. Como funciona um display de 7 segmentos?
O display de 7 segmentos é um componente eletrônico utilizado para representar números por meio de LEDs organizados em sete partes.
Cada parte recebe uma identificação por letra:
A: segmento superior.
B: segmento superior direito.
C: segmento inferior direito.
D: segmento inferior.
E: segmento inferior esquerdo.
F: segmento superior esquerdo.
G: segmento central.
Existe também um oitavo LED, chamado DP (Decimal Point), utilizado para representar o ponto decimal.
Combinando os sete segmentos, conseguimos formar os números de 0 a 9.
Por exemplo:
Número 0: acende A, B, C, D, E e F.
Número 1: acende B e C.
Número 2: acende A, B, D, E e G.
Número 3: acende A, B, C, D e G.
Número 8: acende todos os sete segmentos.
Cada número possui uma combinação específica de segmentos acesos e apagados.
4. Diferença entre display de cátodo comum e ânodo comum
Os displays de 7 segmentos são encontrados principalmente em duas versões: cátodo comum e ânodo comum.
A diferença está na maneira como os LEDs internos são conectados eletricamente.
Display de cátodo comum
No display de cátodo comum, os terminais negativos dos LEDs internos são conectados em comum.
Esses terminais comuns devem ser ligados ao GND (terra).
Para acender um segmento, aplicamos uma tensão positiva em seu respectivo terminal, respeitando a corrente adequada.
Nesse tipo de display:
Nível HIGH: acende o segmento.
Nível LOW: apaga o segmento.
Por isso, o CD4026 foi desenvolvido para trabalhar diretamente com displays de cátodo comum.
Display de ânodo comum
No display de ânodo comum, os terminais positivos dos LEDs internos são conectados em comum.
Esses terminais comuns devem ser ligados à alimentação positiva.
Para acender um segmento, precisamos aplicar nível baixo em seu terminal individual.
Nesse tipo de display:
Nível LOW: acende o segmento.
Nível HIGH: apaga o segmento.
Essa diferença é importante porque os circuitos de acionamento precisam ser compatíveis com o tipo de display utilizado.
5. Montando um contador de 0 a 9 com CD4026
Agora que entendemos os conceitos, podemos colocar a teoria em prática.
Nosso projeto utiliza o circuito integrado CD4026 para construir um contador digital capaz de apresentar os números de 0 a 9 em um display de 7 segmentos de cátodo comum.
Lista de componentes
1 CI CD4026.
1 display de 7 segmentos de cátodo comum.
1 capacitor eletrolítico de 10 µF.
2 botões push button.
7 resistores de 330 Ω.
2 resistores de 10 kΩ.
Protoboard.
Jumpers para as conexões.
Fonte de alimentação de 5 V.
Esquema elétrico
O circuito utiliza um botão para gerar os pulsos de clock e outro para reiniciar a contagem por meio da entrada RESET.
Os sete segmentos do display são conectados às respectivas saídas do CD4026, utilizando resistores de 330 Ω para limitar a corrente dos LEDs.
Os terminais de cátodo comum do display são conectados ao GND.
Como testar o circuito?
Depois de realizar as ligações, alimente o circuito e observe o display.
Ao pressionar o botão CLOCK, o número deverá avançar uma posição.
Continue pressionando e observe a sequência:
0, 1, 2, 3, 4, 5, 6, 7, 8 e 9.
Ao pressionar novamente, o display retornará ao número zero.
O segundo botão permite reiniciar a contagem utilizando a entrada RESET.
Observação: o botão deve gerar um pulso elétrico válido por acionamento. O uso de resistores de polarização e o tratamento do repique dos contatos ajudam a evitar contagens incorretas.
6. O que aprendemos com esse projeto?
Com a montagem do contador utilizando o CD4026, conseguimos compreender alguns conceitos fundamentais da eletrônica digital:
O que é um pulso de clock.
Como funciona um contador de décadas.
Como um circuito integrado armazena e atualiza uma contagem.
Como funciona a decodificação para um display de 7 segmentos.
A diferença entre displays de cátodo comum e ânodo comum.
Como utilizar botões para controlar a contagem e o reset.
O mais interessante é que podemos utilizar esse mesmo projeto como ponto de partida para aprender programação com microcontroladores.
7. E como fazer a mesma contagem utilizando ESP32?
O CD4026 realiza a contagem e o acionamento do display por meio de seus circuitos internos.
Mas será que conseguimos fazer a mesma coisa utilizando um ESP32?
Sim!
O ESP32 é um microcontrolador programável que pode executar essas mesmas funções por meio de software.
Em vez de utilizar um contador dedicado como o CD4026, podemos criar uma variável no programa para armazenar o número atual.
A cada pressão do botão, o ESP32 incrementa essa variável e utiliza suas saídas GPIO para acionar os segmentos correspondentes do display.
Como funciona o contador no programa?
CONTADOR 0 A 9 COM ESP32
INÍCIO DO CÓDIGO
/*
============================================================
Projeto: Contador de 0 a 9 com ESP32
Display: 7 segmentos de catodo comum
Funcao: Incrementar a contagem a cada pressao do botao
============================================================
*/
// -------------------- 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
const int BOTAO = 15; // Botao push button
// -------------------- VARIAVEIS -----------------------------
int contador = 0; // Valor atual: 0 a 9
int estadoAnterior = HIGH; // Estado anterior do botao
unsigned long tempoDebounce = 0; // Tempo do ultimo evento
const unsigned long DEBOUNCE = 50; // Filtro antirruido (ms)
// -------------------- 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
};
// -------------------- MOSTRAR NUMERO ------------------------
void mostrarNumero(int numero) {
for (int i = 0; i < 7; i++) {
digitalWrite(segmentos[i], numeros[numero][i]);
}
}
// -------------------- CONFIGURACAO --------------------------
void setup() {
for (int i = 0; i < 7; i++) {
pinMode(segmentos[i], OUTPUT); // Segmentos como saidas
}
pinMode(BOTAO, INPUT_PULLUP); // Botao ligado ao GND
mostrarNumero(contador); // Inicia mostrando zero
}
// -------------------- LOOP PRINCIPAL ------------------------
void loop() {
int estadoAtual = digitalRead(BOTAO); // Le o botao
if (estadoAtual != estadoAnterior) {
tempoDebounce = millis(); // Registra a mudanca
}
if ((millis() - tempoDebounce) > DEBOUNCE) {
static int estadoEstavel = HIGH; // Ultimo estado validado
if (estadoAtual != estadoEstavel) {
estadoEstavel = estadoAtual;
if (estadoEstavel == LOW) { // Botao pressionado
contador++; // Incrementa a contagem
if (contador > 9) {
contador = 0; // Volta para zero
}
mostrarNumero(contador); // Atualiza o display
}
}
}
estadoAnterior = estadoAtual; // Guarda o estado atual
}
FIM DO CÓDIGO
/*
============================================================
Projeto: Contador de 0 a 9 com ESP32
Display: 7 segmentos de catodo comum
Funcao: Incrementar a contagem a cada pressao do botao
============================================================
*/
// -------------------- 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
const int BOTAO = 15; // Botao push button
// -------------------- VARIAVEIS -----------------------------
int contador = 0; // Valor atual: 0 a 9
int estadoAnterior = HIGH; // Estado anterior do botao
unsigned long tempoDebounce = 0; // Tempo do ultimo evento
const unsigned long DEBOUNCE = 50; // Filtro antirruido (ms)
// -------------------- 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
};
// -------------------- MOSTRAR NUMERO ------------------------
void mostrarNumero(int numero) {
for (int i = 0; i < 7; i++) {
digitalWrite(segmentos[i], numeros[numero][i]);
}
}
// -------------------- CONFIGURACAO --------------------------
void setup() {
for (int i = 0; i < 7; i++) {
pinMode(segmentos[i], OUTPUT); // Segmentos como saidas
}
pinMode(BOTAO, INPUT_PULLUP); // Botao ligado ao GND
mostrarNumero(contador); // Inicia mostrando zero
}
// -------------------- LOOP PRINCIPAL ------------------------
void loop() {
int estadoAtual = digitalRead(BOTAO); // Le o botao
if (estadoAtual != estadoAnterior) {
tempoDebounce = millis(); // Registra a mudanca
}
if ((millis() - tempoDebounce) > DEBOUNCE) {
static int estadoEstavel = HIGH; // Ultimo estado validado
if (estadoAtual != estadoEstavel) {
estadoEstavel = estadoAtual;
if (estadoEstavel == LOW) { // Botao pressionado
contador++; // Incrementa a contagem
if (contador > 9) {
contador = 0; // Volta para zero
}
mostrarNumero(contador); // Atualiza o display
}
}
}
estadoAnterior = estadoAtual; // Guarda o estado atual
}
Para entender melhor, vamos observar algumas das partes mais importantes do código utilizado no projeto.
1. A variável que armazena a contagem
int contador = 0; // Valor inicial da contagemA variável contador é responsável por armazenar o número atual. Inicialmente, ela recebe o valor zero.
2. A leitura do botão
pinMode(BOTAO, INPUT_PULLUP); // Configura o botão com pull-up internoO ESP32 utiliza o resistor interno de pull-up. Quando o botão não está pressionado, a entrada permanece em nível HIGH. Quando pressionamos o botão, o sinal vai para LOW.
O programa identifica essa mudança para reconhecer o acionamento.
3. Incrementando a contagem
contador++; // Soma uma unidadeEssa é uma das instruções mais importantes do contador. Cada vez que o programa reconhece uma pressão válida do botão, acrescenta uma unidade à variável.
4. Retornando ao zero
if (contador > 9) {
contador = 0; // Reinicia a contagem
}Quando o valor ultrapassa 9, o programa retorna a variável para zero, reproduzindo o funcionamento de um contador de décadas.
5. Mostrando o número no display
mostrarNumero(contador); // Atualiza os segmentosEssa função consulta uma tabela que informa quais segmentos devem acender para representar o número armazenado na variável.
Por exemplo, para mostrar o número 1, o programa aciona os segmentos B e C. Para mostrar o número 8, aciona todos os sete segmentos.
Qual é a diferença entre o CD4026 e o ESP32?
No CD4026, a contagem e a decodificação são realizadas pelos circuitos internos do próprio componente.
No ESP32, precisamos programar essas funções utilizando variáveis, condições, tabelas e saídas GPIO.
O resultado é o mesmo: conseguimos contar de 0 a 9 e apresentar os números no display.
A diferença está na maneira como cada dispositivo executa o trabalho.
Essa comparação ajuda a compreender como um microcontrolador pode substituir circuitos dedicados em determinadas aplicações, oferecendo também a possibilidade de realizar outras tarefas no mesmo projeto.
Conclusão
Contadores e timers são recursos fundamentais da eletrônica digital e estão presentes em diversos equipamentos que utilizamos diariamente.
Neste projeto, conhecemos o funcionamento do CD4026, um contador de décadas capaz de realizar a contagem de 0 a 9 e controlar diretamente um display de 7 segmentos de cátodo comum.
Também entendemos como os segmentos são organizados e como a diferença entre cátodo comum e ânodo comum influencia o acionamento dos LEDs.
A partir desse conhecimento, podemos avançar para os microcontroladores e descobrir como o ESP32 consegue executar a mesma contagem por programação.
No próximo passo, vamos explorar como o ESP32 pode realizar uma contagem automática a cada segundo e conhecer melhor os recursos utilizados para controlar intervalos de tempo.
Continue acompanhando os projetos e tutoriais do RodRobot!
🔧 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