Por: Antônio Rogério Messias

CONTROLANDO 32 DISPOSITIVOS E MONITORANDO 32

SENSORES SIMULTANEAMENTE ATRAVÉS DA PORTA PARALELA.
Para uso particular ou educacional.
Copyright(c) 1999-2004 ROGERCOM.COM
Todos os direitos reservados.

       Agora sim, poderemos controlar simultaneamente 32 dispositivos e ao

"mesmo tempo" lê 32 sensores conectados à Porta Paralela através deste projeto.
       Quem trabalha com a Porta Paralela sabe que ela disponibiliza somente 12
saídas: (8 no Registro de Dados e 4 no Registro de controle), portanto, permitindo
o controle simultaneamente de apenas 12 dispositivos.
       O projeto elaborado nesse artigo utiliza apenas 3 pinos da Porta Paralela
para controlar os 32 dispositivos conectados ao circuito de interface, composto
simplesmente de 4 CIs Shift Register 74LS164N e 4 Latchs 74HCT573 e alguns
componentes auxiliares. Já o circuito que lê os 32 sensores utiliza 7 pinos da
Porta Paralela. Ainda assim, ficam disponíveis 6 saídas e 1 entrada da Porta
Paralela para você fazer o que desejar com elas.
       Se analisarmos os princípios básicos de funcionamento dos CIs 74LS164N e
74HCT573, perceberemos que eles se comportam como uma memória de 1 byte
cada um, mas com características de funcionamento diferentes. Para guardar 8
bits (1 byte) dentro do Shift Register 74LS164N temos que enviar os bits um-a-um,
porque sua entrada é serial e só pode entrar um bit de cada vez, isto é feito
através da aplicação de um sinal de clock em um pino especifico do CI. Já o Latch
74HCT573 guarda um byte de uma única vez. Esse byte pode ser protegido
dentro do Latch enviado um sinal para um pino específico desse CI. A grosso
modo, poderemos habilitar ou não a escrita nele.
       Já a leitura de 32 sensores não é novidade, no artigo disponível no link:
http://www.rogercom.com/pparalela/32entradas.htm temos um projeto pronto e
funcional. Uma das vantagens desse novo projeto é que um único software
consegue gerenciar o controle de 32 dispositivos e a leitura dos 32 sensores
simultaneamente.
 Figura 1 - Tela do software que controla todo o hardware do projeto     

Download do software (Dsp32es.zip) 347Kb.

Se o software for rodar no Windows NT, 2000 ou XP, faça download do driver clicando aqui

Características do software:

- O DSP32ES foi criado em C/C++, e seu objetivo inicial é gerenciar todo o

hardware do projeto;
- O acesso ao controle dos dispositivos se dá através de uma senha;
- Somente uma cópia do programa roda de cada vez, ou seja, o sistema
operacional não executa
  duas cópias simultaneamente na memória;
- O programa aceita alteração da senha "master" para um senha definida pelo
usuário. Essa senha antes
  de ser salva é criptografada.

Recursos do software:

- O DSP32ES permite alterar a senha atual;

- Controla 32 dispositivos externos simultaneamente;
- Lê até 32 sensores simultaneamente;
- Ao passar com o ponteiro do mouse sobre um botão ON/OFF, é exibido no
display o número do canal que   se deseja ligar ou desligar;
- Permite Ligar/Desligar todos os dispositivos conectados ao circuito de uma única
vez;
- Mostra na tela os estados dos sensores conectados ao circuito.

Figura 2 - Pinagem do CI Shift Register 74LS164N

       Na Figura 2 temos a pinagem do CI 74LS165N. A entrada Serial 1 (pino 1)

não será utilizada e ficará conectada ao +5v da fonte de alimentação. A entrada
Serial 2 (pino 2) é a entrada de dados para dentro do CI, os bits são deslocados
um de cada vez e ficarão disponíveis nos 8 pinos de saída (3,4,5,6,10,11,12,12)
formando um byte. O pino 9 tem a função de limpar as saídas, ou seja, zerar todos
os bits armazenado no CI. No nosso projeto, esse pino ficará ligado ao +5v da
fonte de alimentação, ou seja, não iremos utilizar esse recurso do CI, se
necessário o próprio software enviará sinais de deslocamento com um bit 0 na
entrada de dados para limpar os bits armazenados no CI. O pino 8 é o clock, a
cada transição do nível baixo para o nível alto o bit presente no pino 2 será
deslocado para o pino 3 e assim sucessivamente enquanto houver sinal de clock.
Ou seja, o bit que entrar no pino 2 passará por todos os pinos de saídas dos
Shifts, portanto ocorrerá um deslocamento dos bits da esquerda para a direita.
 Figura 3 - Demonstração do funcionamento de dois Shift Registers em cascata

       A animação acima simula o armazenamento do valor 8000 em hexadecimal

