Demultiplexador

Twinsen · 18 de outubro de 2012

Boa noite, estou fazendo um projeto de leitura de temperatura com o microcontrolador 16f877a e um lcd 16x2, ate agora estou fazendo 4 leituras e mostrando as 4 temperatura no LCD, mas preciso fazer 12 leituras e mostrar no LCD so que nao posso usar um LCD maior teria q usar 3 LCD 16x2 para mostrar a temperatura. estava pensando em usar um demux para controlar o ENABLE dos LCD so que nao tenho nenhuma ideia de como ficaria o programa do microcontrolador, estou fazendo o programa em C pra facilitar. Se alguem puder ajudar fico grato.

aphawk · 18 de outubro de 2012

Twinsen,

Isso é fácil, use 3 pinos de i/o que estejam sobrando, e ligue cada um a um dos ENABLE dos LCDs. O problema é que voce não vai poder usar o sinal de Ready dos LCDS, ou seja, vai ter de usar timeouts na escrita pois não vai poder ligar juntos os 3 pinos de Ready dos lcds .....

Assim, use a interface no modo de 4 bits, e a cada vez que você for fazer alguma coisa em cada LCD, basta habilitar APENAS o ENABLE dele, e fazer as escritas.

Paulo

mister nintendo · 19 de outubro de 2012

Amigo faÇa esse circuito e ja era seus problemas

abrÇs

aphawk · 19 de outubro de 2012

Mr. Nintendo,

Não entendí esse circuito.....

O nosso amigo quer ligar 3 lcds em paralelo mas NÃO vai escrever a mesma coisa em todos eles, e sim usar o Enable em separado para cada um deles. Como esse seu circuito é ligado nos 3 lcds ?

Paulo

mister nintendo · 19 de outubro de 2012

então amigo alphawk

o ci que falei ali é um demux

então ele bota um valor binario nos pinos de entrada e ele enegiza o pino correspondente

tipo assim

ele manda

0000 o pino 0 fica 1

0001 o pino 1 fica 1

......

cada valor em binario tem um

pino corespondente

então ele manda 0000 o pino 0 fica 1 e a porta and fica conectada nesse pino fica dependente do sinal de EN que vem do pic, e as outras portas logicas conectadas as outras saidas não habilita os EN dos outros display porque não esta setado aquele endereço no demux

qualquer duvida é so perguntar so ruinzão de explicação mas farei o maximo pra deixar entendido meu circuito

abrçs

aphawk · 19 de outubro de 2012

Ué .... Se eu tiver os pinos livres do microprocessador, basta habilitar apenas um deles de cada vez, e isso vai habilitar apenas o display LCD correspondente... Prá que usar um demux ??????? Pensando em binário, em vez de dar um out 0,1,2,3 e ter de usar um demux, não é mais fácil dar um out 1,2,4,8 com os pinos so microprocessador ligados nos Enables dos Lcds ?????

Paulo

mister nintendo · 19 de outubro de 2012

amigo alphawk obrigado, com seu questionamento fui verficar e achei o erro que você tava falando

http://imageshack.us/a/img26/4653/semttulonrx.jpg

ai ta o circuto certo obrigado

abrçs

aphawk · 19 de outubro de 2012

Agora sim, está certo !

Mas ainda não vejo o porque de se utilizar hardware para algo tão simples de se resolver por software....

Paulo

mister nintendo · 19 de outubro de 2012

com certeza se tiver pinos livre mata o demux e basta colocar apenas as portas logicas com o EN em comum e ir selecionado pra qual display mandar o sinal

coloquei o demux pela proposta do titulo do topico

abrçs

insisto em implementar algum hardware porque pelo que sei os compiladores (pelo menos o microC que é o que eu mexo) ão da suporte para 3 EN então a solução que avhei foi essa um sinal comum do EN e chaverar esse sinal conforme o necessario

aphawk · 19 de outubro de 2012

Bom, não pensei nisso....

Eu uso o Bascom, e uso displays no modo 4 bits, e deixo o Enable ligado o tempo todo, sem controle do microprocessador, porisso que falei que bastava controlar o Enable por software, antes de escrever no display correspondente.

Já no MikroC não sei se tem como usar os comandos de display lcd sem precisar usar o Enable.

