Interface Sete Segment Display com o ESPPOP 10 usando Arduino IDE

O ESP32 é uma popular plataforma eletrônica de código aberto que pode ser usado para controlar e interagir com uma ampla variedade de dispositivos eletrônicos, incluindo displays de sete segmentos. Ao usar o microcontrolador ESP32, é possível controlar facilmente o estado de cada segmento em uma tela de sete segmentos, permitindo a criação de displays numéricos personalizados e outros projetos interativos.

Este artigo abrange o seguinte conteúdo:

• 1: Introdução a sete segmentos
• 2: sete pinagem de segmento
• 3: Tipos de sete segmentos
• 4: Como verificar um segmento de sete é um ânodo comum ou cátodo comum
• 5: interface sete segmento com esp32
• 5.1: esquemático
• 5.2: hardware
• 5.3: Instalando a biblioteca necessária
• 6: Controle sete segmentos usando a biblioteca com ESP32
• 6.1: código
• 6.2: saída
• 7: Controle sete segmentos sem usar a biblioteca ESP32
• 7.1: código
• 7.2: saída

1: Introdução a sete segmentos

Um sete segmentos pode exibir informações numéricas usando um programa de microcontrolador. Consiste em sete segmentos individuais, cada um dos quais pode ser iluminado ou desligado de forma independente para criar vários caracteres numéricos.

Uma tela de sete segmentos funciona iluminando diferentes combinações de seus sete segmentos para exibir caracteres numéricos. Cada segmento é controlado por um pino individual, que pode ser ligado ou desligado para criar o caráter numérico desejado. Quando os segmentos são iluminados na combinação correta, o caráter numérico é visível para o espectador.

Ao usar um microcontrolador ESP32 para controlar uma tela de sete segmentos, o ESP32 envia sinais para os pinos específicos na tela de sete segmentos, dizendo quais segmentos ligarem ou desligam para exibir um caractere numérico específico.

Isso é feito escrevendo um programa no Arduino IDE (Integrated Development Environment) usando a linguagem de programação C ++. O programa utiliza a biblioteca Arduino para controlar o estado de cada segmento com comandos simples. O programa também pode ser configurado para exibir diferentes caracteres numéricos com base na entrada de sensores ou interação do usuário.

2: sete pinagem de segmento

A tela de sete segmentos normalmente tem 10 pinos, com um pino para cada segmento, um para os pinos decimais e dois comuns. Aqui está uma tabela da pinagem típica:

Número do PIN	Nome do pino	Descrição
1	b	Pino de LED superior direito
2	a	Pino de LED mais alto
3	VCC/GND	GND/VCC depende da configuração - Catodo/ânodo comum
4	f	Pino de LED superior esquerdo
5	g	Pino do LED do meio
6	dp	Pino de LED do ponto
7	c	Pino LED inferior direito
8	VCC/GND	GND/VCC depende da configuração - Catodo/ânodo comum
9	d	Pino de LED inferior
10	e	Pino de LED inferior esquerdo

Cada segmento é rotulado como A, B, C, D, E, F e G. O pino comum é normalmente usado para controlar todos os segmentos de uma só vez. O pino comum é baixo ativo ou ativo, dependendo da tela.

3: Tipos de sete segmentos

Existem dois tipos principais de telas de sete segmentos:

• Cátodo comum
• Ânodo comum.

1: em um Cátodo comum exibição, todos os terminais negativos dos segmentos de LED são conectados juntos.

2: em um ânodo comum exibição, todos os terminais positivos dos segmentos de LED estão conectados.

4: Como verificar um segmento de sete é um ânodo comum ou cátodo comum

Para verificar o tipo de sete segmentos, apenas precisamos de uma ferramenta simples - Multímetro. Siga as etapas para verificar o tipo de tela de sete segmentos:

1. Segure a exibição de sete sete em mãos e identifique Pino 1 Usando o pinout explicado acima.
2. Pegue um multímetro. Assuma o chumbo vermelho para positivo (+) e chumbo preto do multímetro para negativo (-).
3. Defina o Teste de Multímetro para Continuidade.
4. Após esse cheque, o funcionamento do medidor pode ser verificado tocando tocando em leads positivos e negativos. Um som de bipe será produzido se o medidor estiver funcionando corretamente. Caso contrário, substitua as baterias no seu multímetro por uma nova.
5. Coloque o chumbo preto no pino 3 ou 8 do multímetro. Ambos esses pinos são comuns e conectados internamente. Selecione qualquer pino.
6. Agora coloque o chumbo vermelho ou positivo do multímetro em outros pinos de sete segmentos, como 1 ou 5.
7. Depois de tocar a sonda vermelha se algum segmento brilhar, a tela é um Cátodo comum.
8. Trocar os leads multímetro se nenhum segmento brilhar.
9. Agora conecte o chumbo vermelho ao pino 3 ou 8.
10. Depois disso, colocou o chumbo preto ou negativo nos pinos restantes da tela. Agora, se algum brilho do segmento, sua tela é um ânodo comum, Como no ânodo comum, o pino positivo é comum e o restante é conectado a uma oferta negativa.
11. Repita as etapas para verificar todos os outros segmentos de exibição um por um.
12. Se algum dos segmentos não brilhar, estará com defeito.

Aqui está uma imagem de referência para um teste de sete segmentos usando um Multímetro. Podemos ver que o chumbo vermelho está no pino 8 e o preto está no pino de segmento, então estamos usando Ânodo comum sete segmentos:

5: interface sete segmento com esp32

Para interface uma tela de sete segmentos com um ESP32, você precisará dos seguintes materiais:

• Um microcontrolador ESP32
• Uma tela de sete segmentos
• Uma placa de pão
• Fios de jumper

Esp32 interfaces com exibições de sete segmentos em várias etapas simples.

1: Primeiro, conecte a tela de sete sete à placa de ensaio.

2: Em seguida, conecte o Arduino Nano com uma tela de sete segmentos usando fios. O ESP32 será usado para enviar sinais para a tela de sete segmentos, dizendo quais segmentos ligar ou desativar.

3: Agora escreva um código Arduino no IDE. O programa precisará enviar sinais para os pinos específicos na tela de sete segmentos, dizendo quais segmentos ligar ou desligar para exibir um caractere numérico específico.

4: O Arduino IDE fornece uma biblioteca usando que podemos controlar facilmente o estado de cada segmento com comandos simples.

5: Depois que o programa é escrito e enviado para o ESP32, a tela de sete segmentos deve começar a exibir os caracteres numéricos, conforme o programa.

5.1: esquemático

Para programar sete-segmentos primeiro, precisamos projetar o circuito e conectá-lo ao ESP32. Usando o esquema de referência abaixo conecta sua placa ESP32 com uma tela de sete segmentos.

Seguindo a tabela de pinagem para a conexão ESP32 com uma única tela de sete segmentos:

Número do PIN	Nome do pino	PIN ESP32
1	b	D2
2	a	D15
3	Com	GND/VCC depende da configuração - Catodo/ânodo comum
4	f	D19
5	g	D21
6	dp	Pino de LED do ponto
7	c	D4
8	Com	GND/VCC depende da configuração - Catodo/ânodo comum
9	d	D5
10	e	D18

5.2: hardware

Abaixo da imagem mostra o hardware do ESP32 e sete segmentos:

5.3: Instalando a biblioteca necessária

Depois de conectar sete-segmentos, precisamos instalar uma biblioteca no Arduino IDE. Usando esta biblioteca, podemos programar facilmente o ESP32 com sete segmentos.

Vá para o gerente de biblioteca pesquise Sevseg biblioteca e instale -a no Arduino IDE.

6: Controle sete segmentos usando a biblioteca com ESP32

Depois de instalar a biblioteca, escreveremos um código Arduino usando a mesma biblioteca.

6.1: código

Abra o IDE e o upload de código dado para ESP32:

#include "Sevseg.H " /*Incluída Biblioteca de sete segmentos* /
Sevseg Sevseg; /*Crie uma biblioteca de sete segmentos*/
configuração void ()

byte Sevensegments = 1; /*Número de sete-segmentos conectados*/
byte Commonpins [] = ; /*Defina o pino comum de sete segmentos*/
byte ledsegmentpins [] = 15, 2, 4, 5, 18, 19, 21; /*Defina pinos digitais Esp32 para sete-segmento*/
BOOL ResistorSonsegments = true; /*atribuindo tipo booleano aos registros do sete = segmento*/
Sevseg.BEGIN (Common_anode, Sevensegments, Commonpins, LedsegmentPins, ResistorSonsegments);/ *Configuração de sete-segmento */
Sevseg.Setbrightness (80); /*Sete brilho do segmento*/