nos 2 Shifts. Esse é um valor de 16 bits, portanto, 8 bits ficarão armazenados no
Shift 1 e os outros 8 ficarão armazenados no Shift 2. Como só pode entrar um bit
de cada vez no Shift, serão necessários 32 sinais de clock para que os 16 bits
fiquem armazenados nos Shifts. Você deve está se perguntado, não seria
necessários somente 16 deslocamentos para armazenar os 16 bits, o raciocínio
está correto, mas o Shift Register só desloca um bit quando há a transição de um
nível de clock para um outro, ou seja, para ocorrer um deslocamento de bit no
Shift é necessário que o sinal de clock alterne de '1' para '0'.
       Observe no segundo Shift, que o pino 2 (dados) está ligado ao pino 13 (último
bit do byte armazenado no primeiro shift). Essa ligação é necessária para que os
bits armazenados num Shift da esquerda seja deslocados para um próximo Shift a
direita, dessa forma os bits aplicados no pino 2 do primeiro Shift a esquerda serão
deslocados ou empurrados para os Shifts que estiverem a direita. Analogamente é
como se estivesse fazendo a conexão de um encanamento de água entre vários
reservatórios.
       Enquanto esse processo de deslocamento de bits estiver ocorrendo nos
Shifts, nenhuma das saídas do Latch 74HCT573 será alterada ou modificada, isso
porque o software manterá o Latch desabilitado, ou seja, não permitindo a escrita
no mesmo. Só depois que os bits estão organizados nos Shifts é que o software
envia um sinal para habilitar o Latch. Dessa forma, os bits presente nas saídas
dos Shifts são copiados para as saídas dos Latchs. Com essa técnica poderemos
ligar ou desligar quaisquer das 32 saídas mantendo intacta as saídas anteriores.
 Figura 4 - Pinagem do Latch 74HCT573

       Na Figura 4 temos as pinagens do Latch 74HCT573. O pino 1 do Latch será

aterrado (0v), não iremos utilizar o recurso desse pino. Os pinos 2 ao 9 são
entradas e os pinos 13 ao 19 são as saídas.
       No nosso projeto, o uso de oito CIs 74HCT573 conforme a figura 4 são
utilizados para armazenar o estado das 32 saídas.

CIRCUITO PARA CONTROLAR 32 SAÍDAS

SIMULTANEAMENTE

Figura 5 - Circuito para controlar 32 dispositivos simultaneamente através da Porta Paralela

       No circuito acima os capacitores de 100nF foram utilizados para eliminar
ruídos de fontes externas que possam vir a disparar as saídas dos Latchs. Já os
resistores são para manter as entradas dos Latchs estáveis.
       Observe que os pinos 1, 14 e 16 da Porta Paralela fazem parte do Registro
de Controle. Observe também que o pino 8 (clock) de cada CI estão conectados
entre si, isso é necessário para que ocorra deslocamento de bits em todos os Shift
register.

Obs.:
        Para minimizar a ocorrência de acionamentos inesperados nas saídas dos
Latchs, é muito importante que a fonte de alimentação seja de boa qualidade.

       Mantenha o circuito distante de equipamentos que possam gerar ruídos,

porque os Latchs são muitos sensíveis.

       Logo no começo dos testes desse projeto, houve alguns problemas de ruído.
Ao aproximar uma luminária contendo um transformador e uma luz fluorescente de
9W, as saídas dos Latchs eram acionadas, simplesmente quando ligava e
desligava essa luminária. Com o acréscimo dos capacitores de 100nF conectados
entre os pinos 11 e ao +5v da fonte de alimentação, essa interferência foi
eliminada em 98%, só ocorrendo quando a luminária era ligada muito próxima ao
circuito.

Quaisquer melhorias no circuito serão bem-vindas.

BIBLIOTECA DE FUNÇÕES EM C++ PARA INTERAGIR COM

O
CIRCUITO DA FIGURA 5 - CONTROLE DE 32
DISPOSITIVOS
Listagem 1 - Arquivo "Bibli32s.h"
//Biblioteca de funções para ligar e desligar 32 dispositivos através da Porta Paralela.
//Autor: Antonio Rogério Messias
//www.rogercom.com
//rogercom@rogercom.com
//Copyright(c) 1999-2004 ROGERCOM
//Todos os direitos reservados.
//---------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------
#define STROB          0x0
#define AUTOFEED    0x1

