You are on page 1of 62

KARLA LUCIANA MORAES FREITAS

RODRIGO TAVARES CONDURÚ

CONTROLADOR DE RELÉS UTILIZANDO A PORTA
UNIVERSAL SERIAL BUS - USB

BELÉM
2006
UNIVERSIDADE DA AMAZÔNIA – UNAMA
CCET – CENTRO DE CIÊNCIAS EXATAS E TECNOLÓGICAS
BACHARELADO EM CIÊNCIA DA COMPUTAÇÃO

KARLA LUCIANA MORAES FREITAS
RODRIGO TAVARES CONDURÚ

CONTROLADOR DE RELÉS UTILIZANDO A PORTA
UNIVERSAL SERIAL BUS - USB

Trabalho de Conclusão de Curso apresentado
ao Centro de Ciências Exatas e Tecnológicas,
da Universidade da Amazônia, como
requisito parcial para obtenção do grau de
Bacharel em Ciência da Computação, sob a
orientação do Prof. MSc. Edson do Socorro
Cardoso da Silva.

BELÉM
2006
UNIVERSIDADE DA AMAZÔNIA - UNAMA
CCET – CENTRO DE CIÊNCIAS EXATAS E TECNOLÓGICAS
BACHARELADO EM CIÊNCIA DA COMPUTAÇÃO

KARLA LUCIANA MORAES FREITAS
RODRIGO TAVARES CONDURÚ

CONTROLADOR DE RELÉS UTILIZANDO A PORTA
UNIVERSAL SERIAL BUS - USB

Dissertação apresentada para obtenção parcial do grau de Bacharel em Ciência
da Computação

Banca Examinadora:

_______________________________________

_______________________________________

_______________________________________

BELÉM
2006
Dedico este projeto a Deus e a meus pais, que me
deram força e coragem para enfrentar as dificuldades
e fraquezas por quais passei.

Karla Luciana Moraes Freitas

Dedico esse projeto a todos meus amigos, familiares,
ao meu orientador, banda Midríase e principalmente
ao meu pai e minha mãe que me aturaram todos
esses anos em prol de um futuro decente para mim.

Rodrigo Tavares Condurú
AGRADECIMENTO

Primeiramente a Deus, por me dar força, coragem e
sabedoria; aos meus pais, por patrocinarem toda
minha graduação e estarem sempre ao meu lado
dando-me forças para prosseguir, principalmente no
momento em que minhas forças já não existiam mais
e só persistia a vontade de desistir; aos meus amigos
particulares e da graduação, por termos divido nestes
anos de graduação nossas tristezas, alegrias,
angústias, certezas, dúvidas e vitórias; e claro ao
meu Orientador MS. Profº Edson do Socorro
Cardoso da Silva, que foi a pessoa fundamental neste
projeto.

Karla Luciana Moraes Freitas

Agradeço a toda minha família pelo apoio, nesta
estrada percorrida com muita luta; a meus amigos,
minha banda e minha namorada.

Rodrigo Tavares Condurú
“Uma cerveja antes do almoço é
muito bom para ficar pensando
melhor.”

Chico Science
RESUMO

O presente trabalho descreve o desenvolvimento de um sistema controlador de relés,

utilizando o barramento USB, onde através de um aplicativo em um micro-computador é

possível fornecer (ou cortar) corrente a um dispositivo elétrico qualquer, como exemplo uma

lâmpada de 12 V, através de um relé. Para que a comunicação através do barramento seja

executada, é necessário um chipset (FT232BM) que interprete os sinais gerados pelo software

e entregue strings de comando a um microcontrolador (PIC 16F877) que fará a verificação do

status do relé para ativar ou desativar o presente dispositivo elétrico.

Palavras-chave: Programação C, Barramento USB, Chipset, PIC, Relé.
ABSTRACT

The present work describes the development of a controlling relays system, using the

universal serial bus - USB, where through a microcomputer application it is possible give (or

cut) current to some electric device, for example a 12 V lamp, through a relay. So that this

communication through this bus it is necessary a chipset (FT232BM) to interprets the signals

generated by software and it give command strings to a microcontroller (PIC 16F877) that

will make the verification of relay’s status to set or not the present electric device.

Key Words: C Programming, Universal Serial Bus, Chipset, PIC, Relay.
LISTA DE SIGLAS

CPU - Central Processor Unit

EEPROM - Erasable Programmable Read-only Memory

EPP - Enhanced Parallel Port

FIFO -First In / First Out

FTDI - Future Technology Devices Ltd.

LDO - Low Drop Out

NZRI - No Returne to Zero Inverted

USB - Universal Serial Bus
LISTAS DE FIGURAS

Figura 1 Tipagem do cabo USB................................................................................. 18
Figura 2 Conector fêmea série “A”............................................................................ 18
Figura 3 Conector macho série “A”........................................................................... 18
Figura 4 Conector fêmea série “B”............................................................................ 18
Figura 5 Conector macho série “B”........................................................................... 18
Figura 6 Circuito elétrico genérico Bus-Powered...................................................... 20
Figura 7 Circuito elétrico genérico Self-Powered...................................................... 21
Figura 8 Pacotes de comunicação do Protocolo USB................................................ 23
Figura 9 Endpoint Out................................................................................................ 25
Figura 10 Endpoint In................................................................................................... 25
Figura 11 Pipe de mensagem e Controle...................................................................... 26
Figura 12 Chipset FT232BM....................................................................................... 29
Figura 13 Visão interna dos blocos do chipset FT232BM.......................................... 30
Figura 14 Pinagem do chipset FT232BM.................................................................... 31
Figura 15 Pinagem da memória 93C46........................................................................ 34
Figura 16 Circuito elétrico da memória 93C46 ligada ao chipset FT232BM............. 35
Figura 17 Configuração da interface Bus-Powered..................................................... 36
Figura 18 Configuração da interface Self-Powered..................................................... 36
Figura 19 PIC 16F877.................................................................................................. 38
Figura 20 Pinagem do PIC 16F877.............................................................................. 38
Figura 21 Tela de software controlador de relés.......................................................... 47
Figura 22 Arquivos necessários para instalação do dispositivo................................... 58
Figura 23 Processo de edição, compilação e gravação do PIC 16F877....................... 59
Figura 24 Chipset FT232BM juntamente com um receptor USB série “B”............... 60
Figura 25 Circuito do dispositivo controlador de relés............................................... 60
LISTA DE TABELAS

Tabela 1 - Classe dos dispositivos……..................................................................... 27

Tabela 2 - Descrição da pinagem do Chipset FT232BM........................................... 31

Tabela 3 - Descrição da pinagem da memória EEPROM.......................................... 34
LISTA DE CÓDIGOS

Código 1 - Código-fonte da programação do PIC...................................................... 40

Código 2 - Software controlador de relé..................................................................... 47
SUMÁRIO

1 INTRODUÇÃO............................................................................................. 15

2 BARRAMENTO USB (UNIVERSAL SERIAL BUS).............................. 16

2.1 INTRODUÇÃO AO USB............................................................................... 16

2.2 ESTRUTURA ELÉTRICA DA USB............................................................ 17

2.3 PROTOCOLO USB........................................................................................ 22

2.3.1 Endpoints, Pipes, Descritores...................................................................... 24

2.3.1.1 Endpoints........................................................................................................ 24

2.3.1.2 Pipes................................................................................................................ 24

2.3.1.2.1 Stream.............................................................................................................. 25

2.3.1.2.2 Mensagens e controle...................................................................................... 25

2.3.1.3 Descritores....................................................................................................... 26

2.4 FUNCIONAMENTO DO PROJETO COM A USB...................................... 28

3 CHIPSET FT232BM..................................................................................... 29

3.1 PRINCIPAIS CARACTERÍSTICAS............................................................. 29

3.2 CONFIGURAÇÃO DA MEMÓRIA EEPROM............................................. 34

3.3 CONFIGURAÇÃO DAS INTERFACES BUS-POWERED E SELF-

POWERED..................................................................................................... 35

4 MICROCONTROLADOR PIC 16F877…………………………………. 37

4.1 CARACTERÍSTICAS DO PIC 16F877…………………………………… 37

4.2 PINAGEM………………………………………………………………….. 38

4.2.1 Definição da direção dos pinos de I / O....................................................... 39

4.3 PROGRAMAÇÃO DO MICROCONTROLADOR PIC............................... 39
5 DRIVER DO SOFTWARE CONTROLADOR DE RELÉS................... 45

5.1 FUNÇÕES DO FTD2XX.............................................................................. 45

5.2 LINGUAGEM DE PROGRAMAÇÃO APLICADA NO SOFTWARE

CONTROLADOR DE RELÉS....................................................................... 46

6 DESENVOLVIMENTO PRÁTICO DO PROJETO................................. 57