Mas se não tiver, tenho certeza de que existem bíbliotecas com essa possibilidade.

Paulo

MatheusLPS · 20 de outubro de 2012

você irá ler 12 canais analógicos?

Já escolheu o PIC? Pois o 16F877 só tem 8 ADs.

O 18F4550 tem 13 canais ADs.. Bastante coisa.

Eu nem sabia que daria para usar LCDs em paralelo. Depois irei testar.

Se der certo, postarei o resultado da simulação.

Falou

Twinsen · 20 de outubro de 2012

MatheusLPS,

estarei utilizando um conversor analogico/digital o CI MAX6675.

MatheusLPS · 20 de outubro de 2012

Ao invés de usar 3 LCds, você pode apenas fazer com que as 12 temperaturas rolem no mesmo LCD.

Mas seguindo o título........

Então pessoal, em um primeiro momento fui na dica do colega Paulo pois eu achava que o pino de ENABLE se controla apenas com 1 e 0. Tentei seguir a dica, habilitando ou desabilitando o ENABLE. Mas não deu certo. Imaginei que o driver de LCD que uso no CCS não funciona dessa forma.

Não que a dica dada esteja errada. Mas no meu caso não deu certo. Fui no forum do compilador e um cara chegou a colocar vários LCDs em paralelo lá em 2006 mas não postou o código.

Por curiosidade, coletei a forma de onda da saída do pino de ENABLE para conferir. Vejam que na imagem abaixo, o PIC está escrevendo em somente 1 LCD a cada 1 segundo. Tirei um print de uma parte do sinal:

Veja que na maior parte do tempo o sinal fica baixo. Mas quando se manda escrever ele oscila. Por isso não funcionou.

Tenho duas opções: Modificar o driver padrão do compilador. Onde cheguei a dar uma lida nele mas não consegui a princípio. Dessa forma, parti para a dica do colega Mister Nintendo, utilizando portas AND. Mas nãousei demux não, foi PIC --> AND.

No final deu certinho. Fico chaveando entre os LCDs. Sendo que entre um chaveamento e outro, deixei um tempo só para esperar a transição.

Circuito:

Código (Pode ser feito de outras formas. Fiz da forma mais didática possível). E não confie d+ nos comentários do código pois reaproveitei um código antigo e algumas coisas estão trocadas. :

#include <18F4550.h>             //O PIC utilizado, obigatório!
#device adc=10                   //Habilitar ADC de 10 bits, obrigatório. Pode
                                 //ser utilizado de 8 bits também.
#FUSES NOWDT                     //Sem Watch dog, evitando reset
#FUSES XT                        //Crystal de oscilação igual a 4mhz
#FUSES PUT                       //Tempo de início do PIC
#FUSES NOPROTECT                 //Codigo sem proteção de leitura, software livre!
#FUSES NODEBUG                   //No Debug mode for ICD
#FUSES NOLVP                     //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD                     //No EE protection

#use delay(clock=4000000)        //Meu clock
#include <LCD.C>                 //Rotina de LCD modo 4 vias. Obrigatório!

#DEFINE EN1 PIN_C0
#DEFINE EN2 PIN_C1
#DEFINE EN3 PIN_C2

void lcd_scroll_left(void)
{
lcd_send_byte(0, 0x18);
} 

int16 q;
float p,temp1,temp2,temp3,temp4,temp5,temp6,temp7,temp8,temp9,temp10,temp11,temp12;