//---------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------
//Envia 1 byte para a Porta Paralela.
void Envia(short int PortaEnd, unsigned char Dado)
{
    _DX = PortaEnd;
    _AL = Dado;
    __emit__ (0xEE);
}
//---------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------
//Recebe 1 byte através da Porta Paralela.
unsigned char Recebe(short int PortaEnd)
{
    _DX = PortaEnd;
    __emit__ (0xEC);
    return (_AL);
}
//---------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------
//Desliga qualquer um dos 32 bits da varialvel valor independentemente.
unsigned __int32 Desliga32Bits(unsigned __int32 valor, unsigned char Bit)
{
    unsigned __int32 BitMask=1; //00000000-00000000-00000000-00000001.
    BitMask = (unsigned __int32)BitMask << Bit; //desloca bits para a esquerda.
    if( (valor & BitMask) == BitMask ) //se bit ligado.
        return(valor ^ BitMask); //desliga bit.
    else
        return(valor); //retorna sem modificar.
}
//---------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------
//Liga qualquer um dos 32 bits da varialvel valor independentemente.
unsigned __int32 Liga32Bits(unsigned __int32 valor, unsigned char Bit)
{
    unsigned __int32 BitMask=1; //00000000-00000000-00000000-00000001.
    BitMask = (unsigned __int32)BitMask << Bit; //desloca bits para a esquerda.
    if( (valor & BitMask) == 0 ) //se bit desligado.
        return(valor ^ BitMask); //liga bit.
    else
        return(valor); //retorna sem modificar.
}
//---------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------
//Testa qualquer um dos 32 bits da varialvel valor independentemente.
unsigned char Testa32Bits(unsigned __int32 valor, unsigned char Bit)
{
    unsigned __int32 BitMask = 1; //00000000-00000000-00000000-00000001.
    BitMask = (unsigned __int32)BitMask << Bit; //desloca bits para a esquerda.
    if( (valor & BitMask) == BitMask ) //se bit ligado.
        return 1;
    else
       return 0;
}
//---------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------
//Gera um sinal de clock nível baixo.
unsigned __int32 ClockBordaDescida(unsigned __int32 valor)
{
    return( Liga32Bits(valor, AUTOFEED) ); //Invertido.
}
//---------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------
//Gera um sinal de clock nível alto.
unsigned __int32 ClockBordaSubida(unsigned __int32 valor)
{
    return( Desliga32Bits(valor, AUTOFEED) ); //Invertido.
}
//---------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------
//Habilita todos os LATCHs
unsigned __int32 LigaLatchs(unsigned __int32 valor)
{
    return( Desliga32Bits(valor,STROB) ); //Invertido.
}
//---------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------
//Desabilita todos os LATCHs
unsigned __int32 DesligaLatchs(unsigned __int32 valor)
{
    return( Liga32Bits(valor,STROB) ); //Invertido.
 }
//---------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------
//Liga ou desliga qualquer uma das 32 saídas do circuito.
void Outport32(short int EndPorta, unsigned __int32 BitsDados)
{
    unsigned __int32 valor=0;
    unsigned __int32 Dados = BitsDados;

    valor = DesligaLatchs(valor); //Desliga todos os Latchs.

    Envia(EndPorta+2,valor); //Registro de Controle.

    //Loop.
    for(int cont=31; cont >= 0; cont--) //Percorrer a variável Dados de 32 bits; do bit mais
significativo ao menos signifi.     
    {
        if(Testa32Bits(Dados,cont) == 1) //Se um bit na posição cont da var. Dados está ligado.
             valor = Liga32Bits(valor,2); //Dados 1.
        else
             valor = Desliga32Bits(valor,2); //Dados 0.

        //GERA CLOCK----------------------------------------------------
        valor = ClockBordaDescida(valor); //Clock 0.
        Envia(EndPorta+2,valor); //Registro de Controle.
        valor = ClockBordaSubida(valor); //Clock 1.
        Envia(EndPorta+2,valor); //Registro de Controle.
        //---------------------------------------------------------------------------
    }
    valor = LigaLatchs(valor); //Liga Todos os Latchs.
    Envia(EndPorta+2,valor); //Registro de Controle.
    Sleep(1); //Aguarda 1 milisegundo. Necessário para estabilizar os dados nos Latchs.
    valor = DesligaLatchs(valor); //Desliga todos os Latchs.
    Envia(EndPorta+2,valor); //Registro de Controle.
}

       Se desejar ligar ou desligar qualquer uma das 32 saídas do circuito da Figura
