Display 7 segmentos

Um display de sete segmentos, é um tipo de display (mostrador) barato usado como alternativa a displays de matriz de pontos mais complexos e dispendiosos. Displays de sete segmentos são comumente usados em eletrônica como forma de exibir uma informação alfanumérica (binário, octal, decimal ou hexadecimal) que possa ser prontamente compreendida pelo usuário sobre as operações internas de um dispositivo. Seu uso é corriqueiro por se tratar de uma opção barata, funcional e de fácil configuração.

 

  

Construção

A sua construção é feita com Leds ligados de 2 formas:

• Katodo comum: onde é necessário colocar um nível de tensão positivo (nível lógico “1”) para ligar o segmento.

• Anodo comum: onde é necessário colocar um nível de tensão baixo ou GND (nível lógico “0”) para ligar o segmento.

  

Conceito e estrutura visual:

Os segmentos individuais de um display de sete segmentos.
Um display de sete segmentos, como seu nome indica, é composto de sete elementos, os quais podem ser ligados ou desligados individualmente. Eles podem ser combinados para produzir representações simplificadas de algarismos arábicos. Frequentemente, os sete segmentos são dispostos de forma oblíqua ou itálica, o que melhora a legibilidade.
Os sete segmentos são dispostos num retângulo com dois segmentos verticais em cada lado e um segmento horizontal em cima e em baixo. Em acréscimo, o sétimo segmento bissecta o retângulo horizontalmente. Também existem displays de quatorze segmentos e de dezesseis segmentos (para exibição plena de caracteres alfanuméricos) todavia, estes têm sido substituídos em sua maioria por displays de matriz de pontos. Os segmentos de um display de sete segmentos são definidos pelas letras de A a G, conforme indicado à direita, onde o ponto decimal opcional DP (um "oitavo segmento") é usado para a exibição de números não-inteiros.

  

Exibição dos números

A animação à esquerda passa pelos glifos comuns dos dez numerais e seis "letras-dígito" em hexadecimal (A–F). A variação entre letras maiúsculas e minúsculas para A–F é feita para que cada letra tenha uma forma única e inequívoca (A, C, E e F são maiúsculos, já B e D são minúsculos, pois caso contrário se confundiriam com 8 e 0). Para a exibição de cada número/caractere usa-se um conjunto de segmentos diferentes. As mais comuns são:
Simulação de um display LED de sete segmentos exibindo os 16 dígitos hex.

• 0 (Zero) - a, b, c, d, e, f
• 1 (Um) - b, c
• 2 (dois) - a, b, d, e, g
• 3 (três) - a, b, c, d, g
• 4 (quatro) - b, c, f, g
• 5 (cinco) - a, c, d, f, g
• 6 (seis) - a, c, d, e, f, g
• 7 (sete) - a, b, c
• 8 (oito) - a, b, c, d, e, f, g (todos)
• 9 (nove) - a, b, c, f, g
• A (maiúsculo) - a, b, c, e, f, g
• B (minúsculo) - c, d, e, f, g
• C (maiúsculo) - a, d, e, f
• D (minúsculo) - b, c, d, e, g
• E (maiúsculo) - a, d, e, f, g
• F (maiúsculo) - a, e, f, g

Obs.: Dentre os números, 0, 6, 7 e 9 podem ser representados por glifos diferentes dos citados acima em displays de sete segmentos, entretanto, na imagem, todos os dígitos se assemelham aos indicados.

  

Atividade

Elaborar um programa em linguagem “C” para o PIC18F4550 de forma a ler um nibble (conjunto de 4 bits) colocados na porta B (B3..B0) e mostrar um display de 7 segmentos katodo comum colocado na porta D (D6..D0).

Lógica de programação

• Associa o valor da entrada com o código correspondente
• Escreve o valor associado no display