Void Loop ()

para (int i = 0; i < 10; i++) /*Display number from 0 to 9 using for loop*/

Sevseg.setNumber (i);
Sevseg.refreshDisplay (); /*Atualize a exibição de sete segmentos após cada iteração*/
atraso (1000); /*Atraso de tempo para iteração de loop*/

O código começou ligando para o Sevseg biblioteca. Depois disso, definimos o número de segmentos, estamos usando com ESP32. Os pinos de segmento de LED são definidos para placas ESP32. Altere o pino de acordo com o tipo de ESP32 que você está usando.

Qualquer um dos pinos digitais esp32 pode ser usado.

Em seguida, enquanto estamos usando o tipo de ânodo comum, então o definimos dentro do código.

No caso de cátodo comum, substitua -o pelo código abaixo:

Finalmente a para O loop é usado que exibirá dígitos de 0 a 9 e atualiza a tela sempre que um número for mostrado:

6.2: saída

Podemos ver sete-segmentos exibindo números a partir de 0 a 9:

7: Controle sete segmentos sem usar a biblioteca com ESP32

Para controlar sete-segmentos sem nenhuma biblioteca, precisamos definir manualmente os números dentro do código Arduino em sua representação binária.

7.1: código

Abra o IDE e conecte Esp32. Depois disso, envie o código de sete segmentos fornecido para ESP32:

int segpins [] = 15, 2, 4, 5, 18, 19, 21;/*esp32 pino para sete segmentos*/
byte segcode [10] [7] = /*array do número 0-9 em ordem de a de g* /
//ABCDEFG
0, 0, 0, 0, 0, 0, 1, /*Exibir 0* /
1, 0, 0, 1, 1, 1, 1, /*Exibir 1* /
0, 0, 1, 0, 0, 1, 0, /*Exibir 2* /
0, 0, 0, 0, 1, 1, 0, /*Exibir 3* /
1, 0, 0, 1, 1, 0, 0, /*Exibir 4* /
0, 1, 0, 0, 1, 0, 0,, /*Exibir 5* /
0, 1, 0, 0, 0, 0, 0, /*Exibir 6* /
0, 0, 0, 1, 1, 1, 1, /*Exibir 7* /
0, 0, 0, 0, 0, 0, 0, /*Exibir 8* /
0, 0, 0, 0, 1, 0, 0, /*Exibir 9* /
;
void DisplayDigit (int digit) /*Função para inicializar cada segmento* /

para (int a = 0; a < 7; a++)

DigitalWrite (Segpins [A], Segcode [Digit] [a]);/ * Instruindo os respectivos segmentos para os números de 0 a 9 */


configuração void ()

para (int a = 0; a < 7; a++) // for loop for setting the pins as output*/

pinmode (segpins [a], saída);


Void Loop ()

para (int b = 0; b < 10; b++)/* generating numbers from 0 to 9 */

displayDigit (b);/*Exibir os números gerados*/
atraso (1000);

No código acima primeiro, definimos os pinos digitais para ESP32, onde sete segmentos serão conectados. Uma matriz é inicializada para definir o número de 0 a 9.

Em seguida, dentro da matriz, todos os 10 dígitos a partir de 0 a 9 são definidos em sua representação binária.

Próximo em configuração void () A parte A para loop é definida. Isso para loop com a ajuda de pinmode Função define os pinos de sete segmentos como saída.

Finalmente em Void laço() função Outra para o loop é definida que gerará um número de 0 a 9 sempre que o programa é executado.

7.2: saída

Aqui podemos ver todos os números definidos dentro do código usando seu equivalente binário são exibidos em sete segmentos:

Conclusão

Em conclusão, a interface de uma tela de sete segmentos com um microcontrolador ESP32 é um processo simples que pode ser feito com alguns materiais básicos e um pouco de conhecimento de programação. Com um código ESP32 e Arduino, você pode controlar facilmente o estado de cada segmento em uma tela de sete segmentos, permitindo a criação de displays numéricos personalizados e outros projetos interativos.