Interface de exibição de 7 segmentos com microcontrolador de imagem

Este é o nosso 8º tutorial de como aprender microcontroladores PIC usando MPLAB e XC8. Percorremos todo o caminho desde a instalação do MPLABX até o uso de um LCD com PIC MCU. Se você é novo aqui, então veja os tutoriais anteriores onde você pode aprender cronômetros, LED piscando, interface de LCD etc. Você pode encontrar todos os nossos tutoriais PIC aqui. Em nosso último tutorial, vimos como podemos gerar caracteres personalizados com nosso display LCD 16 * 2, agora vamos nos equipar com outro tipo de módulo de display chamado display de 7 segmentos e fazer a interface com o microcontrolador PIC.

Embora o LCD 16x2 seja muito mais confortável do que a tela de 7 segmentos, existem poucos cenários em que uma tela de 7 segmentos seria mais prática do que uma tela LCD. O LCD tem a desvantagem de ter um tamanho pequeno de caracteres e será um exagero para o seu projeto se você estiver planejando apenas exibir alguns valores numéricos. 7 segmentos também têm a vantagem contra condições precárias de iluminação e podem ser vistos de ângulos maiores do que uma tela LCD normal. Então, vamos começar a conhecê-lo.

Módulo de exibição de 7 segmentos e 4 dígitos e 7 segmentos:

O display de 7 segmentos tem sete segmentos e cada segmento tem um LED dentro dele para exibir os números iluminando os segmentos correspondentes. Por exemplo, se você quiser que o segmento de 7 exiba o número "5", então você precisa iluminar o segmento a, f, g, c e d aumentando seus pinos correspondentes. Existem dois tipos de visores de 7 segmentos: cátodo comum e ânodo comum, aqui estamos usando o visor de cátodo comum de sete segmentos. Saiba mais sobre o display de 7 segmentos aqui.

Agora sabemos como exibir nosso caractere numérico desejado em um único display de 7 segmentos. Porém, é bastante evidente que precisaríamos de mais de um display de 7 segmentos para transmitir qualquer informação com mais de um dígito. Portanto, neste tutorial, usaremos um módulo de exibição de 7 segmentos de 4 dígitos, conforme mostrado abaixo.

Como podemos ver, existem quatro monitores de sete segmentos conectados entre si. Sabemos que cada módulo de 7 segmentos terá 10 pinos e para 4 visores de sete segmentos haveria 40 pinos no total e seria agitado para qualquer pessoa soldá-los em um quadro de pontos, então eu recomendo fortemente que qualquer pessoa compre um módulo ou faça seu próprio PCB para usar um display de 7 segmentos de 4 dígitos. O esquema de conexão para o mesmo é mostrado abaixo:

Para entender como o módulo de sete segmentos de 4 dígitos funciona, temos que olhar para os esquemas acima, como mostrado, os pinos A de todos os quatro monitores são conectados para reunir como um A e o mesmo para B, C…. até DP. Então, basicamente, se o gatilho A estiver ativado, todos os quatro A's devem ser altos, certo?

Mas isso não acontece. Temos quatro pinos adicionais de D0 a D3 (D0, D1, D2 e ​​D3) que podem ser usados ​​para controlar qual display dos quatro deve ficar alto. Por exemplo: Se eu precisar que minha saída esteja presente apenas no segundo display, então apenas D1 deve ser alto, enquanto os outros pinos (D0, D2 e ​​D3) estão baixos. Simplesmente podemos selecionar qual display deve ficar ativo usando os pinos de D0 a D3 e qual caractere ser exibido usando os pinos de A a DP.

Conectando o Módulo de Sete Segmentos de 4 Dígitos com Microcontrolador PIC:

Aqui, usamos o microcontrolador PIC PIC16F877A e o esquema do circuito é mostrado abaixo.

Temos 12 pinos de saída do módulo, dos quais 8 são usados ​​para exibir os caracteres e quatro são usados ​​para selecionar um entre quatro. Portanto, todos os pinos de 8 caracteres são atribuídos ao PORTD e os pinos de seleção de exibição são atribuídos aos primeiros quatro pinos do PORTC.

Nota: O pino de aterramento do módulo também deve ser conectado ao aterramento do MCU, que não é mostrado aqui.

Programação usando PIC16F877A:

