UNIVERSIDADE FEDERAL DO AMAZONAS

Faculdade de Tecnologia
Bacharelado em Engenharia da Computação

Montagem e funcionamento do Mechatronics Control Kit

RELATÓRIO FINAL DO ESTÁGIO SUPERVISIONADO

César Vieira Rocha

JULHO - 2010
 UNIVERSIDADE FEDERAL DO AMAZONAS
Faculdade de Tecnologia
Bacharelado em Engenharia da Computação

RELATÓRIO FINAL DO ESTÁGIO SUPERVISONADO

DEPARTAMENTO: Engenharia da Computação

TITULO DE TRABALHO: Montagem e funcionamento do Mechatronics Control Kit
ALUNO: César Vieira Rocha
EMPRESA: Universidade Federal do Amazonas (UFAM)
Laboratório de Automação Industrial e Robótica

PROFº ORIENTADOR: Vicente Ferreira de Lucena Júnior

Manaus - AM, 28 de julho de 2010.

___________________________________________
Agradecimentos

Agradeço ao prof. Dr.-Ing Vicente Ferreira de Lucena Júnior por acreditar em meu potencial e
pela oportunidade de aprendizado que me proporcionou durante o estágio. Também devo
agradecer ao prof. Dr. João Edgar Chaves Filho por me proporcionar o material necessário para
trabalho disponibilizando o kit utilizado na realização das minhas atividades.

Agradeço a aluna de mestrado Gisele Silva que colaborou tirando dúvidas que surgiam no
decorrer do trabalho bem como disponibilização de documentação e também a aluna Ana
Cristina Franco da Silva que colaborou e me apoiou durante todo o trabalho.

Agradeço a minha família e amigos pelo apoio e conselhos nos momentos mais difíceis, e pelo
apoio que me deram no decorrer de toda graduação proporcionando assim um ambiente perfeito
de estudo e trabalho.
 Lista de Figuras
Figura 1 - Pêndulo de Furuta. [1] .................................................................................................... 9
Figura 2 - Pêndulo com carro na base. [2] ...................................................................................... 9
Figura 3 – Placa 6713 DSK. ......................................................................................................... 13
Figura 4 - Interface de escolha de controle, feita em Visual Basic............................................... 14
Figura 5 - Visão geral das peças que compõem o sistema. [3] ..................................................... 18
Figura 6 - Encoder1 e Encoder2. .................................................................................................. 19
Figura 7 – Experimento 1: Controle de um motor DC. ................................................................ 19
Figura 8 - Encoder óptico. ............................................................................................................ 20
Figura 9 - Montagem da haste que formará o pêndulo. ................................................................ 20
Figura 10 - Visão frontal dos cabos. ............................................................................................. 21
Figura 11 - Visão superior dos cabos. ........................................................................................... 21
Figura 12 - Montagem do pêndulo que será fixado no motor....................................................... 22
Figura 13 - Haste de balanço. ....................................................................................................... 22
Figura 14 - Pendubot finalizado. ................................................................................................... 22
Figura 15 - Fixação do fio do encoder. ......................................................................................... 23
Figura 16 - Fixação frontal do fio. ................................................................................................ 23
Figura 17 - Fixação lateral do fio. ................................................................................................. 23
Figura 18 - Fixação do fio não utilizado. ...................................................................................... 23
Figura 19 - Estrutura em "L" para fixação do motor. ................................................................... 23
Figura 20 - Peças para montar estrutura em "L". .......................................................................... 24
Figura 21 - Conexão de alumínio com encoder na extremidade. ................................................. 24
Figura 22 - Pêndulo de Furuta finalizado. .................................................................................... 24
Figura 23 - Fixação traseira dos fios. ............................................................................................ 25
Figura 24 - Fixação lateral dos fios............................................................................................... 25
Figura 25 - Fixação frontal dos fios. ............................................................................................. 25
Figura 26 - Menu principal. .......................................................................................................... 26
Figura 27 - Menu de instalação. .................................................................................................... 26
Figura 28 - Ícone do 6713DSK Diagnostics Utility...................................................................... 27
Figura 29 - Software de diagnóstico. ............................................................................................ 27
Figura 30 - Failed: Waiting for USB Enumeration. ...................................................................... 28
Figura 31 - Modificando o compilador do Matlab........................................................................ 29
Figura 32 - Menu de configuração do Simulink. .......................................................................... 30
Figura 33 - Configuração do Device Type. .................................................................................. 31
Figura 34 - Configuração do Real-Time Workshop. .................................................................... 31
Figura 35 - Re-build do sistema. ................................................................................................... 32
Figura 36 - Ícone para o Code Composer Studio.......................................................................... 33
Figura 37 - Code Composer Studio. ............................................................................................. 33
Figura 38 - Conectando o CCS com o kit. .................................................................................... 34
Figura 39 - CCS conectado com o kit. .......................................................................................... 34
Figura 40 - Realizar teste de memória. ......................................................................................... 35
Figura 41 - Limpeza da memória. ................................................................................................. 35
Figura 42 - Abrindo um projeto. ................................................................................................... 36
Figura 43 - Embarcando um projeto no DSP. ............................................................................... 36
Figura 44 - Loading program. ....................................................................................................... 37
Figura 45 - Iniciando a placa. ....................................................................................................... 37
Figura 46 - Mensagem de erro no LCD. ....................................................................................... 38
Figura 47 - Reiniciando o DSP. .................................................................................................... 38
Figura 48 - Mensagem do LCD para o PenduBot Top. ................................................................ 39
 5

Figura 49 - Mensagem da execução do balanceamento................................................................ 39

Figura 50 - Mensagem do LCD para PenduBot Mid. ................................................................... 40
Figura 51 - Mensagem de LCD para o Pêndulo de Furuta. .......................................................... 40
Figura 52 - Esperando sinal da interface do Visual Basic ............................................................ 41
Figura 53 - Interface do Visual Basic. .......................................................................................... 41
Figura 54 - DSP preparado para aquisição de dados. ................................................................... 43
Figura 55 - Conectando o Matlab com o DSP. ............................................................................. 43
Figura 56 - Diagrama do Pendubot. .............................................................................................. 44
Figura 57 - Diagrama do Pêndulo de Furuta. ................................................................................ 45
 Lista de Tabelas
Tabela 1 - Configuração do Switch .............................................................................................. 14
Tabela 2 - Modelos fornecidos do Simulink ................................................................................. 15
 7

Sumário