void main()
{
   output_high (EN1);
   output_high (EN2);
   output_high (EN3);

   setup_adc_ports(AN0_TO_AN11);         //Configura canais analógico
   setup_adc(ADC_CLOCK_DIV_8);    //De acordo com relógio interno.

   lcd_init();                   //Inicia LCD, obrigatório!

   output_low (EN2);
   output_low (EN3);


   for (;                      //Para sempre.
   {
   /*===========================================================================
   A resolução do conversor AD segue a seguinte equação:
            1LSB=(Vref-)+{[(Vref+)-(Vref-)]/1024}
   E nesse caso (Vref+)=5V e (Vref-)=0V então a resolução é:
            1LSB=5/1024=4,88mV
   Por exemplo, se a leitura no canal analógico for de 512, a tensão
   analógica será:
            Vin=512*(5/1024)=512*4,88mV=2.5V
   ===========================================================================*/

      output_low (EN3);
      output_high (EN1);
      delay_ms (5);

      set_adc_channel(0);           //Habilita canal 0
      delay_us(20);                 //Espera um pouco, obrigatório!
      q = read_adc();               //Lê canal 0
      p = 5.0 * q / 1024;           //Conversão para tensão. 
      temp1 = (p*100);           

      set_adc_channel(1);           //Habilita canal 0
      delay_us(20);                 //Espera um pouco, obrigatório!
      q = read_adc();               //Lê canal 0
      p = 5.0 * q / 1024;           //Conversão para tensão. 
      temp2 = (p*100);      

      set_adc_channel(2);           //Habilita canal 0
      delay_us(20);                 //Espera um pouco, obrigatório!
      q = read_adc();               //Lê canal 0
      p = 5.0 * q / 1024;           //Conversão para tensão. 
      temp3 = (p*100);      

      set_adc_channel(3);           //Habilita canal 0
      delay_us(20);                 //Espera um pouco, obrigatório!
      q = read_adc();               //Lê canal 0
      p = 5.0 * q / 1024;           //Conversão para tensão. 
      temp4 = (p*100);

      printf(lcd_putc, "\fT1=%1.0f T2=%1.0f\nT3=%1.0f T4=%1.0f", temp1,temp2,temp3,temp4);

      output_low (EN1);
      output_high (EN2);
      delay_ms (5);

      set_adc_channel(4);           //Habilita canal 0
      delay_us(20);                 //Espera um pouco, obrigatório!
      q = read_adc();               //Lê canal 0
      p = 5.0 * q / 1024;           //Conversão para tensão. 
      temp5 = (p*100);           

      set_adc_channel(5);           //Habilita canal 0
      delay_us(20);                 //Espera um pouco, obrigatório!
      q = read_adc();               //Lê canal 0
      p = 5.0 * q / 1024;           //Conversão para tensão. 
      temp6 = (p*100);      

      set_adc_channel(6);           //Habilita canal 0
      delay_us(20);                 //Espera um pouco, obrigatório!
      q = read_adc();               //Lê canal 0
      p = 5.0 * q / 1024;           //Conversão para tensão. 
      temp7 = (p*100);      

      set_adc_channel(7);           //Habilita canal 0
      delay_us(20);                 //Espera um pouco, obrigatório!
      q = read_adc();               //Lê canal 0
      p = 5.0 * q / 1024;           //Conversão para tensão. 
      temp8 = (p*100);

      printf(lcd_putc, "\fT5=%1.0f T6=%1.0f\nT7=%1.0f T8=%1.0f", temp5,temp6,temp7,temp8);

      output_low (EN2);
      output_high (EN3);
      delay_ms (5);

      set_adc_channel(8);           //Habilita canal 0
      delay_us(20);                 //Espera um pouco, obrigatório!
      q = read_adc();               //Lê canal 0
      p = 5.0 * q / 1024;           //Conversão para tensão. 
      temp9 = (p*100);           

      set_adc_channel(9);           //Habilita canal 0
      delay_us(20);                 //Espera um pouco, obrigatório!
      q = read_adc();               //Lê canal 0
      p = 5.0 * q / 1024;           //Conversão para tensão. 
      temp10 = (p*100);      

      set_adc_channel(10);           //Habilita canal 0
      delay_us(20);                 //Espera um pouco, obrigatório!
      q = read_adc();               //Lê canal 0
      p = 5.0 * q / 1024;           //Conversão para tensão. 
      temp11 = (p*100);      

      set_adc_channel(11);           //Habilita canal 0
      delay_us(20);                 //Espera um pouco, obrigatório!
      q = read_adc();               //Lê canal 0
      p = 5.0 * q / 1024;           //Conversão para tensão. 
      temp12 = (p*100);

      printf(lcd_putc, "\fT9=%1.0f T10=%1.0f\nT11=%1.0f T12=%1.0f", temp9,temp10,temp11,temp12);         //Mostre a temperatura.

      delay_ms(1000);
   }
}