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

Publicado em por
Tempo de leitura: 12 minutes

Interface de display de 7 segmentos com microcontrolador Pic: Nos últimos tutoriais, vimos como usar o compilador MPLAB XC8 e como fazer a interface de um LED com microcontroladores pic como PIC16F877A e PIC18F4550. Os displays de 7 segmentos também são um tipo de display LED. Para interfacear e controlá-los com o microcontrolador Pic, usamos pinos GPIO como pinos de saída digital. Porque esses displays consistem em 7 diodos emissores de luz conectados em configuração de ânodo comum ou cátodo comum.

 

Como fazer interface com monitores de 7 segmentos?

Neste tutorial, começaremos com uma introdução aos displays de 7 segmentos? Como fazer a interface de um display de 7 segmentos com microcontroladores PIC. Veremos exemplos com dois compiladores como o compilador MPLAB XC8 e o MikroC Pro.

7 Segmentos Introdução

O display de sete segmentos é considerado o dispositivo de exibição eletrônica mais básico e simples. Mais simples, porque seu funcionamento é fácil de entender e sua interface com o microcontrolador é bastante direta.

Sete segmentos, como o nome sugere, consistem em sete LEDs organizados em um padrão específico. Cada LED é conhecido como um segmento e é atribuído um nome de ‘a’ a ‘g’. Outro 8º LED adicional chamado ‘dp’ também está presente às vezes em um display de 7 segmentos que é usado para iluminar um ponto ou um ponto decimal. Como você pode ver neste diagrama, ele consiste em 10 pinos.

Display de 7 Segmentos os tipos

Um pino comum também está associado ao de 7 segmentos, que é usado para identificar o tipo de display de 7 segmentos; se é o ânodo comum ou um cátodo comum. No display de anodo comum, os pinos positivos de todos os LEDs são unidos para formar o pino comum que precisa receber um sinal ‘HIGH’ que significa sinal de 5 volts. Para ativar um segmento específico, conectamos esse pino ao terra ou nível lógico baixo.

No display de cátodo comum, todas as conexões catódicas dos LEDs são unidas, formando o pino comum que precisa ser aterrado. Para ligar um segmento específico no modo de cátodo comum, conectamos esse pino à tensão ou a um nível lógico alto com um microcontrolador

Como controlar o display de 7 segmentos com o microcontrolador Pic?

Como mencionamos anteriormente, ele consiste em 7 dispositivos emissores de luz dispostos em uma caixa de design retangular. Ao controlar luzes específicas, podemos exibir números de 0 a 9. Cada segmento é referido com o nome de a a g. Por exemplo, se queremos exibir 1, ativamos os segmentos ‘b’ e ‘c’ e para exibir 2, ativamos os segmentos a, b, g, d e e. Da mesma forma, podemos exibir outros números controlando os respectivos dispositivos emissores de luz.

Nota: Se usarmos o display de segmento de 7 segmentos de ânodo comum, os sinais de controle (a-g) serão ativos em baixo (referência de terra) e da mesma forma para o tipo de cátodo comum, os sinais de controle são sempre de alto nível ativo (geralmente 5 volts).

Nas seções anteriores, vimos que como controlar 7 segmentos são exibidos. Como você sabe, podemos facilmente fazer a interface de 7 segmentos com um microcontrolador pic usando pinos GPIO do microcontrolador PIC como pinos de saída digital. Requer uma interface simples semelhante a um tutorial de interface de LED.

 

Interface de exibição de 7 segmentos com microcontrolador Pic no MPLAB XC8

Nesta seção, veremos um exemplo de telas de 7 segmentos fazendo interface com o microcontrolador pic. Usaremos o compilador MPLAB XC8 para programação.

Circuito de Interface

Esta imagem mostra um diagrama de conexão do display de 7 segmentos com microcontrolador pic. Um display do tipo ânodo comum é usado. Portanto, conectamos um terminal comum à referência de terra. Esse circuito de interface usava resistores de 330 ohms para conexão. Esses resistores são os resistores limitadores de corrente. Porque todos os pinos GPIO do microcontrolador PIC18F4550 podem fornecer uma corrente máxima de 25mA e também cada segmento de LED precisa de apenas 10mA de corrente para operar.