6.1 INSTALAÇÃO DOS ARQUIVOS FTD2XX................................................ 57

6.2 DETALHAMENTO DA PROGRAMAÇÃO DO PIC 16F877..................... 58

6.3 CIRCUITO E FUNCIONAMENTO DO DISPOSITIVO.............................. 59

7 CONCLUSÃO............................................................................................... 61

8 REFERÊNCIAS BIBLIOGRÁFICAS....................................................... 62
1. INTRODUÇÃO

O objetivo deste trabalho é criar um software capaz de interagir com um dispositivo

elétrico, com intuito de cortar ou fornecer corrente elétrica a um dispositivo por meio de um

relé, utilizando uma porta USB convencional de um microcomputador. Para que o objetivo

seja atingido, foi necessário desenvolver um software em C/C++ que utiliza bibliotecas da dll

FTD2xx, os quais possuem suas próprias funções descritas no site do fabricante do chipset

utilizado para comunicação USB, no caso deste projeto, o chipset FT232BM. O chip após

comunicação estabelecida enviará uma string que será comparada em um microcontrolador,

PIC 16F877, que por sua vez enviará a um driver que deve ativar ou não o fornecimento de

corrente o dispositivo elétrico escolhido pelo usuário no software controlador de relés.

Um sistema controlador de relés deste modelo pode alcançar grandes proporções

chegando podendo até utilizar tecnologia sem fio, controlando todo ou parte de uma

residência, empresa ou indústria, proporcionando a diminuição nos gastos em energia elétrica,

já que através de um computador, pode-se controlar vários dispositivos, de forma a se

monitorar o tempo ótimo que cada dispositivo ficará ligado.
2 – BARRAMENTO USB (Universal Serial Bus)

O barramento USB é o dispositivo de hardware que será usado para interligar a placa

controladora de relés à CPU, que portará um software gerenciador de “estados” nos atuadores

interligados à placa.

2.1 – INTRODUÇÃO AO USB

Quando o assunto é tecnologia de ponta na área de eletrônicos, atualmente o

barramento USB estará em destaque. Este tipo de tecnologia está presente em muitos

dispositivos disponíveis no mercado como: aparelhos de som, relógios, scanners, MP3

players, impressoras, webcams, entre outros. É possível até se dizer que é algo indispensável

para técnicos, programadores e webdesigners, já que sem seus pendrivers seria muito

inconveniente transportar seus projetos e utilidades através de CDs ou outros dispositivos de

armazenamento de dados.

A tecnologia de Universal Serial Bus chega a substituir outras tecnologias com menor

praticidade como o barramento paralelo e serial. Nesses barramentos, um dispositivo tinha

que ser conectado à CPU, em seqüência instalar o driver através de um software de instalação

específico, terminando em um provável conflito com o sistema. No âmbito USB, o dispositivo

seria imediatamente localizado pelo sistema operacional (dependendo da versão do Sistema

Operacional) e instalado sem maiores preocupações e com desempenho muito maior que os

outros dois barramento, facilitando a remoção, adição e movimentação de dispositivos através

de sua tecnologia plug-and-play.

A popularidade do barramento USB também à sua velocidade: USB versão 1.1 (low-

speed) varia entre 1,5 Mbits/s e 12 Mbits/s e USB versão 2.0 (high-speed) alcança até 480
Mbits/s, velocidade esta trinta vezes superior ao barramento paralelo, o qual funciona à 16

Mbits/s na sua forma ECP (Enhanced Capabilities Port) e à 80 Mbits/s na sua forma IEEE

1284 (ECP + EPP – Enhanced Parallel Port). Se comparado ao barramento serial que funciona

no máximo a velocidade de 115 Mbits/s, a versão USB 4.0 é quatro vezes mais veloz.

2.2 – ESTRUTURA ELÉTRICA DO USB

Os dispositivos USB possuem um formato universal, que segue duas séries de

conectores USB: a série “A” e a série “B”.

Os conectores da série “A” têm um formato retangular e achatado possuindo um tipo

fêmea e um tipo macho, conforme a ilustração da Figura 1. Os conectores do tipo macho são

aqueles encontrados numa das extremidades de um cabo USB e devem ser conectados ao

Root Hub (porta principal da USB localizada no computador) ou em portas downstream de

um Hub (dispositivo que tem como finalidade aumentar o número de portas). Os conectores

tipo fêmea são os localizados na Root Hub e nas portas downstream de um Hub, onde

recebem o conector macho.

Os conectores da série ”B” têm um formato quadrado com um achatado nas pontas

superiores, possuindo também um tipo fêmea e um tipo macho, conforme a ilustração da

Figura 1. Os conectores tipo macho são aqueles encontrados em uma das extremidades de um

cabo USB e devem ser conectados a um dispositivo. Os conectores do tipo fêmea são aqueles

encontrados em dispositivos como impressoras, scanners, máquinas digitais, entre outros onde

recebem o conector tipo “B” macho. Os conectores, tanto da série “A” quanto da série “B”,

possuem formas únicas de conexão, sendo impossível conectá-los de forma diferente ou em

séries diferentes.
Figura 1: Tipagem do cabo USB.

É importante entender a pinagem da porta USB e da extremidade do cabo. O conector

receptor da série “A”, encontrado no Root Hub (Host) e na Downstream do Hub, como dito

anteriormente, recebe uma identificação nos pinos, identificando-os por números, começando

da esquerda para direita, do pino um ao pino quatro conforme a ilustração da Figura 2. Já o

conector macho da mesma séria recebe uma identificação também numérica, porém

começando da direita para esquerda, conforme a ilustração da Figura 3.

O conector receptor da série “B”, encontrados em impressoras, recebe uma

identificação por números em seus pinos, que começa da direita para esquerda na parte

superior e continuando da esquerda para direita na parte inferior, indo do número um ao

quatro, conforme a ilustração da Figura 4. Já o conector macho da mesma série recebe

identificação semelhante, só que na parte superior numera-se da esquerda para direita e na

parte inferior da direita para esquerda conforme a ilustração da Figura 5.

Figura 2: Conector fêmea série “A”. Figura 3: Conector macho série “A”.

Figura 4: Conector fêmea série “B”. Figura 5: Conector macho série “B”.
Assim, o cabo USB possui 4 fios, haja vista que dois são para transferência de dados e

os restantes para transporte de energia. O fio Vbus (cor vermelha) possui 5 V, sendo o fio

positivo, enquanto que GND (cor preta) possui 0 V, fechando o circuito de corrente com o

Vbus. Os fios D+ (cor verde) e D- (cor branca) são responsáveis pela transferência de dados

usando a codificação NRZI - No Return to Zero Inverted. Eles estarão entrelaçados, com o

intuito de minimizar interferências.

O controlador Host encontrado na placa USB ou mesmo na placa mãe, responsável

pela detecção de dispositivos, controle de fluxo, alimentação e monitoramento, possui em sua

configuração física um resistor de Pull-up de 1500 Ω responsável pela deteção de

dispositivos. Este resistor estará ligado ao sinal D+ ou D-, havendo uma tensão circulando

entre eles definindo se funcionará em alta ou baixa velocidade, e caso não haja tensão no

resistor pull-up por mais de 2,5 microssegundos o controlador Host interpretará a desconexão

do dispositivo, assim como este tempo é necessário para a detecção. É por meio desse sistema

de verificação de tensão que a tecnologia plug-and-play funciona.

O dispositivo USB pode trabalhar com duas formas de interface: Bus-powered e Self-

powered. É de suma importância entender como funciona a distribuição de energia pelo

barramento USB antes de entender sua interface.

O computador fornece a cada porta a corrente de 500 mA, igualmente a um hub que

possua fonte própria de energia. Hubs que não possuem fonte própria recebem do Root Hub

(porta USB encontrado no computador) 500 mA, que serão distribuídos em suas portas,

utilizando 100 mA para seu perfeito funcionamento.

O dispositivo Bus-powered é uma forma de dispositivo USB que tem certa

independência em se tratando de energia, logo não precisará de fonte de alimentação, pois é

alimentado pelo próprio Host do computador, ou mesmo por uma porta Downstream de Hub.

Esses dispositivos são geralmente configurados para receber 100 mA, já que poderão ser
alimentados por Downstream com apenas essa quantidade de corrente. Em casos onde um

dispositivo Bus-powered consuma mais de 100 mA, seu funcionamento só ocorrerá caso o

dispositivo esteja ligado no computador ou em Hub com fonte de energia. Dispositivos Bus-

powered tem suas vantagens e desvantagens. Como vantagens citamos: a praticidade de seu

transporte, devido a ausência de um fonte e problemas de serem resetados ou desligados

involuntariamente caso o computador tenha sido desligado ou mesmo resetado. Webcams,

pendrivers e Mp3 players são dispositivos que possuem uma interface Bus-powered. A figura