Tabela de conversão de acordo com a ligação do circuito (display 7 segmentos katodo comum

  

Atividade Adicional

Elabore o mesmo programa / tabela de saída para funcionamento com display de 7 segmentos anodo comum

  

Temporização - Contador binário 8bits

Exemplo de leitura e escrita em 8bits

//******************************************************************************
unsigned char var_temp; // cria uma variável de 8 bits com o nome de var_temp
LATB = 25; // o valor decimal 25 é colocado na porta B
// 25 (decimal) = 0b00011001 (25 escrito em binário)
// b7=0 b6=0 b5=0 b4=1 b3=1 b2=0 b1=0 b0=1
var_temp = 24; // variável var_temp recebe o número 24 decimal
LATB = var_temp; // a porta  B recebe o conteúdo de var_temp (24);
// b7=0 b6=0 b5=0 b4=1 b3=1 b2=0 b1=0 b0=0

LATB = 16; // o valor decimal 16 é colocado na porta B
// b7=0 b6=0 b5=0 b4=1 b3=0 b2=0 b1=0 b0=0
var_temp = PORTB; // a variável var_temp recebe o conteúdo da porta B (16)
//******************************************************************************

Atividade 1.1

Implemente o programa para o PIC18F4550 em linguagem C, para apresentar uma contagem binária de 8 bits (porta D), de forma que o valor seja incrementado ao tempo de 1s.

Sugestão de implementação

• Crie uma variável e indique um valor inicial
• Loop
• Coloque o valor da variável na saída
• Incremente
• Temporize

Atividade 1.2

Modifique o ponto de início para 250

Atividade 1.3

Modifique o ponto de início para 10 e faça o programa decrementar.
.

Atividade 2

Implemente o programa para o PIC18F4550 em linguagem C, para apresentar uma contagem binária de 8 bits (porta D), e seja incrementado assim que o botão presente em B0 seja pressionado

Sugestão de implementação

• Crie uma variável e indique um valor inicial
• Loop
• Coloque o valor da variável na saída
• Teste se a tecla foi pressionada, se foi incremente a variável

Atividade 3

Modifique o código da atividade anterior (2) para decrementar.

Atividade 4

Baseado no código implementado na atividade anterior (contador binário incrementado pela ação de um botão) e utilizando o microcontrolador PIC18F4550, implemente software em linguagem C para termos um contador binário de 8 bits, com as seguintes especificações (características):

• Pinos de entrada:
• B1 – Botão que inicializa o contador em 0 (0b00000000 – 0x00)
• B3 – Botão que incrementa o contador em 1 unidade
• B5 – Botão que decrementa o contador em 1 unidade
• B7 – Botão que seta o contador para o número 128 (0b10000000 – 0x80)
• Pinos de saída
• D7..D0 – Leds mostrando a saída do contador em binário

Diagrama de Circuito

Tecla por nível

No código implementado na atividade "contador binário incrementado pela ação de um botão" a ideia é incrementar o contador a partir de ação da tecla B0.

A explicação deste tutorial presume que a chave esteja montada da seguinte forma:

Para isso teríamos, em tese, dentro do looping principal:
//**************************************************************
while (1){
LATD = contador; // coloca na porta D o conteúdo da variável contador
     if (PORTBbits.RB0 == 0) { // detecta o pressionamento da chave em B0
contador++; // incrementa o contador de a chave estiver pressionada
     }
}
//**************************************************************

Em tese, o programa acima funciona, ou seja, a sua lógica está correta.

Porém, na prática este código se torna ineficiente, pois o nosso microcontrolador executa este código em uma velocidade muito alta, e dessa forma ao pressionar a chave ele passa diversas vezes pelo comando de teste da chave (if), o que provoca o resultado de “corrida” do contador (o contador incrementa mais de uma posição).

Para solucionar é necessário após a detecção de chave pressionada aguardar que ela seja solta.

O truque consiste em abrir um looping para deixar preso o programa até que o botão seja solto.

//**************************************************************
while (1){
     LATD = contador; // coloca na porta D o conteúdo da variável contador
     if (PORTBbits.RB0 == 0) { // detecta o pressionamento da chave em B0
     while (PORTBbits.RB0 == 0);
     contador++; // incrementa o contador de a chave estiver pressionada
     }
}
//**************************************************************

O comando while (PORTBbits.RB0 == 0); fica preso em um looping enquanto que a chave estiver pressionada. Enquanto a condição for verdadeira (chave pressionada) o comando while não executa nada ( o “;” no final do comando while)

Atividades Timer

1. Timer 1 como temporizador:

Implementar hardware e software em linguagem C para o PIC18F4550 para as seguintes especificações:

• Configure o Timer 1 como contador de forma que o tempo do timer seja de 10ms
• Faça um looping (comando for) a fim de ter uma função de múltiplos de 1s.
• Como atividade prática faça um led piscar com 1s desligado e 2 s ligado

Dicas de Implementação

• Utilize como base o programa de exemplo com o Timer0.
• Modifique a função de configuração do Timer0 para o Timer1. A configuração do Timer0 é realizada no registrador TCON0, a configuração do Timer1 é realizada no registrador TCON1. Verifique o que cada bit faz, pois, os 2 registradores não são iguais (cada bit pode ter função diferente) 
• No Timer1 o pré-scaler disponível é menor, então o tempo máximo mesmo utilizando 16btis é bem mais baixo. Como sugestão, ajuste para o timer1 fazer a contagem para atingir 10ms, pois este valor permite múltiplos que gerem valores inteiros como, por exemplo, 1 segundo.
• Na função de tempo monte um looping (comando “for” por exemplo) para multiplicar o tempo de 10ms para atingir 1s ou múltiplos (utilize uma variável como parâmetro que indique o número de segundos desejados.

   

2. Timer configurado como interrupção

Implementar hardware e software em linguagem C para o PIC18F4550 para as seguintes especificações:

• Utilize 2 Interrupções externas a fim de incrementar e decrementar uma variável.
• Atualizar o LCD a cada 500ms pelo timer configurado como interrupção
• Escolha um módulo timer (0, 1, 2 ou 3).

Dicas e sugestões de implementação

• Para simplificar trabalhe todas interrupções como alta prioridade
• Na função “main” o looping “while(1)” está vazio (não faz nenhuma ação)
• Monte a função de configuração geral das interrupções (a mesma config_int() que foi utilizada nos programa de interrupção externa).
• Crie a função de configuração do Timer para o módulo escolhido (0, 1, 2 ou 3). 
• Configure os bits do registrador TCONX para configurar o Timer.
• Configure os bits relativos a interrupção associada ao Timer (IE, IP, IF).
• Dispare o Timer com o tempo escolhido (500ms). Se necessitar utilize um inteirações caso o módulo timer escolhido não atinja o tempo desejado. Ver exemplo de configuração do timer como inetrrupção
• O que atualizar o LCD:
• Coloque no LCD o valor da variável que está sendo controlada pelos botões. 
• Para o funcionamento do programa de acordo com as diretrizes (2 botões para incrementar e decrementar uma variável) como os botões trabalharão por interrupção, você precisará:
• A configuração para interrupção externa necessária.
• Na função de interrupção as ações específicas para cada interrupção

   

3 Controle de velocidade de um motor DC

Uma forma de medir é utilizar um par emissor/receptor de leds infravermelho

Podemos ter esses leds em módulos prontos ou construídos

O circuito para aplicação é simples e consiste de um led alimentado e um receptor que forma um divisor de tensão, que muda o seu valor quando o feixe luminoso é interrompido.

Atividade prática

Implementar hardware e software em linguagem C para o PIC18F4550 para as seguintes especificações:

• Contar o número de voltas do motor DC através de uma interrupção externa (INT0, INT1 ou INT2) gerada por um par infravermelho associado a uma interrupção.
• Configurar um módulo timer para gerar uma interrupção a cada 10s. Nessa interrupção calcule a velocidade em RPM e atualize o LCD com a velocidade corrente. 

  

   

Exemplo com Timer0

Para demonstrar o funcionamento e uso do módulo timer no PIC18F4550, geramos o exemplo mostrado no diagrama ao lado.

O programa utiliza o módulo timer 0 para gerar um atraso de 1s para fazer um led piscar em B0 (tempo on = off = 1s).

  

  Código do programa fonte:

   

/*
 * File:   TRM_exemplo.c
 * Author: Pilger
 *
 * Created on 29 de Agosto de 2017, 17:03
 * 
 * Exemplo de uso do Timer 0 como temporizador simples
 */

#define _XTAL_FREQ 48000000
#define led LATBbits.LATB0

#include <xc.h>
#include "C:\h\Config_PIC18F4550.h"
#include "c:\h\biblioteca_lcd_2x162_48M_XC.h"

void timer0_1s() {
    // 83,333 ns x 256 x 46875 = 1s
    // 65.535 - 46.875 = 18.660 = 0x48E4
    // TMR0H = 0x48
    // TMR0L = 0xE4
    TMR0H = 0x48;   // carrega a parte H do start do contador
    TMR0L = 0xE4;   // carrega a parte L do start do contador e dá início ao contador
    while (INTCONbits.TMR0IF==0); // aguarda o estouro do timer 65.535
    INTCONbits.TMR0IF=0;    // limpa o flag
}

void config_timer0 (void){
    // configuração do Timer 0
//    T0CONbits.TMR0ON = 1;   // Liga o Timer 0
//    T0CONbits.T08BIT = 0;   // 16 bits
//    T0CONbits.T0CS = 0;     // contagem por TCI
//    T0CONbits.T0SE = 0;     // não faz diferença qual valor, pois contagem é por TCI
//    T0CONbits.PSA = 0;      // ativa Pré-scaler
//    T0CONbits.T0PS2 = 1;    // 111 - Pré-scaler 1:256
//    T0CONbits.T0PS1 = 1;
//    T0CONbits.T0PS0 = 1;
    T0CON = 0b10000111;
}

void main(void) {
    TRISB = 0x00;
    TRISD = 0x00;
    PORTD = 0;
    config_timer0();
    lcd_inicia(0x28, 0x0f, 0x06);
    lcd_LD_cursor(0);
    lcd_posicao(1, 1);
    imprime_string_lcd("Timer 0");
    lcd_posicao(2, 1);
    imprime_string_lcd("Tempo = 1s");
    while (1) {
        led = 1;
        timer0_1s();
        led = 0;
        timer0_1s();
    }
}

  

   

Módulo Timer 0

   

   

Semáforo (Sinaleira)

Semáforo simples

Funcionamento de um semáforo de forma individual

1ª etapa - Acionamento do Verde

2ª etapa - Tempo de verde (15s por exemplo)

3ª etapa - Acionamento do Amarelo

4ª etapa - Tempo de amarelo (2s po exemplo)

5ª etapa - Acionamento do vermelho

6ª etapa - Tempo do vermelho (13s por exemplo)

Para completar o ciclo, volta a 1ª etapa

Tarefa

Desenvolver um programa em linguagem “C”, utilizando o microcontrolador PIC18F4550, para controlar um semáforo individual com o circuito correspondente no simulador

• Ligar o semáforo ao PORTD (D0, D1, D2, D3, D4, D5, D6, D7)
• Escolher tempos para
• Aberto (verde)
• Atenção (amarelo)
• Pare (vermelho)

Semáforo cruzamento

Desenvolver um programa em linguagem “C” para controlar um cruzamento e ruas com 3 tempos, com o circuito correspondente no simulador.

• Tempo 1: Av. Loureiro da Silva em ambos sentidos (os dois são iguais)
• Tempo 2: Av. Augusto de Carvalho sentido Norte-Sul
• Tempo 3: Av. Augusto de Carvalho sentido Sul-Norte

Diagrama de estados do projeto