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:
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
Se
o software for rodar no Windows NT, 2000 ou XP, faça download
do driver clicando
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: .
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-2006 ROGERCOM - Antonio Rogério Messias
- rogercom@rogercom.com
Todos os Direitos Reservados - All Rights Reserved. |
CONTROLANDO
32 DISPOSITIVOS E MONITORANDO
32 SENSORES SIMULTANEAMENTE ATRAVÉS
DA PORTA PARALELA
Download do software
(Dsp32es.zip) 347Kb.