5 através de programação, tenha como referência o pequeno programa escrito em
linguagem C++, logo abaixo:

#include <iostream.h>
#include <stdio.h>
#include <conio.h>
#include "bibli32s.h"
void main(void)
{
     unsigned __int32 Valor = 0x80000001;     //Em binário: 10000000-00000000-
00000000-00000001.
     Outport32(0x378, Valor);   //Liga as saídas S1 e S32 do circuito da Figura 5.
     cout << "Pressione uma tecla para finalizar...";
     getch( );
}
 CIRCUITO PARA CONTROLAR DISPOSITIVOS LIGADOS
À REDE ELÉTRICA

       Se desejar, você poderá implementar o circuito abaixo em algumas das 32

saídas para acionar dispositivos eletro/eletrônicos ligados à Rede elétrica, em vez
de acender ou apagar simplesmente LEDs.        Para acrescentar este driver ao
circuito da Figura 5, elimine um dos LEDs das saídas e ligue o pino do resistor R1
da figura abaixo em uma das 32 saídas. Ou melhor, substitua o resistor R1 do
circuito abaixo e um resistor de uma das saídas do circuito da Figura 5, por um
único de 1K.

Figura 6 - Driver para controlar dispositivos ligados à Rede Elétrica

       Observe na figura acima que a Fonte de Alimentação de 12v fica totalmente

isolada do circuito de controle. Quem faz essa isolação é o foto acoplador 4N25.

CIRCUITO PARA FAZER A LEITURA DE 32 SENSORES

SIMULTANEAMENTE
       O circuito abaixo é opcional no projeto, você o inclui se desejar monitorar
sensores. Para mais detalhes sobre o CI 74LS151 e funcionamento do circuito,
acesse o artigo: http://www.rogercom.com/pparalela/32entradas.htm. Observe que
no artigo do projeto citado no link, os pinos para controlar o seletor do CI eram: 1,
14 e 16 do Registro de Controle. Nesse novo projeto, o software DSP32ES
disponível para download nesse artigo utiliza os pinos 2, 3 e 4 do Registro de
Dados. Veja na Figura 7 abaixo:

Figura 7 - Circuito para lê 32 sensores conectados a Porta Paralela

 Figura 8 - Varredura das 32 entradas dos Multiplexiadores 74LS151

       Na animação acima, os pinos 15, 13, 12 e 10 do Registro de Status estão

relacionados aos quatro Multiplexadores. A leitura de cada entrada dos
Multiplexadores são enviadas serialmente ao software.

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

Por: Antônio Rogério Messias

RESOLVENDO O PROBLEMA DA INICIALIZAÇÃO

INVOLUNTÁRIA DA PORTA PARALELA INDUZIDA PELA BIOS E O
SISTEMA OPERACIONAL AO LIGAR O COMPUTADOR.
Para uso particular ou educacional.
Copyright(c) 1999-2004 ROGERCOM.COM
Todos os direitos reservados.

                                              O objetivo desse artigo é apresentar uma solução

simples, econômica e eficaz
                                              para resolver o problema da inicialização involuntária
da Porta Paralela no
                                              momento do auto-teste (POST) e após o processo de
boot, independente da
                                              versão da BIOS e do sistema operacional.
       Quando ligamos um computador ele passa por um processo conhecido como
auto-teste (Power On Self Test - POST). Toda a seqüência lógica para realizar o
auto-teste está gravada na BIOS (memória EPROM ou FLASH) onde está escrito
um programa de entrada e saída básico para testar o hardware e carregar o
Sistema Operacional na memória. Não é somente no auto-teste que ocorre a
reinicialização da Porta Paralela, após o processo de boot alguns Sistemas
Operacionais também reinicializam a Porta.
       Como a Porta Paralela foi projetada pela IBM para conectar uma impressora e
não quaisquer dispositivos, quando ocorre o auto-teste um serviço (programa)
gravado dentro da BIOS é executado, passando a enviar algumas seqüências de
sinais para a Porta Paralela com a finalidade de inicializar uma impressora. A
seqüência lógica de sinais enviados para a Porta Paralela no auto-teste depende
da versão da BIOS. Testes realizados em equipamentos contendo versões
diferentes da BIOS mostram seqüências variadas. Essa seqüência de sinais tanto
afeta o Registro de Controle como o Registro de Dados, fazendo com que
dispositivos conectados a Porta Paralela sejam involuntariamente reinicializados
ao ligar o computador, tornando o desenvolvimento de alguns projetos especiais
inviáveis através da Porta Paralela.
       Não é todo projeto que precisa da solução idealizada neste artigo, é somente