1. Introdução ............................................................................................................................... 8
2. O que pode ser feito com o kit? ............................................................................................ 11
3. Descrição dos componentes do kit ........................................................................................ 13
3.1 Exemplos de Controladores ................................................................................................ 13
3.1.1 Controlando através do Switch da placa ................................................................. 13
3.1.2 Controlando através de uma interface do Visual Basic (VB) ................................. 14
3.1.3 Controlando através do Simulink no Matlab ........................................................... 15
3.2 Lista de Peças ................................................................................................................. 16
3.2.1 Peças que acompanham o kit .................................................................................. 16
3.2.2 Itens Requeridos...................................................................................................... 17
3.2.3 Itens Recomendados ............................................................................................... 17
4. Montagem do hardware ........................................................................................................ 18
4.1 Experimento 1: Controle do motor DC .......................................................................... 18
4.2 Experimento 2: Pêndulo de Reação ............................................................................... 20
4.3 Experimento 3: Pendubot ............................................................................................... 21
4.4 Experimento 4: Pêndulo de Furuta ................................................................................. 23
5. Instalação dos softwares ....................................................................................................... 25
5.1 Instalação e teste do conteúdo do CD ............................................................................ 26
5.2 Instalação e configuração dos softwares necessários e conexões externas .................... 28
5.2.1 Instalação e configuração ........................................................................................ 28
5.2.2 Configuração de conexão externa ........................................................................... 30
6. Executando os exemplos do kit ............................................................................................. 32
6.1 Comunicação via USB, com inicialização pelo switch da placa.................................... 32
6.1.1 Experimento do Pendubot ....................................................................................... 38
6.1.2 Experimento do Pêndulo de Furuta......................................................................... 40
6.2 Comunicação via USB, com inicialização pela interface do Visual Basic .................... 40
6.2.1 Resultados para Pendubot e Pêndulo de Furuta ...................................................... 42
6.3 Comunicação via porta paralela, com inicialização pelo Matlab/Simulink ................... 42
6.3.1 Experimento do Pendubot ....................................................................................... 44
6.3.2 Experimento do Pêndulo de Furuta......................................................................... 44
Considerações Finais .................................................................................................................... 46
Bibliografia ................................................................................................................................... 47
 8

1. Introdução

O objetivo desse estágio é a montagem e funcionamento do Mechatronics Control Kit,

que é um kit para fins educativos e de pesquisa sobre teoria de sistema de controle, bem como
controle inteligente. Ao final deste trabalho o kit estará montado e em pleno funcionamento e
este relatório servirá como um manual de funcionamento que proverá todas as informações
necessárias para alunos iniciar atividades com o kit em questão.
O Mechatronics Control Kit foi desenvolvido pela empresa canadense Quanser
Consulting Inc. O objetivo do seu funcionamento foi para ensino e pesquisa na área de controle
em tempo real. A empresa disponibiliza junto com o kit quatro exemplos de controle de
pêndulos invertidos que demonstram as várias possibilidades que o sistema oferece. Os
componentes eletrônicos são integrados e contam com: um sistema de desenvolvimento DSP
(Digital Signal Processor) da Texas Instruments, uma placa DSK (Development Starter Kit)
TMS320C6713 com interface USB, um encoder ótico de aquisição de dados, um amplificador
PWM (Pulse-width Modulation), suprimento de potência de 5 e 24 volts e todos cabos
necessários para a montagem.
O estudo de sistemas de controle é cada vez mais importante para a engenharia, a
população procura cada vez mais uma forma de automatizar serviços, uma forma de usar
máquinas para realizar trabalho que seja complexo. A vantagem na utilização das máquinas é
que ao lidar com sistemas complexos, a máquina tem uma grande vantagem na velocidade de
realização de cálculos e tomada de decisões em tempo real, isso torna essa linha de pesquisa
muito atraente para os engenheiros. A pesquisa em sistemas de controle é muito ampla, um
controle pode ser desenvolvido para as mais diversas áreas como: controle da trajetória de um
projétil, controle da aceleração de trens, controle de movimentação de um robô a fim de se
manter erguido, controle de lançamento de foguetes e etc. Cada um desses sistemas envolve
cálculos e necessitam de tomar decisões rápidas para manter o centro de massa do sistema na
posição e direção correta. Esses cálculos são complexos fazendo com que o uso de
computadores seja cada vez mais interessante. O que torna esse kit especial é o fato de ele
trabalhar com pêndulos invertidos, mas o que tem de especial em um pêndulo invertido? A ação
de controle em um pêndulo invertido é similar a todos os problemas de controle citados acima,
ou seja, um aluno que use esse kit como ferramenta de estudo e aprenda a lidar com o controle
de um pêndulo, no futuro ele usará a mesma teoria para diversas áreas diferentes.
 9

O que é um pêndulo invertido? Pêndulo invertido é um sistema que tem sua massa acima
do seu ponto de pivô. Um pêndulo normal é estável ao pendurar para baixo, um pêndulo
invertido é inerente instável, e deve ser balançado ativamente a fim de permanecer ereto,
aplicando um torque no ponto de pivô ou movendo o ponto de pivô na horizontal. O pêndulo
invertido é um problema dentro da dinâmica e teoria de controle, onde serve como base para
testes de algoritmos de controle como: controladores PD, PID, redes neurais, algoritmos
genéticos, etc. O que deixa o sistema complexo são as ligações múltiplas, necessitando de forças
de balanceamento para manter todo o sistema em um ponto de equilíbrio. Existem diversos
modelos de pêndulos invertidos (veja dois exemplos nas Figuras 1 e 2), sendo que os mais
utilizados em pesquisa são: o PenduBot, o Pêndulo de Furuta, o Pêndulo de Reação e o Pêndulo
invertido com um carro mantendo o equilíbrio na base.

Figura 1 - Pêndulo de Furuta. [1] Figura 2 - Pêndulo com carro na base. [2]

O kit utilizado no desenvolvimento deste trabalho pode ser utilizado nos mais diversos
níveis de aprendizado. Ele pode ser utilizado como uma ferramenta de demonstração dos
importantes conceitos de dinâmica e controle, domínio da freqüência e espaço de estados,
controle digital, mecatrônica, programação em tempo real, controle linear e não linear, controle
inteligente e robótica. Podendo também ser utilizado em áreas de pesquisa como:

• Controle geométrico não linear;

• Identificação de controle robusto e adaptativo;

• Controle inteligente (redes neurais, lógica Fuzzy e algoritmos genéticos);

• Controle hibrido;

• Identificação, modelagem e controle de fricção;

 10

• Analise e controle de dinâmica caótica.

Para a montagem e teste de funcionamento realizado neste trabalho de estágio foram

utilizados dois dos quatro exemplos fornecidos pela empresa. O primeiro exemplo utilizado foi o
Pendubot e o segundo exemplo o do Pêndulo de Furuta. No decorrer deste relatório serão
discutidos tópicos desde a montagem do sistema até a instalação dos softwares necessários para
o funcionamento dos exemplos.
 11

2. O que pode ser feito com o kit?