Se usarmos um tipo de anodo comum, o terminal comum será conectado a 5 volts ou Vcc.

Código de interface de 7 segmentos MPLAB XC8

Para escrever código, primeiro, precisamos criar um padrão que mostre números enviando padrões específicos para exibição de 7 segmentos do microcontrolador PIC18F4450. Por exemplo, nesta interface, usamos o microcontrolador PORTD do PIC18F4450. Enviamos padrões de bits para ativar e desativar segmentos específicos de acordo com o número que queremos exibir. Geramos esta tabela que contém padrões de bits para todos os números de 0 a 9. Esta tabela mostra a codificação de 7 segmentos para programação do microcontrolador pic.

NumeroA B C D E F GPORTD (Hex)
0 0 0 1 1 1 1 1 10x3F
10 0 0 0 0 1 1 00x06
20 1 0 1 1 0 1 10x5B
30 1 0 0 1 1 1 10x4F
40 1 1 0 0 1 1 00x66
50 1 1 0 1 1 0 10x6D
60 1 1 1 1 1 0 10x7D
70 0 0 0 0 1 1 10x07
80 1 1 1 1 1 1 10x7F
90 1 1 0 1 1 1 10x6F

 

Conforme mostrado na tabela acima, enviamos o valor hexadecimal do número para o PORTD do microcontrolador Pic que desejamos exibir. Usaremos apenas 7 bits de PORD para enviar dados para segmentos de a-g.

Este código exibe números de 0 a 9 no display de 7 segmentos com um atraso de um segundo.

#include <xc.h>
#include "config.h" // Configuration bits file stored in a header file
#define _XTAL_FREQ 20000000 //define crystal frequency to 20MHz

// This array stores binary bit pattern that will be send to PORTD
unsigned char binary_pattern[]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};

void main(void) 
{
    TRISD = 0x00; //define PORTD as a output pin
    while(1)
    {
        //this loop sends all binary patterns to PORTD
        for (int i=0;i<10;i++)
        {
            PORTD = binary_pattern[i];
            __delay_ms(1000);  //add delay of one second
        }
    }
    return;
}

 

Funcionamento do código

Este programa controla apenas um display de 7 segmentos e o funcionamento do código é bastante simples.

  • xc.h e config.h são os arquivos de cabeçalho. Os arquivos de cabeçalho xc.h contêm uma definição de registros internos do microcontrolador PIC18F4550.
  • Por outro lado, o arquivo de cabeçalho config.h contém configurações de bits de configuração.

O array binary_pattern consiste em padrões binários de números para exibição de sete segmentos do tipo catodo comum.

/ This array stores binary bit pattern that will be send to PORTD
unsigned char binary_pattern[]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};

Em seguida, configuramos o PORTD do microcontrolador PIC18F4550 como saída digital usando o registrador de controle de direção TRISD.

TRISD = 0x00; //define PORTD as a output pin

Esta é a parte principal do programa que envia o valor do array binary_pattern para PORTD após cada segundo. while(1) continuará executando indefinidamente.

while(1)
    {
        //this loop sends all binary patterns to PORTD
        for (int i=0;i<10;i++)
        {
            PORTD = binary_pattern[i];
            __delay_ms(1000);  //add delay of one second
        }
    }

Multiplexação de quatro displays de 7 segmentos com PIC18F4550 em MPLAB XC8

Agora você sabe como fazer a interface de um único display de 7 segmentos com o microcontrolador pic. Mas em projetos práticos, sempre precisamos de mais de um display fazendo interface com o microcontrolador pic. Por exemplo, se quisermos exibir o valor ADC, temperatura, tensão, valores de medição de corrente em 7 segmentos, precisamos de mais de um dispositivo de exibição. Portanto, devemos também saber projetar um display de 2 dígitos, 3 dígitos e 4 dígitos usando dispositivos de sete segmentos.

Circuito de exibição de sete segmentos de 4 dígitos PIC18F4550

Este diagrama de circuito mostra uma conexão entre o display de 7 segmentos de 4 dígitos e o microcontrolador PIC18F4550.