Agora que sabemos como este módulo realmente funciona, vamos aprender como programar PIC16F877A para fazê-lo exibir um número de 4 dígitos. Vamos incrementar uma variável de 0 a 1000 e imprimi-la no display de 7 segmentos. Inicie o programa MPLABX e crie um novo projeto, vamos começar com os bits de configuração.

#pragma config FOSC = HS // Bits de seleção do oscilador (oscilador HS) #pragma config WDTE = OFF // Bit de ativação do temporizador Watchdog (WDT desativado) #pragma config PWRTE = ON // Bit de ativação do temporizador de inicialização (PWRT ativado) # pragma config BOREN = LIGADO // Bit de habilitação de redefinição de Brown-out (BOR habilitado) #pragma config LVP = DESLIGADO // Bit de habilitação de programação serial de baixa tensão (fonte única) (RB3 é E / S digital, HV ligado MCLR deve ser usado para programação) #pragma config CPD = OFF // Bit de proteção de código de memória EEPROM de dados (proteção de código EEPROM de dados desativada) #pragma config WRT = OFF // Flash de memória de programa habilitar bits de habilitação (proteção de gravação desativada; toda a memória de programa pode ser escrito pelo controle EECON) #pragma config CP = OFF // Flash Program Memory Code Protection bit (Code protection off)

Como de costume, usamos a janela definir bits de configuração para definir esses bits. Se você não tem certeza do que eles significam, visite o tutorial de LED piscando aqui.

A seguir, vamos definir os pinos de saída para alternar entre cada dígito do display.

// *** Definir os pinos de sinal de todos os quatro monitores *** // #define s1 RC0 #define s2 RC1 #define s3 RC2 #define s4 RC3 // *** Fim da definição ** ////

Aqui, os pinos RC0, RC1, RC2 e RC3 são usados ​​para selecionar entre os quatro dígitos do nosso módulo de display de 7 segmentos. Esses pinos são definidos como s1, s2, s3 e s4 respectivamente.

A seguir, vamos pular para void main (), dentro do qual temos a seguinte declaração de variável:

int i = 0; // o valor de 4 dígitos que deve ser exibido int flag = 0; // para criar atraso sem sinal int a, b, c, d, e, f, g, h; // apenas variáveis ​​sem sinal int seg = {0X3F, // Valor hexadecimal para exibir o número 0 0X06, // Valor hexadecimal para exibir o número 1 0X5B, // Valor hexadecimal para exibir o número 2 0X4F, // Valor hexadecimal para exibir o número 3 0X66, // valor hexadecimal para exibir o número 4 0X6D, // valor hexadecimal para exibir o número 5 0X7C, // valor hexadecimal para exibir o número 6 0X07, // valor hexadecimal para exibir o número 7 0X7F, / / Valor hexadecimal para exibir o número 8 0X6F // valor hexadecimal para exibir o número 9}; // Fim da matriz para exibir números de 0 a 9

Aqui as variáveis i e bandeira são usados para armazenar os valores a serem exibidos e criando um atraso respectivamente. As variáveis ​​inteiras não assinadas a até h são usadas para quebrar os números de quatro dígitos em dígitos únicos e armazená-los (o que será explicado mais tarde aqui).

Uma coisa importante a se observar aqui é a declaração do array "seg" . Neste programa, estamos usando um novo tipo de dados chamado Array. Array nada mais é que uma coleção de valores de tipo de dados semelhantes. Aqui, usamos esta matriz para armazenar todos os valores hexadecimais equivalentes para exibir um número de 0 a 9.

O endereço da matriz sempre começa do zero. Portanto, este array terá o valor hexadecimal de um número numérico (0-9) armazenado no endereço que é o mesmo do número mostrado abaixo

Variável:	seg	seg	seg	seg	seg	seg	seg	seg	seg	seg
Código Hex:	0X3F	0X06	0X5B	0X4F	0X66	0X6D	0X7C	0X07	0X7F	0X6F
Eq. Número numérico:	0	1	2	3	4	5	6	7	8	9

Então, simplesmente, se você quiser exibir o número 0 no seu segmento de 7, você pode chamar seg, da mesma forma , se você quiser exibir o número 6, você só precisa usar seg.

