You are on page 1of 64

Comunicao do Matlab com

microcontroladores via USB





Aplicaes de MQR e MQNR
























Grupo SanUSB, 2012







[ 2 ]
Sumrio

I. Introduo """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" #
PROTOCOLO DE COMUNICAO USB """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" #
MTODOS DE COMUNICAO USB """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" #
II. A ferramenta SanUSB """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" $
GRAVAO DE MICROCONTROLADORES """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" $
GRAVANDO O MICROCONTROLADOR VIA USB NO WINDOWS """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" %#
COMUNICAO WIRELESS DE MICROCONTROLADORES """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" %&
SISTEMA DUAL CLOCK """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" '#
EMULAO DE COMUNICAO SERIAL NO WINDOWS VIA USB """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" '(
GRAVANDO O MICROCONTROLADOR VIA USB NO LINUX """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" )'
GRAVANDO O PIC VIA USB PELO TERMINAL DO LINUX OU MAC OSX """"""""""""""""""""""""""""""""""""""""""""""""""""""""" )#
EMULAO DE COMUNICAO SERIAL NO LINUX """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" )&
CIRCUITO COM84 PARA GRAVAO DO gerenciador.hex """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" )*
III. Comunicao USB com Matlab """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" #%
INTERFACE USB COM O MATLAB """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" #'
IV. Controle de velocidade de motor utilizando estimador de mnimos quadrados
recursivos e no recursivos """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" #&
SISTEMA DE CONTROLE """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" #+
ESTIMADOR POR MNIMOS QUADRADOS RECURSIVO - MQR """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" #$
APLICAO DO MQR PARA ESTIMAO DA PLANTA DO MOTOR CC """""""""""""""""""""""""""""""""""""""""""""""""""""""""""" (,
ESTIMAO POR MNIMOS QUADRADOS NO RECURSIVO - MQNR """""""""""""""""""""""""""""""""""""""""""""""""""""""""""" (#
APLICAO DO MQNR PARA ESTIMAO DA PLANTA DO MOTOR CC """""""""""""""""""""""""""""""""""""""""""""""""""""""" ((
PROJETO DO SISTEMA DE CONTROLE """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" ($
RESULTADOS """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" (*
CONSIDERAES FINAIS """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" &)
REFERNCIAS BILBIOGRFICAS """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" &)





























Dedicamos este trabalho a Deus.

Agradecemos a todos que possibilitaram de forma direta
e indireta que este projeto fosse realizado.



Processo de Comunicao do Matlab com microcontroladores via USB


[ 4 ]
I. Introduo
Um microcontrolador um sistema computacional completo, no qual esto includos
internamente uma CPU (Central Processor Unit), memrias RAM (dados), flash (programa)
e E
2
PROM, pinos de I/O (Input/Output), alm de outros perifricos internos, tais como,
osciladores, canal USB, interface serial assncrona USART, mdulos de temporizao e
conversores A/D, entre outros, integrados em um mesmo componente (chip).
O microcontrolador PIC (Periferal Interface Controler), da Microchip Technology Inc.
(empresa de grande porte, em Arizona, nos Estados Unidos da Amrica), possui uma boa
diversidade de recursos, capacidades de processamento, custo e flexibilidade de aplicaes.
PROTOCOLO DE COMUNICAO USB
A USB, sigla para Universal Serial Bus, o padro de interface para perifricos externos
ao computador provavelmente mais popular dos j criados. Um sistema USB composto
por hardware mestre e escravo. O mestre chamado de host e o escravo denomina-se
dispositivo ou simplesmente perifrico. Todas as transferncias USB so administradas e
iniciadas pelo host. Mesmo que um dispositivo queira enviar dados, necessrio que o host
envie comandos especficos para receb-los.
A fase de preparao, conhecida como enumerao, acontece logo depois de quando o
dispositivo USB fisicamente conectado ao computador. Nesse momento, o sistema
operacional realiza vrios pedidos ao dispositivo para que as caractersticas de
funcionamento sejam reconhecidas. O sistema operacional, com a obtida noo do
perifrico USB, atribui-lhe um endereo e seleciona a configurao mais apropriada de
acordo com certos critrios. Com mensagens de confirmao do dispositivo indicando que
essas duas ltimas operaes foram corretamente aceitas, a enumerao finalizada e o
sistema fica pronto para o uso.
MTODOS DE COMUNICAO USB
Os mtodos mais comuns de comunicao USB, tambm utilizados pela ferramenta
SanUSB, so:

Human Interface Device (HID) - O dispositivo USB reconhecido automaticamente pelo
sistema operacional Windows@ ou linux como um Dispositivo de Interface Humana (HID),
Processo de Comunicao do Matlab com microcontroladores via USB


[ 5 ]
no sendo necessrio a instalao de driver especiais para a aplicao. Este mtodo
apresenta velocidade de comunicao de at 64 kB/s e utilizado pelo gerenciador de
gravao da ferramenta SanUSB no linux. Mais detalhes na vdeo-aula disponvel em
http://www.youtube.com/watch?v=h6Lw2qeWhlM .

Communication Device Class (CDC) Basicamente o driver emula uma porta COM,
fazendo com que a comunicao entre o software e o firmware seja realizada como se
fosse uma porta de comunicao serial padro. o mtodo mais simples de comunicao
bidirecional com velocidade de comunicao de at 115 kbps, ou seja, aproximadamente
14,4 kB/s. Mais detalhes em uma aplicao Windows@ com protocolo Modbus RTU
http://www.youtube.com/watch?v=KUd1JkwGJNk e em uma aplicao de
comunicao bidirecional no Linux
http://www.youtube.com/watch?v=cRW99T_qa7o. Este protocolo o mais
utilizado para comunicao USB com o MATLAB. A emulao serial CDC utilizada para
comunicao com o MATLAB@, foram testadas verses posteriores 3.245 at a
verso 4.084 do CCS Compiler e funcionaram satisfatoriamente.

Mass Storage Device (MSD) - Mtodo customizado para dispositivos de
armazenamento em massa que permite alta velocidade de comunicao USB, limitado
apenas pela prpria velocidade do barramento USB 2.0 (480 Mbps). Este mtodo
utilizado por pen-drives, scanners, cmeras digitais. Foi utilizado juntamente com a
ferramenta SanUSB para comunicao com software de superviso programado em Java.
Mais detalhes na vdeo-aula disponvel em
http://www.youtube.com/watch?v=Ak9RAl2YTr4.
Como foi visto, a comunicao USB baseada em uma central (host), onde o
computador enumera os dispositivos USB conectados a ele. Existem trs grandes classes,
ilustradas na figura 1.11, de dispositivos comumente associados a USB: dispositivos de
interface humana (HID), classe de dispositivos de comunicao (CDC) e dispositivos de
armazenamento em massa (MSD). Cada uma dessas classes, ilustradas na figura 1.1, j
possuem um driver implementado na maioria dos sistemas operacionais. Portanto, se
adequarmos o firmware de nosso dispositivo para ser compatvel com uma dessas classes,
no haver necessidade de implementar um driver.
Processo de Comunicao do Matlab com microcontroladores via USB


[ 6 ]

Figura 1. 1: Drivers e comunicao.
Nos sistemas operacionais Windows@ e Linux, o modo mais fcil de comunicar com
o PIC USB o CDC, por uma razo simples, os programas para PCs so baseados na
comunicao via porta serial, o que torna o processo ainda mais simples. O mtodo CDC
no Linux e o HID no Windows@ so nativos, ou seja, no necessrio instalar nenhum
driver no sistema operacional para que o PC reconhea o dispositivo.

II. A ferramenta SanUSB

O sistema de desenvolvimento SanUSB uma ferramenta composta de software e
hardware bsico da famlia PIC18Fxx5x com interface USB [1]. Esta ferramenta livre se
mostra eficiente no desenvolvimento rpido de projetos reais, pois no h necessidade de
remover o microcontrolador para a atualizao do firmware. Alm disso, esta ferramenta se
mostra eficaz no ensino e na difuso de microcontroladores, bem como em projetos de
eletrnica e informtica, pois todos os usurios podem desenvolver projetos reais no
ambiente de ensino ou na prpria residncia sem a necessidade de um equipamento para
gravao de microcontroladores. Alm disso, o software de gravao de microcontroladores
USB multiplataforma, pois executvel no Windows@, Mac OSX e no Linux e tambm
Processo de Comunicao do Matlab com microcontroladores via USB


[ 7 ]
plug and play, ou seja, reconhecido automaticamente pelos sistemas operacionais sem a
necessidade de instalar nenhum driver. Dessa forma, ela capaz de suprimir:
Um equipamento especfico para gravao de um programa no microcontrolador;
conversor TTL - RS-232 para comunicao serial bidirecional, emulado via USB pelo
protocolo CDC, que permite tambm a depurao do programa atravs da
impresso via USB das variveis do firmware;
fonte de alimentao, j que a alimentao do PIC provm da porta USB do PC.
importante salientar que cargas indutivas como motores de passo ou com corrente
acima de 400mA devem ser alimentadas por uma fonte de alimentao externa.
Conversor analgico-digital (AD) externo, tendo em vista que ele dispe
internamente de 10 ADs de 10 bits;
software de simulao, considerando que a simulao do programa e do hardware
podem ser feitas de forma rpida e eficaz no prprio circuito de desenvolvimento ou
com um protoboard auxiliar.
Alm de todas estas vantagens, os laptops e alguns computadores atuais no
apresentam mais interface de comunicao paralela e nem serial EIA/RS-232, somente
USB.
Como ilustrado na figura 2.1, esta ferramenta possibilita que a compilao, a gravao e a
simulao real de um programa, como tambm a comunicao serial atravs da emulao
de uma porta COM virtual, possam ser feitos de forma rpida e eficaz a partir do momento
em o microcontrolador esteja conectado diretamente a um computador via USB.
Processo de Comunicao do Matlab com microcontroladores via USB


[ 8 ]

Figura 2. 1: Gravao do PIC via PC.
Utilizando esta ferramenta, estudantes foram trs vezes consecutivas campees da
Competio de Robtica do IFCE (2007, 2008 e 2009) na categoria Localizao, campees
da Feira Brasileira de Cincias e Engenharia (FEBRACE09) da USP em So Paulo na
Categoria Engenharia (2009), como tambm obtiveram Prmio de Inovao em Aplicao
Tecnolgica na Feria Explora 2009 em Medelin na Colmbia e foram Campees na
Categoria Supranivel do Foro Internacional de Ciencia e Ingeniera 2010 no Chile, terceiro
lugar em inovao na Semantec 2011 do IFCE e campees na V Feira Estadual de Cincias
e Cultura do Cear na categoria robtica educacional em 2011. Vrios projetos com a
ferramenta SanUSB podem ser visualizados em
http://www.youtube.com/results?search_query=sanusb .
GRAVAO DE MICROCONTROLADORES
A transferncia de programas para os microcontroladores normalmente efetuada
atravs de um hardware de gravao especfico. Atravs desta ferramenta, possvel
efetuar a descarga de programas para o microcontrolador diretamente de uma porta USB
de qualquer PC.
Para que todas essas funcionalidades sejam possveis, necessrio gravar, anteriormente e
somente uma vez, com um gravador especfico para PIC, o gerenciador de gravao pela
USB Gerenciador.hex disponvel na pasta completa da ferramenta no link abaixo, onde
Processo de Comunicao do Matlab com microcontroladores via USB


[ 9 ]
tambm possvel baixar periodicamente as atualizaes dessa ferramenta e a incluso de
novos programas: https://dl.dropbox.com/u/101922388/121007SanUSBOrig.zip
Caso o computador ainda no o tenha o aplicativo Java JRE ou SDK instalado para
suporte a programas executveis desenvolvidos em Java, baixe a Verso Windows@
disponvel em: http://www.4shared.com/file/WKDhQwZK/jre-6u21-Windows@-
i586-s.html ou atravs do link:
http://www.java.com/pt_BR/download/manual.jsp.
Para que os programas em C possam ser gravados no microcontrolador via USB,
necessrio compil-los, ou seja, transform-los em linguagem de mquina hexadecimal.
Existem diversos compiladores que podem ser utilizados por esta ferramenta, entre eles o
SDCC, o C18, o Hi-Tech e o CCS. Devido didtica das funes e bibliotecas USB
disponveis para emulao serial, diversos perifricos e multitasking, um dos compiladores
utilizados com bom rendimento, alm do C18, com exemplos de aplicao disponveis na
pasta de desenvolvimento, o CCS Compiler, testado nas verses 3.245 e 4.084.
As verses posteriores a 4.084 deste compilador apresentam bugs na emulao
serial CDC utilizada para comunicao com o MATLAB@ e funcionaram
satisfatoriamente at a verso 4.084.
Caso grave no microcontrolador o novo gerenciador de gravao pela USB
GerenciadorPlugandPlay.hex, no esquea de colar o novo arquivo cabealho SanUSB.h
dentro da pasta ExemploseBibliotecasCCS localizada na pasta instalada do compilador
(C:\Arquivos de programas\PICC\Drivers ). A representao bsica do circuito SanUSB de
28 pinos montada em protoboard mostrada na figura 2.2:

Processo de Comunicao do Matlab com microcontroladores via USB


[ 10 ]

Figura 2. 2: Esquemtico de montagem da Ferramenta para 28 pinos.
A representao bsica do circuito SanUSB de 40 pinos montada em protoboard
mostrada na figura 2.3:

Figura 2. 3: Esquemtico de montagem da ferramenta para 40 pinos.
Os componentes bsicos do circuito so:
1 microcontrolador da famlia PIC USB (18F2550, 18F2455, 18F4550, etc.);
1 cristal de 20MHz;
Processo de Comunicao do Matlab com microcontroladores via USB


[ 11 ]
2 capacitores de 22pF;
2 capacitores de 1uF (um no pino 14 Vusb e outro entre o +5V e o Gnd ) ;
3 leds e 3 resistores de 390 (s necessrio um led com resistor no pino B7);
1 resistor de 2k2 e um boto ou fio para gravao no pino 1;
1 diodo qualquer entre o +5V e o pino Vdd;
1 Cabo USB qualquer.

Note que, este sistema multiplataforma (Windows@, Linux e Mac OSX),
compatvel com o software de gravao HID USB da Microchip tambm para
Linux e Mac OSX, pode ser implementado tambm em qualquer placa de
desenvolvimento de microcontroladores PIC com interface USB, pois utiliza o
boto de reset, no pino 1, como boto de gravao via USB. Ao conectar o cabo USB e
alimentar o microcontrolador, com o pino 1 no Gnd (0V), atravs do boto ou de um
simples fio, o microcontrolador entra em Estado para Gravao via USB (led no pino B7
aceso) e que, aps o reset com o pino 1 no Vcc (+5V atravs do resistor fixo de 2K2 sem o
jump), entra em Estado para Operao do programa aplicativo (firmware) que foi
compilado.
O cabo USB apresenta normalmente quatro fios, que so conectados ao circuito do
microcontrolador nos pontos mostrados na figura acima, onde normalmente, o fio Vcc
(+5V) do cabo USB vermelho, o Gnd (Vusb-) marrom ou preto, o D+ azul ou verde e
o D- amarelo ou branco. Note que a fonte de alimentao do microcontrolador nos pinos
19 e 20 e dos barramentos vermelho (+5V) e azul (Gnd) do circuito provem da prpria
porta USB do computador. Para ligar o cabo USB no circuito possvel cort-lo e conect-lo
direto no protoboard, com fios rgidos soldados, como tambm possvel conectar sem
cort-lo, em um protoboard ou numa placa de circuito impresso, utilizando um conector
USB fmea. O diodo de proteo colocado no pino 20 entre o Vcc da USB e a alimentao
do microcontrolador serve para proteger contra corrente reversa caso a tenso da porta
USB esteja polarizada de forma inversa.
A figura 2.4 mostra a ferramenta SanUSB montada em protoboard seguindo o
circuito anterior e a posio de cada terminal no conector USB a ser ligado no PC. Cada
terminal conectado diretamente nos pinos do microcontrolador pelos quatro fios
correspondentes do cabo USB.
Processo de Comunicao do Matlab com microcontroladores via USB


[ 12 ]

Figura 2. 4: Esquema montado em protoboard e conector USB.
importante salientar que, para o perfeito funcionamento da gravao via USB, o
circuito desta ferramenta deve conter um capacitor de filtro entre 0,1uf e 1uF na
alimentao que vem da USB, ou seja, colocado entre os pinos 20 (+5V) e 19 (Gnd).
Caso o sistema microcontrolado seja embarcado como, por exemplo, um rob, um
sistema de aquisio de dados ou um controle de acesso, ele necessita de uma fonte de
alimentao externa, que pode ser uma bateria comum de 9V ou um carregador de celular.
A figura abaixo mostra o PCB, disponvel nos Arquivos do Grupo SanUSB, e o circuito para
esta ferramenta com entrada para fonte de alimentao externa. Para quem deseja obter
o sistema pronto para um aprendizado mais rpido, possvel tambm encomendar placas
de circuito impresso da ferramenta SanUSB, como a foto da placa ilustrada na figura 2.5,
entrando em contato com o grupo SanUSB atravs do e-mail: sanusb_laese@yahoo.com.br
.

Figura 2. 5: Esquema montado em PCB.
Processo de Comunicao do Matlab com microcontroladores via USB


[ 13 ]
Se preferir confeccionar a placa, possvel tambm imprimir, em folha de
transparncia, o PCB e o silk configurado em tamanho real, como mostra a figura 2.6,
transferir para a placa de cobre, corroer, furar e soldar os componentes. Mais no vdeo
disponvel em: http://www.youtube.com/watch?v=Xm8YJ_XaGA8 .

Figura 2. 6: PCB da Ferramenta SanUSB.

Para obter vrios programas-fonte e vdeos deste sistema livre de gravao,
comunicao e alimentao via USB, basta se cadastrar no grupo de acesso livre
www.tinyurl.com/SanUSB e clicar no item Arquivos.
Durante a programao do microcontrolador basta inserir, no inicio do programa em
C, a biblioteca cabealho SanUSB (#include <SanUSB.h>) contida dentro da pasta
ExemploseBibliotecasCCS e que voc j adicionou dentro da Drivers localizada na pasta
instalada do compilador ( C:\Arquivos de programas\PICC\Drivers ). Esta biblioteca contm
instrues do PIC18F2550 para o sistema operacional, configuraes de fusveis e
habilitao do sistema Dual Clock, ou seja, oscilador RC interno de 4 MHz para CPU e cristal
oscilador externo de 20 MHz para gerar a frequncia de 48MHz da comunicao USB,
atravs de prescaler multiplicador de frequncia.
Processo de Comunicao do Matlab com microcontroladores via USB


[ 14 ]
Como a frequncia do oscilador interno de 4 MHz, cada incremento dos
temporizadores corresponde a um microssegundo. O programa exemplo1 abaixo comuta
um led conectado no pino B7 a cada 0,5 segundo.
---------------------------------------------------------------------------------------------------------------
#include <SanUSB.h>

void main()
{
clock_int_4MHz();//Funo necessria para habilitar o dual clock (48MHz para USB e 4MHz para CPU)

while (1)
{
output_toggle(pin_B7); // comuta Led na funo principal
delay_ms(500);
}
}
O programa pisca3 abaixo pisca trs leds conectados nos pinos B5, B6 e B7.
#include <SanUSB.h>

main(){
clock_int_4MHz();//Funo necessria para habilitar o dual clock (48MHz para USB e 4MHz para CPU)

while (1)
{
output_high(pin_B5); // Pisca Led na funo principal
delay_ms(500);
output_low(pin_B5);
output_high(pin_B6);
delay_ms(500);
output_low(pin_B6);
output_high(pin_B7);
delay_ms(500);
output_low(pin_B7);
}}
---------------------------------------------------------------------------------------------------------------
Os arquivos compilados .hex assim como os firmwares esto disponveis em
http://www.4shared.com/file/sIZwBP4r/100727SanUSB.html.

GRAVANDO O MICROCONTROLADOR VIA USB NO WINDOWS

Para executar a gravao com a ferramenta SanUSB, importante seguir os
seguintes passos:
1. Baixe o a pasta da ferramenta de desenvolvimento SanUSB, para um diretrio raiz C ou
D, obtida no link http://www.4shared.com/file/sIZwBP4r/100727SanUSB.html.
Processo de Comunicao do Matlab com microcontroladores via USB


[ 15 ]
2. Grave no microcontrolador, somente uma vez, com um gravador especfico para PIC ou
com um circuito simples de gravao ICSP mostrado nas prximas sees, o novo
gerenciador de gravao pela USB Gerenciador.hex disponvel na pasta Gerenciador,
compatvel com os sistemas operacionais Windows@, Linux e Mac OSX.
3. Pressione o boto ou conecte o jump de gravao do pino 1 no Gnd para a transferncia
de programa do PC para o microcontrolador.
4. Conecte o cabo USB, entre o PIC e o PC, e solte o boto ou retire o jump. Se o circuito
SanUSB estiver correto acender o led do pino B7.
5. Caso o computador ainda no o tenha o aplicativo Java JRE ou SDK instalado para
suporte a programas executveis desenvolvidos em Java, baixe a Verso Windows@
disponvel em: http://www.4shared.com/file/WKDhQwZK/jre-6u21-Windows@-
i586-s.html ou atravs do link:
http://www.java.com/pt_BR/download/manual.jsp e execute o aplicativo SanUSB
da pasta SanUSBwinPlugandPlay. Surgir a seguinte tela mostrada na figura 2.7:

Figura 2. 7: Interface de gravao do microcontrolador via USB.
Processo de Comunicao do Matlab com microcontroladores via USB


[ 16 ]
6. Clique em Abrir e escolha o programa .hex que deseja gravar, como por exemplo, o
programa compilado exemplo1.hex da pasta ExemploseBibliotecasSanUSB e clique em
Gravar. Este programa pisca o led conectado no pino B7;
7. Aps a gravao do programa, lembre-se de soltar o boto ou retirar o jump do pino de
gravao e clique em Resetar. Pronto o programa estar em operao. Para programar
novamente, repita os passos anteriores a partir do passo 3.
Para proteger o executvel sanusb de excluso do antivrus, como por exemplo, o AVG,
basta ir em ProteoResidente do antivrus AVG. necessrio ir em Gerenciar Excees
e adicionar caminho. Ento inserir o caminho do executvel que em C:\Program
Files\SanUSB ou em C:\Arquivos de Programas\SanUSB e clicar em OK. Para reinstalar o
executvel da subpasta SanUSBwinPlugandPlay , basta instal-lo de dentro do arquivo .zip
ou .rar.

COMUNICAO WIRELESS DE MICROCONTROLADORES
Estes sistemas tambm podem ser utilizados pelo MATLAB@ para se
comunicar com plantas remotas. A gravao wireless descrita neste trabalho
pode ser feita com modems Zigbee ou Bluetooth, pois eles tambm emulam uma
comunicao serial em 19200 bps. Para a gravao ou comunicao Zigbee so
utilizados dois mdulos XBee da Srie 1 (S1). De um lado, um mdulo conectado a um
PC coordenador conectado ao PC via USB do PC atravs do chip FTDI FT232RL ou atravs
de uma porta serial real com o MAX-232 e, do outro lado da rede, um mdulo Zigbee
conectado ao microcontrolador do dispositivo final. Esta conexo permite a programao
sem fio no microcontrolador PIC. Programas disponveis em:
http://www.4shared.com/get/aP17n4FT/sanusbee.html
Abaixo uma ilustrao na figura 2.8 para realizar gravao de microcontrolador de
forma wireless com tenso de alimentao de 3,3V.

Processo de Comunicao do Matlab com microcontroladores via USB


[ 17 ]


Figura 2. 8: Ilustrao do circuito de gravao wireless Zigbee.

Para mais detalhes basta acompanhar os vdeos Gravao sem fio de microcontroladores
http://www.youtube.com/watch?v=_Pbq2eYha_c e Gravao sem fio de
microcontroladores via Zigbee: http://www.youtube.com/watch?v=BlRjKbXpepg.
Procedimento para gravao wireless:

1- Circuito bsico: Conecte o mdulo Xbee ao microcontrolador da placa SanUSB
(www.tinyurl.com/SanUSB), com alimentao entre 3V e 3,6V e apenas 4 fios: Vcc (3,3V),
Gnd, Tx e Rx, como mostra a figura abaixo. Na figura, o fio vermelho ligado ao pino 20
(Vcc) do microcontrolador e ao pino 1 (Vcc) do modem Zigbee, o fio azul ligado ao 19
(Gnd) do microcontrolador e ao pino 10 (Gnd) do modem Zigbee, o fio laranja ligado ao
pino 18 (Rx) do microcontrolador e ao pino 2 (D
OUT
) do modem Zigbee, e o fio amarelo
ligado ao 17 (Tx) do microcontrolador e ao pino 3 (D
IN
) do modem Zigbee.

2- Configurao dos Mdulos: A gravao wireless s vai acontecer se os mdulos
Xbee da srie 1 (coordenador e dispositivo final) estiverem configurados com o mesmo
baud rate do microcontrolador (19200 bps). Para o coordenador, basta conectar, o mdulo
coordenador ao microcontrolador, ver circuito bsico acima, gravar via USB e examinar em
qual firmware (ConfigCoord9600to19200.hex ou ConfigCoord19200to19200.hex) o led no
Processo de Comunicao do Matlab com microcontroladores via USB


[ 18 ]
pino B7 ir piscar intermitentemente. Se o led no piscar, provavelmente existe um erro na
ligao do circuito. Aps a configurao, coloque o mdulo Coordenador no conversor USB-
serial e conecte ao PC.
Faa posteriormente o mesmo para o mdulo Dispositivo final, gravando o firmware
(ConfigDispFinal9600to19200.hex ou ConfigDispFinal19200to19200.hex), ilustrado na
figura 2.9, e deixe-o conectado ao microcontrolador. Quando o led do pino B7 estiver
piscando, significa que os mdulos esto conectados corretamente e esto aptos para
gravao wireless.


Figura 2. 9: Gravao via USB de Configurao wireless.
3- Adaptador Wireless: Agora grave, novamente via USB, o firmware
AdaptadorSerial.hex da pasta AdaptadorWireless. Se, aps a gravao do Adaptador,
apresentar o erro Odd address at beginning of HEX file error, como na figura abaixo,
necessrio gravar novamente o gerenciador.hex, com qualquer gravador especifico (ver
tutorial), e em seguida, realizar novamente a gravao via USB do firmware aplicativo
AdaptadorSerial.hex, ilustrada na figura 2.10. Aps a transferncia deste firmware, o
microcontrolador est apto para gravao wireless.
Processo de Comunicao do Matlab com microcontroladores via USB


[ 19 ]

Figura 2. 10: Gravao via USB de Adaptador wireless.
Agora basta acessar a pasta sanusbee pelo Prompt do Windows@ (Iniciar ->
Pesquisar -> Prompt de Comando), como na figura 2.11, e digitar, como mostrado no
vdeo Gravao sem fio de microcontroladores via Zigbee, as linhas de comando, para
transferir os programas aplicativos.hex como o Exemplo1wireless.hex contido na pasta
sanusbee.
Exemplo:
sanusbee Exemplo1Wireless.hex p COM2

Figura 2. 11: Gravao wireless zigbee pelo prompt do Windows.

A gravao wireless Bluetooth pode ser realizada com apenas um mdulo
Bluetooth conectado ao microcontrolador, pois normalmente no PC coordenador, como em
Processo de Comunicao do Matlab com microcontroladores via USB


[ 20 ]
laptops e desktops, j existe um mdulo bluetooth interno. A tenso do mdulo Bluetooth
encapsulado, mostrado na figura abaixo, suporta at 6V, diferentemente do mdulo Xbee
que suporta de 3,3V. Dessa forma, pode-se conectar o mdulo Bluetooth diretamente ao
microcontrolador alimentado pela tenso da porta USB de 5V.
De um lado um PC coordenador e, do outro lado da rede, um mdulo bluetooth
conectado ao microcontrolador do dispositivo final. Esta conexo permite a programao
sem fio no microcontrolador PIC. Os Programas esto disponveis em:
http://www.4shared.com/get/aP17n4FT/sanusbee.html. Neste link em anexo:
http://lista.mercadolivre.com.br/sanusb , pode ser adquirido o modem Bluetooth mostrado
neste tutorial.
Na figura 2.12 mostrada uma ilustrao para realizar gravao de microcontrolador
de forma wireless Bluetooth com tenso de alimentao de 5V.


Figura 2. 12: Ilustrao do Circuito de gravao wireless Bluetooth.

Para mais detalhes basta acompanhar os vdeos Gravao sem fio de microcontroladores
http://www.youtube.com/watch?v=_Pbq2eYha_c e Gravao sem fio (wireless) de
microcontroladores http://www.youtube.com/watch?v=0PcCQtsO1Bwg via
Bluetooth. Procedimento para gravao wireless:
1- Circuito bsico: Conecte o mdulo bluetooth ao microcontrolador da placa SanUSB
(www.tinyurl.com/SanUSB), com alimentao entre 3V e 6V e apenas 4 fios: Vcc (3,3V),
Processo de Comunicao do Matlab com microcontroladores via USB


[ 21 ]
Gnd, Tx e Rx, como mostra a figura acima do circuito. Na figura, o fio vermelho ligado ao
pino 20 (Vcc) do microcontrolador e ao pino Vcc do modem bluetooth, o fio azul ligado
ao 19 (Gnd) do microcontrolador e ao pino Gnd do modem bluetooth, o fio verde ligado
ao pino 18 (Rx) do microcontrolador e ao pino Tx modem bluetooth, e o fio amarelo
ligado ao 17 (Tx) do microcontrolador e ao pino Rx do modem bluetooth.

2- Parear o modem Bluetooth: Aps alimentar o modem Bluetooth com 3,3V ou 5V,
conectado ao microcontrolador, realizar o pareamento com o PC indo em:
2.1- Iniciar -> Painel de controle -> Adicionar um dispositivo de bluetooth -> linvor ->
senha padro: 1234;
2.2- Aps o pareamento, clique em Iniciar -> Painel de controle -> exibir impressoras e
dispositivos. Ir aparecer o modem pareado, como, por exemplo, o linvor mostrado na
figura 2.13.


Figura 2. 13: Pareamento do modem bluetooth.

1.3- Clicar em cima, por exemplo, do modem de linvor, e verificar qual porta criada pelo
modem Bluetooth, em Hardware, que ser utilizada para a gravao wireless, ilustraod na
figura 2.14.

Processo de Comunicao do Matlab com microcontroladores via USB


[ 22 ]

Figura 2. 14: Verificao da porta serial criada pelo modem bluetooth.

O nmero da porta Serial Padro por Link Bluetooth (COM37) pode ser modificada,
por exemplo, para COM9 como neste tutorial, atravs do Gerenciador de Dispositivos,
clicando com o boto direito em cima da porta -> propriedades -> Configurao de Porta -
> Avanado -> Nmero da Porta COM.

3- Configurao do Mdulo bluetooth: A gravao wireless s vai acontecer se o
mdulo Bluetooth estiver configurado com o mesmo baud rate do microcontrolador (19200
bps). Para isto, basta conectar, o mdulo bluetooth ao microcontrolador, ver circuito bsico
acima, gravar via USB, como mostra a figura 2.15, o firmware
Configbluetotth9600to19200.hex e verificar se o led no pino B7 ir piscar
intermitentemente. Se o led no piscar, provavelmente existe um erro na ligao do
circuito.
Quando o led do pino B7 estiver piscando, significa que os mdulos esto conectados
corretamente e esto aptos para gravao wireless.
Processo de Comunicao do Matlab com microcontroladores via USB


[ 23 ]

Figura 2. 15: Gravao via USB de Configurao wireless.
4- Adaptador Wireless: Agora grave, novamente via USB, o firmware
AdaptadorSerial.hex da pasta AdaptadorWireless. Se, aps a gravao do Adaptador,
apresentar o erro Odd address at beginning of HEX file error, , como mostra a figura 2.16,
necessrio gravar novamente o gerenciador.hex, com qualquer gravador especifico (ver
tutorial), e em seguida, realizar novamente a gravao via USB do firmware aplicativo
AdaptadorSerial.hex. Aps a transferncia deste firmware, o microcontrolador est apto
para gravao wireless.

Figura 2. 16: Gravao via USB de Adaptador wireless.
Processo de Comunicao do Matlab com microcontroladores via USB


[ 24 ]

Agora basta acessar a pasta sanusbee pelo Prompt do Windows@ (Iniciar ->
Pesquisar -> Prompt de Comando), , como mostra a figura 2.17, e digitar, como mostrado
no vdeo PIC wireless Zigbee programming II, as linhas de comando, para transferir os
programas aplicativos.hex como o Exemplo1wireless.hex contido na pasta sanusbee.
Exemplo: sanusbee Exemplo1Wireless.hex p COM9

Figura 2. 17: Gravao wireless bluetooth pelo prompt do Windows.

As vantagens do modem Bluetooth, em relao ao Zigbee, so o preo e a disponibilidade
de modems Bluetooth j disponveis em vrios sistemas computacionais como
computadores e celulares. A desvantagem em relao ao Zigbee a distncia para
gravao de microcontroladores mxima de 10 metros.

SISTEMA DUAL CLOCK
Devido incompatibilidade entre as frequncias necessrias para a gravao e
emulao serial via USB e a frequncia padro utilizada pela CPU, temporizadores e
interface I
2
C, esta ferramenta adota o princpio Dual Clock, ou seja, utiliza duas fontes de
clock, uma para o canal USB de 48MHz, proveniente do cristal oscilador externo de 20MHz
multiplicada por um prescaler interno, e outra para o CPU de 4 MHz, proveniente do
oscilador RC interno de 4 MHz, como ilustrado na figura 2.18.
Processo de Comunicao do Matlab com microcontroladores via USB


[ 25 ]

Figura 2. 18: Comunicao PIC com PC e via I
2
C.
Esse princpio de clock paralelo, realizado pela instruo clock_int_4MHz(), permite
que um dado digitado no teclado do computador, trafegue para o microcontrolador em 48
MHz via USB, depois para perifricos como um relgio RTC ou para a memria EEPROM em
4 MHz via I
2
C e vice-versa.

EMULAO DE COMUNICAO SERIAL NO WINDOWS VIA USB

Neste tpico mostrado um mtodo de comunicao serial bidirecional atravs do
canal USB do PIC18F2550. Uma das formas mais simples, atravs do protocolo
Communications Devices Class (CDC), que emula uma porta COM RS-232 virtual, atravs
do canal USB 2.0. Dessa forma, possvel se comunicar com caracteres ASCII via USB
atravs de qualquer software monitor serial RS-232 como o HyperTerminal, o SIOW do
CCS Compiler ou o ambiente de programao Delphi. O driver CDC instalado no PC e o
programa aplicativo gravado no PIC, com a biblioteca CDC (#include <usb_san_cdc.h>),
so os responsveis por esta emulao da porta RS-232 virtual atravs da USB.
A biblioteca CDC para o programa.c do microcontrolador est dentro da pasta de
exemplos, a qual deve estar na mesma pasta onde est o programa.c a ser compilado para
a emulao da comunicao serial RS-232. Alm disso, o programa.c deve inserir a
biblioteca usb_san_cdc.h, como mostra a o exemplo de leitura e escrita em um buffer da
EEPROM interna do microcontrolador. As funes CDC mais utilizadas contidas na biblioteca
usb_san_cdc.h para comunicao com a COM virtual so:

usb_cdc_putc() o microcontrolador envia caracteres ASCII emulados via USB.
Processo de Comunicao do Matlab com microcontroladores via USB


[ 26 ]
Ex.: printf(usb_cdc_putc, "\r\nEndereco para escrever: ");
usb_cdc_getc() retm um caractere ASCII emulado pela USB.
Ex.: dado = usb_cdc_getc(); //retm um caractere na varivel dado
gethex_usb() retm um nmero hexadecimal digitado no teclado.
Ex.: valor = gethex_usb();//retm um nmero hexadecimal na varivel valor

usb_cdc_kbhit( ) Avisa com TRUE (1) se acabou de chegar um novo caractere no
buffer de recepo USB do PIC.
Ex.: if (usb_cdc_kbhit()) {dado = usb_cdc_getc();}
O exemplo abaixo mostra a leitura e escrita em um buffer da EEPROM interna do
microcontrolador com emulao da serial atravs da USB:
---------------------------------------------------------------------------------------------------------------
#include <SanUSB.h>

#include <usb_san_cdc.h>// Biblioteca para comunicao serial

BYTE i, j, endereco, valor;
boolean led;

main() {
clock_int_4MHz();
usb_cdc_init(); // Inicializa o protocolo CDC
usb_init(); // Inicializa o protocolo USB
usb_task(); // Une o perifrico com a usb do PC

output_high(pin_b7); // Sinaliza comunicao USB Ok

while (1) {
printf(usb_cdc_putc, "\r\n\nEEPROM:\r\n"); // Display contm os primeiros 64 bytes em hex
for(i=0; i<=3; ++i) {
for(j=0; j<=15; ++j) {
printf(usb_cdc_putc, "%2x ", read_eeprom( i*16+j ) );
}
printf(usb_cdc_putc, "\n\r");
}

printf(usb_cdc_putc, "\r\nEndereco para escrever: ");
endereco = gethex_usb();
printf(usb_cdc_putc, "\r\nNovo valor: ");
valor = gethex_usb();

write_eeprom( endereco, valor );
led = !led; // inverte o led de teste
output_bit (pin_b7,led);
}}
---------------------------------------------------------------------------------------------------------------
Processo de Comunicao do Matlab com microcontroladores via USB


[ 27 ]
Aps gravao de um programa que utilize comunicao serial CDC no microcontrolador
pelo SanUSB e resetar o microcontrolador, v, se for o Windows 7, em propriedades do
sistema -> Configuraes avanadas do sistema -> Hardware -> Gerenciador de
dispositivos e clique com boto direito no driver CDC do microcontrolador e atualizar Driver,
apontando para a pasta DriversSanUSB.
No Windows@ XP, aps a gravao de um programa que utilize comunicao serial CDC no
microcontrolador pelo SanUSB e resetar o microcontrolador, o sistema vai pedir a
instalao do driver CDC, , como mostra a figura 2.19 (somente na primeira vez).



Figura 2. 19: Instalao do driver CDC.

Escolha a opo Instalar de uma lista ou local especifico (avanado). Aps Avanar,
selecione a opo Incluir este local na pesquisa e selecione a pasta DriversSanUSB, onde
est o driver CDC, , como mostra a figura 2.20.
Processo de Comunicao do Matlab com microcontroladores via USB


[ 28 ]

Figura 2. 20: Instalao do driver CDC.

Aps Avanar, clique em Continuar assim mesmo, , como mostra a figura 2.21.


Figura 2. 21: Instalao do driver CDC.

Aguarde enquanto o Driver CDC instalado no Windows@, como ilustrado na figura 2.22.
Processo de Comunicao do Matlab com microcontroladores via USB


[ 29 ]

Figura 2. 22: Instalao do driver CDC .

Clique em Concluir para terminar a instalao, como mostra a figura 2.23

Figura 2. 23: Instalao do driver CDC.

V em painel de controle -> sistema -> Hardware -> Gerenciador de dispositivos -> Portas
(COM & LPT) e confira qual a porta COM virtual instalada, como mostra a figura 2.24.
Processo de Comunicao do Matlab com microcontroladores via USB


[ 30 ]

Figura 2. 24: Verificao de porta COM instalada.
Abrindo qualquer programa monitor de porta serial RS-232, como o SIOW do CCS
Compiler ou o Java-SanUSB, direcionando para a COM virtual instalada
(COM3,COM4,COM5,etc.). No CCS clique em Tools -> Serial port Monitor -> configuration -
> set port options para que o computador entre em contato com o PIC atravs da
emulao serial via USB, como mostra a figura 2.25.

Figura 2. 25: Utilizao da porta COM pelo CCS.
Processo de Comunicao do Matlab com microcontroladores via USB


[ 31 ]
Para utilizar uma funo que necessite de atendimento imediato quando um
caractere for digitado como, por exemplo o caractere L ou D, necessrio inserir no
firmware do microcontrolador a condio para verificar de forma constante e reter o
caractere emulado que chegou pela USB if(usb_cdc_kbhit( ))
{dado=usb_cdc_getc();} no lao infinito da funo principal. O comando
(usb_cdc_kbhit( )) evita que o programa fique parado no usb_cdc_getc (que fica
esperando um caractere para prosseguir o programa). Veja o programa abaixo, que pisca
um led na funo principal (pino B6) e comanda o estado de outro led (pino B7) pelo
teclado de um PC via USB, com visualizao do texto ilustrada na figura 2.26:
---------------------------------------------------------------------------------------------------------------
#include <SanUSB.h>
#include <usb_san_cdc.h>// Biblioteca para comunicao serial virtual

BYTE comando;

void main() {
clock_int_4MHz();//Funo necessria para habilitar o dual clock (48MHz para USB e 4MHz para CPU)
usb_cdc_init(); // Inicializa o protocolo CDC
usb_init(); // Inicializa o protocolo USB
usb_task(); // Une o perifrico com USB do PC

while (TRUE)
{
if (usb_cdc_kbhit( )) //avisa se chegou dados do PC
{ //verifica se tem um novo byte no buffer de recepo, depois o kbhit zerado para prximo byte
comando=usb_cdc_getc(); //se chegou, retm o caractere e compara com L ou D em ASCII

if (comando==L) {output_high(pin_b7); printf(usb_cdc_putc, \r\nLed Ligado\r\n);}
if (comando==D) {output_low(pin_b7); printf(usb_cdc_putc, \r\nLed Desligado\r\n);}
}
output_high(pin_B6); // Pisca Led na funo principal
delay_ms(500);
output_low(pin_B6);
delay_ms(500);
} }


Figura 2. 26: Visualizao de textos via serial emulada.
Para utilizar o programa de comunicao Java-SanUSB para emulao serial virtual
entre o computador e o microcontrolador, necessrio baix-lo atravs do link disponvel
em www.4shared.com/file/1itVIv9s/101009SoftwareComSerial_Window.html .
Processo de Comunicao do Matlab com microcontroladores via USB


[ 32 ]
Aps executar o programa de comunicao serial Java-SanUSB, verifique a porta COM
virtual gerada (COM3,COM4,COM11,etc.) no Windows@, em Painel de Controle\Todos os
Itens do Painel de Controle\Sistema e altere no programa serial Java-SanUSB em
Dispositivos e depois clique em Conectar, como mostra a figura 2.27.

Figura 2. 27: Interface em Java de comunicao serial.

GRAVANDO O MICROCONTROLADOR VIA USB NO LINUX

Esta aplicao substitui a gravao via USB pelo terminal do Linux, pois uma forma
mais simples e direta de gravao. Com apenas dois cliques no instalador automtico
SanUSB.deb possvel instalar este aplicativo em qualquer mquina com Linux (Ubuntu
10.04, equivalente ou posterior). Depois de instalado, a interface de gravao localizada
em Aplicativos -> acessrios.
Se voc j tem o Java instalado (JRE ou SDK) baixe o instalador automtico.deb
atualizado disponvel no link:
http://www.4shared.com/file/RN4xpF_T/sanusb_Linux.html contido tambm na
pasta geral http://www.4shared.com/file/sIZwBP4r/100727SanUSB.html.
Processo de Comunicao do Matlab com microcontroladores via USB


[ 33 ]
Se ainda no tem o Java (JRE ou SDK), baixe o instalador SanUSB, j configurado
com o Java JRE e disponvel em:
http://www.4shared.com/file/3mhWZS5g/sanusb.html .
A figura 2.29 mostra a interface grfica desenvolvida para gravao direta de
microcontroladores via USB:

Figura 2. 28: Mensagem de programa gravado.
Neste aplicativo, esto disponveis botes para Abrir o programa em hexadecimal
compilado, para Gravar o programa hexadecimal no microcontrolador via USB e para
Resetar o microcontrolador no intuito de coloc-lo em operao. A interface apresenta
ainda um boto para gravar e resetar automaticamente.
importante salientar que para utilizar esta ferramenta no Linux necessrio estar
logado com permisso para acessar a porta USB como, por exemplo, super-usurio (sudo
su), e que para estabelecer comunicao com o microcontrolador necessrio gravar
anteriormente no microcontrolador, somente uma vez, com qualquer gravador especfico
para PIC, o gerenciador de gravao pela USB Gerenciador.hex, disponvel na pasta
SanUSB ou em http://www.4shared.com/file/HGrf9nDz/Gerenciador.html .
Processo de Comunicao do Matlab com microcontroladores via USB


[ 34 ]
Aps gravar o Gerenciador.hex com um gravador convencional para PIC, coloque o circuito
SanUSB em modo de gravao pela USB (pino 1 ligado ao Gnd (0V) atravs de boto ou fio
) e conecte o cabo USB do circuito no PC. Se o circuito SanUSB estiver correto,
acender o led do pino B7. Pronto, o sistema j est preparado para gravar no
microcontrolador, de forma simples e direta, quantos programas .hex voc desejar
utilizando a interface USB.
Para programar novamente, basta pressionar o boto de gravao no pino 1, desconecte e
conecte o cabo USB de alimentao, selecione o programa.hex desejado em Abrir e
pressione o boto Gravar&Resetar.

GRAVANDO O PIC VIA USB PELO TERMINAL DO LINUX OU MAC OSX

Esta aplicao realizada de forma simples em linha de comando no terminal do
Mac OSX. Para abrir o terminal necessrio baixar e instalar o software Xcode. No Linux,
instale o sanusb.deb disponvel em
http://www.4shared.com/file/sIZwBP4r/100727SanUSB.html .
Para iniciar a gravao com linhas de comando importante seguir os seguintes passos:
1. Grave no microcontrolador, somente uma vez, com um gravador especfico para PIC
com o circuito simples de gravao COM84 descrito deste trabalho ou outro gravador
qualquer, o gerenciador de gravao pela USB Gerenciador.hex, que multiplataforma
(Linux, Mac OSX e Windows@).
2. Pelo Terminal do Linux ou Mac OSX acesse onde est o executvel sanusb, instalado
pelo arquivo sanusb.deb, e no Mac OSX acesse a pasta de arquivos
SanUSBMacPlugandPlay, onde est o executvel sanusb. Mais detalhes em:
http://www.youtube.com/watch?v=rSg_i3gHF3U .

3. Aps entrar na pasta do executvel sanusb, acesse informaes do contedo deste
arquivo digitando:
. / sanusb-h
A figura 2.29 mostra o printscreen de exemplo de um processo de acesso pasta e
tambm do processo de gravao pelo terminal:
Processo de Comunicao do Matlab com microcontroladores via USB


[ 35 ]



Figura 2. 29: Acesso pasta pelo terminal do LINUX.

4. Com o circuito SanUSB montado, coloque-o em modo de gravao (pino 1 ligado ao Gnd
com boto pressionado ou jump ) e conecte o cabo USB do circuito no PC.

5. Para gravar no microcontrolador, o firmware desejado, como o exemplo1.hex, deve
estar mesmo diretrio do executvel sanusb, ento para a gravao via USB, digita-se:
./ sanusb w exemplo1.hex

6. Depois de gravar, remova o boto ou jump de gravao, ento reset digitando:
./ sanusb r

ou simplemente: ./ sanusb w exemplo1 r

Para programar novamente, basta colocar o jump de gravao, desconecte e
conecte o cabo USB de alimentao, e repita os passos anteriores a partir do passo 6. Se o
Processo de Comunicao do Matlab com microcontroladores via USB


[ 36 ]
microcontrolador no for reconecido, feche o terminal, conecte o microcontrolador em
outra porta USB, abra um novo terminal e repita repita os passos anteriores a partir do
passo 3.
EMULAO DE COMUNICAO SERIAL NO LINUX

Neste tpico mostrado um mtodo de comunicao serial bidirecional atravs do
canal USB do PIC18F2550. Uma das formas mais simples, atravs do protocolo
Communications Devices Class (CDC), que padro no Linux e que emula uma porta COM
RS-232 virtual com o microcontrolador, atravs do canal USB. Dessa forma, possvel se
comunicar com caracteres ASCII via USB atravs de qualquer software monitor serial RS-
232 como o Cutecom, o minicom ou outros aplicativos com interface serial. A biblioteca
CDC_ACM padro no Linux e o programa aplicativo gravado no PIC com a biblioteca CDC
(#include <usb_san_cdc.h>), so os responsveis por esta emulao da porta RS-232
virtual atravs da USB. A emulao serial muito utilizada tambm para debugar, ou
seja, depurar as variveis de um programa.c, imprimindo-as pela USB durante a execuo
real do programa. Dessa forma, o programador pode encontrar possveis erros na
programao do firmware.
A biblioteca CDC (#include <usb_san_cdc.h>) est dentro da mesma pasta de
ExemploseBibliotecas. Para a compilao de um programa aplicativo com emulao serial,
como o exemplo_emulSerial.c, a biblioteca CDC(#include <usb_san_cdc.h>) deve estar na
mesma pasta do programa exemplo_emulSerial.c a ser compilado ou dentro da pasta
instalada do compilador (C:\Arquivos de programas\PICC\Drivers). O programa
exemplo_emulSerial.c abaixo, contido na pasta ExemploseBilbliotecas, pisca um led no pino
B6 na funo principal e comanda, via USB atravs emulao serial, o estado de outro led
no pino B7 com as teclas L e D do teclado de um PC. As funes CDC mais utilizadas para
comunicao com a COM virtual so:

usb_cdc_putc() o microcontrolador envia caracteres ASCII emulados via USB.
Ex.: printf(usb_cdc_putc, "\r\nEndereco para escrever: ");

usb_cdc_getc() retm um caractere ASCII emulado pela USB.
Processo de Comunicao do Matlab com microcontroladores via USB


[ 37 ]
Ex.: dado = usb_cdc_getc(); //retm um caractere na varivel dado
gethex_usb() retm um nmero hexadecimal digitado no teclado.

Ex.: valor = gethex_usb();//retm um nmero hexadecimal na varivel valor

usb_cdc_kbhit( ) Avisa com TRUE (1) se acabou de chegar um novo caractere no
buffer de recepo USB do PIC.

Ex.: if (usb_cdc_kbhit( )) {dado = usb_cdc_getc();}

Outras funes do protocolo so:

get_string_usb(char *s, int max): Recebe uma string;
usb_attach(): Re-conecta o dispositivo, deve ser usada para re-conect-lo quando o
dispositivo foi desconectado, mas ainda noremovido literalmente;
usb_detach(): Desconecta o dispositivo. Deve ser usada antes de sua remoo fsica do
computador;
usb_enumerated(): Verifica se o dispositivo est pronto para a comunicao.

#include <SanUSB.h>
#include <usb_san_cdc.h>// Biblioteca para comunicao serial virtual via USB

BYTE comando;

main() {
clock_int_4MHz();//Funo necessria para habilitar o dual clock (48MHz para USB e 4MHz para CPU)
usb_cdc_init(); // Inicializa o protocolo CDC
usb_init(); // Inicializa o protocolo USB
usb_task(); // Une o perifrico com USB do PC
while (TRUE)
{
if (usb_cdc_kbhit( )) //avisa se chegou dados do PC
{ //verifica se tem um novo byte no buffer de recepo, depois o kbhit zerado para prximo byte
comando=usb_cdc_getc(); //se chegou, retm o caractere e compara com 'L' ou 'D' em ASCII

if (comando=='L') {output_high(pin_b7); printf(usb_cdc_putc, "\r\nLed Ligado!\r\n");}
if (comando=='D') {output_low(pin_b7); printf(usb_cdc_putc, "\r\nLed Desigado!\r\n");}
}
output_high(pin_B6); // Pisca Led na funo principal
delay_ms(300);
output_low(pin_B6);
delay_ms(300);
Processo de Comunicao do Matlab com microcontroladores via USB


[ 38 ]
} }

Este firmware realiza a comunicao serial virtual com o protocolo CDC inserido no
firmware do microcontrolador atravs da biblioteca usb_san_cdc.h. Este protocolo padro
no sistema operacional Linux.
Aps gravar o firmware via USB com o executvel linux sanusb, instale o software de
comunicao serial digitando pelo terminal do linux #sudo apt-get install cutecom .
Verifique a porta serial virtual criada digitando dmesg no terminal. Abra o Cutecom,
ilustrado na figura 2.30, digitando cutecom no terminal e direcione a porta virtual criada
em Device do Cutecom, geralmente a porta ttyACM0 ou ttyACM1. Mais informaes
podem ser obtidas no vdeo: http://www.youtube.com/watch?v=cRW99T_qa7o .


Figura 2. 30: Software de comunicao serial CuteCOM.

possvel tambm utilizar o programa de comunicao serial Java-SanUSB para
emulao serial virtual entre o computador e o microcontrolador.
possvel baixar esta ferramenta de comunicao serial atravs do link disponvel
em http://www.4shared.com/file/5emc7knO/SerialJava-sanusb_10_all.html .
Aps conectar o microcontrolador e abrir o programa de comunicao serial Java-SanUSB
em Aplicativos -> Outros, aparecer a porta serial virtual gerada no Linux (ttyACM0) em
Processo de Comunicao do Matlab com microcontroladores via USB


[ 39 ]
Dispositivos. Para listar a porta serial virtual gerada, utilizando o Terminal do Linux, basta
digitar ls /dev/ttyACM* . possvel realizar a comunicao depois de clicar em Conectar,
como mostra a figura 2.31. Vrios projetos com a ferramenta SanUSB podem ser vistos em
http://www.youtube.com/results?search_query=sanusb .

Figura 2. 31: Interface de comunicao serial em Java para LINUX.

CIRCUITO COM84 PARA GRAVAO DO gerenciador.hex
Para este circuito simples de gravao s necessrio 3 resistores de 10k, um cabo
serial DB9 (RS-232) e uma fonte externa de 5V, que pode ser obtida da porta USB. O
circuito e a figura 2.32 mostram o esquema simples de ligao dos pinos.


Figura 2. 32: Circuito COM84 para gravao do gerenciador.hex
Processo de Comunicao do Matlab com microcontroladores via USB


[ 40 ]

Este circuito a partir da porta COM DB9 pode ser visualizado na figura 2.33.

Figura 2. 33: Esquema de ligao do conector serial.
Este circuito de gravao funciona com o software PICPgm (detectado como JDM
Programmer) ou com WinPic (detectado como COM84 Programmer). Este ltimo se mostra
mais estvel, pois aps a deteco do microcontrolador, possvel gravar o
microcontrolador, e mesmo indicando ERROR: Programming failed, ilustrado na figura 2.34,
o arquivo gerenciador.hex mostrou-se gravado corretamente para gerenciar gravaes no
microcontrolador pela porta USB nos sistemas operacionais Windows@, Linux e Mac OSX.
O software de gravao do gerenciador.hex pode ser baixado atravs do link,
disponvel em http://www.4shared.com/get/1uP85Xru/winpicprCOM84.html.

Figura 2. 34: Tela de configurao do software de gravao.

Processo de Comunicao do Matlab com microcontroladores via USB


[ 41 ]
Aps a instalao, execute o programa. Na guia "Device, Config", escolha o
microcontrolador. Uma vez que o microcontrolador conectado porta COM RS-232 de 9
pinos do PC, v para "Interface", selecione " COM84 programmer for serial port", e
pressione "Initialize". Se o software disser que a inicializao foi um xito "Success", ento
o programa est pronto para gravar o gerenciador.hex no microcontrolador. Para a
gravao, selecione em File Load & ProgramDevice e depois selecione o arquivo
gerenciador.hex. Como citado anteriormente, mesmo que, aps a gravao e verificao
aparea Programmed Failed, provvel que o gerenciador.hex tenha sido gravado
corretamente, , como mostra a figura 2.35.



Figura 2. 35: Tela de confirmao de reconhecimento do circuito.

III. Comunicao USB com Matlab

A constante atualizao na forma de conexo entre computadores e dispositivos variados
levou o mercado tecnolgico a uma ampla difuso da comunicao tipo USB (Universal
Serial Bus). Dessa forma, a comunicao USB vem se tornando a mais utilizada na
comunicao entre computadores pessoais e perifricos, enquanto tipos de comunicaes
mais antigas vm perdendo espao a exemplo das interfaces seriais e paralelas. A
necessidade de atualizao da placa Mnica [2] consequncia das concluses
explicitadas.
Processo de Comunicao do Matlab com microcontroladores via USB


[ 42 ]
O microcontrolador utilizado na placa foi programado para se comportar como um
dispositivo do tipo CDC(communication device class) na comunicao USB
Na pasta PM_PIC, disponvel em https://dl.dropbox.com/u/101922388/MatlabPM_USB.zip ,
se encontra o firmware para ser gravado no microcontrolador via USB:
1) usb_pm.c (Aplicativo)
2) SanUSB (gravao via USB)
3) usb_san_cdc.h (Adiciona porta serial emulada COM ao PC)
4)usb_desc_cdc.h (Definio dos descritores)
A comunicao USB utilizada foi configurada, com a verificao da porta COM instalada
como mostra a figura 2.4, que pode alcanar uma velocidade de comunicao de at 115,2
Kb/s.
A instalao do driver de emulao serial do sistema embarcado pode ser visualizada a
partir da figura 2.19. No trmino da instalao possvel fazer a comunicao USB com o
sistema. Ao conectar o dispositivo e concluir a instalao adicionada uma nova porta
serial ao computador, como mostra a figura 2.24.
A observao de qual porta serial foi adicionada essencial na escolha do parmetro que
deve ser passado a funo inicializa(com). O nmero da porta painel de controle ->
sistema -> Hardware -> Gerenciador de dispositivos -> Portas (COM & LPT) e confira qual
a porta COM virtual instalada, como mostra a figura 2.24.

As funes contidas dentro da pasta Bibliotecas Matlab assim como os arquivos da pasta
Simulink_PM devem ser copiadas para o diretrio de trabalho padro do Matlab de onde
podero ser chamadas atravs do prompt do programa [3]. Em algumas verses do Matlab
o diretrio padro de trabalho a pasta work enquanto em outras a pasta Matlab que
se encontra dentro do diretrio de documentos do usurio.

INTERFACE USB COM O MATLAB

Para testar a comunicao com o PIC USB, foram testadas funes do Matlab para
a placa Mnica [2] em forma de biblioteca [3], como mostra a figura 3.1, onde esto
descritos os processos inicializa(com4), onde a COM gerada pode ser verificada como
mostra a figura 2.24, seta a frequncia setpm_pwm_duty (canal pwm, ciclo de trabalho em
Processo de Comunicao do Matlab com microcontroladores via USB


[ 43 ]
%, frequncia) e finaliza o processo, disponveis na pasta bibliotecas Matlab. O resultado
do PWM real comandado pelo Matlab, ou seja, o resultado do conversor digital-analgico
(DA) ser apresentado no pino RC2 do microcontrolador (canal PWM1).


Figura 3.!: tela de comandos do matlab para controle do PWM da placa.


inicializa (porta)
inicializa.m
Funo que permite inicializao da comunicao com a placa. O comando
deve ser executado antes do incio de qualquer uma das funes abaixo. A
funo deve obedecer seguinte sintaxe, e.g. inicializa(com1).

finaliza
finaliza.m
Funo que permite a correta finalizao da comunicao com a placa. O
comando deve ser executado ao trmino da comunicao estabelecida com a
placa.
envia_pm (canal, valor)
envia_pm.m
Funo que permite enviar uma tenso entre 0 e 5 volts uma das duas
sadas analgicas da placa de aquisio de dados. Assim, o canal deve ser 1
(pino C2) ou 2 (pino C1) , e o valor pode estar entre 0 e 5V. No retorna
Processo de Comunicao do Matlab com microcontroladores via USB


[ 44 ]
nenhum valor.

recebe_pm(canal)
recebe_pm.m
Funo que permite ler (receber) uma tenso entre 0 e 5 volts de uma
das seis entradas analgicas da placa de aquisio de dados. Assim, o canal
deve ser 1, 2, 3, 4, 5 ou 6 , e o valor retornado um float entre 0 e 5.

setpm_pwm_freq(freqncia, duty_cycle)
set_pwm_freq.m
Funo que permite selecionar a freqncia de trabalho e o ciclo de
trabalho dos dois canais PWM ao mesmo tempo. As freqncias podem ser
3khz, 6khz, 12khz, 24khz, 48khz, 60khz, 96khz ou 120khz, passadas como
parmetros 3000, 6000, 12000 e assim por diante. O duty_cycle deve estar
entre 0 e 1. No retorna valor.

set_pwm_duty(canal, duty_cycle, freqncia)
setpm_pwm_duty.m
Funo que permite selecionar o duty cycle do canal de PWM, ou seja, a
porcentagem do perodo na qual se tem nvel lgico alto. Assim, canal deve
ser 1 ou 2 e o duty_cycle deve estar entre 0 e 1. As freqncias podem ser
3khz, 6khz, 12khz, 24khz, 48khz, 60khz, 96khz ou 120khz, passadas como
parmetros 3000, 6000, 12000 e assim por diante. No retorna nenhum valor.

recebepm_dig(canal)
recebepm_dig.m
Funo que permite ler (receber) um valor de nvel lgico alto ou baixo
(5 ou 0 volts respectivamente) um dos trs canais de entrada digital da
placa de aquisio de dados. Assim, o canal deve ser um inteiro 1, 2 ou 3 que
correspondem aos pinos RE0, RE1 E RE2 respectivamente. O valor retornado
ser 0 ou 1.

enviapm_dig(canal, valor )
enviapm_dig.m
Funo que permite enviar um valor de nvel lgico alto ou baixo (5 ou
0 volts respectivamente) um dos dois canais digitais de sada da placa de
aquisio de dados. Assim, os canais podem ser 1 ou 2 que correspondem aos
pinos D0 e D1 e o valor deve ser 0 ou 1. No retorna nenhum valor.

A placa de controle e aquisio o elemento central do projeto, pois estabelece a
comunicao entre o controle realizado pelo Matlab e a planta real [4].
O firmware, em linguagem C, gravado no microcontrolador emula via USB uma porta serial
e organizado como uma mquina de estados possibilitando o acesso s diversas funes
da placa de controle no somente atravs do Matlab, mas tambm atravs de qualquer
Processo de Comunicao do Matlab com microcontroladores via USB


[ 45 ]
outro programa de comunicao serial, como o prprio SIOW do CCS compiler mostrado na
figura 2.25.

IV. Controle de velocidade de motor utilizando estimador de
mnimos quadrados recursivos e no recursivos

A presente aplicao descreve o projeto de um sistema de controle de um motor CC,
disponvel em https://dl.dropbox.com/u/101922388/MatlabPM_USB.zip, atravs do uso de
tcnicas de identificao de sistemas baseadas na anlise experimental entre as entradas e
sadas. Um sistema microcontrolado de aquisio de dados e controle foi implementado,
permitindo a interface da planta com o programa Matlab

Os motores de m permanente (PM permanent-magnet) tm como principais
vantagens no necessitarem de excitao externa, dissipam menos potncia para criar o
campo que o motor correspondente com enrolamento de campo, o espao necessrio para
alocar o m permanente pode ser inferior ao exigido pelos enrolamentos, resultando em
mquinas a m permanentes possivelmente menores, e em alguns casos de custo inferior
ao seu similar com excitao externa.
Neste projeto foi utilizado um motor de m permanente de 12 V acoplado a um
tacogerador para controle de velocidade atravs de um acionamento PWM. A figura 3.2
ilustra o controle de velocidade do motor CC por PWM atravs do Matlab.
Processo de Comunicao do Matlab com microcontroladores via USB


[ 46 ]

Figura 3.2: A figura 3.2 ilustra o controle de velocidade do motor CC por
PWM atravs do Matlab.

O diagrama de blocos que representa um motor de corrente contnua controlado
pelo Matlab no PC que processa e envia dados de controle via USB para o microcontrolador
representado na figura 3.3:



Figura 3.3: Motor CC de Im permanente e diagrama de blocos do controle
realizado pelo Matlab.

Processo de Comunicao do Matlab com microcontroladores via USB


[ 47 ]
SISTEMA DE CONTROLE

Para controle do motor CC foram utilizadas duas placas eletrnicas. Uma placa SanUSB
para interface com o Matlab via interface USB e outra placa para disparo do transistor de
potncia para o motor CC e condicionamento do sinal de tenso do tacogerador, figura 3.4
e figura 3.5, respectivamente. O controle do motor CC atravs do Matlab pode ser visto
tambm em http://www.youtube.com/watch?v=CgXCk6Ub0UY. Os diagramas das
placas so mostrados nas figuras 2 e figura 3. A placa da ferramenta livre SanUSB pode ser
construda seguindo o tutorial e os programas disponveis em
https://dl.dropbox.com/u/101922388/121007SanUSBOrig.zip ou adquirida em
http://lista.mercadolivre.com.br/sanusb .


Figura 3.4: Placa SanUSB

Processo de Comunicao do Matlab com microcontroladores via USB


[ 48 ]


Figura 3.5: Placa de Circuito para PWM e sensor tacogerador

ESTIMADOR POR MNIMOS QUADRADOS RECURSIVO - MQR

O mtodo de mnimos quadrados um dos mais conhecidos e mais utilizados nas
mais diversas reas de cincia e tecnologia. A origem da idia bsica pode ser encontrada
nos trabalhosa de Gauss no mbito da astronomia.
Este mtodo de estimao apresenta vantagens e desvantagens. Segundo [5] algumas
vantagens so:

i) No teste de resposta a entrada degrau, o processo em estudo sofre uma mudana
de um ponto de operao para outro ponto de operao. Nos sistemas fsicos reais
essa mudana abrupta pode levar o sistema para um ponto de no linearidade ou
at mesmo a instabilidade;
ii) O mtodo do teste em resposta ao degrau adequado se o processo em estudo
apresenta um baixo nvel de rudo. O que no ocorre quando o sistema trata de
processos industriais;
iii) Enquanto no mtodo de resposta ao degrau era necessrio se fazer uma anlise
grfica para se determinar os parmetros, o MQ estima os parmetros a partir do
TIP125
6
5
4
1
2
4N25
10k
560R
10k
1N4007
22uF
3k3
1k2
4k6
400nF
MOTOR CC
TACOGERADOR
+12Vcc
0V
PINO 13(RC2)
PINO 19(Vss)
PINO 2(AN0)
BC547
3k3
+
+
-
-
Processo de Comunicao do Matlab com microcontroladores via USB


[ 49 ]
processamento dos sinais de entrada e sada nas formas interativa e no interativa
baseada em algoritmos recursivo e no-recursivo.

As desvantagens associadas aplicao desse mtodo so [5]:
i) condio inicial a cerca dos valores dos parmetros necessria para a convergncia
do mtodo;
ii) os parmetros estimados podem ser tendenciosos se o rudo correlacionado;
iii) existe dificuldade na determinao do atraso de transporte;
iv) no so adequados em sistemas no lineares.


