Como interface 7 segmento exibir com arduino uno
Interface os 7 segmentos com Arduino Uno
Pelo nome, podemos dizer que essa tela é dividida nos sete segmentos usados para exibir os dados numéricos do código Arduino. Esta tela é de tamanho pequeno e também podemos combinar dois ou mais telas se grandes dados numéricos forem exibidos. Essa tela é viável nos projetos como a construção de um cronômetro de contagem regressiva, exibindo a temperatura, o número de visitantes ou exibindo os números de token no banco ou nos hospitais.
Demos a imagem da tela de sete sete abaixo, a partir da qual você pode ter uma idéia mais clara do que é uma tela de sete segmentos e também, demos o esquema da tela de sete segmentos.
Este segmento vem em duas configurações, cátodo comum ou ânodo comum e há um total de 10 pinos do módulo sete dos quais são para cada segmento da tela. Enquanto os dois pinos são ânodo ou cátodo e podemos usar qualquer um deles. Há um pino para o ponto presente no canto inferior direito da tela que é útil quando o valor que está decimal deve ser exibido.
Os pinos da tela são tirados na ordem alfabética a partir de a para g E fornecemos a imagem abaixo que mostra a configuração do pino da tela:
| Pino não. | Nome (começando no canto superior direito) | Descrição |
|---|---|---|
| 1 | b | PIN para controlar o LED superior direito |
| 2 | a | PIN para controlar o LED mais alto |
| 3 | VCC ou GND | Pente |
| 4 | f | PIN para controlar o LED superior esquerdo |
| 5 | g | PIN para controlar o LED do meio |
| 6 | dp | PIN para controlar o LED do ponto no canto inferior direito |
| 7 | c | PIN para controlar o LED inferior direito |
| 8 | VCC ou GND | Pente |
| 9 | d | PIN para controlar o LED inferior |
| 10 | e | PIN para controlar o LED inferior esquerdo |
Para interface a tela de sete segmentos com Arduino, criamos um circuito cujo esquema é dado abaixo:
No esquema, usamos o sete segmentos com um ânodo comum, você também pode usar a outra configuração.
Conjunto de hardware para interface sete-segmentos com Arduino Uno
Para montar o hardware para conectar o sete segmentos com o Arduino, usamos os seguintes componentes
- Arduino Uno
- Conectando fios
- Pão de pão
- Display de sete segmentos (com ânodo ou cátodo comum)
- Sete resistores de 220 ohm
Fornecemos a imagem abaixo para o conjunto de hardware da interface do sete segmentos com Arduino para dar um pouco mais de detalhes das conexões:
Nós conectamos a tela de sete segmentos com Arduino começando de a e indo para g. Para distinguir as conexões superior e inferior, usamos cores diferentes para os pinos na parte superior e abaixo. Os fios de cores verdes conectam os pinos superiores dos sete segmentos, enquanto os pinos inferiores são conectados ao Arduino usando os pinos marrons.
Como instalar a biblioteca para exibição de sete segmentos no Arduino IDE
Para entender como podemos instalar a biblioteca do sete segmentos, fornecemos a imagem abaixo, que mostra o processo de instalação da biblioteca de sete segmentos:
- Para instalar a biblioteca, temos que abrir o gerente da biblioteca do Arduino IDE, clicando na caixa destacada na figura acima, tendo uma escrita nela.
- Depois de abrir o gerente da biblioteca Tipo sete-segmentos na barra de pesquisa do gerente da biblioteca e então você encontrará uma longa lista de bibliotecas para sete segmentos.
- Na lista primeiro, você deve encontrar a biblioteca Sevseg da Reading Reading.
- Depois de encontrar a biblioteca específica, você deve clicar no ícone de instalação destacado em vermelho, tendo 4 escritos nela e este ícone aparecerá à medida que você move o cursor para baixo.
Assim que você clicar na instalação, a biblioteca começará a instalar e você verá um ícone de instalação aparecerá em frente ao nome da biblioteca e o status de instalação também aparecerá no menu de saída do IDE. Pode ser visto na imagem que postamos abaixo:
Código Arduino para interface o sete segmentos com Arduino Uno usando a Biblioteca Sevseg
O sete segmentos pode ser interfocado com Arduino Uno de duas maneiras: uma usando a biblioteca específica para o segmento Sete e a segunda é dar binários para cada dígito que queremos exibir no segmento
Abaixo, demos o código de que podemos interface o sete segmentos usando sua biblioteca
#include "Sevseg.h "// Definindo a biblioteca para o sete segmentos
Sevseg sevseg; // inicializando a variável para sete segmentos
configuração void ()
BYTE SEVENSEGMENTS = 1;/ *Definindo o número de sete segmentos aqui estamos usando apenas um sete segmentos */
Byte Commonpins [] = ;/* Definindo os pinos comuns para o sete segmentos*/
byte ledsegmentpins [] = 2, 3, 4, 5, 6, 7, 8;/ * atribuindo os pinos Arduino para cada segmento de A a G */
BOOL ResistorSonsegments = true; /*atribuindo tipo booleano aos registros do sete = segmento*/
Sevseg.BEGIN (Common_anode, Sevensegments, Commonpins, LedsegmentPins, ResistorSonsegments);/ * Inicializando a configuração do sete segmentos */
Sevseg.setbrightness (80); // dando o brilho ao sete segmentos
Void Loop ()
para (int i = 0; i < 10; i++)/* generating numbers from 0 to 9 using for loop*/
Sevseg.setNumber (i); /*Exibindo os valores de loop for em sete-segmento*/
Sevseg.refreshDisplay (); / * Refrescando a tela de sete segmentos após cada iteração */
atraso (1000); /* tempo após o qual o loop for itera novamente*/
Usando a biblioteca para sete segmentos, executamos o código Arduino primeiro, definindo a biblioteca do segmento e definindo a respectiva variável usada para usar funções do sete segmentos.
Em seguida, definimos o número de segmentos que estamos usando e depois usamos o Sevseg.começar() Função para definir a configuração da tela de sete segmentos. Aqui no código, usamos a configuração comum do ânodo do sete segmentos.
Para fins de demonstração, geramos os números de 0 a 9 usando o loop for na seção de loop do código Arduino e para exibir os números no sete segmentos, usamos o Sevseg.setNumber () função.
Código Arduino para interface sete-segmento sem biblioteca
Para dar a idéia de como podemos interface o sete segmentos sem usar qualquer biblioteca, temos o respectivo código abaixo:
int segpins [] = 2, 3, 4, 5, 6, 7, 8;/*Atribuindo pinos de Arduino para o sete segmentos*/
byte segcode [10] [7] = /*declarando uma matriz do número de 0 a 9 na ordem de a de g* /
//ABCDEFG
0, 0, 0, 0, 0, 0, 1, // para exibir 0
1, 0, 0, 1, 1, 1, 1, // para exibir 1
0, 0, 1, 0, 0, 1, 0, // para exibir 2
0, 0, 0, 0, 1, 1, 0, // para exibir 3
1, 0, 0, 1, 1, 0, 0, // para exibir 4
0, 1, 0, 0, 1, 0, 0,, // para exibir 5
0, 1, 0, 0, 0, 0, 0, // para exibir 6
0, 0, 0, 1, 1, 1, 1, // para exibir 7
0, 0, 0, 0, 0, 0, 0, // para exibir 8
0, 0, 0, 0, 1, 0, 0, // para exibir 9
;
void DisplayDigit (int dígito) /*Criando uma função para inicializar o segmento de cada exibição* /
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++) // assigning the OUTPUT mode to all the 7 seven-segments*/
pinmode (segpins [a], saída);
Void Loop ()
para (int b = 0; b < 10; b++)/* generating numbers from 0 to 9 */
displayDigit (b);/*exibindo os números gerados*/
atraso (1000);
No código acima, usamos o sete segmentos com ânodo comum, mas se você quiser interagir o sete segmentos com cátodo comum, podemos simplesmente inverter os binários.
Para resumir o código que compilamos, podemos dizer que primeiro definimos os binários para cada número e depois criamos a função de exibição que retornará o dígito no sete segmentos usando os binários declarados acima.
Próximo na seção de configuração do código que atribuímos todos os sete segmentos para trabalhar no modo de saída. Depois disso, na seção Loop, usamos o loop for para gerar os números e depois usar o DisplayDigit () Função declarada acima, exibimos os números nos sete segmentos.
Implementação de hardware da interface dos sete segmentos com Arduino Uno
Para dar a melhor idéia de interface o sete segmentos com o Arduino, implementamos o conjunto de hardware descrito acima e fornecemos a figura para a implementação de hardware que é dada abaixo:
Para demonstrar o funcionamento do código Arduino, compilado para interface o sete segmentos com o Arduino é dado abaixo:
Conclusão
Para exibir os parâmetros do programa Arduino, precisamos interface qualquer exibição com a placa Arduino. No mercado, há uma grande variedade de exibições disponíveis que podem ser interface com Arduino, mas depende do tipo e quantidade de dados que devem ser exibidos. Para uma quantidade limitada de dados e apenas para exibir os números, podemos usar a tela de sete segmentos, pois eles são fáceis de trabalhar. Então, interfiguramos a tela de sete segmentos com o Arduino Uno neste guia.