alguns casos especiais onde o circuito não pode parar de funcionar e fornecer
serviços, mesmo que o computador seja desligado.
       O circuito descrito aqui utiliza componentes que já foram utilizados em nossos
artigos anteriores, portanto há informação suficiente para auxiliar-nos no
desenvolvimento desse novo projeto.
       A informação enviada ao Registro de Dados só estará disponível no circuito
LptInit se a combinação correta de bits no Registro de Controle da Porta Paralela
for satisfeita, caso contrário, nenhum sinal de dados será aceito.
       O software para testar o circuito foi elaborado para ligar e desligar 8
dispositivos simulados através de LEDs. Esse software, além de controlar os
dispositivos, armazena em arquivo a última alteração ocorrida nos dados enviados
ao circuito, sendo assim, mesmo que desligarmos e ligarmos o computador, o
software terá a informação do último estado dos dispositivos.
       Segue abaixo, figuras, ilustrações e animações para facilitar o entendimento
de todo o projeto.

Figura 1 - Simulação do Demultiplexador 74LS138

       Na animação acima observamos uma simulação de funcionamento do

Demultiplexador 74LS138, usado em nosso projeto como um seletor de
endereçamento, para permitir que o LATCH 74HCT573 seja habilitado somente
quando o código binário enviado pelo Registro de Controle coincidir com o
endereço de uma das saídas (D0-D7) do 74LS138.
       Observe que somente uma saída é habilitada por vez e estas saídas estão
invertidas em relação à entrada. Por natureza, todas as saídas do 74LS138 estão
em nível lógico "1".
       Sabemos também que os pinos 1-Strob, 14-Auto-Feed e 17-Slct-In do
Registro de Controle da Porta Paralela são naturalmente invertidos. Portanto, para
facilitar a programação e trabalhar com lógica normal para habilitar o
endereçamento do 74LS138, foi acrescentado ao circuito um inversor 74LS04.
       Ao ligarmos o computador tanto a BIOS como o Sistema Operacional enviam
uma seqüência de sinais para o Registro de Controle, como já sabemos, esse
Registro tem 4 bits: C3, C2, C1 e C0 relacionados respectivamente aos pinos 17,
16, 14 e 1 do conector DB25, assim, com 4 bits podem ser geradas
combinações. Portanto, uma das saídas do 74LS138 só será habilitada se os bits
C3, C2, C1 e C0 do Registro de Controle forem combinados corretamente.
        Para descobrimos qual é um "bom endereço" para usarmos no software de
controle de dispositivos (LptInit), teremos que observar ao ligar e desligar o
computador, qual é a saída (S0 à S7) do Demultiplexador 74LS138 que não será
acionada. Para se fazer isso é necessário ligar o pino 9 do 74LS04 a uma das
saídas (S0 à S7) do 74LS138 antes de realizarmos cada teste. Se nenhum dos
LEDs acender, isso indica que descobrimos um "bom endereço", ou seja, nem o
auto-teste e nem o Sistema Operacional gerou essa combinação. Também é bom
observar ao desligar o computador, se ocorre algum acionamento das saídas.

Figura 2 - Pinagem do inversor 74LS04

       Na figura acima temos a pinagem e o esquema das portas NOT do CI

74LS04, usado no circuito para inverter a saída do demultiplexador 74LS138 e os
pinos 1, 14 e 17 do Registro de Controle.

Figura 3 - Inversão do nível alto em baixo

 Figura 4 - Inversão do nível baixo em alto

       As duas animações acima simulam o funcionamento de uma porta NOT, tanto
para inverter um nível alto como um nível baixo.

Figura 5 - Esquema completo do circuito LptInit

       No esquema acima, os dados presentes nos pinos (2 ao 9) relacionados com
o Registro de Dados da Porta Paralela, só estarão disponíveis nas saídas (12 à
19) do LATCH 74HCT573 quando o nível lógico no pino 11 do mesmo for "1".
Observe que o sinal que habilita/desabilita o LATCH 74HCT573 vem de uma das
saídas do demultilexador 74LS138, passando pelo pino 9 do 74LS04 onde será
invertido. A saída do sinal ficará disponível no pino 8 que está ligado diretamente
ao pino 11 do LATCH 74HCT573.
       No circuito, o LATCH 74HCT573 é utilizado tanto para truncar as saídas dos