6 mostra um circuito elétrico genérico para a construção de um dispositivo Bus-powered.

Figura 6: Circuito elétrico genérico Bus-Powered.
No esquema acima pode ser observado a utilização de um resistor R4 de 1500 Ω. Este

resistor tem como objetivo a detecção de conexão ou desconexão de um dispositivo, o que

caracteriza o funcionamento da tecnologia plug-and-play.

Os dispositivos Self-powered possuem fonte própria, não necessitando da energia

fornecida pela porta onde esteja conectado. Scanners, impressoras e alguns modelos de Hubs

USB possuem a interface Self-powered. Na figura 7 é apresentado um circuito elétrico

genérico para a construção de um dispositivo Self-powered.

Figura 7: Circuito elétrico genérico Self-Powered.
No esquema da Figura 7 é possível notar algumas diferenças em relação ao esquema

Bus-powered. O acréscimo de dois novos resistores, R5 e R8 e a ligação do pino 14 do

FT232BM, que agora está conectado a fonte externa através do +5 V.

2.3 – PROTOCOLO USB

O protocolo USB, tem como finalidade a comunicação entre o Host do computador e

um ou mais dispositivos, só que em um formato diferente da comunicação de uma Porta

Paralela ou Serial, que utiliza sinais elétricos através de seus pinos. Na comunicação USB o

protocolo está presente tanto no Host quanto no dispositivo. No primeiro, o protocolo se

apresenta em formato de drivers. No dispositivo, ele é encontrado em um microcontrolador

específico, como o PIC ou em um chipset. Neste será utilizado um microcontrolador PIC, que

será inicialmente programado em linguagem C seguida da respectiva conversão para

hexadecimal, e será utilizado um chipset FT232BM da FTDI, que já possui em seu interior

todo o protocolo USB.

Através do protocolo, é possível se ter quatro tipos de transferências USB, que são:

• Controle: São transferências de dados usadas pelo Host para configurar o

dispositivo recém conectado, de forma a requisitar informações sobre este

dispositivo.

• Interrupção: Nestas transferências os dispositivos fazem os requisitos para o

Host, utilizando pouca banda do sistema USB. Os joysticks, teclados e mouses

utilizam esta forma de transferência, já que não necessitam enviar e receber

dados de forma contínua.

• Isossíncrona: Transferências de dados de forma contínua, sem deteção de erro e

checagem para chegada correta de dados. Dispositivos de vídeo e áudio utilizam
este tipo de transferência de dados, pois precisam de uma velocidade alta e

constante.

• Bulk: Transferência de grande volume de dados, com deteção de erro, correção

e recuperação de dados corrompidos, largura da banda flexível, tráfego seguro e

velocidade não contínua. Impressoras e discos de memória flash utilizam este

tipo de transferência.

Na tecnologia USB, a comunicação se dá devido ao protocolo, que comunica o Host e

o dispositivo através do envio de pacotes. A comunicação se inicia pelo pacote Token, gerado

pelo Host, com intuito de descrever o que virá no próximo pacote, e se é uma escrita ou

leitura; seguido do próximo pacote, o Data, que possui todos os dados que serão lidos ou

escritos e finalizando com o pacote Handshake, que informa se houve falha ou sucesso na

transição (em detalhes na Figura 8).

Figura 8: Pacotes de comunicação do Protocolo USB.
2.3.1 – Endpoints, Pipes e Descritores

Em uma comunicação USB são formados os Pipes e neles trafegam os descritores

enviando informações a serem armazenadas nos Endpoints. Esta comunicação possui alguns

detalhes que devem ser explanados.

2.3.1.1 – Endpoints (área final do dispositivo)

Endpoints estão localizados no dispositivo, como uma área de memória reservada para

armazenar dados e informações que trafegam nos Pipes, sendo que um dispositivo USB pode

ter no máximo 16 Endpoints na versão 2.0 do USB. É também através do Endpoint que o Host

pode obter informações sobre o dispositivo conectado. Isto se dá através de envios de

comandos de controle de baixa velocidade, pelo Host, que obtém informações como: o

número de série, fabricante, classe, subclasse, versão do Bus USB, tipo de protocolo, número

de Endpoints e outros. Essa função se dá apenas ao Endpoint 0 (zero).

Os Endpoints podem ser de quatro tipos: Controle, Interrupção, Isossíncronos e Bulk.

2.3.1.2 – Pipes (tubos)

Pipes não são visíveis, nem físicos, e podem ser comparados como uma via de

comunicação virtual entre o Endpoint do dispositivo e um software no Host, criando assim um

via unidirecional ou bidirecional de comunicação. O Pipe sempre será existente a partir do

momento em que um dispositivo USB for conectado no computador. Sendo que, antes do

dispositivo ser configurado pelo Host, haverá um Pipe de controle (Control Default) que

fornecerá informações de configuração.
2.3.1.2.1 – Stream

Este Pipe possui uma via de comunicação unidirecional, sendo que o Endpoint pode

ser do tipo Interrupção, Isossíncrono ou Bulk. Se o dispositivo com o Pipe Stream precisar

transferir de forma bidirecional um dos tipos de Endpoint, o sistema USB estabelecerá dois

canais de Pipes, sendo o primeiro definido com o Endpoint de saída (Out) e o segundo

definido com o Endpoint de entrada (In).

Figura 9: Endpoint (Out).

Figura 10: Endpoint (In).

2.3.1.2.2 – Mensagem ou Controle

Este Pipe possui um via de comunicação bidirecional, sendo que o Endpoint será do

tipo Controle. Essa via possui dois Endpoints, um de entrada (In) e outro de saída (Out) e

possui uma estrutura definida de dados. Este Pipe é usado pelo Endpoint 0 para obter

informações sobre o dispositivo para que o sistema possa configurá-lo.
Figura 11: Pipe de mensagem e controle.

2.3.1.3 – Descritores

Os descritores constituem uma hierarquia de informações sobre o dispositivo, que

serão disponibilizadas para o Host, informando as características dos mesmos.

• Descritores de Dispositivos: Esse descritor informa de uma forma geral as

características do dispositivo. Sendo que um dispositivo só pode possuir um Descritor de

Dispositivo. As informações cedidas pelo dispositivo são muito importantes para o Host, pois

através delas, o Host poderá saber a versão do USB que o dispositivo suporta.

• Descritores de Configuração: Esse descritor possui informações sobre as

capacidades elétricas e funcionalidades do dispositivo, como a alimentação, o limite de

corrente aceito pelo dispositivo, entre outras.

• Descritores de Interface: Esse descritor possui informações sobre o número de

Endpoints suportado, o protocolo utilizado, e algumas strings de texto especificando o nome

do produto.

• Descritores de Endpoint: Esse descritor possui informações sobre os Endpoints. O

Endpoint 0 é assumido pelo sistema com um endpoint de controle, e será configurado antes

que qualquer descritor. Este descritor possui informações sobre o número de Endpoints,

direção de comunicação e tamanho do pacote de dados a ser transmitido.

• Descritores de Classe: Este descritor possui informações sobre a classe do

dispositivo. Veja abaixo a tabela:
1 Áudio

2 Dispositivos de comunicação.

Dispositivos de interface humana:

3 Mouse, Joysticks, leitor de código de

barras, etc.

6 Imagem: Scanner, câmeras.

7 Impressoras

Armazenamento de massa: Floppy

8 disk, CD-ROM, DVD, SCSI, memória

flash, ATAPI.

9 Hub.

10 Interface de dados.

11 Chip/Smart card.

Dispositivos que não entram nas

255 outras classes: Interface Serial RS232,

rede ponto-a-ponto, etc.

Tabela 1: Descritores

2.4 – FUNCIONAMENTO DO PROJETO COM A USB

O projeto controlador de relés através da porta USB com o uso da freqüência de rádio

seguirá uma seqüência de seis passos para sua perfeita execução. Esse passos são:
1 – Aplicação cliente desenvolvida em C++ na máquina teste chamada rotina da API,

que receberá os parâmetros de controle;

2 – A API por sua vez faz a chamada do software básico do fabricante do dispositivo

USB, mais conhecido como o driver do cliente. Este driver geralmente acompanha o produto

USB que foi adquirido, como no caso da compra de uma impressora ou de um scanner, porém

neste caso o driver será instalado e configurado no sistema operacional conforme o capítulo

anterior;

3 – Este driver terá a função de fazer com que o sistema operacional garanta o suporte

USB, fazendo com que ele interprete e traduza os comandos do driver e envie-os para o

Driver do Controlador Host;

4 – Será processada a parte lógica do sistema USB, devido ao driver do controlador

Host (HCD) – fornecido pelo fabricante da placa – trabalhar diretamente com o controlador

Host;

5 – Agora os sinais eletrônicos já foram interpretados e passam para a parte física da