Para entender como o valor HEX foi realmente obtido, olhemos a tabela abaixo. O valor HEX equivalente para cada número decimal é armazenado na matriz para que possa ser chamado para exibir um número específico.

Agora, vamos passar para a próxima parte do código, que é a configuração de E / S:

// ***** Configuração de E / S **** // TRISC = 0X00; PORTC = 0X00; TRISD = 0x00; PORTD = 0X00; // *** Fim da configuração de E / S ** ///

A configuração de E / S é simples porque todos os pinos em nosso segmento de 7 são pinos de saída e as conexões são mostradas no diagrama de circuito acima, então simplesmente declare-as como saídas e inicialize-as para zero.

Agora, vamos pular para o nosso loop infinito (enquanto (1)). Aqui, temos que dividir o valor de "i" em quatro dígitos e exibi-los no segmento de 7. Primeiro, vamos começar dividindo o valor em "i"

// *** Dividindo "i" em quatro dígitos *** // a = i% 10; // 4º dígito é salvo aqui b = i / 10; c = b% 10; // 3º dígito é salvo aqui d = b / 10; e = d% 10; // 2º dígito é salvo aqui f = d / 10; g = f% 10; // O primeiro dígito é salvo aqui h = f / 10; // *** Fim da divisão *** //

Usando módulo simples e operação de divisão, o número de 4 dígitos (i) é separado em números individuais. Em nosso caso, tomemos um exemplo em que o valor de "i" é 4578. Então, no final desse processo, a variável g = 4, e = 5, c = 7 e a = 8. Portanto, agora será fácil exibir cada dígito simplesmente usando essa variável.

PORTD = seg; s1 = 1; // Liga o display 1 e imprime o 4º dígito __delay_ms (5); s1 = 0; // DESLIGA o display 1 após 5ms de atraso PORTD = seg; s2 = 1; // Liga o display 2 e imprime o 3º dígito __delay_ms (5); s2 = 0; // DESLIGA o display 2 após 5ms de atraso PORTD = seg; s3 = 1; // Liga o display 3 e imprime o 2º dígito __delay_ms (5); s3 = 0; // DESLIGA o display 3 após 5ms de atraso PORTD = seg; s4 = 1; // Liga o display 4 e imprime o primeiro dígito __delay_ms (5); s4 = 0; // DESLIGUE a tela 4 após 5ms de atraso

Este é o lugar real onde o MCU fala com o segmento de 7. Como sabemos , podemos exibir apenas um dígito por vez, mas temos quatro dígitos a serem exibidos e somente se todos os quatro dígitos estiverem Ativados, o número completo de quatro dígitos ficará visível para o usuário.

Então, como vamos fazer isso?

Para nossa sorte, nosso MCU é muito mais rápido do que um olho humano, então o que realmente fazemos: exibimos um dígito por vez, mas fazemos isso muito rápido, conforme mostrado acima.

Selecionamos um dígito para exibi-lo, aguardamos 5ms para que o MCU e o segmento 7 possam processá-lo e, em seguida, desligamos esse dígito e passamos para o próximo dígito e fazemos o mesmo até chegarmos ao último dígito. Este atraso de 5 ms não pode ser observado por um olho humano e todos os quatro dígitos pareciam estar ativados ao mesmo tempo.

É isso, finalmente apenas incrementamos o valor do dígito exibido usando um atraso como mostrado abaixo

if (flag> = 100) // espere até que o flag atinja 100 {i ++; flag = 0; // somente se o sinalizador for cem "i" será incrementado} sinalizador ++; // sinalizador de incremento para cada flash

O atraso é usado para que o tempo necessário para mudar de um número para outro seja longo o suficiente para que percebamos a mudança.

O código completo é fornecido abaixo e o processo também é explicado no Vídeo ao final.

Configuração e teste de hardware:

Como sempre, vamos simular o programa usando Proteus antes de realmente irmos com nosso hardware. Se a simulação for bem sucedida você deve ver algo assim

Este projeto não tem nenhuma configuração de hardware complicada, estamos novamente usando a mesma placa de microcontrolador PIC que criamos no tutorial de LED piscando. Simplesmente conecte o Módulo de 7 segmentos com sua placa de microcontrolador PIC de acordo com o diagrama de conexão. Depois de fazer as conexões, simplesmente despeje o código usando seu programador PicKit 3 e aproveite sua saída.