Como usar um microcontrolador para dirigir 7 gráficos de LED de segem.

No mundo dos eletrônicos, 7 gráficos de LED segmentos são um item básico para exibir informações numéricas e alfabéticas de maneira simples e eficiente. Como fornecedor de7 gráficos de led segement, Testemunhei a crescente demanda por esses componentes em várias aplicações, de relógios digitais simples a painéis de controle industrial complexos. Nesta postagem do blog, eu o guiarei através do processo de uso de um microcontrolador para conduzir 7 gráficos de LED de segmentos, cobrindo tudo, desde o básico dos 7 LEDs do segmento até os aspectos de programação.

Compreendendo 7 gráficos LED de segmento

Antes de mergulharmos nos detalhes de impulsionar os gráficos de 7 segmentos com um microcontrolador, é essencial entender como essas exibições funcionam. Uma tela de LED de 7 segmentos consiste em sete LEDs individuais organizados em um padrão específico para formar os dígitos 0 - 9 e algumas letras. Os segmentos são normalmente rotulados como A, B, C, D, E, F e G, e um segmento de ponto decimal adicional (DP) às vezes é incluído.

Existem dois tipos principais de 7 displays de LED de segmento: cátodo comum e ânodo comum. Em uma exibição de cátodo comum, todos os terminais do cátodo dos LEDs individuais são conectados e aterrados, enquanto em uma exibição comum de ânodo, todos os terminais do ânodo são conectados e fornecidos com uma tensão positiva. A escolha entre esses dois tipos depende do aplicativo específico e dos recursos de saída do microcontrolador.

Selecionando um microcontrolador

A primeira etapa na condução de 7 gráficos de LED do segmento é selecionar um microcontrolador apropriado. Existem inúmeros microcontroladores disponíveis no mercado, cada um com seu próprio conjunto de recursos e recursos. Algumas opções populares para dirigir 7 LEDs de segmento incluem o Arduino Uno, o Raspberry Pi Pico e o ATMEGA328P.

Ao selecionar um microcontrolador, considere os seguintes fatores:

Pinos de E/S.: Verifique se o microcontrolador possui pinos de saída digital suficientes para controlar todos os segmentos da tela LED de 7 segmentos. Para uma tela de um dígito, você precisará de pelo menos 7 pinos (ou 8 se incluir o ponto decimal).
Poder de processamento: Enquanto dirigir uma tela de LED de 7 segmentos não requer um microcontrolador de alto desempenho, ter poder de processamento suficiente pode ser benéfico se você planeja implementar recursos adicionais ou executar tarefas mais complexas.
Linguagem de programação: Escolha um microcontrolador que suporta uma linguagem de programação com a qual você esteja familiarizado. Por exemplo, o Arduino usa uma versão simplificada do C/C ++, que é fácil de aprender e usar para iniciantes.

Conexão do circuito

Depois de selecionar um microcontrolador, a próxima etapa é conectar a tela de 7 LED de segmento ao microcontrolador. As etapas a seguir descrevem o processo geral para conectar uma tela comum de LED de segmento de cátodo 7 a um Arduino Uno:

Identifique os pinos: Consulte a folha de dados da tela LED de 7 segmentos para identificar os pinos correspondentes a cada segmento (a - g e dp) e o pino de cátodo comum.
Conecte os segmentos: Conecte cada segmento (A - G e DP) a um pino de saída digital no Arduino UNO usando resistores apropriados para limitar a corrente que flui através dos LEDs. Um valor típico para o resistor é de cerca de 220 a 330 ohms.
Conecte o cátodo comum: Conecte o pino de cátodo comum da tela LED de 7 segmentos no pino do solo (GND) no Arduino Uno.

Aqui está um diagrama de circuito simples mostrando a conexão entre um Arduino UNO e um visor de LED comum do segmento de cátodo 7:

Arduino UNO 7 Segmento LED Exibir Pino digital 2 ------- Segmento Um pino digital 3 ------- Segmento B Pino digital 4 ------- Segmento C Pino digital 5 ------- segmento D Pino digital 6 ------- Segmento E Pino digital 7 ------- Segmento F Digital Pin 8 ----- Segmento G Digital Pin 9 ------- Decimal Point (DP) GND -----

Programando o microcontrolador

Depois de conectar o visor de 7 LED do segmento ao microcontrolador, a próxima etapa é escrever um programa para controlar a tela. A seguir, é apresentado um exemplo simples de um programa escrito no Arduino IDE para exibir os dígitos 0 - 9 em um visor comum do LED de segmento do cátodo 7:

