Displays multiplexados

Euu · 18 de março de 2012

Pessoal, a questão é a seguinte: tenho dois displays de 7 segmentos, um para unidade, outro para dezena, e um pic 16f84a.

Usando como exemplo a imagem abaixo, onde RA7 controla o dilpay da dezena, e o RA6 controla o display da unidade, minha duvida é: Afinal, como funciona uma multiplexação? Em que momento um display tem que ser deligado e o outro ligado? Como ficará aparecendo (ex numero 37) o número 3 permanentemente até que a unidade mude para 0 e a dezena vá a 4?

O fato de desligar o display faz ele permanecer com o 3????

Por que usar transistors? Se a saída RA6 tiver em 0 e RA7 em 1, o display da unidade estará ligado e o da dezena desligado?

minha dúvida é apenas na parte de controle, como vai acontecer essa contagem, como vai acontecer a permanencia da dezena até que a unidade chegue a 0 novamente...

Pesquisando vi que tem que dividir o número atual da contagem em 10 para mandar o resto da divisão (que será a unidade) para o display da unidade.

Alguém pode me ajudar nessa confusão toda?

link da imagem http://lh4.ggpht.com/_IQgj-vPG0aY/TNiaiP8v5NI/AAAAAAAAAcU/RUjNaSgmi6w/s1600/Circuito%20Proteus.png

Obs.:

1) usarei a interrupção TMR0.

2)Não usarei no circuito os Ra7 e Ra6 como controle, já que são pinos para clock, porém apenas usei como exemplo, já que a imagem já traz eles como exemplo.

3)Não entendo linguagem C, só assembler (ou assembly, não sei qual a forma certa de falar).

vtrx · 18 de março de 2012

Este print parece com um que fiz para mostrar como funciona a multiplexagem a muito tempo a atrás,não achei mais o link mas postei outro para voce ver.

-> Multiplexagem 00 a 99 -<

Usei o timer zero para fazer a multiplexagem dos displays(varredura) e usei o timer1 para a contagem(pois ele pode contar um tempo maior).

Deste modo,o timer1 ficou exclusivo para fazer algo com os números.

Não conseguí fazer o proteus reproduzir fielmente a multiplexagem sem 'flicker',mas numa montagem real é só ajustar os tempos.

O código é em ASM e usa uma tabela de 10 bytes para os números de 0 a 9.

Para voce 'ver' como é feito a multiplexagem,altere as propriedade do cristal do PIC para 0.5 MHZ.

Na verdade é feito uma 'varredura' onde a persistencia do olho humano(os gatos vem um a um)nos da a impressão que os dois displays estão acesos juntos.

É igual a quando voce acende um led no escuro e movimenta para a esquerda e direita rapidamente dando a impressõa que ele formou uma 'linha'.

Conforme seu interesse e conhecimento, posto o código.

Euu · 18 de março de 2012

vtrx, você fez anodo comum, certo? eu quero fazer catodo comum. Mas, tem como você mandar o arquivo asm? A minha dificuldade é entender como eles mostram numeros diferentes nos dois displays, ao invés de 00, 11, 22, 33...

vtrx · 18 de março de 2012

Para 00,01,02 etc.

PORTB = byte que representa '0',primeiro display 'chaveado' recebe o byte.

Primeiro display 'cortado',PORTB = byte que representa '1',segundo display 'chaveado'.

Isso se repete indefinidamente.

Não comentei todas as linhas do código,mas alguem pode postar um mais eficiente ou comentar as linhas.

-> novo link -<

mostram numeros diferentes nos dois displays, ao invés de 00, 11, 22, 33...

Como disse,altere o cristal no proteus(propriedades do PIC)para 0.5 MHZ e poderá tentar entender.

Lembre-se,voce perguntou uma vez como poderia fazer uma execução 'paralela',ao mesmo tempo e foi lhe dito que o processamento é,na verdade,serial.