Como você pode ver neste diagrama de circuito, o módulo de exibição de 4 dígitos possui 12 pinos. Seis pinos são usados para cada segmento de LED e podemos usar esses pinos comuns para acionar todos os quatro dígitos. Os pinos 1-4 são pinos de controle. Como pin1 controla o quarto dígito. Por exemplo, quando queremos exibir um número no quarto segmento de sete segmentos, faremos o pino de controle 1 ativo no caso do tipo de cátodo comum e ativo alto no caso do tipo de ânodo comum.

Neste exemplo, usamos o visor do tipo catodo comum de 4 dígitos. Portanto, tornaremos esses pinos ativos em baixa (referência de terra) sempre que quisermos exibir algo em sete segmentos específicos. Este circuito fornece esses sinais de controle dos pinos PORTB RB0, RB1, RB2 e RB2 para pino1, pino2, pino3 e pino4, respectivamente.

Semelhante à última seção, usamos o PORTD do microcontrolador PIC18F4550 para fornecer padrões binários de acordo com o número que queremos exibir. Portanto, conecte os pinos PORTD RD0-RD6 com os pinos a-g do display de 4 dígitos.

Programação de exibição de sete segmentos de 4 dígitos

A programação do display de 7 segmentos de quatro dígitos é fácil de entender se você conhece a programação de interface de dispositivo único. Primeiro, crie um novo projeto selecionando o microcontrolador PIC18F4550 e defina o arquivo de bits de configuração usando o compilador MPLAB XC8 e salve-o em um arquivo de cabeçalho. O primeiro arquivo de cabeçalho contém as definições dos registradores PIC18F4450 e armazenamos o arquivo de bits de configuração no arquivo de cabeçalho config.h.

#include <xc.h>
#include "config.h" // You must select 'HS' option from oscillator section
// this line define crystal frequency for built-in __delay_ms() functions
#define _XTAL_FREQ 20000000 //define crystal frequency to 20MHz

Como mencionamos anteriormente, quatro pinos (1-4) controlam a exibição de cada sete segmentos. Essas linhas definem o nome de cada pino de controle associado aos pinos PORTB RB0, RB1, RB2 e RB3. Ao definir nomes, podemos usar nomes dentro do código em vez de nomes de pinos. Isso torna o código fácil de entender.

#define digit1 PORTBbits.RB0
#define digit2 PORTBbits.RB1
#define digit3 PORTBbits.RB2
#define digit4 PORTBbits.RB3

Aqui o array binary_pattern consiste em valores hexadecimais de padrões binários de acordo com o número que queremos exibir. Uma matriz é um tipo de dados como int, float ou char, mas pode conter uma coleção de tipos de dados semelhantes. Por exemplo, esta linha define uma matriz de tipo de caractere que consiste em números de tipo de 10 caracteres.

// This array stores binary bit pattern that will be send to PORTD
char binary_pattern[]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};

Como você sabe que em todas as linguagens de programação, as variáveis são usadas para armazenar dados temporários ou permanentes. Neste exemplo, essas variáveis armazenam dados temporários. O contador variável armazena dados que exibiremos no dispositivo de sete segmentos de 4 dígitos. As variáveis a, b, c e d são usadas para armazenar os valores do primeiro, segundo, terceiro e quarto dígitos.

unsigned int a,b,c,d;
unsigned int counter = 0;

Esta seção do programa define a direção dos pinos GPIO do microcontrolador PIC18F4550. Os pinos PORTD e PORTB são usados como pinos de saída digital. Portanto, nós os inicializamos como pinos de saída digital definindo PORTD e PORTB, registros de controle de direção para baixo ativo, ou seja, TRISD=0x00 e TRISB=0.

Outra coisa interessante a ser observada é que declaramos os sinais de controle de dígitos como ativos altos. Isso ocorre porque estamos usando o tipo de cátodo comum de sete segmentos e ele liga com sinais baixos ativos. Portanto, no início, nós os inicializamos como alto ativo.