USB – seu chipset e controlador host – que serão enviados para o HCD que por sua vez

enviara os comandos para o USBD.

6 – A informação chega ao Dispositivo do cliente – dispositivo que utilizará como

base o chipset FT232BM da FTDI – conectado ao Root Hub do HC.
3 – CHIPSET FT232BM

O chipset FT232BM da FTDI – Future Technology Devices Ltd. será o chip usado no

projeto, sendo utilizado na placa controladora de relés com o objetivo de estabelecer a

configuração do mesmo e a comunicação com o Bus USB, visto que o FT232BM já possui o

protocolo USB.

3.1 – PRINCIPAIS CARACTERÍSTICAS

O FT232BM é um chip ideal para construir dispositivos que se comuniquem com a

porta USB, já que no site do fabricante, http://www.ftdichip.com/FTDrivers.html, está

disponibilizado os drivers de controle do chip, sem necessidade de pagamento de royalties,

para vários sistemas operacionais.

Figura 12: Chipset FT232BM.

O chip possui uma velocidade de até 3Mbps através de sinais TTL: RS422 e RS485 e

velocidade máxima de 1Mbs em comunicações utilizando drivers RS323. É compatível com

Host USB versões 1.1 e 2.0. Possui suporte a uma memória externa EEPROM, que pode ser
usada opcionalmente para armazenar descritores para personalizar o produto (dispositivo).

Esta memória pode ser programada pela própria placa via USB.

Tensão de alimentação entre 4,35V a 5,25V com suporte para alimentar dispositivos

diretamente no Bus USB através do pino PWREN#. Regulador integrado de 3.3V para

entrada/saída USB. Um chip manipula tanto transferências USB como Serial, além de ser

compatível com controladores Host: UHCI/OHCI/EHCI.

Figura 13: Visão interna dos blocos do chipset FT232BM.

Na Figura 13 pode-se obter uma visão geral em blocos do chipset FT323BM. Em sua

estrutura é importante conhecer algumas de suas características e limitação para compreender

o seu funcionamento e sua configuração na placa controladora de relés. O chip em questão

possui uma célula reguladora de tensão que fornece 3.3v no pino 3v3OUT; uma célula USB

transeiver que trata diretamente os sinais D+ e D- através do cabo; o USB DPL que trata a

codificação NRZI; um multiplicador de sinal clock; uma interface Serial avançada (SIE); a
UART que disponibiliza os dados seriais para comunicação externa (RS232/RS422/RS485);

uma célula para controle dos Buffers FIFO; o USB Protocol Engine, que trata a pilha de

dados do protocolo USB em baixo nível, como os Pipes e Endpoints.

Figura 14: Pinagem do chipset FT232BM.

Pino Nome Tipo Descrição
1 EESK Saída Sinal de Clock para a EEPROM.
Conexão de dados direta com a
2 EEDATA Entrada/Saída
EEPROM.
Tensão de alimentação (+4,4V a
3 VCC Alimentação
+5,25V).
Através deste pino podemos realizar um
4 RESET# Entrada reset a partir do exterior. Se não for
usado, deve ser conectado ao VCC.
Saída do gerador interno de Reset. Este
5 RSTOUT# Saída pino não é afetado no caso de um reset no
Bus USB.
Saída do regulador LDO (Low Drop Out)
de 3,3V. Este pino deve ser conectado a
um capacitor cerâmico de 33nF. Uma
6 3V3OUT Saída pequena quantidade de corrente (<=
5mA) pode ser obtida deste pino, para
alimentar um circuito a 3.3v se caso
necessário.
Sinal positivo de Dados (D+) USB.
Requer um resistor de pull-up de 1,5K
7 USBDP Entrada/Saída
conectado ao pino 3V3OUT ou
RSTOUT#.
8 USBDM Entrada/Saída Sinal negativo de Dados (D-) USB.
9 GND Alimentação Sinal negativo (massa).
Vai ao estado baixo enquanto está no
10 SLEEP# Saída
modo USB "Suspend".
LED indicador de recepção de dados.
11 RXLED# Saída Este pino quando está em nível baixo
indica recepção de dados.
LED indicador de transmissão de dados.
12 TXLED# Saída Este pino quando está em nível baixo
indica transmissão de dados.
Especifica os níveis de tensão utilizados
13 VCCIO Alimentação
na interface UART (3.0V - 5,25V).
Em nível baixo, o FT232BM é
alimentado através do bus USB (Bus-
14 PWRCTL Entrada powered). Em nível alto é alimentado
mediante conexão externa (Self-
powered).
Está em nível baixo quando se tem
configurado o FT232BM no modo Bus-
15 PRWEN# Saída powered. Está em nível alto durante o
período de suspensão do bus USB. Pode-
se usar este pino para controlar a
alimentação de dispositivos externos,
alimentados diretamente através do bus
USB, mediante a utilização de um
MOSFET Canal-P.
Habilita a transmissão de dados para
16 TXDEN Saída
RS485.
17 GND Alimentação Sinal negativo (massa).
18 RI# Entrada Indicador de Ring.
Data Carrier Detect (detecta a portadora
19 DCD# Entrada
de dados).
20 DSR# Entrada Data Set Ready (Dados pronto).
Data Terminal Ready (Terminal de dados
21 DTR# Saída
pronto).
22 CTS# Entrada Clear To Send.
23 RTS# Saída Request To Send.
24 RXD Entrada Pino de recepção.
25 TXD Saída Pino de transmissão.
Tensão de alimentação (+4,4V a
26 VCC Alimentação
+5,25V).
27 XTIN Entrada Entrada do oscilador de 6MHz.
28 XTOUT Saída Saída do oscilador de 6MHz.
Gnd analógico para o multiplicador x8 do
29 AGND Alimentação
Clock interno.
VCC analógico para o multiplicador x8
30 AVCC Alimentação
do Clock interno.
Põe o FT232BM no modo teste. Para
31 TEST Entrada funcionamento normal, deve-se conectar
ao GND.
32 EECS Entrada/Saída EEPROM-Chip select (seleciona o chip).
Tabela 2: Descrição da Pinagem do Chipset FT232BM
3.2 – CONFIGURAÇÃO DA MEMÓRIA EEPROM

Para exemplificar a configuração da memória, será mostrada a memória 93C46 do tipo

EEPROM serial (SPI), com 64 palavras de 16 bits de largura, podendo armazenar 1024 bits.

Esta memória tem como função personalizar a placa criada, armazenando o nome do

fabricante, número de série, versão, vendedor e outras especificações. No caso desta memória

não ser configurada ou mesmo agregada ao circuito, as especificações com as informações da

placa assumirão valores da própria fabricante do chip, FTDI. As figuras e a tabela mostrada

abaixo descreverão a pinagem e descrição da memória 93C46, e sua conexão com o chipset.

Figura 15: Pinagem da memória 93C46.

Pino Descrição
CS Chip Select (Seleção do chip)

SK Serial Data Clock (Sinal de relógio)

Serial Data Input (Entrada de dado
DI
serial)

D0 Serial Data Output (Saída de dado serial)

VCC Alimentação +5V
NC Não Conectado
GND 0v (massa)
Tabela 3: Descrição da pinagem da memória EEPROM
Figura 16: Circuito elétrico da memória 93C46 ligada ao chipset FT232BM.

3.3 – CONFIGURAÇÃO DAS INTERFACES BUS-POWERED E SELF-POWERED

A construção de circuitos com as duas interfaces foram mostradas na figura 5 e 6 do

capítulo 2. Neste capítulo serão mostradas as diferenças referentes as configurações das

interfaces Bus-Powered e a Self-Powered. Além das configurações físicas mostradas no

capítulo 2, é preciso programar os descritores do dispositivo na memória EEPROM

informando em um de seus campos com qual interface o dispositivo irá operar.

Na figura 17 é mostrado a configuração de uma interface Bus-Powered, onde o pino

14-PWRCTL deve ser levado a nível baixo (0 V). A ferrite é ligada em série 1-Vbus (+5 V do

Bus USB) para eliminar ruídos que possam afetar o bom funcionamento do dispositivo.
Figura 17: Configuração da interface Bus-Powered.

Na figura 18 é mostrado a configuração de uma interface Self-Powered, onde o pino

14-PWRCTL deve ser levado a nível alto (+5 V). Nesta interface será preciso dois resistores,

um de 4K7 e outro de 10K para gerar um sinal no pino 4-RESET#.

Figura 18: Configuração da interface Self-Powered.
4 – MICROCONTROLADOR PIC 16F877

O microcontrolador é de suma importância no desenvolvimento deste projeto, sendo

responsável pela interpretação de sinais e comparação de “strings” com intuito de verificar se

o dispositivo está com os relés acionados ou não de forma a suspender ou fornecer energia ao

atuador ligado no dispositivo.