dados, como também para armazenar uma célula de memória com tamanho de 1
byte, sendo essas características do LATCH vitais para o funcionamento de todo o
projeto.
 Figura 5 - Tela do programa de controle LptInit

       O endereçamento selecionado no software acima deverá ser idêntico ao

escolhido no circuito. Foram feitos testes em dois computadores distintos usando
o Sistema Operacional windows 95 e 2000 e o endereço S5 funcionou
corretamente. Portanto, faça o teste primeiro com o endereço S5, e se não
funcionar corretamente, escolha um outro.
       Quando o programa LptInit é fechado, ele grava o status dos dispositivos e a
configuração do endereçamento num arquivo chamado Disp.txt. Portanto, se o
computador for desligado e ligado mais tarde, o programa LptInit ao ser
executado se auto-configurará a partir dos dados gravados nesse arquivo.

Download do programa (LptInit.zip) 208Kb.

Se o programa for rodar no Windows NT, 2000 ou XP, faça download do driver clicando aqui
 Figura 6 - Descrição do Reg. de Controle para controlar o circuito LptInit

Algoritmo em C++ para controlar o circuito LptInit

//Algoritmo em C++ para controlar o circuito LptInit.
//Autor: Antonio Rogério Messias
//rogercom@rogercom.com
//www.rogercom.com
//Todos os direitos reservados.
//------------------------------------------------------------------------------------------------------
----------------------------------
#define BASE    0x378 //LPT1
#define DADOS     BASE
#define CONTROLE   BASE+2

#define ON     8 //xxxx1xxx - bit C3-Reg. de controle.

#define OFF   0 //xxxx0xxx - bit C3-Reg. de controle.

//Endereço de cada saída do Demux. 74LS138:

                                               //CBA
#define SELECT_S0    0   //00000000
#define SELECT_S1    1   //00000001
#define SELECT_S2    2   //00000010
#define SELECT_S3    3   //00000011
#define SELECT_S4    4   //00000100
#define SELECT_S5    5   //00000101
#define SELECT_S6    6   //00000110
#define SELECT_S7    7   //00000111

unsigned char HABILITA_LATCH = (ON+SELECT_S5);    //00001101

unsigned char DESABILITA_LATCH = (OFF+SELECT_S5);    //00000101

//------------------------------------------------------------------------------------------------------
 ----------------------------------------
//As instruções abaixo liga a saída D0 do circuito LptInit:
//------------------------------------------------------------------------------------------------------
----------------------------------------
outportb(DADOS, 1); //Disponibiliza os dados na Porta Paralela (liga pino 2-
D0).
//Ao executar a próxima função, os dados da Porta Paralela ficarão
disponíveis nas saídas do LACH.
outportb(CONTROLE, HABILITA_LATCH); //Habilita o Latch 74HCT573 -
pino 11.
Sleep( 0 ); //Aguarda um tempo para estabilizar os dados. O valor pode ser
1ms.
outportb(CONTROLE, DESABILITA_LATCH); //Desabilita o Latch
74HCT573 - pino 11.

//------------------------------------------------------------------------------------------------------
----------------------------------------
//As instruções abaixo desligam todas as 8 saídas do circuito LptInit:
//------------------------------------------------------------------------------------------------------
----------------------------------------
outportb(DADOS, 0); //Disponibiliza os dados na Porta Paralela (desliga
todas as saídas).
//Ao executar a próxima função, os dados da Porta Paralela ficarão
disponíveis nas saídas do LACH.
outportb(CONTROLE, HABILITA_LATCH); //Habilita o Latch 74HCT573 -
pino 11.
Sleep( 0 ); //Aguarda um tempo para estabilizar os dados. O valor pode ser
1ms.
outportb(CONTROLE, DESABILITA_LATCH); //Desabilita o Latch
74HCT573 - pino 11.

       Como podemos observar no código fonte acima, os dados a serem enviados

são primeiro preparados, e só depois disponibilizados ao circuito LptInit através da
instrução outportb(CONTROLE, HABILITA_LATCH); que habilita a escrita no LATCH.

http://www.rogercom.com
© Copyright, 1999-2004 ROGERCOM - Antonio Rogério Messias - rogercom@rogercom.com
Todos os Direitos Reservados - All Rights Reserved.
RComAccess
v1.0
Controle de
Acesso
 Por: Antônio Rogério Messias

CONECTANDO 8 TECLADOS NA PORTA SERIAL ATRAVÉS