O mesmo aqui,o PORTB só apresenta um byte (numero)por vez,mas nossa visão 'enxerga' dois ao mesmo tempo,pois a mudança do display 1 para o 2 é muito rápida para nossa visão.

Projetos_afg · 18 de março de 2012

O PIC fica alternando rapidamente entre cada display, por exemplo:

O PIC liga o display das dezenas, coloca um número "1" nele. Depois ele desliga o display da dezena e liga o display das unidades, coloca o número "2" nele. O microcontrolador faz isso tão rapidamente que você não consegue perceber que os displays estão piscando. Você verá o número "12" apresentado nos displays.

Os transistores servem para ligar/desligar cada display, ligar diretamente na porta do PIC não dá porque os displays consomem mais corrente que a porta do PIC pode fornecer.

Um exemplo com o PIC16F628:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;Multiplexação com displays de 7-Seg  			;;
;;Desenvolvido por Augusto Fraga Giachero		;;
;;Oscilador interno de 4MHZ                     ;;
;;												;;
;;                               				;;
;;                        						;;
;;												;;
;;												;;
;;Data: 18/03/2012  							;;
;;												;;
;;PIC 16F628    								;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

processor 16F628
include <p16F628.inc>
__config _WDT_OFF & _PWRTE_ON & _LVP_OFF & _INTRC_OSC_NOCLKOUT & _BODEN_ON


cblock 0x20
W_2			;Byte para o armazenamento temporário de W
STATUS_2	;Byte para o armazenamento temporário do STATUS
DSP_dado	;Byte para o armazenamento do número a ser mostrado no display (em BCD)
endc

#define		DSP_D			PORTA,6		;Pino de seleção do display de dezena
#define		DSP_U			PORTA,7		;Pino de seleção do display de unidade
#define		DSP_P			PORTB		;Porta para os dígitos



								;Definição de macro-comandos	
BANK0 macro						;
bcf		STATUS,RP0 			    ;Muda para o banco 0
bcf		STATUS,RP1				;
Endm							;
								;
BANK1 macro						;
bsf		STATUS,RP0  			;Muda para o banco 1
bcf		STATUS,RP1				;
Endm							;



org 0x0000						;Vetor de RESET
clrf	PCLATH					;Limpa o PCLATH
goto	Main					;Vai para a rotina principal

ORG  0X0004						;Rotina da interrupção
movwf	W_2						;Guarda o registrador W 
movf	STATUS, W				;
movwf	STATUS_2				;Guarda o registrador STATUS

btfss	INTCON,T0IF				;Testa se a interrupção é do timer 0
goto	FIM_TMR0				;Se não for, pula para o fim da rotina
bcf		INTCON,T0IF				;Se for, limpa o flag da interrupção

btfss	DSP_U					;Verifica qual display será ligado/desligado
goto	Display_Dezena			;Se for o display da Dezena, vai para a rotina da Dezena
bcf		DSP_U					;Desativa o display da Unidade
swapf	DSP_dado				;Inverte a dezena com a unidade (para poder converter o número das dezenas em 7 SEG)
movf	DSP_dado, W				;Carrega em W o valor do número 
andlw	0x0F					;Deixa apenas o LOW nibble para ser convertido para 7 SEG
call	Converter_7SEG			;Chama a sub-rotina de conversão para 7 SEG
movwf	DSP_P					;Carrega o valor convertido na porta do display
bsf		DSP_D					;Ativa o display da Dezena
swapf	DSP_dado				;Troca os dígitos (Dezena e Unidade) para a posição correta
goto	Fim_Display_Dezena		;Vai para o fim da rotina

Display_Dezena:
bcf		DSP_D					;Desativa o display da Dezena
movf	DSP_dado, W				;Carrega o número em BCD a ser mostrado no display
andlw	0x0F					;Deixa apenas o LOW nibble para ser convertido para 7 SEG
call	Converter_7SEG			;Chama a sub-rotina de conversão para 7 SEG
movwf	DSP_P					;Carrega o valor convertido na porta do display
bsf		DSP_U					;Ativa o display da Unidade
Fim_Display_Dezena:	