O kit pode ser utilizado para observar posição e controle de velocidade, compensação de
fricção, controle de balanço, monitoramento e regulação, identificação do problema,
escalonamento dos ganhos e rejeição de distúrbios. Cada problema citado acima pode ser
modificado, pois os códigos de cada planta são fornecidos, então além de observar os resultados
os estudantes podem propor melhorias nos controladores, programá-las e verificar os ganhos
obtidos com as modificações realizadas. Abaixo será mostrada uma descrição dos problemas
propostos e que podem ser utilizados pelos estudantes para desenvolvimento de projetos com
implementação de seus próprios algoritmos.
• Identificação: o primeiro passo no design de um sistema de controle é
desenvolver o modelo matemático do sistema a ser controlado. O kit vem com
quatro sistemas distintos como exemplo: um motor DC com carregamento de
inércia, um pêndulo de reação, um Pendubot e um pêndulo de Furuta. A equação
dinâmica para essas plantas são dadas em termos de certos parâmetros, como a
massa das hastes, momentos de inércia, constantes de torque, etc. Métodos de
identificação podem ser aplicados para determinar os valores numéricos destes
parâmetros para mais tarde usá-los no design do controlador.
• Compensação de fricção: o efeito da fricção das escovas com os rolamentos do
motor geralmente resulta em um comportamento indesejado e é necessário ser
compensado pelo controlador. O controle e modelagem da fricção é interesse de
pesquisas atuais e o kit é um bom meio para verificação experimental dos
resultados teóricos dessa área.
• Controle de posição e velocidade: o kit pode ser configurado para controlar um
motor DC. Controle de posição e velocidade do sistema é naturalmente o primeiro
exercício de laboratório para estudantes iniciantes.
• Balanceamento: um exercício de laboratório mais desafiante é configurar o kit
para o pendulo de reação ou o Pendubot. Estes sistemas podem ser usados para
investigar estabilização e também a configuração de equilíbrio ou a configuração
de pendulo invertido. Há exemplos de controladores desenvolvidos para
balancear os três experimentos de pêndulos invertidos para varias configurações
de equilíbrio. O estudante pode também desenvolver controles adicionais usando
 12

outros métodos como controle com lógica Fuzzy, pseudo linearização, controle
robusto, etc.
• Balanço: o problema de encontrar o ponto de equilíbrio do pêndulo de reação, do
Pendubot e do Pêndulo de Furuta é interessante visto a não linearidade e
instabilidade do sistema. Há controladores implementados para resolver este
problema, mas o estudante deve desenvolver os próprios controladores utilizando
algoritmos diferentes como: lógica Fuzzy, métodos de aprendizagem de
máquinas, redes neurais, controladores PID, etc.
• Balanço e balanceamento: embora pareçam iguais estes dois problemas são
distintos, o balanço é a ação de modificar a posição do pêndulo em busca do
ponto de equilíbrio e o balanceamento é a ação de manter o pêndulo no ponto de
equilíbrio, uma vez que ele já foi encontrado. Combinando esses dois problemas
tem-se o cenário ideal para estudar os chamados controles híbridos.
 13

3. Descrição dos componentes do kit

O kit é composto de dois CD’s contendo documentação, exemplos e os softwares

necessários para a instalação das placas, bem como as partes que compõem a montagem do
hardware. Os exemplos e lista de peças serão descritos nas próximas subseções. A instalação
dos softwares e montagem do hardware será descritos em seções posteriores.

3.1 Exemplos de Controladores

No CD de exemplos que acompanha o kit há diferentes exemplos de programas para

controlar os modelos de pêndulo. Abaixo será feita uma descrição dos diferentes modos de
controle disponíveis no kit.

3.1.1 Controlando através do Switch da placa

No CD que disponibiliza os códigos e documentação há um diretório cujo nome é

BootCode, nesse diretório está disponibilizado o código para um programa que controla os
quatro exemplos disponíveis. Esse código precisa ser embarcado na placa e a escolha entre um
exemplo e outro é feito através do switch da placa. O switch utilizado é o SW1 localizado na
placa C6713DSK (Figura 3) e determina qual controlador será executado. A configuração do
switch é apresentada na Tabela 1.

Figura 3 – Placa 6713 DSK.

 14

DIP_0 DIP_1 DIP_2 Controlador

UP UP UP Inicia o pêndulo de reação para o ponto de equilíbrio.
DOWN UP UP Inicia o Pendubot para a posição de equilíbrio do topo.
UP DOWN UP Inicia o Pendubot para a posição de equilíbrio do meio da haste.
DOWN DOWN UP Inicia o Pêndulo de Furuta.
Tabela 1 - Configuração do Switch.

Todos os três controladores requerem que as hastes estejam em repouso antes que o
algoritmo seja iniciado. Como foi dito, os códigos para esse exemplo são encontrados no
diretório bootcode. É recomendado que o estudante leia o código fonte e o arquivo readme.txt
para se familiarizar com este exemplo.

3.1.2 Controlando através de uma interface do Visual Basic (VB)

No CD que disponibiliza os códigos e documentação há um diretório cujo nome é

DspBiosII, nesse diretório está disponibilizado o código para um programa que controla os
quatro exemplos disponíveis. Esse código precisa ser embarcado na placa e a escolha entre um
exemplo e outro é feito através de uma interface programa utilizando o Visual Basic (Figura 4).
Esse exemplo requer o uso do CCS (Code Composer Studio, disponibilizado no CD de
instalação, essa instalação será discutida posteriormente) e Visual Basic 6.0. Nesse exemplo o
estudante utiliza o CCS para carregar o arquivo “balrtdx.out” para a placa 6713DSK. Então é
utilizado o plug-in do Visual Basic para começar os diferentes controladores e fazer a escolha
dos ganhos. O plug-in também disponibiliza um mecanismo para salvar dados de resposta no
formato M-file do Matlab.

Figura 4 - Interface de escolha de controle, feita em Visual Basic.

Neste exemplo cinco controladores diferentes podem ser selecionados e executados a

partir da interface VB.
 15

• Fazer balanceamento do Pendubot para posição no meio da haste;

• Fazer balanceamento do Pendubot para posição do topo;
• Fazer balanceamento do Pêndulo de Reação para posição invertida;
• Fazer balanceamento do Pêndulo de Furuta para posição invertida;
• Controlador de PI, para controlar velocidade do motor DC.

Os arquivos deste exemplo estão disponíveis no diretório dspbiosii/rtdxproj no CD de

documentação e códigos.

3.1.3 Controlando através do Simulink no Matlab

No CD de documentação e código há um diretório com o nome Matlab\RTW, dentro

desse caminho haverá mais dois diretórios, um chamado WinCon e outro chamado
WindowsTarget. Nesses diretórios estão armazenados os modelos e códigos do Simulink, esses
são os dois modos de fazer uma conexão externa no Matlab. Os dois modos são:
• WinCon da Quanser, ou
• Real-time Windows Target (RTW) da MathWorks.
Para executar os exemplos utilizando o WinCon é necessário ter os seguintes softwares
instalados: Matlab/Simulink 6 (ou mais novo), o toolbox da Real-Time Workshop, Microsoft
Visual C++ 6.0 ou Microsoft Visual Studio .NET 2002-2003 e WinCon 3.0 (ou mais novo).
Para executor os exemplos utilizando o Windows Target é necessário ter os seguintes
softwares instalados: Matlab/Simulink 6 (ou mais novo), o toolbox da Real-Time Workshop,
Microsoft Visual C++ 6.0 ou Microsoft Visual Studio .NET 2002-2003 e Real-Time Windows
Target 2.0 (ou mais novo).
Neste trabalho foi utilizado o Real-Time Windows Target 2.5 porque não havia o WinCon
disponível para utilização. Detalhes de configuração serão apresentados na seção de instalação
dos softwares e na seção de execução dos exemplos. Os arquivos de controladores que são
oferecidos são mostrados na tabela abaixo.
Modelo do Simulink Descrição do Controlador
swpendmid.mdl Inicia o Pendubot da posição de suspensão baixa para o ponto de posição
de equilíbrio do meio e faz o balanceamento.
swpendtop.mdl Inicia o Pendubot da posição de suspensão baixa para o ponto de posição
de equilíbrio do topo e faz o balanceamento.
swpendtopobs.mdl Inicia o Pendubot da posição de suspensão baixa para o ponto de posição
 16