4.1 – CARACTERÍSTICAS DO PIC 16F877

O PIC 16F877 é um microcontrolador da família de 8 bits e núcleo de 14 bits com 33

pinos de I/O. Possui 8k de memória de programa FLASH com 8192 palavras de 14 bits, 368

bytes de memória RAM e memória EEPROM com 256 bytes. Sua freqüência de operação

chega no máximo a 20 MHz, chegando a uma velocidade de processamento de 5 MIPS. Tem

35 instruções em seu conjunto de instruções RISC. Pode funcionar com alimentação de 2V a

5,5V.

Possui como periféricos:

• 5 conjuntos de portas de entrada e saída (total de 33 portas)

• Conversor analógico-digital de 10 bits de resolução e 8 canais de entrada

• Periférico de comunicação paralela e serial (USART e MSSP), tendo porta paralela

escrava (PSP) e porta serial síncrona (SSP, SPI e I2C)

• 2 Módulos CCP (Comparação, Captura e PWM)

• 3 Timers (1 de 16 bits e 2 de 8 bits)

• Watchdog timer (WDT)
Figura 19: PIC 16F877.

4.2 – PINAGEM

A pinagem do PIC 16F877 é formada por 40 pinos, sendo que a maioria possui mais

de uma função, que pode ser verificado na figura 20. Como exemplo pode-se ver o pino 10

que tem as funções de entrada/saída digital (RE2) ou de selecionar um chip SPI (CS) ou a

função de um canal A/D (AN7). Os pinos (RA0 a RA5) estão associados a porta ‘A’, (RE0,

RE1, RE2) associados a porta ‘E’, (RC0 a RC7) a porta ‘C’, (RD0 a RD7) a porta ‘D’ e os

pinos (RB0 a RB7) associados ao porta ‘B’. Cada um desses pinos pode ser usado como

entrada e saída e são definidos na programação.

Figura 20: Pinagem do PIC 16F877.
O PIC 16F877 é composto, em sua estrutura interna, de cinco módulos que separam

sua pinagem. Possui um modulo lógico e de controle, módulos de memória RAM e ROM,

postas de I/O e o módulo de periféricos, onde se localizam o Watchdog, Timers, USART e

outros periféricos.

4.2.1 – Definição da direção dos pinos de i/o

No PIC, os pinos de I/O podem ser configurados tanto com entradas ou saídas, em um

único pino. Essa configuração é feita através de sua programação em C, que será mostrado

com maior profundidade no próximo capítulo, utilizando a função set_tris_X(Y). Onde X é o

porta que será configurada e Y o parâmetro que será enviado a função configurando quais

portas serão de entrada e quais serão de saída. O parâmetro deve seguir o padrão obZZZZZZZ,

onde Z será definido por 1 ou 0, haja visto que 1 para entrada e 0 para saída seguindo a ordem

nos pinos da direita para esquerda. Como exemplo, a configuração da porta D, onde o pino

RD7 e RD1 estivessem que ser configurados para entrada e o resto dos pinos para saída,

usaríamos a função set_tris_D(ob1000010).

4.3 –PROGRAMAÇÃO DO MICROCONTROLADOR PIC

Na programação de microcontroladores, a linguagem nativa é Assembler, pois é uma

linguagem de baixo nível e está associada diretamente com endereços na memória e

registradores do microcontrolador. Mas isso não significa que apenas ela pode ser usada na

programação do PIC. Linguagens de alto nível como C - linguagem utilizada no projeto -

também podem ser usadas, com suas vantangens e desvantagens.
Há anos, os microcontroladores possuíam pouco espaço na memória para alocar

programas, e por este motivo a utilização do Assembler era obrigatória, já que finalizaria em

um programa compacto, leve e rápido. Porém com a evolução da microeletrônica, hoje é

possível usar linguagens de alto nível, devido os microcontroladores disponibilizarem

quantidade maior de memória, deixando assim a programação mais produtiva, segura e com

uma portabilidade e manutenção mais eficiente. A linguagem Assembler ainda sim, é

utilizada em projetos onde o hardware necessita de toda a velocidade que ele dispõe para

aumentar a eficácia da rotina.

Neste projeto, o PIC 16F877 irá receber uma “string” do chipset e fará a sua devida

validação através de uma comparação. Caso seja válida ele irá executar uma ação que

dependerá da “string” (ligar ou desligar) e enviará uma resposta ao programa do PC,

informando que o relé foi ligado ou desligado, conforme o código abaixo.

//Controle de Relés
//TCC – UNAMA
//Rodrigo Tavares Condurú e Karla Luciana M. Freitas
//-------------------------------------------------------------------------------------------------------
#include <16F877.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#use delay(clock=4000000)

#define MAX_BUFFER 15
char BufferRX[MAX_BUFFER+1];
boolean CHEGOU_COMANDO = false;

//--------------------------------------------------------------------------
//Interrupção de recebimento de caracter pela UART.
//---------------------------------------------------------------------------
#int_rda
void Serial_Recebe_Car()
{
static unsigned char ch;
static int IndexBuf=0;
ch = getc(); //Pega o caracter no registrador da UART.

BufferRX[IndexBuf] = ch; //Guarda o caracter no buffer.

if( BufferRX[IndexBuf] == '*' ) //Se é o fim da string de comando.
{
BufferRX[IndexBuf+1] = '\0'; //Finaliza sting.
IndexBuf = 0;
CHEGOU_COMANDO = true; //Avisa que chegou uma string de comando.
}else{
IndexBuf++;
}
if( (BufferRX[0] != '>' ) || (IndexBuf >= MAX_BUFFER) )
{
IndexBuf = 0;
}

}
//--------------------------------------------------------------
//Para fazer o LED piscar.
#int_timer0
void MeuTimer()
{
static boolean led;
static int conta;
set_timer0(131-get_timer0());
conta++;
if(conta == 125)
{
conta=0;
led = !led;
output_bit(pin_d1, led); //pisca o LED1
}
}
//--------------------------------------------------------------
//Programa Principal.
void main(void)
{
char COMANDO[15];
set_timer0(131);
setup_timer_0(RTCC_INTERNAL | RTCC_DIV_64);
enable_interrupts(int_rda); //Habilita interrupção de recebimento.
enable_interrupts(int_timer0);
enable_interrupts(GLOBAL); //Habilita registrador de interrupção.
set_tris_d(0b00000000); //Todos os pinos da porta D como saídas.
set_tris_b(0b00000000); //Todos os pinos da porta B como saídas.
output_b(0b00000000); //Desliga todos os pinos da porta B.
while( true ) //Loop infinito.
{

if(CHEGOU_COMANDO == true)
{
CHEGOU_COMANDO = false;

strcpy(COMANDO,">CMD#01#ON*");
if( strcmp(BufferRX,COMANDO) == 0)
{
output_high(pin_b0); //Liga Relé 1.
printf("Relê #1 LIGADO\r\n");
continue; //volta para o início do loop while().
}
strcpy(COMANDO,">CMD#01#OFF*");
if(strcmp(BufferRX,COMANDO) == 0)
{
output_low(pin_b0); //Desliga Relé 1.
printf("Relê #1 DESLIGADO\r\n");
continue;
}
//--------------------------------------------------------------
strcpy(COMANDO,">CMD#02#ON*");
if( strcmp(BufferRX,COMANDO) == 0)
{
output_high(pin_b1); //Liga LED.
printf("Relê #2 LIGADO\r\n");
continue;
}
strcpy(COMANDO,">CMD#02#OFF*");
if(strcmp(BufferRX,COMANDO) == 0)
{
output_low(pin_b1); //Desliga LED.
printf("Relê #2 DESLIGADO\r\n");
continue;
}
//--------------------------------------------------------------
strcpy(COMANDO,">CMD#03#ON*");
if( strcmp(BufferRX,COMANDO) == 0)

{
output_high(pin_b2); //Liga LED.
printf("Relê #3 LIGADO\r\n");
continue;
}
strcpy(COMANDO,">CMD#03#OFF*");
if(strcmp(BufferRX,COMANDO) == 0)
{
output_low(pin_b2); //Desliga LED.
printf("Relê #3 DESLIGADO\r\n");
continue;
}
//--------------------------------------------------------------
strcpy(COMANDO,">CMD#04#ON*");
if( strcmp(BufferRX,COMANDO) == 0)
{
output_high(pin_b3); //Liga LED.
printf("Relê #4 LIGADO\r\n");
continue;
}
strcpy(COMANDO,">CMD#04#OFF*");
if(strcmp(BufferRX,COMANDO) == 0)
{
output_low(pin_b3); //Desliga LED.
printf("Relê #4 DESLIGADO\r\n");
continue;
}
//--------------------------------------------------------------
strcpy(COMANDO,">CMD#05#ON*");
if( strcmp(BufferRX,COMANDO) == 0)
{
output_high(pin_b4); //Liga LED.
printf("Relê #5 LIGADO\r\n");
continue;
}
strcpy(COMANDO,">CMD#05#OFF*");
if(strcmp(BufferRX,COMANDO) == 0)
{
output_low(pin_b4); //Desliga LED.
printf("Relê #5 DESLIGADO\r\n");
continue;
}
//--------------------------------------------------------------
strcpy(COMANDO,">CMD#06#ON*");
if( strcmp(BufferRX,COMANDO) == 0)
{
output_high(pin_b5); //Liga LED.
printf("Relê #6 LIGADO\r\n");
continue;
}
strcpy(COMANDO,">CMD#06#OFF*");
if(strcmp(BufferRX,COMANDO) == 0)
{
output_low(pin_b5); //Desliga LED.
printf("Relê #6 DESLIGADO\r\n");
continue;
}
//--------------------------------------------------------------
strcpy(COMANDO,">CMD#07#ON*");
if( strcmp(BufferRX,COMANDO) == 0)
{
output_high(pin_b6); //Liga LED.
printf("Relê #7 LIGADO\r\n");
continue;
}
strcpy(COMANDO,">CMD#07#OFF*");
if(strcmp(BufferRX,COMANDO) == 0)
{
output_low(pin_b6); //Desliga LED.
printf("Relê #7 DESLIGADO\r\n");
continue;
}
//--------------------------------------------------------------
strcpy(COMANDO,">CMD#08#ON*");
if( strcmp(BufferRX,COMANDO) == 0)
{
output_high(pin_b7); //Liga LED.
printf("Relê #8 LIGADO\r\n");
continue;
}
strcpy(COMANDO,">CMD#08#OFF*");
if(strcmp(BufferRX,COMANDO) == 0)
{
output_low(pin_b7); //Desliga LED.
printf("Relê #8 DESLIGADO\r\n");
continue;
}
//--------------------------------------------------------------
}
}
}