DE UM MICROCONTROLADOR PIC 16F877 PARA CONTROLE DE
ACESSOS.
Para uso particular ou educacional.
Copyright(c) 1999-2004 ROGERCOM.COM
Todos os direitos reservados.

      Durante mais de um ano recebendo             emails de vários usuários do site

Rogercom.com sobre controle de acesso através do compu-            tador, mesmo
já havendo no site um artigo sobre o assunto, através da porta Paralela, resolvi
desenvolver um projeto passo-a-passo, muito mais elaborado, mas de fácil
implementação e economicamente viável, utilizando um único computador para
gerenciar até 8 teclados de 12 teclas para a leitura das senhas. Os teclados são
conectados através de uma interface microcontrolada usando um PIC 16F877. A
comunicação com a interface é estabelecida através da Porta Serial, utilizando-se
para seu controle um protocolo via software.
       Cada teclado é composto de 12 teclas (0,1,2,3,4,5,6,7,8,9, Limpar e Entrar) e
dois LEDs, um verde e outro vermelho. Os dois LEDs têem o objetivo de informar
se o acesso foi permitido ou não.
       O "cérebro" do hardware é um microcontrolador PIC 16F877, que gerencia
todos os teclados, sensores, protocolo de comunicação, Porta Serial,
temporizadores e drivers de acionamento das fechaduras elétricas.
       O hardware consegue detectar tanto o pressionamento de uma tecla em
qualquer um dos 8 teclados simultaneamente, como também saber se um dos 8
sensores de porta aberta/fechada foi acionado. Tudo isso pode ser controlado ou
detectado em tempo real através de um software específico escrito em linguagens
de programação como C/C++, C#, Java, Delphi, Visual Basic entre outras que
disponham de recursos para se comunicar com a Porta Serial do computador.
       Há bastante outros usos para esse projeto, se não desejar usá-lo como
controle de acesso, poderá utilizar os teclados para enviar comandos de controle
de jogos, avisos de alerta, controle de mesas de Sybercafes etc. O 8 sensores
poderão ser usados para detectar passagens de pessoas num recinto, como
alarme etc. Já as 8 saídas poderão ser utilizadas para ligar e desligar dispositivos,
controle de motores, relês e outros atuadores.
       Como a comunicação entre o computador e a interface é através de um
protocolo embutido num microcontrolador, mesmo que o computador seja
desligado e depois reiniciado, não ocorrerá nenhuma alteração nas configurações
atuais da placa interface. Somente através do envio de comandos pré-
estabelecidos no protocolo de comunicação é que a placa interface irá responder.
       Foram feitos testes de extensão dos cabos entre a placa de interface, os
sensores e os teclados, com 60 metros de distância e nenhuma interferência foi
detectada. Distâncias maiores não foram experimentadas.
       Nesse projeto 100% do hardware está disponível publicamente. Também os
fontes do aplicativo e as características do protocolo de comunicação estão
disponíveis integralmente.
       O programa gravado no PIC foi escrito em linguagem C e tem mais de 1000
linhas de código fonte.
       Nesse artigo está disponível gratuitamente para download, o código Hex para
gravar o PIC 16F877 e gerenciar até no máximo 2 teclados, ideal para começar a
desenvolver aplicativos e dominar a tecnologia. Acima de dois teclados,
fornecemos o PIC já gravado, pronto para ser acrescentado ao hardware
disponível nesse artigo.
       Você não está limitado a somente um sistema operacional para desenvolver
aplicações de controle de acesso para esse hardware. Poderá desenvolver em
Linux e outros sistemas operacionais.
       Como esse artigo não é pequeno, foi desmembrado em várias páginas para
mostrar todo o desenvolvimento do projeto de uma forma fácil e compreensível
pelos "navegantes" da Internet. No final dessa página, há três botões: "Anterior",
"Próxima" e "Home", utilizados para "navegar" entre as páginas do artigo e voltar à
página principal da Rogercom.com.
       Começaremos com o desenvolvimento de todo o hardware necessário, depois
iremos entender o protocolo de comunicação, a programação do computador para
acessar a Porta Serial e a criação de um programa aplicativo simples para
interagir com o circuito.
 Figura 1 - Ilustração da topologia estrela da Rede de teclados

       Conforme exibido na figura acima, a conexão dos teclados assemelha-se a

uma Rede de computadores com topologia estrela. Cada teclado funciona
independentemente um do outro e pode ser conectado ou desconectado da placa
em funcionamento, a qualquer momento se for necessário. Ao conectar ou
desconectar um teclado da placa, o programa gravado no PIC detecta esse evento
e envia a informação através do protocolo para o aplicativo no computador, dessa
forma o aplicativo poderá saber se um teclado foi removido da placa ou
acrescentado a ela.