de equilíbrio do topo e faz o balanceamento. O controlador de

balanceamento implementa um observador linear para estimar a
velocidade da haste.
swIwhlE.mdl Inicia o pêndulo de reação da posição de suspensão baixa para o ponto de
posição invertida e faz o balanceamento.
swIwhlEobs.mdl Inicia o pêndulo de reação da posição de suspensão baixa para o ponto de
posição invertida e faz o balanceamento estimando a velocidade da haste.
swfurutaEnergy.mdl Inicia o pêndulo de Furuta da posição de suspensão baixa para o ponto de
posição invertida e faz o balanceamento. Para causar o balanço é
utilizado um algoritmo baseado em energia.
Tabela 2 - Modelos fornecidos do Simulink.

3.2 Lista de Peças

3.2.1 Peças que acompanham o kit

1) Motor DC de 24 volts com 1000Cnt/Rev e encoder ótico da Pittman Inc. Part-number

8222D116. Veja Pittman website para especificações no
www.pittmannet.com/pdf/lcm_bulletin.pdf.
2) Encoder ótico de 1000 Cnt/Rev da US Digital Inc. Part-number S1-1000-B. Veja U.S.
Digital website para especificações no www.usdigital.com/products/s1s2/.
3) C6713DSK da Texas Instruments, que inclui placa DSK, suprimento de força de 5VDC
de 5AMP, cabo USB e CD de instalação do Code Composer Studio. Part-number
TMDS320006713. Veja www.ti.com para maiores informações.
4) Suprimento de força de 24VDC e 2.1AMP da ELPAC Power Systems. Modelo W4024.
Esta peça pode ser encontrada na DigiKey. www.digikey.com.
5) Tela de LCD 20 Char x 2 linhas de Matriz orbital. Part-number LK202-25
www.matrixorbital.com.
6) C6XDSK_DigIO construída pela Quanser.
7) Interface Quanser Standard / Placa de amplificador PWM construída pela Quanser.
8) Cabo do LCD construído pela Quanser.
9) Cabo US Digital Optical Encoder construído pela Quanser.
10) Cabo de sinal do amplificador PWM construído pela Quanser.
11) Peças em alumínio todas construídas pela Quanser.
 17

a. Chapa de baixo
b. Chapa base
c. Plástico do topo
d. Duas peças de LCD
e. Motor e encoder ótico
f. Peças da conexão 1 do Pendubot
g. Peças da conexão 2 do Pendubot
h. Peças do acoplador da conexão 2 do Pendubot
i. Peças da conexão do pêndulo de reação
j. Peças da roda de reação
k. Quatro extensões para a configuração do pêndulo de reação
l. Peça da base do pêndulo de Furuta
m. Peça de cima do pêndulo de Furuta
n. Conexão 1 do pêndulo de Furuta
12) CD de instalação com os códigos de exemplo do kit

3.2.2 Itens Requeridos

1) Pentium II ou mais novo rodando Windows 2000/XP, com porta USB. Opcional: Se
usando a placa DSP para aquisição de dados, então também precisará um porta paralela
no PC.
2) Mesa limpa para permitir que os pés de borracha tenham aderência.
3) Instrumentos:
a. Soquete de ½ polegada;
b. Chaves Allen de 7/64, 3/32 e 5/64 polegadas;
c. Pequena chave de fenda;
d. Chave de fenda plana, três milímetros de precisão.
4) Fita para prender os cabos;

3.2.3 Itens Recomendados

1) Microsoft Visual Basic 6.0 para usar a interface VB;

2) Matlab com Simulink e Real-Time Workshop (RTW) e também o Quanser WinCon real-
time software (preferível) ou MathWorks Real-Time Windows Target;
3) Para usar também o software Quanser WinCon 3.0 (ou mais novo) ou o MathWorks
Real-Time Windows Target 2.0 (ou mais novo), os seguintes softwares são necessários:
 18

a. Matlab 6.0;
b. Simulink;
c. Toolbox da Real-Time Workshop;
d. Microsoft Visual C++ 6.0 ou Microsoft Visual Studio .NET 2002-2003.

4. Montagem do hardware

O Mechatronics Control Kit vem com um conjunto de peças que torna possível a
montagem de uma base onde ficam posicionadas todas as placas e LCD e mais as peças que
montam os experimentos. Algumas das peças são utilizadas para mais de um experimento o que
não torna possível a montagem de mais de um experimento ao mesmo tempo. Na Figura 5 é
mostrada uma visão geral das peças que compõem o sistema.

Figura 5 - Visão geral das peças que compõem o sistema. [3]

Depois que o kit está montado como mostrado na Figura 5, o que resta fazer é montar o
experimento desejado. As peças remanescentes são as que compõem os experimentos. Nas
próximas subseções será mostrado como funciona a montagem de cada experimento. Vale
ressaltar que todas as peças, inclusive parafusos e chaves já vêem incluídas no kit.

4.1 Experimento 1: Controle do motor DC

O primeiro experimento é para controlar um motor DC, esse experimento é o mais

simples de montar. Depois que o usuário já tem o kit montado como na Figura 5, tudo que ele
precisa fazer para realizar esse experimento é adicionar o motor e ligá-lo no local certo da placa.
 19

O motor é adicionado na parte frontal do kit e o cabo deve ser ligado no encoder1 da placa
(Figura 6).

Figura 6 - Encoder1 e Encoder2.

Como pode ser observado na Figura 6, o usuário não terá problemas em identificar o
local de conexão, pois em frente de cada conexão da placa tem o nome especificando qual porta
ela representa. Para todos os experimentos, com exceção do Pêndulo de Reação, o motor será
ligado no encoder1 e o sensor ótico será ligado no encoder2.
Depois de adicionado o motor e o cabo ligado na placa, o sistema do usuário deverá se
parecer como o da Figura 7.

Figura 7 – Experimento 1: Controle de um motor DC.

 20

4.2 Experimento 2: Pêndulo de Reação

O segundo experimento é para controlar o pêndulo de reação. Nesse experimento o

usuário precisa ficar atento para não danificar o material. Primeiro motivo: o motor será retirado
da posição mostrada na Figura 7 e colocado fixo em uma haste. Segundo motivo: o usuário tem
que estar atento na ligação dos cabos, esse experimento é o único experimento que o motor é
ligado no encoder 2, isso porque o motor nesse experimento opera como função secundário.
Tomando os cuidados necessários a montagem começa retirando o motor da base e no
lugar do motor, o encoder óptico será aparafusado (Figura 8).

Figura 8 - Encoder óptico.

Depois disso o estudante deve pegar a haste maior e fixar a roda e o motor nela, de tal
modo que o motor conseguirá rodar essa roda (Figura 9). Como foi demonstrado na Figura 5,
para realizar essa tarefa o estudante necessitará usar a Inertia Wheel Link e a Flywheel.

Figura 9 - Montagem da haste que formará o pêndulo.

 21