//--------------------------------------------------------------

Código 1: código-fonte da programação do PIC.
5 – DRIVER DO SOFTWARE CONTROLADOR DE RELÉS

Para a programação do software controlador de relés será utilizado os arquivos dll

FTD2xx encontrados no site http://www.ftdichip.com/Drivers/FT232-FT245Drivers.htm, que

ao serem baixados e descompactados, fornecerão os arquivos FTD2XX.lib e o arquivo

cabeçalho FTD2XX.h, que deverão ser adicionados a biblioteca do programa utilizado para a

programação do aplicativo, no projeto o Borland C++ Builder.

5.1 – FUNÇÕES DO FTD2XX

No presente projeto, não será utilizado todas as funções disponibilizadas pelo

FTD2xx, outras terão que ser entendidas para o funcionamento do aplicativo em questão.

Primeiramente existem duas variáveis que serão utilizadas em qualquer função da dll da

FTDI, elas são: FT_STATUS, variável responsável pelo status geral do dispositivo conectado,

e assim entrando com outras funções que retornaram o valor FT_OK no caso de sucesso em

sua função específica; FT_HANDLE é a variável responsável pelo armazenamento do Handle

que deve ser usado pelas funções, para ter acesso ao dispositivo. Em suas funções utilizadas

no projeto, serão elas: FT_open() responsável pela abertura do dispositivo conectado no

computador e retorna um identificador (handle) para ser usado na maioria as funções, precisa

de dois parâmetros para sua execução, que na seqüência seria um inteiro para dizer qual

dispositivo será aberto, iniciando no 0 para o primeiro dispositivo e seguindo essa seqüência e

um fthandle, que será o ponteiro para a variável FT_HANDLE;

FT_SetDataCharacteristics(), função que define as características de comunicação com o

dispositivo, possui quatro parâmetros, na seqüência um fthandle, o tamanho dos dados

(FT_BITS_7 ou FT_BITS_8), número de stop bits (FT_STOP_BITS_1 ou

FT_STOP_BITS_2) e a paridade (FT_PARITY_NONE, FT_PARITY_ODD, entre outros);
FT_SetBaudRate(), função que define a velocidade da comunicação com o dispositivo, possui

dois parâmetros, na seqüência um fthadle e a velocidade (Baud rate); FT_SetTimeouts(),

função que seta os timeouts de leitura e escrita do dispositivo, possui três parâmetros, em

seqüência um fthandle, o timeout de leitura em milisegundos e o timeout de escrita em

milisegundos; FT_Purge(), função responsável pela limpeza dos buffers de transmissão e

recepção do dispositivo (TX e PX), possui dois parâmetros, em seqüência um fthandle e o

buffer a ser feito a limpeza (FT_PURGE_RX e/ou FT_PURGE_TX); FT_Close(), função que

fecha o dispositivo aberto pelo FT_Open(), possui um parêmetro que é o fthandle;

FT_Write(), função responsável por escrever dados para um dispositivo, possui quatro

parâmetros, na seqüência um fthandle, um ponteiro para o buffer onde contém os dados a

serem escritos no dispositivo, número de bytes a serem escritos no dispositivo e um ponteiro

que obtém o número de bytes escritos no dispositivo; FT_Read(), função responsável pela

leitura dos dados para um dispositivo, possui quatro parâmetros que tem funcionalidade igual

ao FT_Warite(), só que para leitura. Todas essas funções descritas acima retornam um

FT_OK no caso de sucesso em sua operação.

5.2 – LINGUAGEM DE PROGRAMAÇÃO APLICADA NO SOFTWARE

CONTROLADOR DE RELÉS

O código para o software em questão foi contruido no C++ Builder possuindo apenas

uma tela de controle, sendo possível abrir e fechar a USB e ligar e desligar os relés ligados no

dispositivo, mostrando uma tela de status. Haja visto que sua codificação e funções estão

programadas de acordo com o funcionamento dos botões.
Figura 21: Tela do Software controlador de relés.

//---------------------------------------------------------------------------
//CURSO USB/Serial
//Liga/Desliga 8 Relês através do CI USB FT232BM e PIC16F877.
//LOOP: Usando Thead.
//---------------------------------------------------------------------------
#include <vcl.h>
#include <stdio.h>
#pragma hdrstop
#include "ftd2xx.h"

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "PERFGRAP"
#pragma resource "*.dfm"
//Variáveis globais.
TForm1 *Form1;
TMultLinha *MultLinha; //Classe Thread. declarada em Unit1.h
boolean CONECTADO=false;
FT_HANDLE ftHandle;
FT_STATUS ftStatus;
char RxBuffer[100];
char AuxBuffer[100];
void Status(String Comando);