Figura 2 - Animação
       Na animação acima temos uma visão geral da placa controladora, dos
teclados e do computador.

Figura 3 - Visão geral da placa controladora com detalhes dos conectores (ilustração)

       A figura acima é ilustrativa, mas serve como ponto de partida para o
desenvolvimento de uma placa que comporte todos os componentes e os
conectores necessários para "plugar" os periféricos.
       Observe que na placa há 9 LEDs, um deles indica se a placa está alimentada
(energizada) e os outros 8 para indica o acionamento das saídas (controle dos
dispositivos).
       A escolha do melhor conector para conectar os periféricos fica por conta do
projetista. Escolha conectores de dimensões pequenas para que a placa não
assuma grandes dimensões.
 Figura 4 - Descrição dos pinos do PIC 16F877 especificamente para o projeto Controle de
Acesso

       Na Figura 4 acima temos a descrição de todos os pinos do PIC 16F877

especificamente para ser usado no projeto elaborado nesse artigo.
       Todos os módulos dos circuitos apresentados aqui serão conectados aos
pinos do PIC e para facilitar, estão todos nomeados; as cores auxiliam na
identificação dos mesmos, e aos módulos a serem conectados.

Figura 5 - Circuito oscilador de 10Mhz para o PIC 16F877

       O circuito da Figura 5 acima é um dos primeiros módulos a ser conectado ao
microcontrolador, sendo o "coração" do PIC. O componente descrito na figura
acima como XTAL, nada mais é do que um cristal de quartzo oscilando a
10.000.000 (dez milhões de vezes por segundo) ou simplesmente 10Mhz. É esse
cristal que gera os pulsos precisos para o bom funcionamento do
microcontrolador.
       Observe que o circuito acima deve ser conectado aos pinos 13 e 14 do PIC, e
ao negativo da fonte de alimentação.

Figura 6 - Conversor de sinais RS232/TTL para comunicação Serial entre a placa

controladora e o computador

       O circuito da Figura 6 acima é um conversor de sinais RS232/TTL utilizado

para fazer a conexão entre o microcontrolador e o computador através da Porta
Serial.
Observe que os pinos 11 e 12 do Max232 são ligados respectivamente aos pinos
25 (TX) e 26 (RX) do PIC.        O cabo serial ligado ao computador é composto de 3
fios (RX, TX e GND). Os pinos 2 e 3 do conector DB9 são conectados através do
cabo serial respectivamente aos pinos 14 e 13 do Max232. O pino 5 (GND) do
conector é ligado à fonte de alimentação da placa controladora de acessos.
       Os capacitores eletrolíticos são utilizados para configurar o funcionamento
correto do Max232, alguns deles trabalham com sua polaridade invertida.
       Para mais informações sobre o CI MAX232 consulte o da Datasheet do
fabricante.

Figura 7 - Módulo de entradas multiplexadas

       O circuito exibido na Figura 7 define todas as entradas multiplexadas, como
as linhas de todos os teclados, os sensores de porta aberta/fechada, e as
entradas que detectam a conexão de um teclado plugado na placa controladora.
       Os pinos 19, 20 e 21 do PIC deverão ser conectados respectivamente aos
pinos 11, 10 e 9 do dos Multiplexadores (MUXs). Esses pinos têem a função de
selecionar uma das entradas dos MUXs, nos pinos (4, 3, 2, 1, 15, 14, 13 e 12).
Por exemplo, quando o PIC enviar o valor binário "000" aos pinos de seleção
(11,10 e 9), todas as entradas do pino 4 dos MUXs serão selecionadas.
       Os pinos (33, 34, 35, 36, 37 e 38) do PIC fazem a leitura de todos os MUXs
serialmente. Sendo assim, o pino 33 do PIC tem a função de lê serialmente todas
as entradas do MUX 1. Já a entrada 34 do PIC, lê o MUX 2, e assim por diante.
 Figura 8 - Módulo de controle das colunas dos teclados

       O circuito da Figura 8 é dotado de um buffer 74LS244, tendo como objetivo

amplificar o sinal enviado pelo PIC para selecionar as colunas dos teclados.
       O buffer 74LS244 foi esquematizado no circuito acima de forma a distribuir o
sinal amplificado a todos os 8 teclados, aproveitando todos os pinos de saída.
       O circuito deve ser conectado diretamente aos pinos 28, 29 e 30 do PIC, e as
colunas, aos seus respectivos teclados.

Página 1 de 5    «  HOME  »

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