IMPORTANTE: Nesse experimento o estudante não pode esquecer. O motor será ligado no
ENCODER2 e o sensor ótico será ligado no ENCODER1.

Uma coisa importante, na qual o estudante deve estar atento é no posicionamento dos
fios. Quando o pêndulo é executado o motor aplica um torque para que consiga levar a haste
para o ponto de equilíbrio, se no caminho para o ponto de equilíbrio existir algum distúrbio
(como a haste esbarrar em um fio) o torque que havia sido calculo e aplicado não será mais
suficiente, então a haste não alcançará o ponto de equilíbrio, o calculo terá que ser feito
novamente para que o motor aplique outro valor de torque. Em um caso extremo, por exemplo,
se a haste sempre esbarrar no fio, o pêndulo nunca chegará ao ponto de equilíbrio. Nas Figuras
10 e 11 o estudante pode observar como é o modo ideal de prender os fios para o caso desse
experimento.

Figura 10 - Visão frontal dos cabos. Figura 11 - Visão superior dos cabos.

4.3 Experimento 3: Pendubot

O terceiro experimento é para controlar o Pendubot. Para o caso da montagem do

Pendubot o kit voltará a sua configuração inicial (Figura 7). Nesse pêndulo o motor é utilizado
na base do kit. Para iniciar a montagem desse pêndulo a haste deve ser montada. Observando a
Figura 5, as peças utilizadas para montar a haste serão: Pendubot Link 1, US Digital Encoder e a
haste de balanço. O primeiro passo é montar o Pendubot Link (Figura 12a e 12b), pois ele será
fixado no motor para causar o balanço na haste principal.
 22

Figura 12 - Montagem do pêndulo que será fixado no motor.

Depois de feita a montagem apresentada na Figura 12, o estudante pode fixar essa peça
no motor e adicionar a haste de balanço (Figura 13) na parte frontal do US Digital Encoder, e a
configuração final é mostrada na Figura 14.

Figura 13 - Haste de balanço.

Figura 14 - Pendubot finalizado.

 23

Como foi dito na subseção anterior, um ponto importante é o cuidado com a fixação dos
fios, então nas Figura 14, 15, 16 e 17 será apresentado o método mais conveniente de fixação
para o Pendubot.

Figura 15 - Fixação do fio do encoder. Figura 16 - Fixação frontal do fio.

Figura 17 - Fixação lateral do fio. Figura 18 - Fixação do fio não utilizado.

4.4 Experimento 4: Pêndulo de Furuta

O quarto experimento é o pêndulo de Furuta. Para este experimento o kit terá uma
configuração diferente da configuração inicial. O motor será retirado da base e instalado no topo
de uma peça em forma de “L” (Figura 19). Essa peça em forma de “L” não vem montada, o
estudante deve montá-la utilizando as peças mostradas na Figura 20.

Figura 19 - Estrutura em "L" para fixação do motor.

 24

Figura 20 - Peças para montar estrutura em "L".

Continuando a montagem do pêndulo de Furuta existe uma conexão de alumínio com um

encoder posicionado na extremidade (Figura 21).

Figura 21 - Conexão de alumínio com encoder na extremidade.

Essa peça será fixada no eixo do motor. O motor deve ser fixado no topo da estrutura em
“L”. O estudante primeiramente deverá fixar o motor, e em seguida fixar a peça mostrada na
Figura 21, no eixo do motor. No topo da peça mostrada na Figura 21 deverá ser fixada a haste
mostrada na Figura 13. A configuração final deverá ficar igual à Figura 22.

Figura 22 - Pêndulo de Furuta finalizado.

 25

Depois de todas as peças devidamente montadas é hora de o estudante atentar para a

fixação dos fios. Nas Figuras 23, 24 e 25 será mostrada a fixação ideal para o bom
funcionamento do pêndulo.

Figura 23 - Fixação traseira dos fios. Figura 24 - Fixação lateral dos fios.

Figura 25 - Fixação frontal dos fios.

5. Instalação dos softwares

Nessa seção será descrito como o estudante deve proceder na instalação dos softwares
referentes ao funcionamento da placa e os softwares referentes ao funcionamento dos modelos e
conexões externas.
 26

5.1 Instalação e teste do conteúdo do CD

Nessa subseção será demonstrado como proceder na instalação do conteúdo do CD. Este
conteúdo é o que garante o funcionamento e comunicação da placa com o computador. Depois
de inserido o CD do Code Composer Studio no driver abrirá um menu com opções de
documentação e instalação (Figura 26).

Figura 26 - Menu principal.

Depois de clicado na primeira opção Install Products abrirá outro menu com os softwares
que devem ser instalados. Na Figura 27 esse menu é mostrado juntamente com a ordem que deve
ser instalado cada componente.

Figura 27 - Menu de instalação.

Depois de instalada cada opção terá sido criado dois ícones no Desktop: 6713 DSK
CCStudio v3.1 e 6713DSK Diagnostics Utility v3.1. Depois de esses passos terem sido seguidos
o cabo USB da placa já poderá ser ligado no computador para reconhecimento do driver. O
driver é reconhecido automaticamente, mas deve ser instalado utilizando a opção de procurar em
disco, depois de selecionada essa opção o Windows irá encontrar o driver automaticamente e
 27

instalá-lo. Para realizar um teste de conexão e verificar se o driver foi instalado com sucesso, o
usuário deverá clicar no ícone do programa de diagnóstico (Figura 28).

Figura 28 - Ícone do 6713DSK Diagnostics Utility.

Depois de clicado no ícone, será aberto um software que realiza um teste completo na
placa e conexões. Este software (Figura 29) realizará testes na memória flash da placa, na
comunicação USB, memória externa, leds, etc.

Figura 29 - Software de diagnóstico.

Para utilizar o software apresentado na Figura 29, o usuário deve primeiro conectar a
placa ao computador, através da porta USB. Depois de realizada a conexão o usuário pode abrir
o software e apenas dar um clique na opção Start. Quando feito isso, o software irá iniciar um
diagnóstico completo do sistema informando possíveis falhas ou informando se o diagnóstico foi
finalizado com sucesso.
Existem alguns erros que podem ocorrer quando o software tentar comunicar com a
placa, dentre eles os principais são:
• Mensagem: Failed: Requires Win98, Win2k or WinXP. Problema: O sistema operacional
não suporta conexões USB.
• Mensagem: Failed: USB device is NOT enumerated or plugged in. Problema: Windows
não conseguiu encontrar o DSK. Pode ser checado o cabo de energia e o cabo USB.
• Mensagem: Failed: Load USB Application. Problema: Não foi possível carregar a
aplicação de emulação. O controlador de emulação da placa pode estar com problemas.
 28

• Mensagem: Failed: USB Channel in use by another app. Problema: Uma outra aplicação
está utilizando o mesmo canal de comunicação que o DSK utiliza. Somente uma
aplicação por vez é permitida para comunicar com o DSK. Checar por aplicações ativas
no computador.
• Mensagem: Failed: Waiting for USB Enumeration. Problema: Esta é a mensagem de
status que indica que o Code Composer Studio está esperando pela comunicação USB, o
usuário não precisa clicar no botão de Close (Figura 30) ao menos que esteja obvio que
alguma coisa de errado aconteceu, caso em que a barra de progresso não se mova mais.