//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//------------------------------------------------------------------------------
__fastcall TMultLinha::TMultLinha(bool CreateSuspended) : TThread(CreateSuspended)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ButtonAbrirClick(TObject *Sender)
{
ftStatus = FT_Open(0, &ftHandle); //Abre USB DEV0.

if(ftStatus == FT_OK) //Se OK.
{

FT_SetDataCharacteristics(ftHandle,FT_BITS_8,FT_STOP_BITS_1,FT_PARITY_NONE);
FT_SetBaudRate(ftHandle,FT_BAUD_9600); //Define velocidade bps.
FT_SetTimeouts(ftHandle,1,0);

ButtonAbrir->Enabled = false;
ButtonFechar->Enabled = true;
Memo1->Enabled = true;

SpeedRele1->Enabled = true;
SpeedRele2->Enabled = true;
SpeedRele3->Enabled = true;
SpeedRele4->Enabled = true;
SpeedRele5->Enabled = true;
SpeedRele6->Enabled = true;
SpeedRele7->Enabled = true;
SpeedRele8->Enabled = true;
MultLinha->Resume(); //Inicia processo.
CONECTADO = true;
FT_Purge(ftHandle,FT_PURGE_RX | FT_PURGE_TX); //Limpa os buffers TX e RX do
dispositivo.
}else{
ShowMessage("Erro ao abrir o dispositivo USB (DEV0).");
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ButtonFecharClick(TObject *Sender)
{
if(ftStatus == FT_OK) //Se USB DEV0 está aberto.
{
FT_Close(ftHandle);
ButtonFechar->Enabled = false;
ButtonAbrir->Enabled = true;
Memo1->Enabled = false;

SpeedRele1->Enabled = false;
SpeedRele2->Enabled = false;
SpeedRele3->Enabled = false;
SpeedRele4->Enabled = false;
SpeedRele5->Enabled = false;
SpeedRele6->Enabled = false;
SpeedRele7->Enabled = false;
SpeedRele8->Enabled = false;
}else{
ShowMessage("Erro ao fechar dispositivo USB (DEV0).");
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedRele1Click(TObject *Sender)
{
ULONG TamaDados;
ULONG BytesEscritos=0;
char *StrON=">CMD#01#ON*";
char *StrOFF=">CMD#01#OFF*";

if(SpeedRele1->Down)
{
TamaDados = strlen(StrON);
ftStatus = FT_Write(ftHandle,StrON,TamaDados,&BytesEscritos);
if(ftStatus != FT_OK)
{
ShowMessage("Erro ao tentar enniar dados.");
}
}
if(!SpeedRele1->Down)
{
TamaDados = strlen(StrOFF);
ftStatus = FT_Write(ftHandle,StrOFF,TamaDados,&BytesEscritos);
if(ftStatus != FT_OK)
{
ShowMessage("Erro ao tentar enviar os dados.");
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedRele2Click(TObject *Sender)
{
ULONG TamaDados;
ULONG BytesEscritos=0;
char *StrON=">CMD#02#ON*";
char *StrOFF=">CMD#02#OFF*";

if(SpeedRele2->Down)
{
TamaDados = strlen(StrON);
ftStatus = FT_Write(ftHandle,StrON,TamaDados,&BytesEscritos);
if(ftStatus != FT_OK)
{
ShowMessage("Erro ao tentar enviar os dados.");
}
}
if(!SpeedRele2->Down)
{
TamaDados = strlen(StrOFF);
ftStatus = FT_Write(ftHandle,StrOFF,TamaDados,&BytesEscritos);
if(ftStatus != FT_OK)
{
ShowMessage("Erro ao tentar enviar os dados.");
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedRele3Click(TObject *Sender)
{
ULONG TamaDados;
ULONG BytesEscritos=0;
char *StrON=">CMD#03#ON*";
char *StrOFF=">CMD#03#OFF*";

if(SpeedRele3->Down)
{
TamaDados = strlen(StrON);
ftStatus = FT_Write(ftHandle,StrON,TamaDados,&BytesEscritos);
if(ftStatus != FT_OK)
{
ShowMessage("Erro ao tentar enviar os dados.");
}
}
if(!SpeedRele3->Down)
{
TamaDados = strlen(StrOFF);
ftStatus = FT_Write(ftHandle,StrOFF,TamaDados,&BytesEscritos);
if(ftStatus != FT_OK)
{
ShowMessage("Erro ao tentar enviar os dados.");
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedRele4Click(TObject *Sender)
{
ULONG TamaDados;
ULONG BytesEscritos=0;
char *StrON=">CMD#04#ON*";
char *StrOFF=">CMD#04#OFF*";

if(SpeedRele4->Down)
{
TamaDados = strlen(StrON);
ftStatus = FT_Write(ftHandle,StrON,TamaDados,&BytesEscritos);
if(ftStatus != FT_OK)
{
ShowMessage("Erro ao tentar enviar os dados.");
}
}
if(!SpeedRele4->Down)
{
TamaDados = strlen(StrOFF);
ftStatus = FT_Write(ftHandle,StrOFF,TamaDados,&BytesEscritos);
if(ftStatus != FT_OK)
{
ShowMessage("Erro ao tentar enviar os dados.");
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedRele5Click(TObject *Sender)
{
ULONG TamaDados;
ULONG BytesEscritos=0;
char *StrON=">CMD#05#ON*";
char *StrOFF=">CMD#05#OFF*";

if(SpeedRele5->Down)
{
TamaDados = strlen(StrON);
ftStatus = FT_Write(ftHandle,StrON,TamaDados,&BytesEscritos);
if(ftStatus != FT_OK)
{
ShowMessage("Erro ao tentar enviar os dados.");
}
}
if(!SpeedRele5->Down)
{
TamaDados = strlen(StrOFF);
ftStatus = FT_Write(ftHandle,StrOFF,TamaDados,&BytesEscritos);
if(ftStatus != FT_OK)
{
ShowMessage("Erro ao tentar enviar os dados.");
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedRele6Click(TObject *Sender)
{
ULONG TamaDados;
ULONG BytesEscritos=0;
char *StrON=">CMD#06#ON*";
char *StrOFF=">CMD#06#OFF*";

if(SpeedRele6->Down)
{
TamaDados = strlen(StrON);
ftStatus = FT_Write(ftHandle,StrON,TamaDados,&BytesEscritos);
if(ftStatus != FT_OK)
{
ShowMessage("Erro ao tentar enviar os dados.");
}
}
if(!SpeedRele6->Down)
{
TamaDados = strlen(StrOFF);
ftStatus = FT_Write(ftHandle,StrOFF,TamaDados,&BytesEscritos);
if(ftStatus != FT_OK)
{
ShowMessage("Erro ao tentar enviar os dados.");
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedRele7Click(TObject *Sender)
{
ULONG TamaDados;
ULONG BytesEscritos=0;
char *StrON=">CMD#07#ON*";
char *StrOFF=">CMD#07#OFF*";

if(SpeedRele7->Down)
{
TamaDados = strlen(StrON);
ftStatus = FT_Write(ftHandle,StrON,TamaDados,&BytesEscritos);
if(ftStatus != FT_OK)
{
ShowMessage("Erro ao tentar enviar os dados.");
}
}
if(!SpeedRele7->Down)
{
TamaDados = strlen(StrOFF);
ftStatus = FT_Write(ftHandle,StrOFF,TamaDados,&BytesEscritos);
if(ftStatus != FT_OK)
{
ShowMessage("Erro ao tentar enviar os dados.");
}
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedRele8Click(TObject *Sender)
{
ULONG TamaDados;
ULONG BytesEscritos=0;
char *StrON=">CMD#08#ON*";
char *StrOFF=">CMD#08#OFF*";

if(SpeedRele8->Down)
{
TamaDados = strlen(StrON);
ftStatus = FT_Write(ftHandle,StrON,TamaDados,&BytesEscritos);
if(ftStatus != FT_OK)
{
ShowMessage("Erro ao tentar enviar os dados.");
}
}
else
{
TamaDados = strlen(StrOFF);
ftStatus = FT_Write(ftHandle,StrOFF,TamaDados,&BytesEscritos);
if(ftStatus != FT_OK)
{
ShowMessage("Erro ao tentar enviar os dados.");
}
}
}
//---------------------------------------------------------------------------
void Status(String Comando)
{
if(Comando == "Relê #1 LIGADO\r\n")
{
Form1->ShapeRele1->Brush->Color = clLime;
Form1->SpeedRele1->Font->Color = clBlack;
Form1->SpeedRele1->Caption = "Relê #1 LIGADO";
}else
if(Comando == "Relê #1 DESLIGADO\r\n")
{
Form1->ShapeRele1->Brush->Color = clGreen;
Form1->SpeedRele1->Font->Color = clWhite;
Form1->SpeedRele1->Caption = "Relê #1 DESLIGADO";
}else
if(Comando == "Relê #2 LIGADO\r\n")
{
Form1->ShapeRele2->Brush->Color = clLime;
Form1->SpeedRele2->Font->Color = clBlack;
Form1->SpeedRele2->Caption = "Relê #2 LIGADO";
}else
if(Comando == "Relê #2 DESLIGADO\r\n")
{
Form1->ShapeRele2->Brush->Color = clGreen;
Form1->SpeedRele2->Font->Color = clWhite;
Form1->SpeedRele2->Caption = "Relê #2 DESLIGADO";
}else
if(Comando == "Relê #3 LIGADO\r\n")
{
Form1->ShapeRele3->Brush->Color = clLime;
Form1->SpeedRele3->Font->Color = clBlack;
Form1->SpeedRele3->Caption = "Relê #3 LIGADO";
}else
if(Comando == "Relê #3 DESLIGADO\r\n")
{
Form1->ShapeRele3->Brush->Color = clGreen;
Form1->SpeedRele3->Font->Color = clWhite;
Form1->SpeedRele3->Caption = "Relê #3 DESLIGADO";
}else
if(Comando == "Relê #4 LIGADO\r\n")
{
Form1->ShapeRele4->Brush->Color = clLime;
Form1->SpeedRele4->Font->Color = clBlack;
Form1->SpeedRele4->Caption = "Relê #4 LIGADO";
}else
if(Comando == "Relê #4 DESLIGADO\r\n")
{
Form1->ShapeRele4->Brush->Color = clGreen;
Form1->SpeedRele4->Font->Color = clWhite;
Form1->SpeedRele4->Caption = "Relê #4 DESLIGADO";
}else
if(Comando == "Relê #5 LIGADO\r\n")
{
Form1->ShapeRele5->Brush->Color = clLime;
Form1->SpeedRele5->Font->Color = clBlack;
Form1->SpeedRele5->Caption = "Relê #5 LIGADO";
}else
if(Comando == "Relê #5 DESLIGADO\r\n")
{
Form1->ShapeRele5->Brush->Color = clGreen;
Form1->SpeedRele5->Font->Color = clWhite;
Form1->SpeedRele5->Caption = "Relê #5 DESLIGADO";
}else
if(Comando == "Relê #6 LIGADO\r\n")
{
Form1->ShapeRele6->Brush->Color = clLime;
Form1->SpeedRele6->Font->Color = clBlack;
Form1->SpeedRele6->Caption = "Relê #6 LIGADO";
}else
if(Comando == "Relê #6 DESLIGADO\r\n")
{
Form1->ShapeRele6->Brush->Color = clGreen;
Form1->SpeedRele6->Font->Color = clWhite;
Form1->SpeedRele6->Caption = "Relê #6 DESLIGADO";
}else
if(Comando == "Relê #7 LIGADO\r\n")
{
Form1->ShapeRele7->Brush->Color = clLime;
Form1->SpeedRele7->Font->Color = clBlack;
Form1->SpeedRele7->Caption = "Relê #7 LIGADO";
}else
if(Comando == "Relê #7 DESLIGADO\r\n")
{
Form1->ShapeRele7->Brush->Color = clGreen;
Form1->SpeedRele7->Font->Color = clWhite;
Form1->SpeedRele7->Caption = "Relê #7 DESLIGADO";
}else
if(Comando == "Relê #8 LIGADO\r\n")
{
Form1->ShapeRele8->Brush->Color = clLime;
Form1->SpeedRele8->Font->Color = clBlack;
Form1->SpeedRele8->Caption = "Relê #8 LIGADO";
}else
if(Comando == "Relê #8 DESLIGADO\r\n")
{
Form1->ShapeRele8->Brush->Color = clGreen;
Form1->SpeedRele8->Font->Color = clWhite;
Form1->SpeedRele8->Caption = "Relê #8 DESLIGADO";
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
Memo1->Clear();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ButtonSairClick(TObject *Sender)
{
Close();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{
MultLinha = new TMultLinha(true); //Aloca memória para o objeto.
MultLinha->Priority = tpNormal; //Define a prioridade.
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCloseQuery(TObject *Sender, bool &CanClose)
{
MultLinha = NULL;
delete MultLinha;
//Somente se TMultLinha for false "new TMultLinha(false);"
//MultLinha->Terminate();
//MultLinha->WaitFor();

if(CONECTADO)
FT_Close(ftHandle);
}
void __fastcall TMultLinha::MostraString(void)
{
Form1->Caption = AuxBuffer;
}
//---------------------------------------------------------------------------
void __fastcall TMultLinha::Execute()
{
static DWORD BytesRecebidos;
static String StrComandos;
static unsigned int cont=0;
FreeOnTerminate = true; //O objeto é destruído automaticamente quando a Thead terminar.
while(!Terminated) //loop infinito. Vida do programa.
{
if(CONECTADO == true) //Se está conectado.
{

ftStatus = FT_Read(ftHandle,RxBuffer,100,&BytesRecebidos);
if(ftStatus == FT_OK)
{
cont=0;
if(BytesRecebidos > 0)
{
RxBuffer[BytesRecebidos] = '\0'; //Finaliza string.
StrComandos += RxBuffer;

while(cont < BytesRecebidos) //Enquanto houver bytes a serem lidos.
{
if( (RxBuffer[cont] == '\n') || (RxBuffer[cont] == '\0') ) //Se achou o final da string.
{
Form1->Memo1->SetSelTextBuf(StrComandos.c_str());
strcpy(AuxBuffer,StrComandos.c_str());
AuxBuffer[StrComandos.Length()-2] = '\0'; //Remove os caracteres '\r\n'.
Synchronize(MostraString); //Mostra no Caption do Form1.
Status(StrComandos);
StrComandos="\0"; //Limpa string.
}
cont++;
}
}
}
}else{//Se não conectado.
Sleep(1); //Para não consumir processo da CPU.
}
}//while.
}

Código 2: Código do Software controlador de relês

6 – DESENVOLVIMENTO PRÁTICO DO PROJETO

Este capítulo abordará o desenvolvimento prático deste projeto, passando pela

instalação dos drivers, programação do microcontrolador PIC 16F877 finalizando no circuito

para o controle de relé.

6.1 – INSTALAÇÃO DOS ARQUIVOS FTD2XX

Os arquivos dll para a comunicação com o BUS USB estão disponíveis, como dito nos

capítulos anteriores, no site da FTDI no link Drivers. Lá podem ser encontrados drivers

D2XX para várias versões do Windows e outros sistemas operacionais, no caso o Microsoft

Windows XP SP2. É realizado o download dos drivers em um formato .zip, possuindo

arquivos próprios para serem adicionados nas bibliotecas de programação e outros para

instalação do dispositivo.
Figura 22: Arquivos necessários para instalação do dispositivo.

Com os arquivos armazenados no disco rígido do PC, pode-se conectar o dispositivo

no host USB do computador, que neste caso será reconhecido pelo sistema operacional. Em

sua instalação, deve-se escolher a localização do driver e referenciar o arquivo ftd2xx.inf na

pasta onde o arquivo baixado foi descompactado. Com isso o dispositivo esta pronto para ser

utilizado.

6.2 – DETALHAMENTO DA PROGRAMAÇÃO DO PIC 16F877

Neste capítulo não será explanado a programação em si, e sim como fazê-la. Sendo

inicialmente necessário compilar o código assim transformando-o em linguagem de máquina

(seqüência lógica de endereços de memória e instruções internas próprias do

microcontrolador). Para essa tarefa, foi utilizado o CSS C Compiler, versão Trial Evaluation.

Por meio deste programa é possível compilar o código em C e transformá-lo em hexadecimal,

linguagem aceita pelo PIC 16F877.
Figura 23: Processo de edição, compilação e gravação do PIC 16F877

No processo de gravação foi utilizado uma placa de gravação de microcontroladores

cedida pelo IESAM – Instituto de Estudos Superiores da Amazônia e o programa MPLAB

IDE versão 7.21, que por meio da porta serial e do arquivo antes compilado pelo CCS, faz a

gravação no PIC 16F877. O programa também disponibiliza uma opção para verificar se o

programa foi gravado corretamente ou mesmo apagá-lo para inserir novos códigos.

6.3 – CIRCUÍTO E FUNCIONAMENTO DO DISPOSITIVO

Para a montagem do dispositivo e de seu circuito, foi encomendada uma placa com o

chipset FT232BM juntamente com o receptor USB da série “B”, que esta ligada a um

microcontrolador PIC 16F877 onde fará a comparação de strings para ligar e desligar o pino

que esta ligado ao driver ULN 2803. Este driver possui oito entradas TTL e oito saídas que

podem controlar até 45V/500mA. Neste projeto será utilizada uma fonte de 12v controlando

relés de 12v, no caso, apenas um. Este relé consome em média 50mA, o que da para ligar

mais sete outros relés, o que daria 400mA de consumo, sobrando ainda 100mA de folga para

o ULN 2803.
Figura 24: Chipset FT232BM juntamente com um receptor USB série “B”

O circuito completo para o controle de relés foi montado em um protoboard, seguindo

as especificações da figura 25. Em seu teste, ligando apenas um circuito de controle de relé na

entrada RL1 do ULN 2803, sendo este o dispositivo relé de 12 V, foi possível pelo software

ligar e desligar o dispositivo, apesar de que a garantia do PIC esta em apenas desligar e ligar

um pino corretamente, mas não garantindo se realmente o relé foi desligado ou ligado.

Figura 25: Circuito do dispositivo controlador de relés.
7 – CONCLUSÃO

Vimos neste projeto, que interligar um microcomputador através de software e
hardware, a um eletroeletrônico qualquer, envolve muito mais que saber programar, pois,
abrange o conhecimento do funcionamento de barramento de comunicação – como USB,
estudo de hardware com elementos que realizem a leitura de sinais e que possuam protocolos
coerentes para a funcionalidade do problema proposto – como Chipset - e hardware também
programáveis como PIC, logo, é notável que com a evolução da tecnologia, abre-se um leque
vasto de informação proporcionando a criação de soluções mais tecnológicas para facilitar a
vida cotidiana, tanto do usuário final quanto dos profissionais da área da tecnologia .
7 – REFERÊNCIAS BIBLIOGRÁFICAS

MESSIAS, Antônio R. Curso usb/serial – controle de dispositivos, - Curso de Barramento
USB; aula 1, 1999/2005. Disponível em: http://www.rogercom.com . Acesso: em 14 de abril
de 2006.

UNIVERSAL SERIAL BUS. Disponível em: http://www.usb.org . Acesso em: 01 de maio de
2006.

FUTURE TECHNOLOGY DEVICES INTERNATIONAL LTD. 2006. FTDI Chip.
Disponível em: http://www.ftdichip.com/Documents/ProgramGuides/D2XXPG30.pdf.Acesso
em 18 de maio de 2006

PEREIRA, Fábio; Microcontroladores PIC: Programação em C. 4ª edição .ed. Érica, 2005.