movlw	.131					;
movwf	TMR0					;Recarrega a contagem do timer 0
FIM_TMR0:



movf	STATUS_2,W				;Recupera o registrador STATUS
movwf	STATUS					;
movf	W_2						;Recupera o registrador W
retfie							;Termina a rotina da interrupção
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Fim do tratamento das interrupções, começo da rotina princiapal.
Main
	BANK1						;Vai para o banco 1 de memória
	movlw	b'11000101'			;Configura o timer 0 com um prescaler 1:64
	movwf	OPTION_REG			;

	bcf		DSP_D				;Configura como saída os pinos de controle do display
	bcf		DSP_U				;
	clrf	DSP_P				;
	BANK0

	clrf	PORTA				;Limpa a porta A
	clrf	PORTB				;Limpa a porta B

	movlw	.131				;Configura o timer 0 para gerar 125 interrupções por segundo (125Hz)
	movwf	TMR0				;((OSC/4)/PRESCALER)/(256-TMR0) -> (4MHz/4)/64)/(256-131) = 125Hz

	movlw	b'10100000'			;Ativa a interrupção do timer 0
	movwf	INTCON				;

	movlw	0x12				;Coloca o número "12" no display
	movwf	DSP_dado			;

Loop:

	goto	Loop


sleep
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;Começo das sub-rotinas

Converter_7SEG:
	addwf	PCL,F
	retlw	b'00111111'	;0
	retlw	b'00000110'	;1
	retlw	b'01011011'	;2
	retlw	b'01001111'	;3
	retlw	b'01100110'	;4
	retlw	b'01101101'	;5
	retlw	b'01111101'	;6
	retlw	b'00000111'	;7
	retlw	b'01111111'	;8
	retlw	b'01101111'	;9
	retlw	b'01110111'	;A
	retlw	b'01111100'	;B
	retlw	b'00111001'	;C
	retlw	b'01011110'	;D
	retlw	b'01111001'	;E
	retlw	b'01110001'	;F



END

Circuito:

Euu · 18 de março de 2012

vou tentar entender aqui, valeu.

victormantuaneli · 19 de março de 2012

Amigo, falei um pouco sobre multiplexação num tópico, o mais entendível possível, espero que ajude:

Amigo, conhece um termo utilizado nos displays de segmentos de múltiplos algarismos chamado multiplexação? Uma breve descrição:
Multiplexar significa acender um display por vez. Essa técnica é utilizada para "economizar" portas no microcontrolador e linhas de código. Ela consiste interligar as linhas de segmentos de todos os algarismos, mandando a configuração de segmentos para formar o número e ir comutando propositamente algarismos individuais, isso acontece dezenas de vezes em um segundo, criando a ilusão devido à Persistência Retiniana de que os display estão ambos acesos e com algarismos diferentes.

Um exemplo: exibir número 27.

define o PORT responsável pelos segmentos para exibir "7" (unidade)

liga o comum do display de unidade (acende o número 7 na unidade)

desliga o comum

define o PORT responsável pelos segmentos para exibir "2" (dezena)

liga o comum do display de dezena (acende o número 2 na dezena)

Isso se repetirá, de modo que tenhamos a ilusão de que os dois algarismos distintos estão acesos.

aphawk · 19 de março de 2012

Vou tentar descrever a técnica de multiplexação :

Como sabemos, a persistência retiniana faz com que percebamos como contínua qualquer visualização discreta, desde que essa visualização seja maior do que 30 vezes por segundo. Claro que isso varia um pouco de pessoa para pessoa, mas em tese, se fazermos uma imagem piscar 40 vezes por segundo, iremos perceber como se essa imagem estivesse sempre ligada !