TRISD = 0x00; //define PORTD as a output pin
PORTD = 0X00; //initialize PORTD pins to active low
TRISB = 0x00;
digit1 = 1;
digit2 = 1;
digit3 = 1;
digit4 = 1;

Essas linhas extraem dígitos para milhares, centenas, 10º e lugar da unidade do valor do contador. Neste programa de exemplo, exibimos o valor do contador em sete segmentos de 4 dígitos. Dentro do loop while, o valor do contador é incrementado após cada iteração. Essas variáveis a, b, c e c recuperam dados de dígitos de 1000, 100, 10 e unidade.

Por exemplo, após 1233 iterações, o valor do contador será 1234. Após a execução dessas instruções, os valores dessas variáveis serão a=1, b=2, c=3 e d=4;

a = counter / 1000;   // holds 1000's digit
b = ((counter/100)%10); // holds 100's digit
c = ((counter/10)%10);  // holds 10th digit
d = (counter%10);  // holds unit digiat value

Esta é a parte principal do programa que realmente envia dados para o display de sete segmentos. Após calcular os valores de dígitos da última etapa, esta linha envia os dados para cada unidade de exibição. Devido às linhas de dados comuns, podemos enviar dados para um dispositivo de um dígito por vez, ligando seu pino de sinal de controle.

Agora a questão é o que fazer para exibir todos os 4 dígitos de uma vez? Não se preocupe, os microcontroladores operam em uma frequência muito alta e atualizaremos os dados para cada unidade de exibição tão rápido que o olho humano não pode detectar esse tempo de ativação/desativação. Adicionamos um atraso de 10 ms antes de enviar dados para cada sete segmentos. O olho humano não consegue detectar essa diferença de 10ms.

PORTD=binary_pattern[a]; // send 1000's place data to fourth digit
digit1=0;   //  turn on forth display unit
__delay_ms(10);
digit1=1;   //  turn off forth display unit
PORTD=binary_pattern[b];  // send 100's place data to 3rd digit
digit2=0;    //  turn on 3rd display unit
__delay_ms(10);
digit2=1;  //  turn off 3rd display unit
PORTD=binary_pattern[c];  // send 10th place data to 2nd digit
digit3 = 0;  //  turn on 2nd display unit
__delay_ms(10);
 digit3 = 1;   //  turn off 2nd display unit
PORTD=binary_pattern[d];  // send unit place data to 1st digit
digit4 = 0;  //  turn on 1st display unit
__delay_ms(10);
digit4 = 1;  //  turn off 1st display unit

Após a exibição de um número de 4 dígitos, essas linhas verificam se o contador = 9999, se o valor do contador atingir 9999, ele zerará o valor do contador e caso contrário, incrementará seu valor em um.

if(counter>=9999) //wait till flag reaches 100
{
    counter=0; //only if flag is hundred "i" will be incremented 
}
counter++; //increment flag for each flas
    }

 

Código de exibição de sete segmentos de 4 dígitos MPLAB XC8

#include <xc.h>
#include "config.h"
#define _XTAL_FREQ 20000000 //define crystal frequency to 20MHz
#define digit1 PORTBbits.RB0
#define digit2 PORTBbits.RB1
#define digit3 PORTBbits.RB2
#define digit4 PORTBbits.RB3
// This array stores binary bit pattern that will be send to PORTD
unsigned char binary_pattern[]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};
unsigned int a,b,c,d;
unsigned int counter = 0;;
void main(void) 
{
    TRISD = 0x00; //define PORTD as a output pin
    PORTD=0X00;   // initialize PORTD pins to active low
    TRISB=0X00;
    digit1 = 1;
    digit2 = 1; 
    digit3 = 1;
    digit4 = 1;
    while(1)
    {
        
           a = counter / 1000;   // holds 1000's digit
           b = ((counter/100)%10); // holds 100's digit
           c = ((counter/10)%10);  // holds 10th digit
           d = (counter%10);  // holds unit digit value
        
PORTD=binary_pattern[a]; // send 1000's place data to fourth digit
digit1=0;   //  turn on forth display unit
__delay_ms(10);
digit1=1;   //  turn off forth display unit
PORTD=binary_pattern[b];  // send 100's place data to 3rd digit
digit2=0;    //  turn on 3rd display unit
__delay_ms(10);
digit2=1;  //  turn off 3rd display unit
PORTD=binary_pattern[c];  // send 10th place data to 2nd digit
digit3 = 0;  //  turn on 2nd display unit
__delay_ms(10);
 digit3 = 1;   //  turn off 2nd display unit
PORTD=binary_pattern[d];  // send unit place data to 1st digit
digit4 = 0;  //  turn on 1st display unit
__delay_ms(10);
digit4 = 1;  //  turn off 1st display unit

if(counter>=1000) //wait till flag reaches 100
{
    counter=0; //only if flag is hundred "i" will be incremented 
}
counter++; //increment flag for each flas
    }
    return ;
}

 