De acordo com o descrito por [5] a formulao bsica dos mnimos quadrados recursivos
dada por:



Onde (N) o vetor de medidas, u(N) e y(N) so a entrada e a sada na N-sima amostra.


P(N) uma matriz onde a preciso da estimao est diretamente ligada a magnitude de
seus elementos [5]. Um valor inicial deve ser atribudo a matriz quadrada P, que tem a
ordem igual ao tamanho do vetor .



O elemento (N) representa o erro de estimao e a estimao gerada na N-sima
amostragem do sistema.
Eq. 2
Eq. 1
Eq. 3
Processo de Comunicao do Matlab com microcontroladores via USB


[ 50 ]


O valor de K(N) uma medida da ponderao do erro na prxima estimao.


A equao 5 atualiza os valores estimados de acordo com o valor da amostragem
anterior, do erro entre o valor estimado e o real e do fator de ponderao K.
A matriz de parmetros dada por:



Para atualizao do vetor dos parmetros estimados, devem-se executar os seguintes
passos:
Atualizao do vetor de medidas (N+1) (de acordo com a equao 1;
Atualizao da covarincia P(N+1) (de acordo com a equao 2);
Atualizao do erro (N+1) (de acordo com a equao 3);
Atualizao do ganho do estimador K(N+1) (de acordo com a equao
4));
Estimao dos parmetros (de acordo com a equao 5).

