O objetivo do circuito abaixo é enviar, para a Porta Paralela, 4 bits (1 Nibble) de cada vez, usando o modo padrão.
       Para que esse projeto tenha uma boa utilidade, usaremos o Conversor Analógico Digital ADC0804 e o Multiplexador 74LS157 com a intenção de criarmos um medidor de luminosidade digital.
       O Conversor Analógico Digital ADC0804 converte uma tensão elétrica entre 0 a 5v, com passos de 0,0196v, em um número de 8 bits. Como o modo padrão da Porta Paralela só permite receber 5 bits por vez, nesse caso, dividiremos os 8 bits em duas partes conhecidas como Nibble, e usaremos o circuito integrado Multiplexador 74LS157 com esse objetivo.
    

Circuito NibbleANibble

Esquema elétrico do circuito

Funcionamento do circuito:

       Os dados processados no ADC0804 são disponibilizados nos pinos (18, 17, 16, 15, 14, 13, 12 e 11) formando 8 bits. Essas saídas de 8 bits no entanto, serão as entradas para o Multiplexador 74LS157, que tem 8 bits de entradas. Por sua vez, o 74LS157 só poderá disponibilizar em suas saídas 4 bits (1 nibble) por vez nos pinos 4, 7, 9 e 12 que estão conectados aos pinos 11, 10, 12 e 13 da Porta Paralela. Os 8 pinos do 74LS157 são separados em duas partes, os pinos 3, 6 10 e 8 que formam o nibble alto, e os pinos 2, 5 11 e 14 que formam o nibble baixo. Para selecionar o nibble que ficará disponível nas saídas do 74LS157, é enviado um bit 0 ou 1 para o pino 1. Se enviado um bit 0, o nibble baixo ficará disponível nas saídas do 74LS157, se for enviado um bit 1, o que ficará disponível nas saídas é o nibble alto. Então quem controla qual nibble ficará disponível nas saídas, o pino 1 do 74LS157.
       O ADC0804 é comandado através do pino 3 (WR) conectado à Porta Paralela no pino 7 (D7).
       O foto-transistor é o responsável pela detecção da luminosidade.
       Criaremos um software que fará a junção dos dois nibbles, formando um byte que será exibido em forma de gráfico representando a luminosidade.

Diagrama genérico do Mux 74LS157

Diagrama genérico de funcionamento do projeto

//---------------------------------------------------------------------------
// Classe TMux;
// Objetivo: Protocolo de comunicação entre a porta paralela e o Mux 74LS157;
// Autor: Antonio Rogério Messias;
// E-Mail: rogerc@uol.com.br;
// Todos os Direitos Reservados
//---------------------------------------------------------------------------
#include "Porta.h"
#define BASE     0x378
#define DADOS    BASE + 0
#define STATUS   BASE + 1
#define CONTROLE BASE + 2
//---------------------------------------------------------------------------

class TMux //Declaração da class;
{
   private:
        unsigned char Byteb;
        unsigned char NibbleBaixo;
        unsigned char NibbleAlto; 

   public:
        void __fastcall SelecionaNibbleBaixo(void);
        void __fastcall SelecionaNibbleAlto(void);
        void __fastcall LeNibbleBaixo(void);
        void __fastcall LeNibbleAlto(void);
        unsigned char __fastcall MontaByteDados(void);
}; 
//---------------------------------------------------------------------------
void __fastcall TMux::SelecionaNibbleBaixo(void)
{
   //Seleciona Nibble Baixo (A) do Chip 74LS157.
   //O enviando um bit 0(zero).
   //No caso abaixo estamos usando o pino 1(Strob)lógica invertida.
   //0x01 - 00000001.  
   PortaLpt->Envia(CONTROLE, (unsigned char)(PortaLpt->Recebe(CONTROLE) | 0x01) ); 
}
//---------------------------------------------------------------------------
void __fastcall TMux::SelecionaNibbleAlto(void)
{
   //Seleciona Nibble Alto (B)do Chip 74LS157.
   //O enviando um bit 1(um).
   //No caso abaixo estamos usando o pino 1(Strob)lógica invertida
   //0xFE - 11111110.
   PortaLpt->Envia(CONTROLE, (unsigned char)(PortaLpt->Recebe(CONTROLE) & 0xFE) ); 
}

//---------------------------------------------------------------------------
void __fastcall TMux::LeNibbleBaixo(void)
{
   //Lê Nibble baixo.   
   NibbleBaixo = (unsigned char)(PortaLpt->Recebe(STATUS) & 0xF0); 
}

//---------------------------------------------------------------------------
void __fastcall TMux::LeNibbleAlto(void)
{
   NibbleAlto = (unsigned char)(PortaLpt->Recebe(STATUS) & 0xF0); //Lê Nibble alto.
}

//---------------------------------------------------------------------------
unsigned char __fastcall TMux::MontaByteDados(void)
{
    SelecionaNibbleBaixo();
    LeNibbleBaixo();
    SelecionaNibbleAlto();
    LeNibbleAlto();

    NibbleBaixo = (unsigned char)(NibbleBaixo >> 4); //Desloca p/ a direita 4 Bits.
    //0x88: 1000-1000, corrige os bits D7 e D3 e combina os nibbles. 
    Byteb = (unsigned char)((NibbleAlto | NibbleBaixo) ^ 0x88); 
    return(Byteb);
}

 
 

http://www.rogercom.com
© Copyright, 1999-2006 ROGERCOM - Antonio Rogério Messias - rogerc@rogercom.com
Todos os Direitos Reservados - All Rights Reserved.