Interface de exibição de sete segmentos com Pic usando o MikroC Pro Compiler

Esta seção discute um exemplo de interface de exibição de sete segmentos com o microcontrolador PIC16F877A usando o compilador MikroC para PIC. Embora a parte máxima do código permaneça a mesma, a única diferença é a configuração do compilador e como criar um novo projeto.

 

Multiplexação de dois contadores de exibição de 7 segmentos Exemplo

Nesta seção, discutimos um exemplo de multiplexação de dois displays de 7 segmentos com o microcontrolador PIC16F877A. Usamos dois displays de 7 segmentos neste exemplo para exibir um contador de 0-99. Vamos avançar definindo a exibição de sete segmentos. O código para este projeto é escrito usando MikroC para pic.

Para exibir um contador de 0-99, dois segmentos de 7 segmentos do tipo ânodo comum são interfaceados com o PIC16F877A neste projeto, um para dezenas e outro para unidades. Os sete pinos de cada segmento são conectados aos sete pinos de PORTB e PORTC, partindo do LSB, através de um resistor de 560R. Cada pino representa um alfabeto que liga e desliga a barra de LED correspondente em relação ao código.

De acordo com as conexões mostradas no diagrama de circuito, o alfabeto ‘a’ do segmento de dezenas é conectado ao pino RC0 do MCU, ‘b’ é conectado ao pino RC1 e assim por diante. O mesmo padrão é seguido para um segmento conectado ao PORTB. Escolhemos ambos os 7 segmentos com um display de ânodo comum. Como tal, o pino comum de ambos os 7 segmentos está conectado ao Vcc.

Multiplexação do código de exibição de sete segmentos MikroC

Escreva o seguinte código na janela do editor de código do compilador mikroC:

/* 7 Segment display counter 0-99 interfacing with PIC1F877A*/
 
void delay();
void main()
{
unsigned char i,j,ar[]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90};
TRISB=TRISC=0x00;
do
{
for(i=0;i<10;i++)
{
PORTC=ar[i]; // for tens
for(j=0;j<10;j++)
{
PORTB=ar[j];    // for ones
delay();
}
}
}
while (1);
}
 
void delay() //delay routine
{
unsigned char i,j;
for(i=0;i<255;i++)
for(j=0;j<50;j++);
}

Estes são os valores que precisam ser gerados nos pinos da porta para que o dígito correspondente apareça no 7-segmento. Por exemplo, para exibir ‘5’ no segmento de 7, os LEDs que devem ser iluminados são ‘a’, ‘c’, ‘d’, ‘f’ e ‘g’. Assim, os pinos da porta devem fornecer a saída 0b10010010 para o segmento de 7, que é equivalente em hexadecimal a 0x92.

O loop ‘for’ interno exibe o contador de unidades e o loop ‘for’ externo é para o contador de dezenas. O programa é executado infinitas vezes até ser abortado.

Aplicativos de Exibição de 7 Segmentos

Os displays de sete segmentos são amplamente utilizados em nossos equipamentos da vida diária, sejam os relógios digitais em nossas casas ou os medidores eletrônicos em nossas estações de trabalho. Ele pode ser usado como uma contagem regressiva ou um cronômetro ao jogar ou em competições, etc. As calculadoras básicas também usam um display de 7 segmentos.

 
Twittar
Compartilhar
Compartilhar
0 Compart.