Figura 30 - Failed: Waiting for USB Enumeration.

5.2 Instalação e configuração dos softwares necessários e conexões externas

5.2.1 Instalação e configuração

Existem duas opções de funcionamento dos exemplos, porque os exemplos são divididos
em duas partes, a primeira parte são os exemplos programados em C que serão embarcados na
placa através da conexão USB, a segunda parte são os exemplos desenvolvidos no Simulink e
são executados através da porta paralela.
Para a primeira opção são necessários apenas os softwares disponibilizados no CD de
instalação do kit (discutidos na seção anterior). Para a segunda opção são necessários a
instalação de softwares extras como:
• Matlab 7.0;
• Simulink;
• Microsoft Visual C++ 6.0 Standard Edition;
• Real Time Windows Target;
• WinCon 3.0.
 29

As versões descritas acima foram as utilizadas na realização deste trabalho, é importante

ressaltar que a modificação na versão de um dos softwares acarreta uma modificação nos
demais. As versões descritas acima têm perfeita compatibilidade, então elas são recomendadas.
Outro ponto importante para ressaltar é a utilização do WinCon, no decorrer do trabalho não
haverá explicações de como utilizá-lo, pois ele não estava disponível na realização deste
trabalho, ele não é um software grátis. A explicação de configuração será dada para a utilização
do Real Time Windows Target.
A ordem de instalação é a apresentada anteriormente, o Matlab 7.0 e o Simulink são
instalados juntamente, quando o usuário instalar o Matlab o Simulink é instalado
automaticamente. Depois disso o usuário deve instalar o Microsoft Visual C++ 6.0 Standard
Edition. Depois de instalado os componentes acima o usuário deve abrir o Matlab para poder
realizar a instalação do Real Time Windows Target (RTW). Uma vez que o Matlab está aberto o
usuário deve escrever na linha de comando: “rtw –install”. Com esse comando o RTW será
instalado automaticamente. Pronto, agora todos os componentes estão instalados, então o
usuário deve configurar o Matlab e os drivers da placa para serem reconhecidos.
No Matlab há apenas uma configuração a ser feita. O compilador padrão reconhecido
pela placa é o Microsoft Visual C++, mas o compilador padrão do Matlab é outro, então o
usuário deve modificar o compilador, para realizar essa modificação o usuário deve digitar na
linha de comando do Matlab: “mex –setup”. Esse comando irá perguntar qual o compilador que
o usuário deseja estabelecer como padrão (Figura 31).

Figura 31 - Modificando o compilador do Matlab.

 30

Depois de modificado o compilador e instalados os componentes, o usuário deve

configurar os drivers da placa, para que eles sejam reconhecidos pelo Matlab. O usuário precisa
abrir o diretório “Matlab\RTW\WindowsTarget\WindowsTarget 2.5” que está no CD que
contem os exemplos e copiar os seguintes arquivos: c6xbd.h, c6xen.h, c6xpwm.h, c6xen.dll,
c6xpwm.dll, c6xen.tlc e c6xpwm.tlc. Depois de copiados eles devem ser colados no diretório
c:\MATLAB\rtw\c\mechkit. O diretório final (mechkit) não existirá, o usuário deverá adicioná-
lo. Depois de realizada essa operação o Matlab já reconhecerá os drivers, mas o usuário
necessita copiar o arquivo “c6xlib.mdl” para a pasta onde se encontram os exemplos do
Simulink. O arquivo está no diretório “Matlab\RTW\WindowsTarget\WindowsTarget 2.5” e a
pasta de exemplos o usuário que decide, ela pode ser copiada para qualquer pasta que o usuário
deseje. O importante é que se o usuário vai trabalhar com o arquivo do pêndulo de Furuta, o
arquivo “c6xlib.mdl” deve estar na mesma pasta onde se encontra o exemplo do pêndulo.

5.2.2 Configuração de conexão externa

Para realizar uma conexão entre o Matlab/Simulink e uma placa externa algumas
configurações são necessárias. O usuário deve abrir o modelo do Simulink e acessar o menu
Tools
Real-Time Workshop
Options. Esse menu abrirá uma tela (Figura 32) de
configuração.

Figura 32 - Menu de configuração do Simulink.

Ao clicar no menu opções do Simulink o usuário terá opções de modificar tipo do device,
implementações de hardware, arquivos de instalação, etc. A primeira opção a ser modificada é o
tipo de device, nessa opção o usuário deve escolher “32-bit Real-Time Windows Target” (Figura
33).
 31

Figura 33 - Configuração do Device Type.

Depois de selecionado o device type a tela do usuário deve se parecer com a Figura 33.
Agora o usuário deve abrir a opção Real-Time Workshop para verificar se os arquivos de
compilação estão corretos, normalmente esses arquivos são estabelecidos automaticamente
quando o device type é escolhido, mas é aconselhável fazer uma checagem depois de
configurado o passo anterior. A tela do usuário deve se parecer com a Figura 34.

Figura 34 - Configuração do Real-Time Workshop.

Se as telas estão com as mesmas configurações da apresentada neste trabalho, então o

usuário pode aplicar as configurações (Apply) e confirmar a operação (OK). Lembrando que
depois de realizada essa operação o modelo do Simulink precisa ser compilado novamente, para
fazer isso, basta o usuário clicar na opção Re-build (Figura 35).
 32

Figura 35 - Re-build do sistema.

Pronto, agora o modelo está configurado e pronto para ser executado.

6. Executando os exemplos do kit

Como havia sido mencionado na seção 1, na realização deste trabalho foram utilizados
dois dos quatro exemplos disponíveis, mas foram usados todos os três métodos de comunicação.
Durante o progresso do trabalho percebeu-se que realizá-lo desta forma seria obtido um ganho
maior de aprendizado, pois os métodos de comunicação são completamente diferentes, mas uma
vez que o estudante domina o método de comunicação o estudante não terá mais problemas para
executar quaisquer exemplos de pêndulo disponível, pois todos são executados da mesma forma.
Então foi percebido que seria mais interessante criar um manual que explicasse todos os
métodos de comunicação disponíveis no kit para dois exemplos, do que utilizar os quatro
exemplos e talvez não dispor de tempo para explicar todos os métodos de comunicação.

6.1 Comunicação via USB, com inicialização pelo switch da placa

A primeira abordagem a ser apresentada é utilizando comunicação via USB. Nessa

abordagem o controlador é programado em C e embarcado na placa. No código que será
embarcado estão os quatro exemplos que o kit oferece, então para definir qual exemplo o usuário
deseja executar é preciso utilizar o switch (Figura 3) da placa. A configuração necessária para
escolher cada exemplo foi apresentada na Tabela 1, subseção 3.1.1. O usuário deve abrir o
 33

projeto no Code Composer Studio. Na instalação um ícone (Figura 36) para o CCS foi criado no
Desktop.

Figura 36 - Ícone para o Code Composer Studio.

Depois de clicado no ícone o CCS será aberto e tentará testar a conexão com a placa na
abertura, então a placa deve estar devidamente plugada e ligada antes de o usuário abrir o
software, a tela inicial do programa é apresentada na Figura 37.

Figura 37 - Code Composer Studio.

