Meu projeto de iniciação científica. O artigo ilustra o desenvolvimento de uma solução simples, barata e segura em hardware que permite a transmissão de dados extraídos da porta paralela de um computador tipo PC com a finalidade de controlar dispositivos à distância.

1. Faculdade de Informática de Presidente PrudenteCiência da Computação <br />Controle de protótipo movimentado por liga de memória de forma (SMA) pelo PC, via rádio<br />Felipe Nisrallah Saab<br />Presidente Prudente – SP<br />2006<br />Sumário TOC quot;
1-3quot;
RESUMO PAGEREF _Toc251326034 3ABSTRACT PAGEREF _Toc251326035 3JUSTIFICATIVA PAGEREF _Toc251326036 3OBJETIVOS PAGEREF _Toc251326037 4Objetivo Geral PAGEREF _Toc251326038 4Objetivo Específico PAGEREF _Toc251326039 4REVISÃO DE LITERATURA PAGEREF _Toc251326040 4Porta Paralela PAGEREF _Toc251326041 4Circuitos transmissores-receptores PAGEREF _Toc251326042 5Circuitos codificadores-decodificadores PAGEREF _Toc251326043 7Microcontroladores PAGEREF _Toc251326044 9METODOLOGIA PAGEREF _Toc251326045 10Testando comunicação entre TXC1 e RXD1 PAGEREF _Toc251326046 10Testando comunicação entre HT12E e HT12D PAGEREF _Toc251326047 11Transmitindo dados codificados sem fio PAGEREF _Toc251326048 12Integrando o microcontrolador Basic Step 1 PAGEREF _Toc251326049 14Enviando dados através da porta paralela PAGEREF _Toc251326050 21CONCLUSÃO PAGEREF _Toc251326051 27REFERÊNCIAS PAGEREF _Toc251326052 27ANEXOS PAGEREF _Toc251326053 28Anexo 1 – Código fonte em PBasic do programa do BS1 PAGEREF _Toc251326054 28Anexo 2 – Código fonte da classe ParallelPort.java PAGEREF _Toc251326055 30Anexo 3 – Código fonte da classe Principal.java PAGEREF _Toc251326056 32<br />RESUMO<br />O uso de módulos transmissores digitais híbridos facilita enormemente o projeto e desenvolvimento de circuitos transmissores de informações digitais. Neste projeto pretende-se desenvolver uma solução econômica e ao mesmo tempo segura para a transmissão de sinais digitais extraídos de portas de comunicação de computadores tipo PC, para controle de dispositivos à distância. Tais sinais devem ser codificados na transmissão e decodificados na recepção de forma a evitar interferência em outros dispositivos. Como aplicação desta solução, pretende-se controlar à distância um protótipo movimentado por uma liga com memória de forma, desenvolvido em projeto paralelo.<br />ABSTRACT<br />The use of hybrid digital transmitters greatly facilitates the design and development of digital information transmitter circuits. This project aims to develop a cheap and safe solution to transmission of digital signs extracted from communication ports of PC type computers, to control devices remotely. Such signs must be encoded in the transmission and decoded at the reception to avoid interference in other devices. As an application of this solution, is intended to control remotely a prototype handled by an alloy with shape memory.<br /> <br />JUSTIFICATIVA<br />O controle de dispositivos eletrônicos utilizando o computador já é relativamente comum nos dias de hoje, sendo a saída paralela a mais utilizada devido à facilidade de implementação de hardware, software e de expansão (Soares1, 2005) (Soares2, 2005). Muitos textos explicativos bastante completos estão disponíveis como, por exemplo, Messias (2008), que aborda diversas formas de controle de dispositivos externos ao computador. Tal controle normalmente faz uso de interfaces transistorizadas e/ou com acopladores ópticos para a proteção do microcomputador, tendo em comum o fato de precisarem de conexões físicas entre a porta paralela e o equipamento controlado, o que limita a distância máxima entre as partes.<br />Por outro lado, o desenvolvimento de módulos transmissores-receptores híbridos facilitou muito o desenvolvimento de dispositivos para a troca de informações digitais sem fio (Braga, 2005) e, juntamente com circuitos dedicados codificadores e decodificadores como os Holtek HT12E e HT12D, pode-se transmitir códigos relativamente sofisticados e, com isso, controlar diversos dispositivos simultaneamente.<br />Uma solução de controle sem fio permite uma flexibilidade muito maior no controle de dispositivos móveis como os robóticos.<br />OBJETIVOS<br />Objetivo Geral<br />Este projeto tem como objetivo geral o desenvolvimento de uma solução simples, barata e segura em hardware que permita a transmissão de dados extraídos da porta paralela de um computador tipo PC com a finalidade de controlar dispositivos à distância.<br /> Objetivo Específico<br />Este projeto tem como objetivo específico, o controle de um protótipo movimentado por liga de memória de forma (SMA) à distância utilizando a solução de hardware previamente citada.<br />Tal protótipo irá ser desenvolvido em projeto paralelo.<br />REVISÃO DE LITERATURA<br />Porta Paralela<br />A porta paralela é uma interface de comunicação entre o computador e um periférico. Quando a IBM criou seu primeiro PC (Personal Computer ou Computador Pessoal), a ideia era conectar a essa Porta uma impressora, mas atualmente, são vários os periféricos que utilizam esta Porta para enviar e receber dados para o computador (Messias, 2009). <br />Um dos principais motivos dessa porta ser largamente utilizada para controlar dispositivos periféricos é a facilidade de acesso e manipulação.<br />A porta paralela geralmente utiliza o conector DB25 que é explicado a seguir na Figura 1.<br />Figura 1 – Conector DB25 Macho<br />Como mostrado na Figura 1, a porta paralela reserva 8 pinos para dados (2-9).<br />A porta paralela possui três endereços para escrita e leitura de dados, como indicado a seguir:<br />EndereçoPinos378hD0 – D7379hAKNOWLEDGE, BUSY, PAPER END, SELECT OUT, ERROR37AhSTROBE, AUTO FEED, INIT, SELECT IN<br />Circuitos transmissores-receptores<br />Um dos problemas encontrados nos projetos que envolvem controles remotos sem fio (usando sinais de rádio – RF) é a dificuldade em se obter ou fabricar as bobinas e depois fazer os ajustes. Além disso, para se conseguir um bom alcance e uma boa imunidade a ruídos, existem diversos outros problemas a serem solucionados, exigindo circuitos complexos (Braga, 2005).Com a utilização de módulos híbridos, o projeto desses circuitos é simplificado, pois o transmissor e o receptor previamente ajustados de fábrica podem ser obtidos em faixas de frequências apropriadas, onde o nível de ruído e interferência é menor.Esses módulos nada mais são do que pequenas placas que já têm o circuito completo de um receptor, ou de um transmissor casado, e que facilmente podem ser integrados numa montagem.<br />Para o desenvolvimento deste projeto, foram escolhidos os módulos Spirit-on RXD1 e TXC1. Receptor e transmissor, respectivamente. <br />É importante ressaltar que o transmissor TXC1 só consegue transmitir dados seriais, ou seja, só tem um pino que recebe os dados a serem enviados sem fio. Do mesmo modo, o receptor RXD1, após receber os sinais sem fio e converte-los em digitais, os joga em apenas um pino de saída.<br />Ambos os circuitos podem operar em 315MHz ou 434MHz. Neste projeto, eles irão operar em 315MHz, ou seja, 315M ciclos de onda serão enviados a cada segundo. Como o receptor consegue receber em média 2048 bits por segundo (operando a 315MHz), deve-se ajustar o codificador para enviar até no máximo 2048 bps para o emissor, garantindo assim, que o receptor conseguirá receber todos os dados corretamente.<br />O alcance máximo desses módulos operando a 315MHz em campo aberto é de 100m. Caso existam paredes e obstáculos entre os módulos, a distância máxima é drasticamente afetada.<br />Tais módulos são demonstrados na figura 2 e 3, a seguir.<br />Figura 2 – Receptor RXD1<br />Figura 3 – Transmissor TXC1<br />Circuitos codificadores-decodificadores<br />Um codificador é um circuito que transforma uma entrada (de codificação conhecida) em uma saída de codificação desconhecida. <br />O decodificador já faz o contrário: transforma um código desconhecido em um conhecido. <br />Como os circuitos transmissor e receptor utilizados neste projeto (TXC1 e RXD1) só trabalham com dados seriais (apenas um bit por vez, ou seja, um único pino para os dados) e os dados extraídos da porta paralela são paralelos (8 bits de dados, ou seja, 8 pinos), é necessário que estes dados paralelos sejam codificados em dados seriais para que possam ser transmitidos sem fio. <br />Após o recebimento dos dados pelo circuito receptor, eles precisam ser descodificados em paralelo novamente para o microcontrolador poder entendê-los (iremos abordar o microcontrolador na próxima seção).<br />Para conseguir transformar os bits extraídos da porta paralela em bits seriais, neste projeto, serão utilizados os circuitos Holtek HT12E e HT12D, codificador e decodificador, respectivamente.<br />Tais circuitos conseguem codificar/decodificar até 12 bits, sendo eles: 8 bits para dados e 4 bits para endereço, porém, todos os bits podem ser usados para dados.<br />Os circuitos são demonstrados nas figuras 4 e 5.<br />Figura 4 – Codificador HT12E<br />Figura 5 – Decodificador HT12D<br />Uma característica interessante desses modelos em específico, é que eles possuem gerador de clock interno, ou seja, não é necessário um clock externo para a codificação/decodificação dos dados. Porém, o processo de codificar os dados é mais rápido do que o processo de decodificar os dados, então para que ambos trabalhem em sintonia, deve-se utilizar resistores ligando os pinos OSC1 e OSC2 dos circuitos para que eles consigam operar na mesma velocidade.<br />Lembrando que o resistor no circuito codificador deve ser escolhido de modo a fazer o circuito codificador respeitar os limites dos circuitos transmissor-receptor (neste caso, 2Kbps) e o resistor do circuito decodificador deve ser escolhido de acordo com o resistor do codificador, para ambos operarem na mesma velocidade.<br />Microcontroladores<br />Microcontroladores são computadores digitais que realizam operações em seqüência sem intervenção humana. As operações são programadas por um programador, que segue uma lista de instruções que compõe a linguagem de programação (Assembly, C, Java). <br />Os microcontroladores são conhecidos como computadores embutidos em circuito-integrado. Em um microcontrolador podemos encontrar memória, CPU, entradas e saídas. Alguns ainda possuem periféricos como conversores A/D e D/A, comparadores, entre outros. <br />Neste projeto será usado o microcontrolador Basic Step 1 da Tato Equipamentos Eletrônicos. Ele foi escolhido pelo baixo custo e pelas configurações de hardware não serem muito avançadas (o que seria um desperdício no escopo do projeto), consequentemente, a linguagem utilizada para se programar também não é tão complexa (PBASIC, versão simplificada da antiga BASIC).<br />O Hardware do Basic Step 1 engloba em uma única placa: um microprocessador PIC16F628, uma memória de 256B com o interpretador PBASIC e um regulador de tensão que o permite ser alimentado com tensão de 7,5 a 15V.<br />A figura 6 demonstra o hardware do Basic Step 1 e a função de cada um dos pinos.<br />Figura 6 – Hardware do Basic Step 1<br />O pino RESET, como dito na Figura 6: reseta o microcontrolador com nível baixo, ou seja, a ausência de voltagem nesse pino indica que o microcontrolador será resetado e o programa não funcionará como esperado. Para o funcionamento correto do programa, esse pino deverá ter sempre tensão positiva.<br />O BS1 funciona com fonte de alimentação entre +7 e +15V, uma bateria comum de 9V é uma boa opção de fonte de alimentação (alternativa adotada neste projeto).<br />Uma característica que deve ser ressaltada é que os pinos de dados P0-P7 podem ser utilizados ou como entrada ou como saída de dados, nunca ambas funções. Ou seja, deve-se utilizar um pino para receber certo dado e outro pino para passá-lo adiante. Existem técnicas de programação dinâmica para mudar um pino de saída para entrada ou vice-versa durante a execução do programa, porém não serão abordadas neste projeto.<br />DESENVOLVIMENTO<br />Testando comunicação entre TXC1 e RXD1<br />Antes de tudo, é necessário verificar se os módulos básicos estão funcionando corretamente. Para tal, deve-se fazer uma ligação simples entre eles para verificar se a sua comunicação está correta. A Figura 7 representa o modelo do circuito:<br />Figura 7 – Circuito para testar comunicação entre TXC1 e RXD1<br />R1 e R2 – Resistores de 470 Ω<br />As antenas devem ser fios de cobre com 22,5 cm de comprimento e por volta de 26 AWG.<br />Caso os circuitos estejam transmitindo corretamente, os LED’s ligados nos pinos DATA do RXD1 serão ligados ou desligados de acordo com o interruptor ligado no pino DATA do TXC1.<br />Uma característica que vale ser ressaltada é que quando o RXD1 fica algum tempo ocioso (sem receber sinal sem fio), é automaticamente colocado +5V nos pinos DATA, deve-se levar isso em consideração quando estiver trabalhando com o microcontrolador, caso contrário esse pequeno detalhe poderá afetar drasticamente o funcionamento do sistema.<br />Testando comunicação entre HT12E e HT12D<br />Seguindo a mesma ideia do tópico anterior, deve-se testar se os circuitos codificador e decodificador conseguem se comunicar corretamente. A Figura 8 representa o modelo do circuito:<br />Figura 8 – Circuito para testar comunicação entre HT12E e HT12D<br />R1 - Resistor de 1,5 MΩ<br />R2 - Resistor de 120 KΩ<br />R3, R4, R5, R6, R7 - Resistores de 470 Ω<br /> <br />O HT12E codifica os sinais presentes nos pinos A0-A7 e D8-D11 em um único sinal e o transmite através do pino DOUT, porém, enquanto o pino TE (Transmission Enabled) possuir +5V, o circuito permanecerá em stand by. Para começar o processo de codificação, é necessário colocar 0V neste pino.<br />O HT12D não tem um pino específico para ativar seu funcionamento, ele está sempre em stand by e começa a funcionar quando recebe algum sinal no pino DIN. Quando o sinal é válido, o pino VT (Valid Transmission) recebe +5V e os dados são decodificados e repassados para os seus respectivos pinos.<br />Transmitindo dados codificados sem fio<br />Uma vez que os dois módulos necessários para a transmissão sem fio estão em perfeito funcionamento (transmissor-receptor e codificador-decodificador), a junção deles é extremamente simples. A Figura 9 representa o modelo do circuito:<br />Figura 9 – Circuito para transmitir dados codificados sem fio<br />R1 - Resistor de 1,5 MΩ<br />R2 - Resistor de 120 KΩ<br />R3, R4, R5, R6, R7 - Resistores de 470 Ω<br />Os dados a serem transmitidos são enviados aos pinos D8-D11 do HT12E (neste caso, por meio de interruptores), após a codificação, o único sinal resultante é enviado ao TXC1 que por sua vez transmite sem fio para o RXD1. Quando o RXD1 recebe o sinal sem fio, ele o transforma novamente em sinal digital e repassa para o HT12D, que por fim decodifica os dados e os envia para os pinos correspondentes. <br />Neste circuito, os leds ligados aos pinos D8-D11 do HT12D irão acender de acordo com os interruptores ligados aos pinos D8-D11 do HT12E. Lembrando que o HT12E fica em stand by enquanto o pino TE possuir +5V, para começar o processo de codificação deve-se colocar 0V nesse pino.<br />Observação: perceba que alguns instantes após o envio do sinal (após os leds acenderem conforme os interruptores) e o HT12E entrar em stand by de novo (por meio da passagem de +5V no pino TE), o RXD1 irá enviar +5V na sua saída, consequentemente o HT12D irá receber somente +5V e irá repassar esse valor para todos os pinos, ou seja, todos os leds irão ficar acesos, independente da codificação anterior dos interruptores.<br />Integrando o microcontrolador Basic Step 1<br />Com a transmissão sem fio funcionando, uma boa opção é começar a integrar o hardware com o software, ou seja, enviar dados extraídos do computador e não mais de interruptores, porém, construir o software agora é meio arriscado, pois não sabemos como o microcontrolador irá se comportar, ou seja, não sabemos como os dados devem ser enviados para ele, portanto, a melhor opção agora é programar o microcontrolador.<br />O Basic Step 1 é um microcontrolador programável (como já foi explicado anteriormente), ou seja, escrevemos um software em uma linguagem de programação (PBasic), compilamos e depois descarregamos o programa na memória do microcontrolador.<br />O compilador pode ser baixado gratuitamente do site da fabricante: www.tato.ind.br e funciona no sistema operacional Windows 95 ou superior. A Figura 10 mostra a tela do compilador:<br />Figura 10 - Tela do Compilador Basic Step 1<br />Uma vez instalado, já podemos começar a escrever o programa, compilá-lo e descarregá-lo no microcontrolador. Para tais funções, iremos utilizar alguns botões da barra de ferramentas, explicada na Figura 11:<br />Figura 11 - Barra de ferramentas do Compilador Basic Step 1<br />Os botões Compile e Download serão usados para compilar e descarregar o programa no microcontrolador, respectivamente.<br />Para poder descarregar o programa no microcontrolador, ele deve estar ligado ao computador pela porta paralela (conector DB25) ou pela porta serial (conector DB9). A Figura 12 representa os dois tipos de conexões possíveis:<br />Figura 12 - Ligações necessárias para conectar o Basic Step 1 com o computador<br />Caso a porta selecionada seja a serial (parte esqueda da Figura 12), o pino 2 deve se conectar ao pino PCO (PC Out) do BS1, o pino 3 ao pino PCI (PC In) do BS1 e o pino 5 ao terra (0V).<br />Caso a porta selecionada seja a paralela (parte direita da Figura 12), o pino 2 deve se conectar ao pino PCI do BS1, o pino 3 ao pino PCO do BS1 e o pino 7 ao terra (0V).<br />Uma vez que a conexão necessária para o download do programa para o microcontrolador está feita, iremos ligar o BS1 com o HT12D, o qual irá de fato, enviar dados para o BS1. <br />Vamos então assumir que o pino VT do HT12D irá estar ligado no pino P0 do BS1, vamos assumir também que os pinos P1, P2 e P3 do BS1 estarão ligados aos pinos D8, D9 e D10 do HT12D, como mostrado na Figura 13:<br />Figura 13 - Ligação entre os pinos de dados do HT12D e do BS1<br />Os pinos P4, P5, P6 serão conectados ao protótipo desenvolvido em paralelo com a finalidade de enviar os sinais elétricos necessários para movimentá-lo. Como até o momento da escrita deste artigo, o projeto referente ao protótipo ainda não está completo, iremos apenas simular o funcionamento de tal, ou seja, iremos “imaginar” que os pinos P4, P5 e P6 do BS1 serão responsáveis por movimentar o protótipo para esquerda, direita e frente, respectivamente.<br />Basicamente, o pino P1 controla o pino P4, ou seja, se houver +5V em P1, iremos enviar +5V em P4 (andar para a esquerda) e vice-versa. O mesmo acontece com os pares P2,P5 e P3,P6.<br />Lembrando que não no BS1 cada pino pode ser ou entrada, ou saída. Sendo assim, utilizamos P1, P2 e P3 como entrada e P4, P5 e P6 como saída.<br />Para facilitar a visualização dos resultados, sugiro que sejam ligados leds aos pinos correspondentes ao movimento das pernas (P4, P5 e P6), sem esquecer de adicionar resistores de 470 Ω.<br />Agora que o hardware já está corretamente conectado, podemos partir para a lógica do programa. Como o escopo deste projeto não é o ensino da linguagem PBasic, será assumido que o leitor já possua tal conhecimento (caso não possua, uma boa fonte de leitura se encontra em Angnes (2003).<br />Uma característica do BS1 que vale ser lembrada é que ele possui fluxo único de informações, ou seja, não possui paralelismo, então temos que pensar cautelosamente em como escrever o programa para que ele esteja sempre no fluxo certo.<br />Com essas informações em mente, podemos começar a pensar no programa do microcontrolador. Detalhe: não podemos esquecer que o RXD1 envia +5V na sua saída após algum tempo ocioso, fazendo assim, o HT12D enviar +5V em todas suas saídas também. Isso deve ser evitado, pois não queremos que o decodificador coloque +5V em todas as saídas, isso iria atrapalhar o funcionamento do programa, consequentemente, o movimento do protótipo. <br />Uma solução é monitorar o pino VT (Valid Transmission) do decodificador e quando chegar uma transmissão, parar o processamento por 50 milissegundos (uma vez que a transmissão vinda do RXD1 quando joga +5V após algum tempo ocioso é muito mais rápida do que isso), se após esse período o pino VT ainda tiver +5V significa que a transmissão é realmente válida e não o RXD1 ocioso enviando +5V.<br />A Figura 14 mostra o fluxograma do programa para o BS1:<br />Figura 14 - Fluxograma do programa para o BS1<br />Como o BS1 possui um único fluxo de execução, uma boa maneira de pensar em um programa para ele é através de um fluxograma.<br />O fluxograma é autoexplicativo, basicamente o que o programa irá fazer é: <br />Monitorar o pino P0 (ligado ao VT) até ele possuir valor lógico 1 (+5V);<br />Se possuir valor 1, para o processamento por 50 milissegundos (pause);<br />Verifica de novo P0, caso ainda tenha valor 1 é porque é uma transmissão válida;<br />Verifica P1 e liga ou desliga P4 (+5V ou 0V respectivamente);<br />Verifica P2 e liga ou desliga P5 (+5V ou 0V respectivamente);<br />Verifica P3 e liga ou desliga P6 (+5V ou 0V respectivamente);<br />Verifica novamente se P0 tem valor 1, se sim pula a pausa de 50 milissegundos e volta a verificar P1, P2 e P3 pois continua sendo uma transmissão válida.<br />O código PBasic resultante deste fluxograma encontra-se no Anexo 1.<br />Depois do código ser digitado no Compilador Basic Step 1 e compilado com sucesso, basta fazer a conexão do BS1 com o PC (como indicado anteriormente) e clicar no botão Download na barra de ferramentas do compilador. <br />Após o download para o BS1, é recomendável desconectá-lo do computador. Assim que o BS1 receber energia da sua fonte de alimentação ele já vai iniciar o programa. Basta conferir os resultados alterando os interruptores ligados nos pinos D8, D9 e D10 do codificador (HT12E). <br />A Figura 15 mostra o modelo completo do circuito até agora:<br />Figura 15 – Modelo completo do circuito (sem conexão com o computador)<br />Enviando dados através da porta paralela<br />Agora que todo o hardware está quase todo pronto e sabemos como ele funciona (é apenas uma suposição, uma vez que o projeto em paralelo ainda não foi concluído), precisamos adicionar interação com o computador.<br />Para tal, precisamos escrever um software que envie dados para a porta paralela, depois coletar esses dados, enviá-los para o circuito codificador (HT12E) e ativar a codificação (enviar 0V para o pino TE). Daí para frente o processo já é bem conhecido.<br />Como tem sido até aqui, o hardware vem sempre antes do software, o que não vai ser diferente com a porta paralela. Primeiro devemos conectar os fios do cabo da porta paralela com o codificador, a Figura 16 representa o modelo do circuito:<br />Figura 16 – Modelo das ligações da porta paralela com o restante do circuito<br />Apenas por questão de padronização (separar bits de dados dos de controle), iremos usar o pino INIT (16) da porta 37Ah para controlar o início e o fim da codificação dos dados, já que este está ligado no pino TE do codificador. Já os pinos de dados terão seus correspondentes na porta de dados (378h). Seguem os pares (HT12E - DB25): D8 – D0, D9 – D1, D10 – D2.<br />Agora que o hardware está completamente montado basta escrever o software para podermos enviar os dados. Neste projeto foi utilizada a linguagem Java para realizar essa tarefa.<br />O único meio de acessar a porta paralela através do Java é utilizando uma biblioteca bem conhecida nesse meio: a Parport. A Parport pode facilmente ser encontrada na internet. Após o download do arquivo “parport.dll” é necessário que este seja colocado nos diretórios do JDK e da JRE:<br />.../Java/jre/Bin<br />.../Java/jdk/bin<br />.../Java/jdk/jre/Bin<br />Geralmente o download do arquivo “parport.dll” traz consigo a classe “ParallelPort.java” (código fonte disponível no Anexo 2) que já implementa os métodos necessários para efetuar a comunicação com a porta paralela: write e read.<br />Uma vez que o Java consegue se comunicar com a porta paralela, é preciso conceder acesso, já que os sistemas operacionais Windows não liberam o acesso de suas portas para programas feitos em Java. Para tal, deve-se utilizar o UserPort (facilmente encontrado na internet), software que libera o acesso das portas especificadas. <br />Para o UserPort funcionar corretamente, o arquivo “UserPort.sys” deve ser copiado para o diretório “C:indowsystem32rivers”.<br />Sempre antes de executar o software em Java (desenvolvido mais adiante) deve-se executar o “UserPort.exe” e clicar no botão Start, como demonstrado na Figura 17:<br />Figura 17 - UserPort<br />Com as portas acessíveis e liberadas, é hora de se concentrar no software.<br />Para facilitar o desenvolvimento do software será utilizado o Netbeans IDE 6.7.1.<br />Com o Netbeans aberto, deve-se criar um novo projeto: Java > Aplicativo da área de Trabalho Java. O Netbeans já cria um esqueleto pronto, porém não é interessante para esse projeto. Deve-se apagar todos os pacotes e criar um novo pacote. Dentro deste novo pacote deve-se criar um novo Formulário JFrame. A estrutura do projeto deve ficar como mostrada na Figura 18:<br />Figura 18 – Estrutura do projeto<br />O novo formulário irá conter três botões, responsáveis por enviar os sinais correspondentes ao movimento para a esquerda, direita e frente. Os botões deverão ter os nomes: jB_Esquerda, jB_Direita, jB_Frente, respectivamente.<br />A Figura 19 mostra como fica o formulário pronto:<br />Figura 19 – Formulário contendo os 3 botões necessários<br />Antes de começar a codificar, vamos criar um novo pacote chamado “parport” e adicionar a classe “ParallelPort.java”. A estrutura do projeto deve ficar como na Figura 20:<br />Figura 20 – Estrutura do projeto após inserção da classe ParalellPort<br />Lembrando que o nome do pacote DEVE ser “parport”, caso contrário ocorrerão erros durante a execução.<br />Agora está faltando apenas o código fonte, o que não é algo muito complexo.<br />Daqui pra frente será abordado apenas o código referente ao acesso à porta paralela. Todo o código fonte da classe Principal.java encontra-se no Anexo 3.<br />O programa deverá conter dois objetos da classe ParallelPort, um responsável pela porta de dados (378h) e o outro responsável pela porta de controle (37Ah).<br />Tais objetos devem ser instanciados no construtor da classe principal. Só para garantir que o programa não vai começar enviando dados (devido a algum tipo de lixo), deve-se enviar valor lógico 1 (+5V) no pino responsável pelo começo da codificação dos dados. Segue o código do construtor da classe principal:<br /> dados = new ParallelPort(0x378);<br /> controle = new ParallelPort(0x37A);<br /> try {<br /> controle.write(4);<br /> dados.write(0);<br /> } catch (Exception e) {<br /> JOptionPane.showMessageDialog(this, e.toString());<br /> }<br />O comando “controle.write(4)” joga o valor binário 00000100 (4 decimal) na porta 37Ah, pois o objeto foi instanciado com essa porta. O pino INIT é o terceiro pino menos significativo da porta 37Ah. Uma vez que o bit 1 é enviado para o pino INIT, o codificador ficará em stand by e o circuito inteiro estará parado.<br />Quando o usuário clicar no botão desejado (Frente, Direita ou Esquerda) o software irá enviar o respectivo sinal (3 move para frente, 2 para a direita e 1 para a esquerda) na porta de dados e habilitar a codificação dos dados e a transmissão sem fio (enviando valor lógico 0 no pino INIT). O software manterá esse estado até que o usuário solte o botão do mouse. Quando isso acontecer, a codificação será desabilitada e a porta de dados receberá valor nulo (0). <br />Para adicionar algum código nesses eventos, deve-se implementar listeners nos eventos MousePressed e MouseReleased. No Netbeans, apenas um clique com o botão direito sobre o botão desejado e navegar até a opção Eventos > Mouse > MousePressed/MouseReleased. O Netbeans já cria automaticamente todo o código necessário e o método “nome_do_botaoMousePressed/Released”. Segue o código dos métodos referentes ao botão jB_Esquerda:<br />private void jB_EsquerdaMousePressed(java.awt.event.MouseEvent evt) {<br /> try {<br /> dados.write(1);<br /> controle.write(0);<br /> } catch (Exception e) {<br /> JOptionPane.showMessageDialog(this, e.toString());<br /> }<br /> }<br /> private void jB_EsquerdaMouseReleased(java.awt.event.MouseEvent evt) {<br /> try {<br /> controle.write(4);<br /> dados.write(0);<br /> } catch (Exception e) {<br /> JOptionPane.showMessageDialog(this, e.toString());<br /> }<br /> }<br />Os métodos dos botões jB_Direita e jB_Frente são quase iguais, a única diferença é no método MousePressed, onde eles enviam o valor 2 e 3 respectivamente no comando “dados.write(1)”.<br />CONCLUSÃO<br />Como demonstrado neste artigo, a transmissão de dados sem fio, extraídos do PC não tem uma solução muito complexa, pelo contrário, é relativamente fácil de implementar (deve-se possuir alguns entendimentos básicos de eletrônica e programação) e o custo é baixo. <br />A integração de um microcontrolador limita a capacidade do circuito apenas à imaginação do projetor, podendo integrar seu próprio circuito a micro-ondas, geladeiras, portões elétricos, lâmpadas, televisores, entre uma variedade enorme de dispositivos elétricos e eletrônicos, bastando apenas conhecer como cada dispositivo funciona para evitar pequenos erros que levem a defeitos.<br />Lembrando que a ideia passada sobre a movimentação do protótipo em todo o desenvolvimento foi apenas uma possível ideia, já que o projeto em paralelo ainda não foi totalmente desenvolvido. É provável que após o desenvolvimento de tal, deva-se mudar o modo como o microcontrolador trata os dados e consequentemente como eles devem ser enviados para ele através do computador (acarretando mudanças no software também).<br />REFERÊNCIAS <br />[1] Braga, Newton C.; Módulos Híbridos; Eletrônica Total; No 110; Editora Saber; São Paulo; 2005. <br />[2] Caçula, Mirian Elaine Fernandes & Quintilio, Robson; Estudo sobre Aplicabilidade das Ligas com Memória de Forma (SMA) em Robótica. Anais do ENAPI2005; Unoeste; 2005.<br />[3] Cohen, Sacha, Training & Development. Small business encyclopedia, Apr96, Vol. 50, Número 4, 1996.<br />[4] Deal III, Walter F., and Steve C. Hsiung. 2007. quot;
Exploring TeleRobotics: A Radio-Controlled Robot.quot;
Technology Teacher 67, no. 2: 11-17. Academic Search Premier, EBSCOhost (accesso em outubro de 2008).<br />[5] Messias, Antonio Rogério. Rogercom. http://www.rogercom.com. Consultado em 30/09/2008<br />[6] Soares, Marcio José. Robô RF; Revista Mecatrônica Fácil; No 15; Editora Saber; São Paulo, 2004.<br />[7] Soares1, Marcio José. Porta Paralela II; Ampliando o Número de entradas; Revista Eletrônica Total; No 106; Editora Saber; São Paulo, 2005.<br />[8] Soares2, Marcio José. Porta Paralela I; Ampliando o Número de Saídas; Revista Eletrônica Total; No 105; Editora Saber; São Paulo, 2005.<br />[9] Telecontrolli; Telecontrolli, thick film technology, design & manufacturing facilities, hybrids circuits, RF applications; Disponível em http://www.telecontrolli.com/eng/, acessado em outubro/2008.<br />[10] Angnes, Derli Luís; Microcontrolador Basic Step 1; 2003; Disponível em www.radiopoint.com.br/MICROCONTROLADORES/MicrocontroladoresBASICStep.pdf, acessado em janeiro/2010.<br />ANEXOS<br />Anexo 1 – Código fonte em PBasic do programa do BS1<br />output 4<br />output 5<br />output 6<br />input 0<br />input 1<br />input 2<br />input 3<br />pin4 = 0<br />pin5 = 0<br />pin6 = 0<br />loop:<br />if pin0=1 then recebendo<br />goto loop<br />recebendo:<br />pause 50<br />if pin0=1 then transmissaoValida<br />goto loop<br />transmissaoValida:<br />if pin1=1 then liga4<br />if pin1=0 then desliga4<br />verifica2:<br />if pin2=1 then liga5<br />if pin2=0 then desliga5<br />verifica3:<br />if pin3=1 then liga6<br />if pin3=0 then desliga6<br />verificaTrans:<br />if pin0=1 then transmissaoValida<br />goto loop<br />liga4:<br />pin4 = 1<br />goto verifica2 <br />desliga4:<br />pin4 = 0<br />goto verifica2 <br />liga5:<br />pin5 = 1<br />goto verifica3<br />desliga5:<br />pin5 = 0<br />goto verifica3<br />liga6:<br />pin6 = 1<br />goto verificaTrans<br />desliga6:<br />pin6 = 0<br />goto verificaTrans<br />Anexo 2 – Código fonte da classe ParallelPort.java<br />package parport;<br />public class ParallelPort {<br /> /** The port base address (e.g. 0x378 is base address for LPT1) */<br /> private int portBase;<br /> /** To cunstruct a ParallelPort object,<br /> * you need the port base address<br /> */<br /> public ParallelPort (int portBase)<br /> {<br /> this.portBase = portBase;<br /> }<br /> /** Reads one byte from the STATUS pins of the parallel port.<br /> *<br /> * The byte read contains 5 valid bits, corresponing to 5 pins of input<br /> * from the STATUS pins of the parallel port (the STATUS is located<br /> * at quot;
portBase + 1quot;
, e.g. the STATUS address for LPT1 is 0x379).<br /> * <br /> * This diagram shows the content of the byte:<br /> *<br /> * Bit | Pin # | Printer Status | Inverted<br /> * -----+-------+-----------------+-----------<br /> * 7 | ~11 | Busy | Yes<br /> * 6 | 10 | Acknowledge |<br /> * 5 | 12 | Out of paper |<br /> * 4 | 13 | Selected |<br /> * 3 | 15 | I/O error |<br /> * <br /> * Note that Pin 11 is inverted, this means that quot;
Hiquot;
input on pin<br /> * means 0 on bit 7, quot;
Lowquot;
input on pin means 1 on bit 7.<br /> */<br /> public int read ()<br /> {<br /> return ParallelPort.readOneByte (this.portBase+1);<br /> }<br /> /** Writes one byte to the DATA pins of parallel port.<br /> * The byte is written to the DATA pins of the port. The DATA pins are<br /> * located at the base address of the port (e.g. DATA address for LPT1<br /> * is 0x378).<br /> *<br /> * This diagram shows how the byte is written:<br /> *<br /> * Bit | Pin # | Printer DATA<br /> * -----+-------+--------------<br /> * 7 | 9 | DATA 7<br /> * 6 | 8 | DATA 6<br /> * 5 | 7 | DATA 5<br /> * 4 | 6 | DATA 4<br /> * 3 | 5 | DATA 3<br /> * 2 | 4 | DATA 2<br /> * 1 | 3 | DATA 1<br /> * 0 | 2 | DATA 0<br /> */<br /> public void write (int oneByte)<br /> {<br /> ParallelPort.writeOneByte (this.portBase, oneByte);<br /> }<br /> /** Reads one byte from the specified address.<br /> * (normally the address is the STATUS pins of the port)<br /> */<br /> public static native int readOneByte (int address);<br /> /** Writes one byte to the specified address<br /> * (normally the address is the DATA pins of the port)<br /> */<br /> public static native void writeOneByte (int address, int oneByte);<br /> static<br /> {<br /> System.loadLibrary(quot;
parportquot;
);<br /> }<br />}<br />Anexo 3 – Código fonte da classe Principal.java<br />package controlandoportaparalela;<br />import javax.swing.JOptionPane;<br />import parport.ParallelPort;<br />/**<br /> *<br /> * @author Felipe<br /> */<br />public class Principal extends javax.swing.JFrame {<br /> ParallelPort dados,controle;<br /> /** Creates new form Principal */<br /> public Principal() {<br /> initComponents();<br /> dados = new ParallelPort(0x378);<br /> controle = new ParallelPort(0x37A);<br /> try {<br /> controle.write(4);<br /> dados.write(0);<br /> } catch (Exception e) {<br /> JOptionPane.showMessageDialog(this, e.toString());<br /> }<br /> }<br /> /** This method is called from within the constructor to<br /> * initialize the form.<br /> * WARNING: Do NOT modify this code. The content of this method is<br /> * always regenerated by the Form Editor.<br /> */<br /> @SuppressWarnings(quot;
uncheckedquot;
)<br /> // <editor-fold defaultstate=quot;
collapsedquot;
desc=quot;
Generated Codequot;
><br /> private void initComponents() {<br /> jB_Esquerda = new javax.swing.JButton();<br /> jB_Frente = new javax.swing.JButton();<br /> jB_Direita = new javax.swing.JButton();<br /> setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);<br /> setTitle(quot;
Controlando Porta Paralelaquot;
);<br /> jB_Esquerda.setText(quot;
Esquerdaquot;
);<br /> jB_Esquerda.setName(quot;
jB_Esquerdaquot;
); // NOI18N<br /> jB_Esquerda.addMouseListener(new java.awt.event.MouseAdapter() {<br /> public void mousePressed(java.awt.event.MouseEvent evt) {<br /> jB_EsquerdaMousePressed(evt);<br /> }<br /> public void mouseReleased(java.awt.event.MouseEvent evt) {<br /> jB_EsquerdaMouseReleased(evt);<br /> }<br /> });<br /> jB_Frente.setText(quot;
Frentequot;
);<br /> jB_Frente.setName(quot;
jB_Frentequot;
); // NOI18N<br /> jB_Frente.addMouseListener(new java.awt.event.MouseAdapter() {<br /> public void mousePressed(java.awt.event.MouseEvent evt) {<br /> jB_FrenteMousePressed(evt);<br /> }<br /> public void mouseReleased(java.awt.event.MouseEvent evt) {<br /> jB_FrenteMouseReleased(evt);<br /> }<br /> });<br /> jB_Direita.setText(quot;
Direitaquot;
);<br /> jB_Direita.setName(quot;
jB_Direitaquot;
); // NOI18N<br /> jB_Direita.addMouseListener(new java.awt.event.MouseAdapter() {<br /> public void mousePressed(java.awt.event.MouseEvent evt) {<br /> jB_DireitaMousePressed(evt);<br /> }<br /> public void mouseReleased(java.awt.event.MouseEvent evt) {<br /> jB_DireitaMouseReleased(evt);<br /> }<br /> });<br /> javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());<br /> getContentPane().setLayout(layout);<br /> layout.setHorizontalGroup(<br /> layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)<br /> .addGroup(layout.createSequentialGroup()<br /> .addGap(55, 55, 55)<br /> .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)<br /> .addGroup(layout.createSequentialGroup()<br /> .addComponent(jB_Esquerda)<br /> .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)<br /> .addComponent(jB_Direita))<br /> .addGroup(layout.createSequentialGroup()<br /> .addGap(44, 44, 44)<br /> .addComponent(jB_Frente)))<br /> .addContainerGap(64, Short.MAX_VALUE))<br /> );<br /> layout.setVerticalGroup(<br /> layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)<br /> .addGroup(layout.createSequentialGroup()<br /> .addGap(50, 50, 50)<br /> .addComponent(jB_Frente)<br /> .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)<br /> .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)<br /> .addComponent(jB_Direita)<br /> .addComponent(jB_Esquerda))<br /> .addContainerGap(57, Short.MAX_VALUE))<br /> );<br /> pack();<br /> }// </editor-fold><br /> private void jB_FrenteMousePressed(java.awt.event.MouseEvent evt) { <br /> try {<br /> dados.write(3);<br /> controle.write(0);<br /> } catch (Exception e) {<br /> JOptionPane.showMessageDialog(this, e.toString());<br /> }<br /> } <br /> private void jB_FrenteMouseReleased(java.awt.event.MouseEvent evt) { <br /> try {<br /> controle.write(4);<br /> dados.write(0);<br /> } catch (Exception e) {<br /> JOptionPane.showMessageDialog(this, e.toString());<br /> }<br /> } <br /> private void jB_EsquerdaMousePressed(java.awt.event.MouseEvent evt) {<br /> try {<br /> dados.write(1);<br /> controle.write(0);<br /> } catch (Exception e) {<br /> JOptionPane.showMessageDialog(this, e.toString());<br /> }<br /> }<br /> private void jB_EsquerdaMouseReleased(java.awt.event.MouseEvent evt) {<br /> try {<br /> controle.write(4);<br /> dados.write(0);<br /> } catch (Exception e) {<br /> JOptionPane.showMessageDialog(this, e.toString());<br /> }<br /> }<br /> private void jB_DireitaMousePressed(java.awt.event.MouseEvent evt) {<br /> try {<br /> dados.write(2);<br /> controle.write(0);<br /> } catch (Exception e) {<br /> JOptionPane.showMessageDialog(this, e.toString());<br /> }<br /> }<br /> private void jB_DireitaMouseReleased(java.awt.event.MouseEvent evt) {<br /> try {<br /> controle.write(4);<br /> dados.write(0);<br /> } catch (Exception e) {<br /> JOptionPane.showMessageDialog(this, e.toString());<br /> }<br /> }<br /> /**<br /> * @param args the command line arguments<br /> */<br /> public static void main(String args[]) {<br /> java.awt.EventQueue.invokeLater(new Runnable() {<br /> public void run() {<br /> new Principal().setVisible(true);<br /> }<br /> });<br /> }<br /> // Variables declaration - do not modify<br /> private javax.swing.JButton jB_Direita;<br /> private javax.swing.JButton jB_Esquerda;<br /> private javax.swing.JButton jB_Frente;<br /> // End of variables declaration<br />}<br />