// Defina os pinos conectados a cada segmento const int segmentpins [] = {2, 3, 4, 5, 6, 7, 8, 8, 9}; // Defina os padrões para cada dígito (0 - 9) const byte digitpatterns [] = {0B00111111, // 0 0B00000110, // 1 0B01011011, // 2 0B01001111, // 3 0B01110, // 401101101, 0B01111111, // 8 0B01101111 // 9}; void setup () {// Defina todos os pinos de segmento como saída para (int i = 0; i <8; i ++) {pinmode (segmentpins [i], saída); }} void loop () {// exibe cada dígito de 0 a 9 com um atraso de 1 segundo entre cada dígito para (int digit = 0; dígito <10; digit ++) {displayDigit (digit); atraso (1000); }} void DisplayDigit (int digit) {byte padrão = digitpatterns [dígito]; for (int i = 0; i <7; i ++) {digitalWrite (segmentpins [i], bitread (padrão, i)); } // Desligue o ponto decimal DigitalWrite (segmentpins [7], baixo); }

Neste programa, primeiro definimos os pinos conectados a cada segmento da tela de 7 LED do segmento e os padrões para cada dígito (0 - 9). Noconfigurar()função, definimos todos os pinos do segmento como saída. Nolaço()função, iteramos através de cada dígito de 0 a 9 e chamamos oDisplayDigit ()Função para exibir o dígito na tela LED de 7 segmentos. ODisplayDigit ()A função leva um número inteiro representando o dígito a ser exibido e define os pinos apropriados altos ou baixos com base no padrão de dígitos.

Dirigindo vários dígitos

Se você precisar exibir vários dígitos usando 7 Displays de LED de segmento, poderá usar uma técnica chamada multiplexação. A multiplexação envolve alternar rapidamente entre os dígitos em alta frequência, para que o olho humano perceba todos os dígitos como sendo iluminados simultaneamente.

Para implementar a multiplexação, você precisará usar pinos adicionais no microcontrolador para controlar o cátodo comum ou os pinos de ânodo de cada dígito. Por exemplo, se você quiser dirigir umLED de três dígitos de 7 segmentosExibir, você precisará de 3 pinos adicionais para controlar os pinos de cátodo ou ânodo comuns de cada dígito.

Aqui está uma versão modificada do programa anterior para conduzir um visor de LED de três dígitos do Common Cathode 7 Segment usando multiplexação:

// Defina os pinos conectados a cada segmento const int segmentpins [] = {2, 3, 4, 5, 6, 7, 8, 8, 9}; // Defina os pinos conectados ao cátodo comum de cada dígito const int digitpins [] = {10, 11, 12}; // Defina os padrões para cada dígito (0 - 9) const byte digitpatterns [] = {0B00111111, // 0 0B00000110, // 1 0B01011011, // 2 0B01001111, // 3 0B01110, // 401101101, 0B01111111, // 8 0B01101111 // 9}; void setup () {// Defina todos os pinos de segmento como saída para (int i = 0; i <8; i ++) {pinmode (segmentpins [i], saída); } // Defina todos os pinos de dígitos como saída para (int i = 0; i <3; i ++) {pinmode (digitpins [i], saída); }} void loop () {// exibe os dígitos 123 int digits [] = {1, 2, 3}; para (int digitIndex = 0; digitIndex <3; digitIndex ++) {DisplayDigit (dígitos [DigitIndex], DigitIndex); atraso (2); // ajuste o atraso para controlar a velocidade multiplexadora}} void DisplayDigit (int digit, int digitIndex) {// Desligue todos os dígitos para (int i = 0; i <3; i ++) {digitalWrite (digitpins [i], alto); } padrão de byte = digitpatterns [dígito]; for (int i = 0; i <7; i ++) {digitalWrite (segmentpins [i], bitread (padrão, i)); } // Desligue o ponto decimal DigitalWrite (segmentpins [7], baixo); // Ligue o Digit Digitwrite selecionado (Digitpins [DigitIndex], baixo); }

Neste programa, adicionamos uma variedade de pinos (Digitpin) para controlar os pinos cátodo comuns de cada dígito. Nolaço()função, iteramos através de cada dígito e chamamos oDisplayDigit ()função para exibir o dígito na posição de dígito correspondente. ODisplayDigit ()A função primeiro desliga todos os dígitos e, em seguida, define os pinos de segmento apropriados com base no padrão de dígitos e, finalmente, liga o dígito selecionado.

Conclusão

A condução de 7 gráficos LED de segmento usando um microcontrolador é um processo relativamente direto que pode ser facilmente realizado com os componentes corretos e as habilidades de programação. Seguindo as etapas descritas nesta postagem do blog, você poderá conectar uma tela LED de 7 segmentos a um microcontrolador e exibir informações numéricas.

Se você estiver interessado em comprar alta qualidade7 gráficos de led segement, Assim,LED de três dígitos de 7 segmentos, ouLED de quatro dígitos de 7 segmentosExibe, não hesite em entrar em contato conosco para obter mais informações e discutir seus requisitos específicos. Estamos comprometidos em fornecer aos nossos clientes os melhores produtos e serviços a preços competitivos.

Referências

Documentação do Arduino: https://www.arduino.cc/reference/en/
7 Faixas de dados de exibição LED de segmento: Sites de vários fabricantes