Interface Sete Segmento Display com Arduino Nano

Arduino Nano é 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 um nano microcontrolador Arduino, é possível controlar facilmente o estado de cada segmento em uma tela de sete segmentos, permitindo a criação de telas numéricas personalizadas e outros projetos interativos.

Este artigo abrange o seguinte conteúdo:

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

1: Introdução ao 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 Arduino para controlar uma tela de sete segmentos, o Arduino 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: pinagem de sete segmentos

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 estão conectados.

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

4: Como verificar um sete segmentos é 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 dos segmentos brilharem, 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-segmentos com Arduino Nano

Para interagir uma tela de sete segmentos com um Arduino Nano, você precisará dos seguintes materiais:

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

O Arduino Nano interfina 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 Arduino Nano será usado para enviar sinais para o monitor de sete segmentos, dizendo quais segmentos para ligar ou desligar.

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 Arduino Nano, a tela de sete segmentos deve começar a exibir os caracteres numéricos de acordo com o programa.

5.1: esquemático

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

Após a tabela de pinagem para a conexão Arduino Nano com uma única tela de sete segmentos:

Número do PIN	Nome do pino	Pin Arduino Nano
1	b	D3
2	a	D2
3	Com	GND/VCC depende da configuração - Catodo/ânodo comum
4	f	D7
5	g	D8
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	D6

5.2: hardware

Abaixo da imagem mostra o hardware do Arduino Nano 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 Arduino Nano 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 Arduino Nano

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

6.1: código

Abra o IDE e envie o código fornecido para Arduino Nano:

#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 [] = 2, 3, 4, 5, 6, 7, 8; /*Defina pinos digitais Arduino para sete segmentos*/
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); /*brilho de sete segmentos*/

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 que estamos usando com Arduino Nano. Os pinos de segmento de LED são definidos para as placas de nano Arduino. Mude o pino de acordo com o tipo de arduino nano que você está usando.

Qualquer um dos pinos digitais de nano Arduino pode ser usado. Em seguida, enquanto estamos usando o Ânodo comum Digite, 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 Arduino Nano

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 o Arduino Nano. Depois disso, envie o código de sete segmentos fornecido para Arduino Nano:

int segpins [] = 2, 3, 4, 5, 6, 7, 8;/*pino Arduino 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, definimos os pinos digitais para Arduino Nano, 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 no Void Loop () 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 nano microcontrolador Arduino é um processo simples que pode ser feito com alguns materiais básicos e um pouco de conhecimento de programação. Com um código Arduino Nano 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.