Depois de aberto o CCS, o usuário precisa conectá-lo com a placa para poder enviar
informações para a placa. Como pode ser observado no topo da Figura 37 ao abrir o CCS o
software realiza uma checagem de conexão, mas não conecta. A opção de conexão é
mostrada na Figura 38.
 34

Figura 38 - Conectando o CCS com o kit.

Depois de clicado na opção de conectar a tela do usuário deverá se parecer com a Figura
39.

Figura 39 - CCS conectado com o kit.

Depois que o CCS foi conectado com o kit o usuário precisa iniciar um teste de memória
que irá mapear a testar se a placa está pronta para receber os arquivos. A opção para realizar esse
teste é mostrada na Figura 40.
 35

Figura 40 - Realizar teste de memória.

Depois de realizado o teste há uma opção para limpar a placa. Esta opção não é
obrigatória sempre que o usuário vai executar um exemplo. Ela pode ser usada apenas se o
usuário deseja limpar a memória para adicionar um novo projeto, mas não tem necessidade
sempre realizar essa limpeza. A Figura 41 mostra a opção de limpeza.

Figura 41 - Limpeza da memória.

Depois de realizado todos os passos anteriores é hora do usuário decidir qual projeto
deseja embarcar e abri-lo. Na Figura 42 mostra o local de abertura do projeto.
 36

Figura 42 - Abrindo um projeto.

Depois de aberto o projeto desejado o usuário, se desejar, pode fazer modificações no

código e depois embarcar o projeto na placa. Todo projeto criado e compilado tem gerado um
arquivo *.out, esse é o arquivo que precisa ser embarcado na placa. Na Figura 43 será mostrado
como embarcar o projeto.

Figura 43 - Embarcando um projeto no DSP.

 37

Quando o botão de Load Program for clicado, abrirá uma tela pedindo para que o
caminho do arquivo *.out seja especificado e depois os arquivos serão passados para a placa
(Figura 44).

Figura 44 - Loading program.

Depois de carregado o programa para a placa o usuário precisa iniciar a placa. Na Figura
45 será mostrado onde o usuário necessita clicar para executar a placa.

Figura 45 - Iniciando a placa.

Como foi mencionado anteriormente para esse exemplo de conexão as decisões quanto
ao pêndulo são dependentes da configuração do switch da placa. Então o usuário deve configurar
o switch, de acordo com a Tabela 1, para qual pêndulo ele deseja executar. De acordo com o
pêndulo desejado, uma mensagem será mostrada no LCD da placa identificando a opção
escolhida. A mensagem variará de acordo com o nome do pêndulo escolhido, como será
mostrado nas subseções seguintes, ou irá mostrar uma mensagem de erro, caso o usuário escolha
uma opção do switch que não contenha exemplos configurados (Figura 46).
 38

Figura 46 - Mensagem de erro no LCD.

Como foi mencionado anteriormente e pode ser observado na Figura 46, foi escolhida
uma configuração do switch que não havia exemplos configurados, então a mensagem diz que
está opção não está em uso e para o usuário modificar a configuração do switch e reiniciar o
DSP. O DSP é reiniciado utilizando o CCS, na Figura 47 será mostrado onde o DSP pode ser
reiniciado.

Figura 47 - Reiniciando o DSP.

Essa opção de reiniciar a placa é utilizada para modificar o exemplo a ser executado. Se o
usuário iniciar o pêndulo de Furuta, por exemplo, e depois quiser observar o Pendubot, o usuário
não necessita embarcar o programa novamente, basta ele modificar o switch e depois reiniciar o
DSP, que o Pendubot será iniciado.

6.1.1 Experimento do Pendubot

Depois de realizar os passos descritos na seção 6.1, o usuário já pode iniciar os exemplos
de pêndulo. O primeiro iniciado foi o Pendubot. Nessa seção serão apresentados os resultados
 39

mostrados no LCD. Na seção anterior foi dito como abrir um projeto. Para utilizar esse método
de conexão o projeto que precisa ser aberto é o Boot Code, que está no CD de exemplos dentro
do diretório BootCode. Depois de aberto o projeto o usuário posiciona o switch da placa para a
posição do PenduBot (Tabela 1) e então embarca o arquivo bootflsh.out. Existem dois modos de
execução do PenduBot, o primeiro modo o pêndulo alcança a posição de equilíbrio no topo, ou
seja ele fica completamente ereto, no segundo modo, o pêndulo para na metade da
circunferência e equilibra a haste nesse ponto. Na Figura 48 será mostrada a mensagem do LCD
para o caso de escolha ter sido a posição de equilíbrio do topo.

Figura 48 - Mensagem do LCD para o PenduBot Top.

Depois de iniciada a oscilação do pêndulo o LCD se modificará mostrando mensagem

com relação ao ângulo e tempo de execução (Figura 49).

Figura 49 - Mensagem da execução do balanceamento.

Descrevendo o significado da esquerda para a direita e de cima para baixo:

• O nome é apenas a informação do tipo de mensagem, no caso mensagem de
movimentação;
• Ao lado do tipo da mensagem está o tempo de execução (em segundos);
• Na segunda linha, o primeiro número é o ângulo (em radianos) do encoder1;
• O segundo número é o ângulo (em radianos) do encoder2;
• O terceiro e último número é o ganho do controle.

Na Figura 50 será mostrada a mensagem do LCD para o Pendubot Mid, quando ele
estabiliza no centro da circunferência ao invés do topo.
 40

Figura 50 - Mensagem do LCD para PenduBot Mid.

A mensagem de balanceamento é sempre igual a apresentada na Figura 49, para todos os

exemplos.

6.1.2 Experimento do Pêndulo de Furuta

Como foi mencionado anteriormente, depois de realizada todas as configurações da seção

6.1 o usuário precisa configurar o switch para o pêndulo de Furuta. O programa que será
embarcado será o mesmo, pois como foi dito o código Boot Code contém os códigos fontes para
todos os pêndulos. Depois de embarcado e iniciado o LCD irá indicar que o switch passou para o
pêndulo de Furuta (Figura 51).

Figura 51 - Mensagem de LCD para o Pêndulo de Furuta.

A mensagem de balanceamento do pêndulo de Furuta tem a mesma configuração das

mensagens dos outros pêndulos, como foi mencionado anteriormente, e pode ser observada na
Figura 49.

6.2 Comunicação via USB, com inicialização pela interface do Visual Basic

Nessa seção será discutido como utilizar a interface do Visual Basic para executar os
exemplos. A comunicação será realizada da mesma forma da seção anterior, ou seja, todos os
passos que foram mostrados na seção anterior serão usados nessa seção. A única diferença é o
projeto que será embarcado. Nessa seção o arquivo a ser embarcado se encontra no diretório
 41

DspBiosII\rtdxproj\dsp e o nome do arquivo é balrtdx.out. A posição do switch não importa

nesse método de comunicação e após o arquivo ser embarcado o LCD mostrará uma mensagem
(Figura 52) indicando que o DSP está pronto para receber o sinal de qual pêndulo será
executado.

Figura 52 - Esperando sinal da interface do Visual Basic

Depois de embarcado a mensagem da Figura 52 será mostrada, essa mensagem significa