APLICAO DO MQR PARA ESTIMAO DA PLANTA DO MOTOR CC
Para estimao dos parmetros do motor CC foi utilizado o programa do Matlab abaixo
para estimao dos parmetros segundo a equao abaixo:



% ----------------------------------------------------------------------------------------------
% ESTIMADOR PELOS MINIMOS QUADRADOS RECURSIVOS
Eq. 4
Eq. 5
Eq. 6
Eq. 7
Processo de Comunicao do Matlab com microcontroladores via USB


[ 51 ]
% ----- CONDIES INICIAIS
y = [0 0 0 0 0];u = [0 0 0 0 0];e = [0 0 0 0 0];
emq = [0 0 0 0 0];
teta = [.1 0.01 .1];yr = [0 0 0 0 0];
nstep=100;nit = nstep*10;pinic=1000;p = pinic*eye(3);I(1:nit) =0;
% ----------------------------------------------------------------------------------------------
% ----- REFERNCIA
% ----------------------------------------------------------------------------------------------
% Referencia 1;
% Referencia 2;
% ----------------------------------------------------------------------------------------------
% ----------------------------------------------------------------------------------------------
% ----- ESTIMAAO DOS PARAMETROS POR MQR
% ----------------------------------------------------------------------------------------------
for k=3:nit % estimaao dos parametros por MQR
% ------- SADA DO PROCESSO
y(k)=recebe_pm(1);
% ------- ESTIMADOR DOS MQR
vm = [-y(k-1) -y(k-2) u(k-1)];
yhat = vm*teta';
emq(k)=y(k) - yhat;
ganho = (p*vm') / (1 + vm*p*vm');
teta = teta + (ganho')*emq(k);
p = p - ganho*(1 + vm*p*vm')*(ganho');
a1(k) = teta(1); a2(k) = teta(2); b0(k) = teta(3);
if (k < 100) && (k >= 0)
u(k)=0.3
end
if (k < 200) && (k >= 100)
u(k)=0
end
if (k < 300) && (k >= 200)
u(k)=0.3
end
if (k < 400) && (k >= 300)
u(k)=0
end
if (k < 500) && (k >= 400)
u(k)=0.3
end
if (k <= 600) && (k >= 500)
u(k)=0
end
if (k < 700) && (k >= 600)
u(k)=0.3
end
if (k < 800) && (k >= 700)
u(k)=0
end
if (k < 900) && (k >= 800)
u(k)=0.3
end
if (k <= 1000) && (k >= 900)
u(k)=0
end;
yr(k)=u(k);
setpm_pwm_duty( 1,u(k),12000);
Processo de Comunicao do Matlab com microcontroladores via USB


[ 52 ]
end

setpm_pwm_duty( 1,0,12000);

% ----------------------------------------------------------------------------------------------
% ----- RESULTADOS DE SIMULAO
% ----------------------------------------------------------------------------------------------
t = 1:nit;
figure(1)
plot(t,y(t),t,yr(t)),title('Sada e Referncia'),xlabel('Amostra');
figure(2)
hold on
plot(t,a1(t),'r'),title('Parametros Estimados'),xlabel('Amostra');
plot(t,a2(t),'y'); plot(t,b0(t),'b');
hold off;

O resultado da simulao de 1000 amostras de uma funo de entrada composta por trens
de pulso de 0,3 pode ser visto na figura 3.5:

0 100 200 300 400 500 600 700 800 900 1000
-3
-2
-1
0
1
2
3
4
5
X: 1000
Y: -1.119
Parametros Estimados
Amostra

Figura 3.5: Estimao pelos mnimos quadrados recursivo

Parmetro Amostra 1 Amostra 2 Amostra 3 Amostra 4
b
0
2,02 2,132 2.313 2,145
a
1
-1,18 -1,109 -1,145 -1,119
a
2
0,3151 0,2496 0,2848 0,2601

Tabela 1 Parmetros obtidos pelo mtodo MQNR
Com o perodo de amostragem aproximado de 0,04 foi calculado a funo de transferncia,
com grfico na figura 3.6.



Processo de Comunicao do Matlab com microcontroladores via USB


[ 53 ]
b0 =

2.1450

a2=0.2601

a2 =

0.2601

a1=-1.119

a1 =

-1.1190

z=tf([b0 0],[1 a1 a2],0.04)

Transfer function:
2.145 z
----------------------
z^2 - 1.119 z + 0.2601

Sampling time: 0.04
c=d2c(z)

Transfer function:
39.74 s + 2493
-------------------
s^2 + 33.67 s + 164

step(c)
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
0
2
4
6
8
10
12
14
16
Step Response
Time (sec)
A
m
p
lit
u
d
e

Figura 3.6: Resposta ao degrau da planta estimada pelo MQR


Processo de Comunicao do Matlab com microcontroladores via USB


[ 54 ]

ESTIMAO POR MNIMOS QUADRADOS NO RECURSIVO - MQNR
Considere um processo fsico caracterizado por uma entrada, u(t), uma sada, y(t), uma
perturbao e(t) e com funo de transferncia discreta linear da forma

A(z
-1
)y(t) = z
-d
B(z
-1
)u(t) + e(t)

Onde:


A(z
-1
)= 1 + a
1
z
-1
+ ... + a
na
z
-na
B(z
-1
)= b
0
+ b
1
z
-1
+ ... + b
nb
z
-nb

e cuja representao por uma equao a diferenas :

y(t) = -a
1
y(t-1) a
2
y(t-2) - ... a
na
y(t-na) +
b
0
u(t-d) + b
1
u(t-d-1) + ... + b
nb
u(t-d-nb) + e(t)



Definindo-se o vetor de medidas, (t), com dimenso [(na + nb + 1)x1]

T
(t) = [-y(t-1) -y(t-2) ... -y(t-na) u(t-d) ... u(t-d-nb)]


e o vetor de parmetros, (t), com dimenso [(na + nb + 1)x1]

T
(t) = [a1 a2 ... ana b0 b1 ... bnb]

Podemos escrever a equao 9 como:

y(t) =
T
(t).
T
(t) + e(t)

Admitindo que so realizadas N medidas, suficiente para determinar os
parmetros ai e bj, ento tem-se que


A representao matricial da equao 13 :

Y = . + E

onde a matriz de observao :
Eq. 8
Eq. 9
Eq. 10
Eq. 11
Eq. 12
Eq. 14
Eq. 13
Processo de Comunicao do Matlab com microcontroladores via USB


[ 55 ]

O vetor de sada dado por:


Segundo [5] o estimador dos mnimos quadrados dado por:





APLICAO DO MQNR PARA ESTIMAO DA PLANTA DO MOTOR CC
Para estimao dos parmetros do motor CC foi utilizado o programa do Matlab abaixo
para estimao dos parmetros segundo a equao abaixo:

2 1
2
1
2
0
2
2
1
1
1
1 0
.
.
. 1
.
) (
a z a z
z b z b
z a z a
z b b
z G
+ +
+
=
+ +
+
=
! !
!


Utilizando o sistema eletrnico j apresentado foi feito o diagrama de blocos no simulink
(figura 3.7) baseado nas funes da pasta Bibliotecas Matlab disponvel em para obter os
dados de entrada e sada da planta atravs de um gerador de pulsos:

Eq. 16
Eq. 15
Eq. 17
Eq. 18
Processo de Comunicao do Matlab com microcontroladores via USB


[ 56 ]
To Workspace1
u
To Workspace
y
Step
Sine Wave
Real -time
Clock1
Random
Number
Ramp Pulse
Generator
PWM_pm
MATLAB recebe _pm
MATLAB
Function

Figura 3.7: Diagrama de blocos para aquisio dos valores de entrada e sada.

Foi utilizado o programa do Matlab a seguir:

% ESTIMACAO DE UM PROCESSO DE SEGUNDA ORDEM
% DADOS CONTIDOS NO ARQUIVO MEDIDAS.DAT
%-----------------------------------------------
%load medidas.dat
npts=1001;
%u=medidas(1:npts,1);
%y=medidas(1:npts,2);
Y=[];
fi=[];
for j=1:npts
if j<=2
y1=0; y2=0; u1=0; u2=0;
else y1=y(j-1); y2=y(j-2); u1=u(j-1); u2=u(j-2);
end;
Y=[Y; y(j)];
fi=[fi; -y1 -y2 u1 u2];
end;
teta=inv(fi'*fi)*fi'*Y
for t=1:2,
yest(t)=0;
end;
a1=teta(1) ; a2=teta(2) ; b1=teta(3) ; b2=teta(4);
for t=3:npts,
yest(t)=-a1*yest(t-1)-a2*yest(t-2)+b1*u(t-1)+b2*u(t-2);
end;
plot(y,'g');
hold on;
plot(yest,'r');

O programa gerou o grfico da figura 3.8 mostrando a aproximao entre a planta real e a
planta estimada:
Processo de Comunicao do Matlab com microcontroladores via USB


[ 57 ]
0 200 400 600 800 1000 1200
0
0.5
1
1.5
2
2.5
3
3.5
4
4.5

Figura 3.8: Comparao entre valores estimados e valores reais

teta =

-0.4648
0.0545
9.4108
0.0531

Com o perodo de amostragem aproximado de 0,1 , foi calculado a funo de transferncia
em tempo contnuo:


z=tf([9.4108 0.0531 0],[1 -0.4648 0.0546],0.1);
c=d2c(z)

Transfer function:

9.411 s^2 + 341.6 s + 3409
--------------------------
s^2 + 29.08 s + 212.5


A resposta ao degrau mostrada na figura 3.9:
Processo de Comunicao do Matlab com microcontroladores via USB


[ 58 ]
0 0.1 0.2 0.3 0.4 0.5 0.6
9
10
11
12
13
14
15
16
17
Step Response
Time (sec)
A
m
p
lit
u
d
e

Figura 3.9: Resposta ao degrau da planta estimada por MQNR

Observa-se que apesar da funo acima possuir uma quantidade de zeros maior
que o modelo estimado por MQR, o valor final e o tempo para atingir este valor so
aproximadamente iguais.


PROJETO DO SISTEMA DE CONTROLE
Foi utilizada a ferramenta sisotool do matlab para projetar o controlador para controle de
velocidade do motor CC da planta estimada anteriormente. O modelo utilizado foi o modelo
obtido por MQNR.

15 . 212 08 . 29
3409 6 . 341 411 . 9
) (
2
2
+ +
+ +
=
s
s s
s G


Utilizando o mtodo Ziegler-Nichols em malha aberta o aplicativo sisotool estimou a
seguinte funo de transferncia para o controlador, obtido pelo seguinte comando:

s
s
s G
2
) 47 , 39 .( 0010685 . 0
) (
+
=


Eq. 19
Eq. 20
Processo de Comunicao do Matlab com microcontroladores via USB


[ 59 ]


Figura 3.10: Utilizao da ferramenta sisotool para projetar o controlador
Os parmetros PID foram obtidos pelo seguinte commando:

1.6648*conv([0.025 1],[0.025 1])

ans =
0.0010 0.0832 1.6648
Parmetros:

P = 0,0832 I = 1,6648 D=0,0010

RESULTADOS


Foram atualizados o valores dos PID e construdo um novo diagrama de blocos para
controle do sistema. A figura 3.11 mostra o diagrama no simulink para controle do motor
CC.

Processo de Comunicao do Matlab com microcontroladores via USB


[ 60 ]


Scope 1
Real -time
Clock1
PWM_pm1
MATLAB recebe _pm
MATLAB
Function
Discrete
PID Controller
PID
Constant 2
2

Figura 3.11: Parmetros PID e Malha fechada de controle do motor CC de m
permanente
Clculo da funo de transferncia no Matlab com resposta ao degrau unitrio da planta
com controlador PID mostrada na figura 3.12.
sisotool

C

Zero/pole/gain from input "Input" to output "Output":
0.0010685 (s+39.47)^2
---------------------
Processo de Comunicao do Matlab com microcontroladores via USB


[ 61 ]
s

c

Zero/pole/gain from input "Input" to output "Output":
9.4108 (s^2 + 36.29s + 362.2)
-----------------------------
(s^2 + 29.08s + 212.5)

feedback(c*C,1)

Zero/pole/gain from input "Input" to output "Output":
(s+39.47)^2 (s^2 + 36.29s + 362.2)
----------------------------------------
(s+174) (s+17.42) (s^2 + 23.31s + 186.2)

Gfb=feedback(c*C,1)


Zero/pole/gain from input "Input" to output "Output":
(s+39.47)^2 (s^2 + 36.29s + 362.2)
----------------------------------------
(s+174) (s+17.42) (s^2 + 23.31s + 186.2)

step(Gfb)
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7
0.5
0.6
0.7
0.8
0.9
1
1.1
1.2
From: Input To: Output
Step Response
Time (sec)
A
m
p
litu
d
e

Figura 3.12: Resposta ao degrau unitrio da planta com controlador PID
Foram alterados os valores de referncia sem carga, de acordo com o grfico da figura
3.13:

Processo de Comunicao do Matlab com microcontroladores via USB


[ 62 ]


Figura 3.13: Simulao de valores de referncia sem carga
Dados: Linha magenta = referncia
Linha Azul Varivel controlada (tenso tacogerador)
Linha Amarela Varivel manipulada (Duty cycle do PWM)

Foi mantido a referncia e inserida uma pertubao no eixo do motor para simular uma
carga e os resultados podem ser vistos na figura 3.14:



Figura 3.14: Resposta a pertubaes do sistema de controle projetado






Processo de Comunicao do Matlab com microcontroladores via USB


[ 63 ]
CONSIDERAES FINAIS
O sistema microcontrolado para aquisio e controle da planta foi considerado eficaz pela
baixa quantidade falhas e pela facilidade de conexo via interface USB. O mesmo Hardware
pode ser utilizado em diversos sistemas de controle a partir do Matlab.
O mtodo de sintonia PID Ziegler Nichols em malha aberta mostrou-se eficiente, tornando
a resposta do motor mais rpida e estvel como foi observado nos grficos.
O perodo de amostragem mostrou-se uma varivel importante ao se realizar controles a
partir de um computador utilizando o Matlab. Tempos de amostragem muito pequenos
tornam os clculos realizados pelo computador maiores e o sistema pode se tornar instvel
devido o atraso em ler os sinais. Os valores obtidos pelo MQR apresentaram uma planta
estimada mais simples e com menos zeros, porm a resposta pelo MQNR mostrou-se
semelhante quando ambas foram submetidas a uma entrada em degrau.
O gerador de pulsos mostrou-se mais eficaz quando comparado com outros tipos de sinais
como rampa ou senoidal para estimao da planta do sistema.
Aps a concluso da confeco e montagem, o sistema de controle passou por uma fase de
testes, onde apresentou o resultado esperado no projeto, mostrando ser eficiente,
confivel e de simples de operao.

REFERNCIAS BILBIOGRFICAS

[1] GRUPO SANUSB. Ferramenta SanUSB. Disponvel em: <
http://br.groups.yahoo.com/group/GrupoSanUSB > Acessado em: 19 jan 2013.

[2] PLACA MNICA. Disponvel em <www.das.ufsc.br/~aarc/ensino/graduacao> Acessado
em: 19 jan 2013.

[3] COSTA FILHO, F. L. M. Desenvolvimento de controle e aquisio microcontrolado.
Monografia DEE-UFC. 2010. Monografia (Graduao) - Universidade Federal do Cear,
Fortaleza, 2010.

Processo de Comunicao do Matlab com microcontroladores via USB


[ 64 ]
[4] ALMEIDA FILHO, C. R. N. Sistema de Aquisio de dados para aplicao em
transformadores de Potncia com comunicao serial EIA-485. 2011. Monografia
(Graduao) - Universidade Federal do Cear, Fortaleza, 2011.

[5] COELHO, A. A. R., COELHO, L. S., Identificao de Sistemas Dinmicos Lineares. Ed. Do
Autor. Florianpolis: Editora UFSC, 2004.