Esse é o princípio da multiplexação, que no seu caso é acender apenas um dos displays, deixar um pouquinho aceso, apagar, acender o outro display, esperar um pouquinho, etc, e assim indefinidamente.

Imagine o numero 81, queremos que ele seja mostrado no display.

O primeiro display é o dezenas, e o segundo display é o das unidades.

Portanto, temos de colocar na saída do PIC o numero 8, selecionar a saída do display das dezenas, esperar um pouco, apagar o display, e aí colocamos o numero 1 na saída do PIC, selecionamos a saída do display das unidades, esperamos um pouco, apagamos, e voltamos ao início novamente.

Se fizermos esse processo 40 vezes por segundo para cada display, voce não irá perceber as piscadas que existem, e o melhor de tudo, como apenas 1 display está aceso , sempre a corrente será a de um só display !

Isso fica melhor ainda se voce imaginar que tem 4 displays em vez de 2, imagine se voce fosse acender todos eles ao mesmo tempo, a corrente que seria consumida pelo seu circuito !

No caso dos PICs, que suportam uma boa corrente de saída em seus pinos, podemos ligar os displays diretamente aos pinos, com apenas um resistor limitador, e não precisamos de nenhum driver adicional de corrente.

como se faz essa multiplexação a nivel de software ( e hardware ... ) ?

Usamos um dos TIMERS do PIC, geralmente o TIMER 0 , e programamos ele para interromper o programa principal no mínimo 80 vezes por segundo, para fazermos a sequência descrita acima. Assim, fica fácil de perceber que iremos acender cada um dos displays 40 vezes a cada segundo, e cada display ficará aceso por cerca de 1/80 = 12,5 milisegundos a cada vez !

Claro que esse procedimento faz com que a luminosidade de cada display seja baixa, pois em 1 segundo cada display ficará aceso por apenas 0,5 segundos, ou seja, a luminosidade será a metade !

O que fazemos para melhorar isso é utilizar uma característica dos LEDs : se normalmente a corrente máxima para um display é de 25 ma para cada segmento, se consultarmos a documentação veremos que eles podem suportar uma corrente bem maior ( por exemplo, 100 ma ) por alguns milissegundos, e com uma certa taxa de repetição máxima .

Assim, baseado no datasheet do display, escolhemos a frequência de refresh , e aumentamos a corrente dos segmentos, para mantermos o brilho alto. Claro que nesse caso usamos drivers de corrente tipo source, por exemplo, o UDN2981.

Resumindo, o programa principal calcula o valor a ser mostrado, e coloca esse valor em duas variáveis separadas ( dezenas e unidades ), e sinaliza à rotina de multiplexação que os dados estão completos e corretos. Ou seja, se o programa principal está na iminência de alterar um dos dois valores, ele sinaliza através desse flag, e quando ele concluir a alteração dos dois valores, ele sinaliza novamente através desse flag.

Assim, a rotina de multiplexação consulta sempre o flag ANTES de mostrar, asssim evitamos um problema recorrente que é o de perceber uma "piscada" de um valor meio maluco de vez em quando ( imagine que o valor está mudando de 10 para 09, e a rotina de multiplex interrompeu justamente após a mudança da dezena apenas, o que irá aparecer rápidamente no display será 00 ! ) . Ao consultar o flag, a rotina de multiplex simplesmente não faz nada e termina, o que pode fazer com que um dos displays seja atualizado apenas 39 em vez de 40 vezes, na prática isso não é perceptível !

Caso voce ainda tenha dúvidas, sugiro que leia o Tutorial no link abaixo :

http://forum.clubedohardware.com.br/showpost.php?p=3712305&postcount=3

Bons projetos.

Paulo

Philippe Henrique · 11 de dezembro de 2016

@Projetos_afg Caramba, gostei do seu código, foi você quem bolou essa técnica de separar o byte em 2 pra armazenar o valor de cada display em um só registrador?