que o DSP está esperando um sinal que será enviado pela interface do Visual Basic (Figura 53),
esse sinal indicará qual pêndulo será executado.

Figura 53 - Interface do Visual Basic.

Para abrir essa interface o usuário deve ir ao diretório DspBiosII\rtdxproj\vb e abrir o

arquivo RTDXproj. Essa interface controla todo o processo da execução dos pêndulos e
apresenta uma simulação na parte direita. Os botões que se localizam na parte inferior esquerda
definem qual pêndulo será executo, e ao pressionado o programa calculará os ganhos e saídas
dos controladores que serão mostrados nos espaços que se encontram no centro do lado
 42

esquerdo. O botão Download Gains irá enviar esses dados para o programa que executará o
torque do motor para estabilizar o pêndulo.
No lado direito logo acima da simulação há um botão chamado Friction OFF, este botão
é importante para o funcionamento correto do pêndulo. Como foi mencionada anteriormente, a
fricção causada pelas escovas do motor afetam a estabilização do pêndulo, então é necessário ter
um calculo de compensação da fricção para o modelo funcionar corretamente, esse botão
habilita e desabilita o controlador da compensação de fricção, dessa forma o estudante pode
avaliar a importância dessa compensação. Ao desabilitar a compensação o pêndulo não consegue
estabilizar e mantendo a compensação habilitada o pêndulo estabiliza em poucos segundos.
Finalizando, há dois botões no topo do lado direito, Start e Halt, como o nome mesmo
diz, esses botões servem para ligar e desligar a execução.

6.2.1 Resultados para Pendubot e Pêndulo de Furuta

Os resultados para esses experimentos são os mesmos apresentados na seção anterior, a

única diferença nessa seção é o modo de conexão e envio de sinais. Os resultados aqui serão
estabilização do pêndulo e o LCD apresentará as mesmas informações que foram mostradas na
Figura 49.

6.3 Comunicação via porta paralela, com inicialização pelo Matlab/Simulink

Nesta seção será discutido como fazer a comunicação via porta paralela através do
Matlab/Simulink. Este modo de conexão tem uma inicialização um pouco diferente. O primeiro
passo é posicionar todos os switches da placa para a posição DOWN, então o usuário deve
embarcar o código Boot Code. Seguindo os passos da seção 6.1 o usuário deve embarcar o
código que se encontra no diretório BootCode, mas o usuário não deve iniciar o DSP. O passo da
Figura 45 não deve ser feito. Ao invés de iniciar o DSP o usuário pode fechar o CCS. Ao fechar
o CCS o DSP estará configurado para aquisição de dados e mostrará uma mensagem no LCD
(Figura 54).
 43

Figura 54 - DSP preparado para aquisição de dados.

Esse modo se chama aquisição de dados, pois neste método de comunicação o programa
que realiza os cálculos não é embarcado na placa, o Matlab realiza uma troca de informações. A
placa envia sinais de posição e torque através dos sensores para o Matlab, o Matlab realiza os
cálculos necessários e envia um sinal de volta a placa com os novos valores, ou seja, os cálculos
são realizados no computador e não no DSP.
Depois de realizado os passos anteriores agora o usuário pode abrir os modelos do
Simulink para iniciar a comunicação. Supondo que o usuário já realizou as configurações
mostradas na seção 5.2, então o usuário pode abrir o modelo que se encontra no diretório
Matlab\RTW\WindowsTarget\WindowsTarget 2.5\Examples. Como foi explicado anteriormente,
para a realização deste trabalho só foi utilizado o Windows Target, pois o WinCon não estava
disponível. No diretório estão os modelos de todos os pêndulos, o usuário deve escolher qual
pêndulo ele deseja executar e abrir o modelo. Depois de o modelo estar aberto o usuário precisa
se conectar (Figura 55).

Figura 55 - Conectando o Matlab com o DSP.

 44

Se o usuário seguiu todos os passos de configuração apresentados anteriormente a

conexão ocorrerá com sucesso. Após a conexão ser realizada aparecerá um botão de Play na
barra de ferramentas do Simulink. O usuário só precisa pressionar esse botão e o balanceamento
do pêndulo será executado.

6.3.1 Experimento do Pendubot

Nessa subseção será apresentado o diagrama realizado no Simulink para o Pendubot

(Figura 55).

Figura 56 - Diagrama do Pendubot.

Com este diagrama o estudante pode modificar valores para verificar o comportamento,
bem como criar seus próprios controladores. O estudante pode criar controladores com
inteligência artificial (redes neurais, lógica Fuzzy ou algoritmos genéticos), pode trocar para
controladores PID, PD e etc. O Simulink tem a possibilidade de inserir osciloscópios para
analisar as ondas de saída e entrada dos sinais que são enviados e recebidos pelo Matlab. O
diagrama traz a liberdade para o estudante modificar e criar.

6.3.2 Experimento do Pêndulo de Furuta

Nessa subseção será apresentado o diagrama realizado no Simulink para o pêndulo de

Furuta (Figura 56).
 45

Figura 57 - Diagrama do Pêndulo de Furuta.

O diagrama do pêndulo de Furuta tem as mesmas funcionalidades do PenduBot e é

iniciado da mesma forma, como foi explicado na seção 6.3.
 46

Considerações Finais

Esse trabalho foi realizado nas dependências do Laboratório de Automação Industrial e

Robótica da Universidade Federal do Amazonas – UFAM .

O Mechatronic Control Kit foi devidamente montado e os softwares instalados. Todos os

exemplos foram testados com sucesso e todo equipamento está funcional para que estudantes
dos cursos de Engenharia da Computação, bem como estudantes do mestrado de Engenharia
Elétrica da Universidade Federal do Amazonas possam utilizá-lo em disciplinas de laboratório,
experimentos para desenvolvimento de tese, pesquisas e etc.

No referido estágio foi dada a oportunidade de ter uma visão de como será o trabalho de
um engenheiro, pois o trabalho foi pegar um equipamento novo, aprender sobre ele, descobrir
como funciona, montá-lo e deixá-lo em pleno funcionamento. Para isso foi preciso utilizar
conceitos aprendidos ao longo do curso de Engenharia de Computação como: eletrônica,
comunicação via porta USB, comunicação via porta paralela, programação em C, a utilização de
ferramentas como o Matlab e teoria de controle. Outro fator relevante foi a oportunidade de
trabalhar mantendo comunicação com os engenheiros fabricantes do equipamento, pois no
decorrer do trabalho foram solicitados mais de uma vez e foi possível perceber como funciona a
cooperação entre engenheiros fabricantes e consumidores e como eles tentam resolver os
problemas.

Como resultado final do trabalho, pode-se dizer que agora o Laboratório de Automação
Industrial e Robótica da UFAM dispõem de um equipamento que irá beneficiar professores e
estudantes que estão na área de sistemas de controle.
 47

Bibliografia
[1] http://www.hedisc.ietec.org/uploads/Plantas/furuta_photo.jpg
Acessado em: 27/07/2010

[2] http://www.lara.unb.br/~gaborges/pesquisa/controle/pendulo/pendulo1.jpg
Acessado em: 27/07/2010

[3] Quanser Inc. (2006). “Mechatronics Control Kit User’s Manual”.