Plataforma de Aquisição de Dados, Monitoramento e Controle Utilizando Arduindo Due e Matlab

UNIVERSIDADE FEDERAL DO ESPRITO SANTO
CENTRO TECNOLGICO
DEPARTAMENTO DE ENGENHARIA ELTRICA
LEONARDO LYRIO MARCONI
PLATAFORMA DE AQUISIO DE DADOS,

MONITORAMENTO E CONTROLE EM TEMPO REAL
UTILIZANDO ARDUINO DUE E MATLAB.
VITRIA ES
MARO/2015
LEONARDO LYRIO MARCONI
PLATAFORMA DE AQUISIO DE DADOS, MONITORAMENTO E

CONTROLE EM TEMPO REAL UTILIZANDO ARDUINO DUE
MATLAB.
Parte manuscrita do Projeto de Graduao do aluno Leonardo Lyrio Marconi, apresentado

ao Departamento de Engenharia Eltrica do Centro Tecnolgico da Universidade Federal
do Esprito Santo, como requisito parcial para obteno do grau de Engenheiro Eletricista.
COMISSO EXAMINADORA:
______________________________________________
__
Prof. Dr. Celso Jos Munaro
Universidade Federal do Esprito Santo - UFES
Orientador
______________________________________________
__
Prof. Dr. Jos Leandro Flix Salles
Examinador
______________________________________________
__
Prof. Dr. Alessandro Mattedi
Examinador
VITRIA ES
MARO/2015
Aos meus avs.
AGRADECIMENTOS
Agradeo a todos aqueles que me apoiaram e ajudaram durante toda essa jornada para me tornar
engenheiro. Aos colegas de curso, amigos de infncia, professores e funcionrios da
Universidade Federal do Esprito Santo e todos aqueles que tive o prazer de conhecer durante
esse perodo, mas em especial aos meus familiares e a minha namorada Geainny.
RESUMO
O presente trabalho descreve o desenvolvimento de uma plataforma de aquisio de dados,

monitoramento e controle em tempo real, com o intuito de ser aplicada no laboratrio de
controle da Universidade Federal do Esprito do Santo. Ser utilizado o ambiente MATLAB, o
qual permitir que o usurio envie informaes para o hardware Arduino Due realizar a
amostragem dos sinais e o controle de uma planta atravs de algoritmos introduzidos nele. O
trabalho explica tambm o que ser preciso para garantir que a plataforma garanta o tempo real
nas suas aplicaes.
Os testes de funcionamento dessa plataforma sero realizados no kit didtico DC Servo Trainer
ED-4400B, e sero feitos tambm circuitos que permitiro a adequao dos nveis de tenso
entre esse kit e o Arduino.
LISTA DE FIGURAS
Figura 1-Diagrama de blocos de um sistema amostrado ........................................................ 14

Figura 2-Controlador PID ....................................................................................................... 15
Figura 3-Fluxograma da realimentao de estados ................................................................ 16
Figura 4-Fluxograma de realimentao de estados com integral do erro. .............................. 17
Figura 5- Circuito conversor de tenso da planta para o Arduino .......................................... 20
Figura 6-Amplificador Somador Inversor .............................................................................. 21
Figura 7-Amplificador Inversor .............................................................................................. 22
Figura 8-Circuito conversor de tenso da planta para o Arduino ........................................... 23
Figura 9-Confeco do sistema de converso de sinais.......................................................... 24
Figura 10-Visal geral da plataforma de aquisio de dados, monitoramento e controle ........ 25
Figura 11-Esquemtico de ligaes para monitoramento e controle ...................................... 27
Figura 12-Esquemtico de ligaes para controle via realimentao de estados. .................. 27
Figura 13-Protocolo de comunicao ..................................................................................... 30
Figura 14- Resposta ao degrau do sistema de velocidade para diferentes tempos de
amostragem ............................................................................................................................. 40
Figura 15-Resposta ao Degrau do sistema de velocidade ...................................................... 41
Figura 16-Sinal Binrio Pseudo Aleatrio (PRBS) ................................................................ 41
Figura 17-Resposta do sistema ao sinal binrio pseudo-aleatrio (PRBS) ............................ 43
Figura 18-Resposta do sistema de posio em malha aberta .................................................. 44
Figura 19- Diagrama de blocos do controle de velocidade .................................................... 45
Figura 20-Controle de Velocidade com PI ............................................................................. 46
Figura 21-Diagrama de blocos do controle de Posio .......................................................... 46
Figura 22-Controle de Posio com controlador PI ............................................................... 47
Figura 23-Sistema de Posio com controlador PI ................................................................. 48
Figura 24-Sistema de posio com controlador PID .............................................................. 49
Figura 25-Sistema de posio com controladores PI e PID ................................................... 49
Figura 26-Efeito do coeficiente do filtro do termo derivativo do PID no controle de
posio .................................................................................................................................... 50
Figura 27- Comparativo entre PID com derivada da sada e derivada do erro....................... 51
Figura 28-Efeito do tempo de amostragem no controle de posio ....................................... 52
Figura 29-Diagrama de blocos do sistema de controle por realimentao de estados ........... 53
Figura 30-Resposta do sistema com realimentao de estados .............................................. 53
Figura 31-Diagrama de blocos do sistema de controle por realimentao de estados com
integral do erro ........................................................................................................................ 54
Figura 32-Resposta do Sistema com realimentao de estados com Integral de erro ............ 54
Figura 33-Resposta do sistema de velocidade rampa com controlador proporcional ......... 55
Figura 34-Resposta do sistema de velocidade rampa com controlador proporcional-integral
................................................................................................................................................ 56
Figura 35-Resposta do sistema de posio rampa com controlador proporcional............... 57
Figura 36-Resposta do sistema de posio rampa com controlador proporcional-integral . 57
LISTA DE TABELAS
Tabela 1-Modelos de posio ................................................................................................. 43

LISTA DE ABREVIATURAS E SIGLAS
CPU Central Processing Unit (Central de Processamento de Dados)

DAC Digital Analogic Converter (Conversor Digital Analgico)
IDE Arduino Software
MATLAB MATrix LABoratory
NI National Instruments
PCI Peripheral Component Interconnect (Interconexo de components perifricos)
PID Proporcional-Integral-Derivativo
PWM Pulse-Width Modultation (Modulao por Largura de Pulso)
SRAM Static Random Acess Memory (Memria Esttica de Acesso Aleatrio)
USB Universal Serial Bus (Barramento Serial Universal)
SUMRIO
1 INTRODUO ............................................................................................................... 11
1.1 Apresentao ............................................................................................................... 11
1.2 Motivao .................................................................................................................... 12
1.3 Objetivo Geral e Objetivos Especficos ...................................................................... 12
1.3.1 Objetivo Geral ................................................................................................... 12
1.3.2 Objetivos Especficos ........................................................................................ 12
1.4 Estrutura do Trabalho .................................................................................................. 13
2 ASPECTOS TERICOS ................................................................................................ 14
2.1 Sistemas de Controle ................................................................................................... 14
2.2 Sistemas de Controle Digital ....................................................................................... 14
2.3 Controlador PID .......................................................................................................... 15
2.4 Controle por realimentao de estados ........................................................................ 16
3 HARDWARE ................................................................................................................... 18
3.1 Arduino ........................................................................................................................ 18
3.2 Circuitos Conversores de Sinais .................................................................................. 20
3.2.1 Introduo .......................................................................................................... 20
3.2.2 Conversor de -15/+15V para 0/3.3 V ................................................................ 20
3.2.3 Conversor de 0.52/2.72 V para -15/+15V ......................................................... 23
3.2.4 Ligao com o Arduino ..................................................................................... 25
3.3 Kit Didtico DC Servo Trainer ED-4400B ................................................................. 26
4 SOFTWARE .................................................................................................................... 28
4.1 Introduo .................................................................................................................... 28
4.2 Estrutura do cdigo...................................................................................................... 30
4.2.1 Estabelecendo a comunicao Serial. ................................................................ 30
4.2.2 Protocolo de Comunicao ................................................................................ 30
4.2.3 Controle de erros. .............................................................................................. 32
4.2.4 Buffer do MATLAB.......................................................................................... 33
4.2.5 Fluxograma ........................................................................................................ 34
4.2.6 Algoritmos de Controle ..................................................................................... 35
Algoritmo PID ..................................................................................... 35
Realimentao de estados .................................................................... 37
5 RESULTADOS ................................................................................................................ 39
5.1 Introduo .................................................................................................................... 39
5.2 Testes com o Motor DC .............................................................................................. 39
5.2.1 Tempo de Amostragem ..................................................................................... 39
5.2.2 Identificao do Modelo .................................................................................... 40
Modelo de Velocidade......................................................................... 42
Modelo de Posio .............................................................................. 43
5.2.3 Controle de Velocidade ..................................................................................... 45
Controlador PI ..................................................................................... 45
5.2.4 Controle de Posio ........................................................................................... 46
Controlador PI ..................................................................................... 47
Controlador PID .................................................................................. 48
Influncia do tempo de amostragem.................................................... 52
5.2.5 Realimentao de estados .................................................................................. 53
5.2.6 Realimentao de estados com integral do erro. ............................................... 54
5.3 Entrada Rampa.......................................................................................................... 55
5.3.1 Sistema de velocidade ....................................................................................... 55
Controlador P ...................................................................................... 55
Controlador PI ..................................................................................... 56
5.3.2 Sistema de Posio ............................................................................................ 57
Controlador P ...................................................................................... 57
Controlador PI ..................................................................................... 57
6 CONCLUSO ................................................................................................................. 58
6.1 Trabalhos Futuros ........................................................................................................ 59
7 BIBLIOGRAFIA ............................................................................................................. 60
11
1 INTRODUO
1.1 Apresentao
A teoria de controle muito rica e fascinante, porm muito complexa e o aluno necessita de
[...] demasiado poder imaginativo para entender o significado no-matemtico do contedo
que lhe apresentando [...]. (NEVES, SILVA e BARREIROS, 2004, p.1)
Isso faz com que as aulas de laboratrio sejam to importantes para que os alunos possam
assimilar com maior facilidade esses contedos e tambm ver de perto a teoria de controle sendo
aplicada no mundo real.
Para isso, so necessrios kits didticos que permitam a realizao de tais feitos. Porm, existe
uma srie de complicaes na utilizao de tais kits. O que mais compromete a utilizao o
fato que, muitas vezes, o hardware que executa a aquisio de dados da planta caro e ainda
possui um software fechado, o que, por questes comerciais, no permite programar livremente
algoritmos de controle por conta prpria, o que deixa o usurio engessado com os algoritmos
do fabricante, limitando muito o uso desses equipamentos.
muito importante o desenvolvimento de plataformas que realizem a aquisio e permitam a
elaborao de controle atravs de softwares livres. Alm de possibilitar sempre a incluso de
novas rotinas no software, mais uma ferramenta para capacitar os alunos da rea de controle
e automao de sistemas e de reas adjacentes, como eletrnica e computao. (NEVES,
SILVA e BARREIROS, 2004, p.2)
Na Universidade Federal do Esprito Santo, mais precisamente no Laboratrio de Controle do

Centro Tecnolgico II, existe um kit didtico, composto de um motor DC, eventualmente usado
como um sistema de testes para alguma nova plataforma de aquisio de dados, monitoramento
e controle. Atualmente, utilizada nas aulas do laboratrio a placa NI USB-6008, juntamente
com o software criado em MATLAB por (TEIXEIRA,2008).
Contudo, essa plataforma no vem apresentando uma boa performance, primeiramente por
causa do alto tempo de amostragem e tambm por no garantir que esse tempo tenha um valor
fixo durante toda a amostragem do sinal, isto , no garante o tempo real. Como os algoritmos
de controle so executados dentro de um PC rodando o Windows, e este no um sistema em
12
tempo real, no possvel garantir que o intervalo de tempo em que a cada uma das amostras
coletada, seja fixo.
Outros trabalhos tambm foram feitos por estudantes da UFES na mesma linha, sempre
utilizando o MATLAB e algum hardware. (CAZELI, 2012) utilizou um Arduino Uno para
realizar o controle do motor DC do kit didtico do laboratrio de controle. (TEIXEIRA, 2008)
utilizou a placa NUDAQ PCI para fazer o controle de um tanque de nvel. J (BOZI,2011) usou
o NI USB-6008 para fazer o controle de temperatura de uma planta didtica. Entretanto, todos
esses estudantes utilizaram esses hardwares apenas com dispositivos de entrada e sada (I/O),
ou seja, apenas como uma ponte entre a planta e o computador, ficando a maior parte do
processamento a cargo deste, o que impede que o controle seja realizado em tempo real.
1.2 Motivao
A motivao desse projeto a criao de uma plataforma utilizando um hardware de baixo

custo e de alto poder de processamento, que o Arduino Due, o qual permitir a criao de
rotinas de controle. Ser utilizado tambm o MATLAB o qual um software pago, mas que a
maioria dos estudantes de engenharia possui domnio, por ter uma interface bem amigvel para
o usurio, e que por possuir uma sesso de ajuda que to til quanto qualquer site de busca.
Com isso espera-se ter uma plataforma de aquisio de dados, monitoramento e controle mais
eficiente do que a que se encontra no laboratrio de controle, e que ela sirva para outros
trabalhos futuros de alunos da rea.
1.3 Objetivo Geral e Objetivos Especficos
1.3.1 Objetivo Geral
Criar uma plataforma de aquisio de dados, monitoramento e controle em tempo real

utilizando o Arduino Due e MATLAB.
1.3.2 Objetivos Especficos
Realizar a amostragem dos sinais das variveis de interesse em um tempo inferior

daquele realizado pela plataforma atual presente no laboratrio de controle.
Criar um sistema de envio de erros dentro da plataforma para que o usurio posso saber
quando e porque algum erro ocorreu.
Embarcar no Arduino algoritmos de controle: PID e realimentao de estados
13
Realizar o controle em tempo real.

Tornar essa plataforma mais eficaz do que a utilizada atualmente no laboratrio e
possibilitar o uso para trabalhos futuros.
1.4 Estrutura do Trabalho
O captulo 1 apresenta a contextualizao deste trabalho e, alm de expor a motivao que

resultou na deciso de abordar o assunto aqui tratado, e lista os objetivos gerais e especficos.
O captulo 2 trata de aspectos tericos relacionados teoria de Controle.
O captulo 3 descreve todo o hardware utilizado nesse processo, desde a placa Arduino,
passando pelos circuitos necessrios para esse projeto, e tambm a planta de testes do kit
didtico.
O captulo 4 descreve o software desenvolvido no MATLAB e no Arduino, que representa a
parte mais importante desse projeto.
Finalmente, o captulo 5 dedicado a execuo de testes na planta do kit didtico.
14
2 ASPECTOS TERICOS
2.1 Sistemas de Controle
2.2 Sistemas de Controle Digital
Nesse trabalhado ser realizado o controle de uma planta atravs de um controlador digital
implementado dentro de um hardware, o qual, nesse projeto ser o Arduino. Para isso,
necessrio um sistema que converta os sinais analgicos para digitais e de digitais para
analgicos. Na figura 1, esse tipo de sistema detalhado no formato de diagrama de blocos.
Figura 1-Diagrama de blocos de um sistema amostrado
Fonte: Produo do prprio autor.
A regio circundada diz respeito aos elementos que estaro presentes dentro do Arduino. Tem-
se o controlador discreto C(Z) enviando um sinal que ser a entrada da planta G(s), em
intervalos de tempos de amostragem T, o qual convertido em um sinal constante por um
segurador de ordem zero.
O bloco H(s) um elemento da planta que nesse projeto poder ser um amplificador taco ou
potencimetro, os quais convertem velocidade e posio, respectivamente, em um sinal eltrico.
Esse sinal ser amostrado em intervalos de amostragem T pelo Arduino para ser utilizado no
clculo do sinal de erro.
15
2.3 Controlador PID
O controlador PID muitas vezes referido como um controlador de trs termos e um dos mais
utilizados na indstria de processos. O sinal de controle gerado por um termo proporcional ao
erro, um termo integral do erro e um termo que a derivada do erro.
Termo proporcional: o erro multiplicado por um ganho Kp. Um ganho muito alto
pode causar instabilidade do sistema, j um ganho muito baixo pode fazer que a sada
do sistema se afaste muito da referncia.
Termo Integral: A integral do erro multiplicada por um ganho Ki. O ganho pode ser
ajustado para zerar o erro de estado estacionrio. Um ganho muito alto pode causar
oscilaes no sistema, entretanto, um ganho muito pequeno pode tornar o sistema muito
lento.
Termo Derivativo: O termo derivativo serve para amortecer a resposta do sistema

quando ela est chegando muito rpido referncia. Ele muito til quando se precisa
manter o sistema rpido, aumentando o ganho Kp, mas se quer evitar sobressinais e
oscilaes.
Na figura 3 e na equao (1) pode-se ver a estrutura ideal desse controlador, e na equao (2)
tem-se a estrutura do PID paralelo. No captulo 4 sero mais detalhadamente explicados os
algoritmos de controle PID e como eles foram discretizados para serem introduzidos no
Arduino.
Figura 2-Controlador PID
Fonte: IBRAHIM, (2006, p.231)

16
()
= + + (1)
()
()
= + + (2)
()
2.4 Controle por realimentao de estados
Outra estrutura de controle usual a realimentao de estados. Nela, ao invs de se realimentar

a sada do sistema, realimenta-se todas as variveis de estado multiplicadas por um ganho.
Haver portanto, n ganhos para n variveis de estado acessveis do sistema. Com isso podemos
ajustar esses ganhos para produzir os valores desejados dos polos em malha fechada.
No sistema representativo do servoposicionador do kit didtico tem-se duas variveis de

estados: a velocidade e posio, os ganhos desses estados optou-se por chamar de Kvel e Kpos
respectivamente.
Na figura abaixo pode-se observar a fluxograma de realimentao de estados desse
servoposicionador e tambm a sua funo de transferncia. Com isso basta calcular os ganhos
Kvel e Kpos para que os polos se posicionem aonde se deseja. Os polos em malha fechada sero
as razes do denominador da funo de transferncia mostrada em (3).
Figura 3-Fluxograma da realimentao de estados

17
() 1 2
= 2 (3)
() + (1 + ) + 1 2
possvel utilizar a integral do erro junto com a realimentao de estados para acrescentar um
polo na origem e, com isso, zerar o erro estacionrio.
Figura 4-Fluxograma de realimentao de estados com integral do erro.
A funo de transferncia do sistema com a realimentao de estados e com a integral do erro

pode ser vista a seguir:
() 1 2
= 3 (4)
() + (1 + ) 2 + (1 2 ) + 1 2
Sendo,
1 : Igual ao ganho da funo de transferncia do sistema de velocidade dividido pela

constante de tempo ().
2 : ganho do sistema de posio.
K : ganho a ser escolhido para zerar o erro de estado estacionrio.
18
3 HARDWARE
3.1 Arduino
O Arduino uma placa de prototipagem muito utilizada hoje em dia, tanto por iniciantes, quanto
por profissionais mais experientes. Um dos pontos que o tornam muito atraente o baixo custo.
Comparando com outras placas utilizadas para aquisio de dados, como a USB-6008 da
National Instruments, o Arduino supera bastante em relao ao preo. (NATIONAL
INSTRUMETS CORPORATION, 2015). Outro diferencial que possvel embarcar cdigos,
tornando possvel, por exemplo, inserir o algoritmo do controlador PID, no sendo necessrio
utilizar o computador para esse fim. Enquanto que no Arduino esse processamento ser
realizado obedecendo um tempo de amostragem definido graas utilizao de temporizadores,
no computador existem outros processos rodando junto ao MATLAB, o que poderia promover
um certo atraso no envio da resposta do controlador planta.
O Arduino uma plataforma open source, isto significa que qualquer um pode ter acesso ao
seu cdigo fonte, o que permite que sejam feitas bibliotecas com os mais diversos propsitos e
que estas sejam disponibilizadas na Web gratuitamente. Esse fato, juntamente com a linguagem
de alto nvel utilizada baseada em C++/Java, facilita muito a programao.
(SOFTWARE LIVRE BRASIL, 2015).
Existem vrios modelos de Arduino no mercado. A escolha depende das necessidades

especficas, tais como: quantas entradas analgicas so necessrias, se ele precisar ter uma
grande quantidade de memria e a resoluo das entradas analgicas. Foi feita a anlise de
todos esses pontos e finalmente optou-se pelo Arduino Due, pois ele possui as caractersticas
desejadas.
Ele possui 96 KB de memria SRAM, enquanto os outros modelos no ultrapassam 2.5 KB.
Alm disso, a sua CPU possui um clock de 84 MHz, contra 8 e 16 MHz dos outros modelos.
Isso permitir coletar amostras das variveis com pequenos tempos de amostragem. As entradas
analgicas tambm possuem um diferencial no Due, elas fornecem uma resoluo de 12 bits.
19
Outro ponto positivo do Due que o nico que possui sadas analgicas reais (DACs), alm
das j conhecidas sadas PWM presentes nos outros Arduinos. (ARDUINO, 2015a)
As caractersticas mais importantes da placa Arduino Due so: (ARDUINO, 2015b)
Micro controlador AT91SAM3X8E

Tenso das entradas analgicas 0/3.3V
Tenso das entradas digitais 0/3.3V
Tenso das sadas analgicas 0.52 /2.72V
Tenso de entrada (recomendada) 7-12V

Tenso de entrada (limites) 6-16V
Pinos de I/O Digitais 54 (12 proveem PWM)
Pinos de entrada Analgica 12
Pinos de sada analgica 2 (DAC)
Corrente por pino de I/O 130 mA
Corrente DC por pino de 3.3 V 800 mA
Corrente DC para pino de 5V 800 mA
Memria Flash 512 KB
SRAM 96 KB (dois bancos: 64KB e 32KB)
Velocidade do clock 84 MHz
20
3.2 Circuitos Conversores de Sinais
3.2.1 Introduo
As entradas analgicas do Arduino trabalham com tenses que variam de 0 a 3.3 V, as sadas
analgicas trabalham com tenses que variam de 0.52 V a 2.72 V e o kit do Laboratrio de
Controle (KIT ED-4400B) trabalha com tenses que variam de -15 +15 V. Logo, necessrio
realizar a converso de tenso e, para isso, sero utilizados dois circuitos, um para realizar a
converso do sinal que sai do Arduino para a planta e o outro para converter o sinal que sai da
planta para o Arduino.
3.2.2 Conversor de -15/+15V para 0/3.3 V
Esse circuito faz a converso que sai da planta e entra no Arduino. Seu esquemtico pode ser
visualizado na figura 5.
Figura 5- Circuito conversor de tenso da planta para o Arduino
O primeiro amplificador foi utilizando na configurao somador inversor, o qual possui a

funo de transferncia dada pela equao (5) e pode ser visto na figura 6.
21
Figura 6-Amplificador Somador Inversor
Fonte: NILSON E RIEDEL(2003).

01 = ( + )
(5)
Substituindo os valores dos componentes da figura 5 na equao (5), o primeiro amplificador

operacional possui sua sada dada pela equao (8).
2
01 = ( 1 + )
1 2 (6)
T1 e T2 so potencimetros de preciso que so ajustados para obter a relao deseja. Na

equao (7) so mostrados os valores de ajuste que deram a relao de tenses desejadas.
1 1
01 = ( 12 + )
7.3 9.09 (7)
01 = (1.65 + 0.11 ) (8)
O segundo amplificador operacional (figura 7) foi utilizado como amplificador inversor, o qual
possui a tenso de sada dada pela equao (9).
22
Figura 7-Amplificador Inversor
Fonte: NILSON e RIEDEL (2003)

= ( )
(9)
Substituindo os valores dos componentes na equao (9) e desenvolvendo tem-se que a sada
do segundo amplificador operacional dada pela equao (12).
4
= ( )
3 01 (10)
100
= ( )
100 01 (11)
= 01
(12)
Substituindo a equao (8) na equao (12) obtm-se a sada completa do circuito a seguir:
0 = (1.65 + 0.11 )
(13)
23
3.2.3 Conversor de 0.52/2.72 V para -15/+15V
Esse circuito faz a converso da tenso que sai do Arduino e entra na planta. Seu esquemtico
pode ser visualizado na figura abaixo.
Figura 8-Circuito conversor de tenso da planta para o Arduino
Nesse circuito foi utilizada a mesma quantidade de componentes. Os dois amplificadores

tambm esto na configurao somador inversor e inversor, respectivamente.
A sada do amplificador somador inversor dada pela equao (14).
6 6
01 = ( (2 ) + )
4 3 (14)
E a sada do amplificador inversor dada pela equao (15).
8
02 = ( )
7 01 (15)
Substituindo a equao (14) na equao (15) e os valores dos componentes da figura 8, tem-se
a sada completa do circuito dada pela equao (17).
24
56 56
= ( (12) + )
30.42 4.1 (16)
T3 e T4 so potencimetros de preciso que so ajustados para obter a relao desejada. Na

equao (16) so mostrados os valores de ajuste que deram a relao de tenses desejadas.
= (22.09 + 13.65 )
(17)
Foram feitas duas placas de circuitos impresso contendo cada um desses circuitos e ambas
foram colocadas em uma caixa plsticas junto com o Arduino com bornes, para assim trazer
segurana e facilidade ao manuseio do hardware. (Figura 9)
Figura 9-Confeco do sistema de converso de sinais.

25
3.2.4 Ligao com o Arduino
As duas sadas analgicas do Arduino Due (DAC0 e DAC1) so ligadas nos circuitos de
converso de 0.52 a 2.72 V para +/-15V. As entradas analgicas A5 e A7 so ligadas nos
circuitos que convertem o sinal de +/-15 V para 0 a 3.3 V.
Na caixa, os bornes E0 e E1 representam as entradas analgicas A5 e A7, respectivamente, e
os bornes S0 e S1 representam as sadas analgicas DAC0 e DAC1, respectivamente.
A figura 10 abaixo mostra um panorama geral como ocorre a interao entre computador,
Arduino, circuito conversor de sinais e a planta.
Figura 10-Visal geral da plataforma de aquisio de dados, monitoramento e controle

26
3.3 Kit Didtico DC Servo Trainer ED-4400B
Para realizar os testes dessa plataforma foi utilizado um kit didtico composto pelos seguintes
componentes:
U-156 B Fonte de alimentao CC (+/- 15 V 0,2 A e alimentao do motor)
U-154 B Driver amplificar de tenso (10 watts)
U-161 B Servo motor
U-155 B Unidade taco amplificadora
U-152 B Amplificador Somador-Inversor
U-158 B Potencimetro
Utilizando esses componentes, foi montada a planta para realizar testes de monitoramento,
controle de posio e controle velocidade.
Na figura 11 possvel ver o esquemtico das ligaes do kit e da caixa contendo o circuito
conversor de sinais e o Arduino.
O sinal a ser aplicado na planta, seja no modo monitoramento ou controle, enviado pela caixa
no borne S0 e aplicado no amplificador inversor. A resposta, no caso do sistema de velocidade,
gerada pela unidade taco amplificadora, cuja sada est conectada na entrada E0 da caixa. No
caso do sistema de posio, o sinal gerado no bloco do potencimetro ligado no eixo mais
lento do motor. Pode-se observar que existe uma chave comutando entre os pontos 1 e 2,
indicando qual sistema est sendo usado. Essa chave apenas uma ilustrao de como a ligao
dever ser feita manualmente. O nmero 1 indica o sistema de velocidade e o nmero 2 indica
o sistema de posio. Vale ressaltar que esse esquemtico serve tanto para monitoramento,
como para controle.
27
Figura 11-Esquemtico de ligaes para monitoramento e controle
Quando executa-se o controle por realimentao de estados, liga-se a sada do potencimetro

da entrada E0 da caixa e a sada do amplificador taco na entrada E1. O restante das ligaes
permanece inalterado. (Figura 12)
Figura 12-Esquemtico de ligaes para controle via realimentao de estados.

28
4 SOFTWARE
4.1 Introduo
O planejamento inicial previa utilizar o ambiente SIMULINK nesse projeto, mais

especificamente a sua biblioteca Real Time Workshop, porm, descobriu-se haver
incompatibilidade dependendo do sistema operacional e do computador utilizado, o que poderia
causar problemas quando fosse utilizado nos computadores do laboratrio de controle, por
exemplo. Por isso, decidiu-se elaborar um cdigo no MATLAB para enviar dados para o
Arduino e nesse foi elaborado outro cdigo que permitiu o recebimento dessas informaes
para a realizao do monitoramento ou controle em tempo real.
No MATLAB foi feito o envio de informaes necessrias para o funcionamento da

plataforma, como por exemplo, o tempo de amostragem, a quantidade de amostras, qual entrada
ser aplicada na planta, ganhos do controlador e qual o algoritmo de controle ser utilizado.
Executa tambm o controle de erros, informando ao usurio, na ocorrncia de algum problema,
qual foi a causa.
No Arduino ocorre o processamento em tempo real, o que no seria vivel se fosse utilizado
um sistema que no permite tal processamento, como o Windows. Nele[...] tarefas de alta
prioridade podem ser interrompidas para que tarefas de baixa prioridade sejam executadas,
fazendo com que seja impossvel garantir um tempo de resposta constante para suas
aplicaes. [...] (MECATRNICA ATUAL,2015). Por isso a importncia de se executar os
algoritmos de controle em um hardware dedicado ao invs de executar em um PC, como feito
hoje em dia no laboratrio de controle.
Para se alcanar o tempo real no Arduino, foi feito uso de interrupes comandadas por
temporizadores, os quais permitem que o Arduino pare momentaneamente a execuo normal
do programa para fazer a tarefa que lhe foi destinada em intervalos de tempos definidos. Foi
encontrada uma biblioteca j pronta intitulado de DueTimer, exclusiva para o Arduino Due,
que fazia exatamente o que era necessrio para esse projeto. (SEIDEL, 2015).
Alm de garantir o tempo real, interessante que a plataforma execute a amostragem em tempos
baixos, essencial para o controle de alguns sistemas. Isso foi possvel graas poderosa CPU
29
de 84 Mhz, a melhor entre todos os Arduinos. Com isso pode-se executar os algoritmos que
realizam o controle mesmo utilizando um baixo tempo de amostragem.
Uma preocupao que ocorreu, foi em relao a integridade dos dados que seriam enviados do
Arduino ao MATLAB. Poderia ocorrer um problema de perda de dados se no existisse um
buffer no MATLAB para fazer o armazenamento, e foi constatado por meio de testes que o
MATLAB permite a configurao do tamanho do seu buffer de entrada, e ele grande o
suficiente para armazenar a quantidade mxima de amostras que o Arduino poder enviar. Com
isso, temos a garantia de executar o controle em tempo real sem haver perda de informaes.
A primeira etapa do projeto foi exclusivamente dedicada a realizar a aquisio dos dados, isto
, o Arduino amostraria os sinais eltricos provenientes da planta e os enviaria para o
MATLAB. Comeou-se enviando os dados para o Arduino como strings, o que foi logo visto
como um erro, pois cada caractere de um nmero iria ocupar 1 byte, o que seria um problema
quando fosse enviado uma grande quantidade de dados, pois a memria do Arduino um
recurso muito limitado. Todas as informaes que seriam enviadas ao Arduino possuiriam
valores inteiros, incluindo a entrada que seria aplicada na planta, pois as sadas analgicas do
Arduino possuem uma resoluo de 12 bits, e o intervalo de valores que precisaramos enviar
iria variar ente 0 e 4095. Ento, optou-se por enviar os dados no formato uint16, ou seja, inteiro
sem sinal de 16 bits. Com isso podia-se enviar um nmero variando entre 0 e 65536 em apenas
2 bytes.
Caso o modo de controle fosse escolhido, tambm seria necessrio enviar os ganhos do
controlador. Esses ganhos poderiam ter valores possuindo algumas casas decimais, por isso
foram enviados como variveis do tipo float que variam entre -3.40282334E+38 a
3.40282334E+38 e ocupam 4 bytes. (ARDUINO, 2015).
Para tornar o sistema mais confivel e de fcil utilizao, foi criado um sistema de alerta de
erros que informa quando algum problema ocorrer. Por exemplo, se a quantidade de dados que
o Arduino est esperando no chegar ou se a quantidade de amostras esperadas no for enviada
ao MATLAB, uma mensagem de erro ir informar o que ocorreu.
30
4.2 Estrutura do cdigo
4.2.1 Estabelecendo a comunicao Serial.
O programa se inicia no MATLAB. Primeiramente, necessrio iniciar a comunicao serial

entre o Arduino e o MATLAB e a taxa de envio dos dados com os comandos abaixo.
O primeiro e segundo comandos respectivamente fazem: deleta as comunicaes seriais

existentes no MATLAB na porta de interesse e cria um objeto atrelado quela porta serial. O
terceiro comando estabelece a taxa de envio de bits pela porta serial. E o quarto comando
estabelece o tamanho do buffer do MATLAB em bytes. Esse comando muito importante pois
o buffer do MATLAB possui um papel fundamental no controle em tempo real.
Vale ressaltar que a porta serial usada pelo Arduino poder variar de um computador para
outro. Para saber em qual porta o Arduino est conectado, basta entrar na IDE do Arduino e
descobrir em qual porta ele est conectado.
4.2.2 Protocolo de Comunicao
O usurio no MATLAB ir escolher os valores que sero enviados ao Arduino, os quais so: o
tempo de amostragem, a quantidade de amostras que ser coletada e se ser executado o
monitoramento ou controle de uma varivel. Se for escolhido o modo controle, tambm ser
selecionado o algoritmo a ser utilizado. Alm disso, sero enviados os parmetros dos
controladores e a entrada a ser aplicada na planta.
Independentemente do modo escolhido, os dados obedecero um protocolo de envio que pode
ser visto na figura 13.
Figura 13-Protocolo de comunicao
Quantidade Quantidade Parmetros dos

de dados Ts de amostras P1 P2 controladores Entrada

31
A primeira informao a ser enviada ser a quantidade de dados que o Arduino dever esperar
chegar. Aps isso, o Arduino receber o valor do tempo de amostragem (Ts) e a quantidade de
amostras, que ser coletada e enviada ao MATLAB. Existem tambm dois parmetros
importantes a serem enviados, P1 e P2.P1 ter seu valor variando entre 0 e 3 para informar qual
modo ser executado e qual algoritmo de controle ser utilizado, P2 informar qual sada
analgica estar utilizada, se a DAC0 ou DAC1.
Essas primeiras informaes sero colocadas dentro do Arduino dentro de um vetor chamado
de VetDados. Se for desejo futuramente colocar mais dados nesse vetor, basta alterar o tamanho
dele e modificar o valor da varivel TamDados no cdigo do MATLAB e do Arduino para a
quantidade de interesse
Em seguida, estaro os parmetros do controlador com um nmero de quatro elementos, pois

foi o mximo necessrio para esse projeto. Se em projetos futuros for necessrio aumentar o
nmero de parmetros enviados, basta modificar o valor de uma varivel chamada de
TamGanho dentro do Arduino para o valor desejado de elementos. Esses parmetros sero
colocados dentro de um vetor chamado de VetGanhos, o qual tambm dever ter seu tamanho
alterado, se necessrio. Dependendo do modo de escolhido, algumas posies do vetor de
ganhos no sero utilizados e sero enviados zeros para serem preenchidos.
Por ltimo, ser enviada a entrada que ser aplica na planta. Ela ser construda no MATLAB
pelo usurio, mas ter uma limitao de tamanho, pois dentro do Arduino ela ser armazenada
dentro de um vetor de inteiros de 16 bits chamado vetdados com 40 mil posies. Como a
memria Ram do Arduino possui 96 K, estar sendo usado 80K de memria s para este vetor,
o que mais do que suficiente. Por exemplo, se for escolhido um tempo de amostragem 1 ms,
ser possvel realizar at 40 s de aquisio de dados. Para tempos de amostragem maiores,
logicamente o tempo de coleta de dados aumenta.
Os valores que os parmetros P1 e P2 podero assumir e seus respectivos significados esto

mostrados a seguir:
32
P1 = 0: Monitoramento
P1 = 1: Controle PID com derivada da sada
P1 = 2: Controle PID com derivada do erro
P1 = 3: Controle Realimentao de estados.
P2 = 0: DAC0
P2 = 1: DAC1
4.2.3 Controle de erros.
Conforme as informaes vo sendo enviadas, o MATLAB ir esperar por confirmaes

enviadas do Arduino, informando se o mesmo recebeu corretamente tudo o que deveria. A
aquisio dos dados s se iniciar aps o MATLAB ter todas as confirmaes que as
informaes chegaram.
A primeira informao a ser enviada ao Arduino o tamanho do vetor de dados. Quando o

Arduino receber esse tamanho, ele enviar de volta ao MATLAB para se ter certeza de que o
valor est correto, pois essa informao crucial para o funcionamento da plataforma. Se o
MATLAB no receber de volta o tamanho ou se ele estiver incorreto, a seguinte mensagem de
erro ser exibida: O Arduino no recebeu corretamente o tamanho do vetor de dados.
Se tudo estiver correto, o MATLAB ir enviar os dados do vetor para o Arduino e o MATLAB
ficar esperando uma flag chamada de Flag 1 do Arduino, informando se a quantidade chegou
ou no. Se ocorrer algum problema em alguma informao ou de a sinalizao no chegar, o
usurio receber a seguinte mensagem de erro: O Arduino no recebeu todos os dados.
Com a certeza de que todos os dados chegaram corretamente ao Arduino, o MATLAB ir enviar
um comando para comear a aquisio de dados, a qual s ir terminar quando a quantidade de
amostras pedida for alcanada. Ao mesmo tempo em que faz a aquisio, o Arduino j envia as
amostras para o MATLAB.
33
A ltima mensagem de erro para informar ao usurio se a quantidade de amostras esperadas

no chegar. Se tiver acontecido algo que impossibilitou o recebimento de alguma amostra, o
usurio ser informado com a seguinte mensagem de erro: A quantidade de amostras
esperadas no chegou.
Na pgina a seguir pode-se ver um esquemtico do cdigo resumido na forma de um
fluxograma.
4.2.4 Buffer do MATLAB
Quando os dados so enviados do Arduino para o MATLAB, eles so armazenados em um

buffer e so movidos para variveis no workspace com o comando fread. Porm, se o tamanho
do buffer for pequeno, pode acontecer de no haver tempo de realizar a leitura e algum dado
ser perdido. Nesse projeto, enviado ao MATLAB as amostras de dois sinais simultaneamente,
junto com o sinal de controle, e todos eles so enviados como inteiros de 16 bits, ou seja, 2
bytes. Ento, a cada tempo de amostragem so enviados ao MATLAB 6 bytes de dados. Como
a entrada a ser aplicada ao sistema limitada pelo tamanho do vetor vetdados, o qual possui
40 mil posies, poder ser enviado ao MATLAB at 240 mil bytes de dados. Com isso,
necessrio que o buffer do MATLAB tenha esse tamanho para assegurar que nenhum dado seja
perdido.
Descobriu-se que, utilizando o comando InputBufferSize, possvel configurar o tamanho do

buffer com o valor desejado. Para testar se isso realmente funcionava, foi pedido para o Arduino
coletar a quantidade mxima possvel de amostras do sinal, mas no lugar de realizar a leitura
do buffer, esperou-se pelo seu preenchimento, para ento usar o comando BytesAvailable, o
qual informa a quantidade de dados presentes no buffer. O comando informou que existia no
buffer exatamente 240 mil bytes, o que comprova que o tamanho dele suficiente para as
aplicaes dessa plataforma.
34
4.2.5 Fluxograma
Matlab inicia comunicao

serial com o Arduino
Escolha do modo e
definio de parmetros
no Matlab
Envio do tamanho do
vetor de dados
No
O tamanho do vetor de dados
Msg Erro 1 Fim do programa
chegou ao Arduino ?
Sim
Envio do vetor de
dados
No
A quantidade de dados esperados
Msg Erro 2 Fim do programa
chegou ao Arduino ?
Sim
Envio de comando
do Matlab para o Arduino
comear a Aquisio das
amostras do sinal
Coleta de uma Sim

Modo controle selecionado? Execuo do algoritmo de
amostra do sinal e controle
envio ao Matlab
No
No
Quantidade de
amostras alcanado ?
Sim
No
Quantidade de amostras pedidas Msg Erro 3
chegou ao Matlab ? Fim do programa
Sim
Fim do programa
35
4.2.6 Algoritmos de Controle
Algoritmo PID
Nessa plataforma foram implementados dos tipos de algoritmos PID que utilizam um filtro
passa baixa na parte derivativa, o que deixa o sinal de controle menos ruidoso.
O primeiro realiza a derivada do erro e sua equao pode ser vista a seguir.
()
() = + +
() (18)
1+
Onde Kp, Ki e Kd so os ganhos do controlador e N coeficiente do filtro passa-baixa.
Passando a equao (18) para o domnio discreto temos:
() (1 1 )
= + + (19)
() (1 1 ) (1 + ) 1
U(z) o sinal de controle, e E(z) o erro entre o set-point e a sada.

Desenvolvendo a equao (19), chegamos equao (20).
1 1 2 0 1 2
() = () 2 () + () + + 1 () + + 2 ()
0 0 0 0 0 (20)
Sendo,
0 = (1 + ) + (1 + ) +
1 = ( (2 + ) + + 2 )
2 = +
0 = (1 + )
1 = (2 + )
2 = 1
36
Quando realizamos a derivada do erro, a mudana de referncia resulta em uma indesejvel

ao de controle chamado de chute derivativo. Isso ocorre pois a derivada do erro na mudana
de referncia resulta em um nmero muito grande. Para se evitar tal fenmeno, possvel
utilizar uma tcnica chamada Derivative on Measurement. (COOPER, 2015). Essa tcnica
consiste subtrair a derivada da sada do sinal de controle no lugar de somar a derivada do erro.
Isso possvel de ser feito pois a derivada do erro igual a derivada da sada com sinal negativo
sempre que a referncia for constante, pois a derivada de uma constante sempre igual a zero.
(Equao(18)). Com isso conseguimos ter praticamente o mesmo efeito do PID com derivada
do erro mas sem o chute do sinal de controle.
(()) (() ) ()
= = (21)

O sinal de controle gerado por esse PID possui a seguinte equao:

() = () + () ()
(22)
1+
Passando a equao (22) para o domnio discreto chega-se na equao (23).
(1 1 )
() = () + () ()
(1 1 ) (1 + ) 1 (23)
Desenvolvendo a equao (23) chegamos na equao a seguir:
1 1 2 0 1 2 0 1 2 (24)
() = () + 2 () + () + 1 () + 2 () + () + 1 () + 2 ()
0 0 0 0 0 0 0 0
37
Sendo,
0 = (1 + NT)
1 = (NT 2)
2 = 1
0 = (1 + ) + (1 + )
1 = ( 2)
2 =
0 =
1 = 2
2 =
Com isso, as equaes (20) e (24) dos dois controladores PID podem ser implementadas no
Arduino.
Realimentao de estados
O algoritmo da realimentao de estados o mais simples de todos os utilizados. Ele apenas

subtrai da referncia amostras dos dois estados acessveis do sistema, os quais so posio e
velocidade, multiplicados por um ganho.
= (25)
Kvel e Kpos so os ganhos a serem multiplicados pelas amostras de velocidade e posio

respectivamente.
Quando necessrio eliminar o erro estacionrio, introduz-se um integrador aps o erro entre
a entrada e a sada.
38
Na equao(26) possvel ver a equao da integral no domnio discreto e a desenvolvendo

chega-se na equao(27).
()
= (26)
() 1 1
() = () 1 + () (27)
Com isso a referncia da equao (25) passa a ser o sinal de sada do integrador (Equao (27)).
39
5 RESULTADOS
5.1 Introduo
Nesse captulo sero detalhados os testes executados com Kit Didtico DC Servo Trainer ED-
4400B. Ser realizada a identificao dos sistemas de velocidade e posio atravs do mtodo
dos mnimos quadrados utilizando como entrada o sinal binrio pseudo aleatrio (PRBS) e o
degrau. Com base nesses modelos sero projetados controladores para se obter um bom
transitrio para a resposta dos sistemas. Sero feitas tambm anlises do efeito do coeficiente
do filtro passa baixa do termo derivativo do PID e do tempo de amostragem no controle de
posio. Tambm ser comentado o que a derivada da sada pode trazer de benefcios no
controle de posio. Alm disso, ser aplicada uma entrada do tipo rampa nos sistemas de
posio e velocidade para posteriormente analisar os resultados.
5.2 Testes com o Motor DC
5.2.1 Tempo de Amostragem
Foi utilizado o sistema de velocidade em malha aberta para testar a flexibilidade que essa
plataforma nos oferece em relao escolha do tempo de amostragem.
Na figura 14 possvel ver vrias curvas da resposta do sistema para uma entrada do tipo degrau
no instante t=0, com uma amplitude de 3V.
O tempo de amostragem no influencia no formato da curva de resposta. A diferena que
quanto menor o tempo de amostragem, maior quantidade de rudo. ver possvel que a curva
referente utilizao do tempo de amostragem de 1ms possui muito mais rudo se comparada
com a curva do tempo de amostragem de 80ms.
40
Figura 14- Resposta ao degrau do sistema de velocidade para diferentes tempos de amostragem
5.2.2 Identificao do Modelo
O mtodo mais simples para se identificar o modelo de um sistema , sem dvidas, utilizando
uma entrada do tipo degrau e encontrando o ponto referente ao valor de regime e o ponto onde
a resposta alcana 63% do valor de regime. Entretanto, quando existem rudos de medio,
como acontece em praticamente todos os sistemas de aquisio de dados, este mtodo fica
comprometido. Isto pode ser observado na figura 15. Ela representa a resposta do sistema de
velocidade a uma entrada do tipo degrau com um tempo de amostragem de 1ms. possvel
observar que ela possui rudos que podem ocasionar a escolha de valores errados para identificar
o sistema.
41
Figura 15-Resposta ao Degrau do sistema de velocidade
Por isso, nesse projeto usou-se o mtodo dos mnimos quadrados para a identificao dos
modelos de posio e velocidade do motor
Enquanto o mtodo da resposta ao degrau utiliza apenas pontos da curva, o mtodo dos mnimos
quadrados ajusta os parmetros usando todos os pontos da curva, de modo a reduzir o erro
quadrtico entre a sada medida e a estimada
Para o sistema de velocidade ser utilizado um sinal Binrio Pseudo Aleatrio (PRBS) (figura
16), o que permite identificar as dinmicas lentas e rpidas presentes na planta.
Figura 16-Sinal Binrio Pseudo Aleatrio (PRBS)
O sinal PRBS foi criado no ambiente Matlab usando a funo idinput, a seguir ele enviado
para o Arduino, onde ele fica armazenado dentro do vetor designado para manter as entradas
que sero aplicadas na planta.
42
Para a identificao do sistema de velocidade do Kit didtico foi criado um sinal PRBS com
amplitude variando entre 0 e 5V, com durao de 50s e com uma taxa de amostragem de 10ms,
ou seja, foi construdo um sinal com 5000 pontos.
Na figura 17 pode-se conferir a resposta do sistema de velocidade ao sinal PRBS.
Tendo posse da entrada e da resposta do sistema, possvel utilizar o toolbox Ident,
disponibilizado pelo prprio Matlab para realizar o processo de identificao do sistema,
utilizando o mtodo dos mnimos quadrados.
Modelo de Velocidade
Selecionando o modo process models dentro do Ident, pode-se escolher a estrutura do sistema
(nmero de polos, zeros, com ou sem atraso) e o MATLAB fica responsvel por calcular os
parmetros dele para reduzir o erro quadrtico entre a sada medida e a estimada.
Para o modelo de velocidade, escolheu-se duas estruturas diferentes, uma contendo um polo
apenas, ou seja uma estrutura de primeira ordem, e outro com dois polos, ou seja uma estrutura
de segunda ordem. As duas estruturas sem atraso.
Com o modelo de primeira obteve-se um FIT de 74,76%. Sua estrutura j com os parmetros
calculados, pode ser visto na equao a seguir:
0.97895
() = (28)
0.15773 + 1
Tentando melhorar o modelo, tentou-se uma estrutura com dois polos e chegou-se a um FIT de
90,48%. A sua estrutura com os parmetros calculados dada por:
0.9783 (29)
() =
0.004974 2 + 0.1411 + 1
Para verificar a qualidade dos modelos, plotou-se juntos no mesmo grfico, (figura 17): a
resposta real do sistema e a resposta obtidas com os modelos utilizando o sinal PRBS.
43
Figura 17-Resposta do sistema ao sinal binrio pseudo-aleatrio (PRBS)
Modelo de Posio
Foram utilizadas as rotinas procest e arx para estimar os parmetros do modelo de posio. A
primeira usa um algoritmo de otimizao no linear e a segunda usa o mtodo clssico dos
mnimos quadrados.
Para isso foi aplicado um degrau de amplitude de 3 V com tempo de amostragem de 1ms no
instante t=0, para coletar a resposta do sistema de posio em malha aberta
Utilizando a rotina procest do MATLAB, escolheu-se algumas configuraes de estruturas
que podem ser conferidas na tabela a seguir junto com seus respectivos FITs.
Tabela 1-Modelos de posio

Estrutura Modelo FIT
Integrador e atraso 3.01 0.04 95,7%

Integrador 2.902 92,4%

Tentou-se tambm identificar um polo no sistema, porm, foi encontrando um modelo cujo
polo estava em 106 , ento ele foi descartado.
44
Para a rotina arx, escolheu-se valores de 1,1,0 para os parmetros nb, nf e nk, respectivamente,
e foi encontrado um bom modelo com um FIT de 95,88%.
A estrutura do modelo discreto ARX pode ser visualizada abaixo.
()() = ()() + () (30)
Sendo,
() = 1 1
() = 0.002804
possvel notar pelos modelos encontrados que o processo praticamente um integrador puro.
Na figura 18 esto os grficos com os dados coletados e as respostas dos modelos para verificar
a qualidade deles.
Figura 18-Resposta do sistema de posio em malha aberta

45
5.2.3 Controle de Velocidade
Utilizou-se o diagrama de blocos do Simulink (figura 19) para realizar o projeto de um

controlador PI que fizesse com que o sistema tivesse um bom transitrio e erro estacionrio
nulo. Nesse esquemtico do Simulink foi includa a saturao do sinal de controle em -15 e
+15V e a zona morta do sistema que varia entre -0.6 e 0.6 V. Em todas as simulaes daqui
para frente, esses valores no sero modificados.
O sinal aplicado como referncia do sistema foi um degrau de amplitude 3V e as amostras foram
coletadas com um tempo de amostragem de 10 ms.
Figura 19- Diagrama de blocos do controle de velocidade
Controlador PI
Com o auxlio da funo Tune do bloco PID, buscou-se um projeto de controlador que fizesse
com que o transitrio da resposta tivesse pouco ou nenhum sobressinal e um rpido tempo de
assentamento. Os valores de Kp e Ki que permitiram que se alcanasse tal objeto podem ser
visualizados na equao a seguir:
8.8354
() = 0.9808 + (31)

Na figura 20, tem-se a resposta do sistema utilizando esse controlador junto com simulao
realizada no SIMULINK. Tambm foi mostrado o sinal de controle enviado pelo Arduino e
aplicado na planta.
46
Figura 20-Controle de Velocidade com PI
5.2.4 Controle de Posio
O diagrama de blocos do SIMULINK foi utilizado para se efetuar as simulaes para o projeto
dos controladores, como pode ser visto na figura 21. Como foi feito para o controle de
velocidade, a referncia do sistema foi um degrau de 3V no instante 0,5 segundos e o tempo de
amostragem foi de 10ms.
Figura 21-Diagrama de blocos do controle de Posio

47
Controlador PI
Como foi feito para o sistema de velocidade, buscou-se uma configurao de controlador que
resultasse em uma resposta com baixo sobressinal e rpido tempo de assentamento. De novo
foi utilizada a ferramenta Tune do bloco PID do Simulink.
Na equao (32) pode ser vista a configurao do controlador utilizado e na figura abaixo a
resposta do sistema e do simulado.
Figura 22-Controle de Posio com controlador PI
0.04
() = 1.5 + (32)

possvel observar que a resposta tem uma leve diferena no transitrio. Um dos motivos
porque sistema possui uma no linearidade chamada zona morta. No linearidades so difceis
de serem simuladas com preciso e com isso podem ocorrer diferenas. Contudo, j uma
aproximao j muito satisfatria para o projeto de controladores.
48
Controlador PID
Apesar do sistema de posio com o controlador PI ter tido uma boa resposta, possvel torna-
la mais rpida aumentando o ganho Kp. Porm, esse aumento de ganho faz surgir um
sobressinal no transitrio da resposta como pode visto na figura 23.
Figura 23-Sistema de Posio com controlador PI
Para contornar isso, ir ser feito agora o uso do controlador PID que utiliza a derivada do erro
possvel na figura 24 como o PID consegue diminuir consideravelmente o sobressinal, porm,
mantendo a resposta rpida obtida com o PI. Foi utilizado um ganho Kd = 0.2 e um coeficiente
de filtro N = 15, mantendo os mesmos valores de Kp e Ki. A sua equao pode ser vista na
equao (33). A entrada do sistema novamente foi um degrau de amplitude 3 V e amostragem
do sinal foi feita com um intervalo de tempo de 10ms.
0.04 15 (33)
() = 5 + + 0.2
15
1+
49
Figura 24-Sistema de posio com controlador PID
Na figura 25, as trs respostas, controlador PI, controlador PI com aumento de Kp e controlador
PID, foram plotadas. possvel ver de forma mais ntida ainda como o aumento de Kp deixa o
sistema mais rpido, porm, tendendo a oscilar. E como a introduo do termo derivativo com
o ganho Kd consegue amortecer a resposta.
Figura 25-Sistema de posio com controladores PI e PID
Outro fator que influencia diretamente na resposta do sistema, o coeficiente do filtro do termo
derivativo do PID. Foram efetuados vrios testes utilizando o mesmo controlador PID, apenas
variando esse coeficiente.
50
Na figura 26 possvel conferir as respostas do sistema obtidas com esses testes. Valores
grandes de N suprimem o efeito do filtro, e tem-se apenas o efeito derivativo. Para valores
pequenos, a filtragem tem mais efeito, porm, um polo lento adicionado em N, reduzindo o
amortecimento produzido pelo zero na origem do controlador.
Figura 26-Efeito do coeficiente do filtro do termo derivativo do PID no controle de posio
Para testar o efeito que a derivada da sada provoca no sinal de controle e na resposta do sistema,
foram utilizados os dois tipos de PID com os mesmos valores de ganhos e coeficiente de filtro
para efetuar o controle de posio. As respostas do sistema de posio esto figura 27 e as
equaes dos controladores podem ser vistas a seguir:
(34)
() 1 10
= 1.3 + + 0.3
() 1 + 10

1 10 (35)
() = 1.3() +
() + 10 0.2()
1+

51
Figura 27- Comparativo entre PID com derivada da sada e derivada do erro.
Nota-se (figura 27), que a derivada do erro provoca um incremento muito grande no sinal de
controle quando ocorre mudana de referncia, o que indesejvel em praticamente todos os
sistemas de controle. Existe tambm um efeito na resposta do sistema, o tempo de assentamento
utilizando o PID com derivada da sada menor do que utilizando a derivada do erro.
52
Influncia do tempo de amostragem
Como foi dito no incio desse captulo, o tempo de amostragem tem um papel crucial no controle
de sistemas. Para evidenciar esse fato, foram feitos testes no sistema de posio utilizando o
mesmo controlador PID da equao (33). As curvas da resposta do sistema para uma entrada
do tipo degrau de 3V com diferentes tempos de amostragem podem ser conferidas na figura 28.
Figura 28-Efeito do tempo de amostragem no controle de posio
Fica bem claro que a utilizao de tempos de amostragem muito altos pode ser prejudicial ao
controle de sistemas. Nota-se que utilizando 40ms de tempo de amostram a resposta do sistema
muito oscilatria. Por isso a importncia de ter-se uma plataforma que alm de prover o
controle em tempo real, tambm permita a amostragem do sinal em tempos de amostragem
pequenos se comparado constante de tempo da planta.
53
5.2.5 Realimentao de estados
Para efetuarmos o controle por realimentao de estados, efetuou-se primeiramente simulaes

no Simulink como foi feito para os controladores clssicos. Escolheu-se valores de Kvel e Kpos
que fizessem com que o sistema tivesse um transitrio satisfatrio.
Logo a seguir pode-se conferir os diagramas de blocos utilizados nas simulaes.
Figura 29-Diagrama de blocos do sistema de controle por realimentao de estados
Com ganhos Kvel e Kpos iguais a 1 e 3 respectivamente, foi obtida um bom transitrio para a
resposta do sistema de posio. As curvas das simulaes e das respostas reais do sistema, como
tambm do sinal de controle, podem ser visualisadas na figura 30.
Figura 30-Resposta do sistema com realimentao de estados

54
5.2.6 Realimentao de estados com integral do erro.
Para eliminar o erro estacionrio necessrio que a malha seja e fechada e o erro entre a
referncia e a sada seja integrado, alm de adicionar-se um ganho. Abaixo pode-se ver como
fica a realimentao de estados com a integral do erro.
Figura 31-Diagrama de blocos do sistema de controle por realimentao de estados com integral do erro
Escolheu-se um valor de K que fizesse com que a resposta do sistema fosse sobreamortecida
como no sistema sem a integral do erro, mas que zerasse o erro estacionrio.
Com um ganho K=6 e mantendo Kvel e Kpos com mesmos ganhos utilizados anteriormente
conseguiu-se alcanar o objetivo. Todas as curvas de resposta podem ser visualizadas na figura
32.
Figura 32-Resposta do Sistema com realimentao de estados com Integral de erro

55
5.3 Entrada Rampa
Com essa plataforma tem-se a flexibilidade de se criar qualquer tipo de entrada desejada para
aplicar ao sistema. Por isso, para efeito de teste, aplicou-se uma entrada do tipo rampa tanto no
sistema de velocidade, como no de posio, e analisou-se os resultados obtidos.
5.3.1 Sistema de velocidade
Controlador P
Como o sistema de velocidade do tipo zero, o erro de estado estacionrio tende ao infinito
com a utilizao de um controlador proporcional apenas. Como pode ser visto na figura 33.
Figura 33-Resposta do sistema de velocidade rampa com controlador proporcional
Fonte: Produo do prprio autor

56
Controlador PI
Com um controlador proporcional-integral eleva-se o sistema para tipo 1, com isso o erro de
estado estacionrio tende a um valor finito, o que pode ser visualizado na figura 34.
Figura 34-Resposta do sistema de velocidade rampa com controlador proporcional-integral

57
5.3.2 Sistema de Posio
Controlador P
O sistema de posio j um sistema de tipo 1, com isso, diferentemente do sistema de posio,
o erro de estado estacionrio possui um valor finito quando utilizado um controlador
proporcional.
Figura 35-Resposta do sistema de posio rampa com controlador proporcional
Controlador PI
Quando utilizado um controlador proporcional-integral, o erro estacionrio zerado, pois o
sistema resultante do tipo 2, ou seja, 2 polos na origem. (Figura 36)
Figura 36-Resposta do sistema de posio rampa com controlador proporcional-integral

58
6 CONCLUSO
Chegando ao final desse projeto, possvel dizer que todos os objetivos almejados foram
conquistados. Foi possvel elaborar uma plataforma de aquisio de dados, monitoramento e
controle em tempo real que permitisse a coleta das amostras em tempos de amostragem
pequenos e que tivesse um sistema de controle de erros para o usurio. Portanto, uma plataforma
mais eficiente do que a utilizada atualmente na disciplina de Laboratrio de Controle.
O controle em tempo real foi possvel graas utilizao do Arduino, com o qual fez-se uso de
temporizadores que permitiram a coleta das amostras em tempos de amostragem definidos, e
tambm devido presena do grande buffer no MATLAB, que garantiu que as amostras
enviadas no seriam perdidas.
A comprovao do correto funcionamento da plataforma foi constatada atravs de testes

executados no Kit Didtico DC Servo-Trainer ED-4440B. Foram feitas experincias muito
parecidas das que so feitas nas aulas da disciplina de Laboratrio de Controle como a
identificao de sistemas e a utilizao de controladores para a manipulao das respostas dos
sistemas de posio e velocidade. Alm disso, novas configuraes dos controladores PID com
derivada da sada e utilizao do filtro passa-baixa no termo derivativo traro ao usurio uma
maior flexibilidade no projeto dos mesmos.
O presente trabalho serviu tambm para pessoalmente entender vrios conceitos de controle e
eletrnica que foram vistas durante o curso de graduao. Foi possvel entender melhor, por
exemplo, como o processo de discretizao de um controlador PID e a implementao dele
em um hardware como o Arduino. E entender tambm como cada termo desse controlador
influencia a resposta de um sistema.
Portanto, a experincia de se elaborar uma plataforma desde a parte do hardware com os

circuitos conversores de sinais, que permitiram a utilizao do Arduino com a planta, at a
programao do cdigo que permitiu a troca de informaes entre MATLAB e Arduino e a
implementao de algoritmos de controle, foi uma experincia muito enriquecedora, o que
mostra como o curso foi bem aproveitado pelo aluno.
59
6.1 Trabalhos Futuros
Alunos de iniciao cientfica ou em fase de concluso de curso podero usar esse trabalho
como base para outros projetos na a rea de controle e automao. Por meio dele ser possvel
implementar algoritmos de controle sem grandes dificuldades, pois foi feita uma documentao
detalhada nesse trabalho, o que permitir que o aluno tire suas dvidas a respeito do
funcionamento da plataforma. Com isso, ela poder ser eventualmente melhorada para o uso da
comunidade universitria, seja da prpria UFES, seja de outras universidades pelo pas.
60
7 BIBLIOGRAFIA
ARDUINO. Compare board specs.

Disponvel: <http://arduino.cc/en/Products.Compare>. Acesso em: 29 jan 2015.
ARDUINO. Arduino Due.

Disponvel: < http://arduino.cc/en/Main/arduinoBoardDue>. Acesso em: 29 jan 2015.
ARDUINO. Float. Diponvel em: <http://arduino.cc/en/Reference/Float>. Acesso em: 29 jan.

2015.
BOSI, L.L. Realimentao de Estados no Servoposicionador com a Placa de

Aquisio NUDAQ PCI 9112. Trabalho de concluso de curso (Graduao em
Engenharia Eltrica). Colegiado do Curso de Engenharia Eltrica, Vitria 2011
CAZELI, A.B. Interface de aquisio de dados para o laboratrio de controle

utilizando Arduino. Trabalho de concluso de curso (Graduao em Engenharia
Eltrica). Colegiado do Curso de Engenharia Eltrica, Vitria 2013.
COOPER, D.J.; PID Control and Derivative on Measurement. Disponvel em:<

http://www.controlguru.com/wp/p76.html>. Acesso em: 05 mar. 2015
IBRAHIM, D. Microcontrooler Based Applied Digital Control. 1. Ed. West Sussex: John
Wiley & Sons Ltd. 2006.
MECATRNICA ATUAL. O que um sistema operacional em tempo real ?

Disponvel em:< http://www.mecatronicaatual.com.br/educacao/1871-o-que-um-sistema-
operacional-de-tempo-real-rtos>. Acesso em: 17 mar.2015.
NATIONAL INSTRUMENTS CORPORATION. USB-6008.

Disponvel em: <http://sine.ni.com/nips/cds/view/p/lang/pt/nid/201986>. Acesso em: 29 jan.
2015.
NEVES, M.R.; SILVA, O.F.; BARREIROS, J.A.L. Metodologia para construo de

prottipos didticos para os cursos de controle e automao de sistemas. In:
CONGRESSO BRASILEIRO DE ENSINO DE ENGENHARIA, 2004, Braslia. Disponvel
em: <http://www.abenge.org.br/CobengeAnteriores/2004/artigos/01_057.pdf>. Acesso em: 28
jan 2015.
NILSON, J.W.; RIEDEL, S.A.; Circuitos Eltricos. 6.ed. Rio de Janeiro: LTC.2003
SIDEL, I. Due Timer. Disponvel em: <https://github.com/ivanseidel>. Acesso em: 29 jan.

2015.
SOFTWARE LIVRE BRASIL. Pgina inicial da Comunidade Opens Source.

Disponvel em: <http://softwarelivre.org/open-source-codigo-aberto> Acesso em: 29 jan.
2015.
TEIXEIRA, H.T. Desenvolvimento de um Ambiente de Controle e Monitoramento
61
em Tempo Real Usando o Matlab e a Placa de Aquisio NUDAQ PCI-9112.

Trabalho de concluso de curso (Graduao em Engenharia Eltrica). Colegiado do
Curso de Engenharia Eltrica, Vitria 2008.
THE MATHWORKS. The Language of Technical Computing.

Disponvel em: <http://www.mathworks.com/products/matlab/features.html#data_analysis>.
Acesso em: 29 jan. 2015.
62
APNDICE A- CDIGO DO MATLAB

%%Plataforma de Aquisio de dados, Monitoramento e Controle
%%%%%%%%%utilizando o Arduino Due e o Matlab.%%%%%%%%%%%%%%%
%%Projeto de Graduao
%%Aluno: Leonardo Lyrio Marconi
%%Orientador:Celso Jos Munaro
%%Ultima edio: Maro/2015;
%%
%%
%Estabelece a comunicao e abre a porta Serial.
%%----------------------------------------------------%%
%%------------Estabelece a comunicao Serial---------%%
%%----------------------------------------------------%%
delete(instrfind({'Port'},{'COM6'}));
portaserial=serial('COM6');
portaserial.BaudRate=115200;
portaserial.InputBufferSize=600000; %100 mil amostras
fopen(portaserial);
pause(2);
%%
%%-----------------------------------------------------%%
%%-------Inicializa os valores de algumas variveis----%%
%------------------------------------------------------%%
vetor=0;vetorAR=0;degrauAR=0;degrau=0;totalvar=0;
P2=1; %0-DAC0 1-DAC1
Ganhos=[0 0 0 0];
Tamdados=4; % Pq 4 ? -> |Ts | Quantidade de amostras |P1 |P2|
TamGanho=4; % Pq 4 ? -> |Kp |Ki|Kd|Nfiltro|
%%
%%----------------------------------------------------%%
%%---------O usurio ir escolher agora :-------------%%
%%----------------------------------------------------%%
entrada=input('Modo: 1-Monitoramento ,2-PRBS 3-Controle \n');

tsIN=input('tempo de amostragem (ms)\n');
NamostrasIN=input('Nmero de amostras \n');
switch(entrada)
case 1
%-----------------------------%
load Degrau5;Input=Degrau5; %-Escolha do usurio
%-----------------------------%
P1=0;
case 2
%-----------------------------%
load PRBS5 ;Input=PRBS5; %-Escolha do usurio
63
%-----------------------------%
P1=0;
case 3
Controle=input('1-PID D(sada), 2-PID D(entrada), 3-Realimentao \n');
switch(Controle)
case 1
%---------------------------%
load Degrau4;Input=Degrau4; %->Escolha do usurio
%----------------------------%
Kp=1;Ki=3;Kd=0.2;Nfiltro=100; %->Escolha do usurio
%----------------------------%
P1=1;Ganhos=[Kp Ki Kd Nfiltro];
case 2
%--------------------------%
load Degrau4;Input=Degrau4; %-> Escolha do usurio
%--------------------------%
Kp=1.3;Ki=1;Kd=0.3;Nfiltro=10; %-> Escolha do usurio
%--------------------------%
Ganhos=[Kp Ki Kd Nfiltro];P1=2;
case 3
%---------------------------%
load Degrau4;Input=Degrau4; %-> Escolha do usurio
%---------------------------%
Kvel=1;Kpos=3;K=0; %-> Escolha do usurio
%----------------------------%
Ganhos=[Kvel Kpos K 0];P1=3;
end
end
%---------------------------------------------------%%
%%----------Vetor de dados que ser enviado----------%
%%---------------------------------------------------%%
u=[tsIN NamostrasIN P1 P2 Ganhos Input];
N=length(u);
Nvet=uint16(N);
Nvet=typecast(Nvet,'uint8');
fprintf(portaserial,'m');
%%
%-----------------------------------------------------------------------%
% ENVIA O TAMANHO DO VETOR DE DADOS PARA O ARDUINO %
%-----------------------------------------------------------------------%
fwrite(portaserial,Nvet,'uint8');
%-----------------------------------------------------------------------%
% RECEBIMENTO DA SINALIZAO AFIRMANDO QUE O %
% ADUINO RECEBEU O TAMANHO DO VETOR DE DADOS %
%-----------------------------------------------------------------------%
a=tic;
64
while(portaserial.BytesAvailable<2)
b=toc(a);
if(b>1)
fprintf('O Arduino no recebeu corretamente o tamanho do vetor de
dados');
return;
end
end;
Tamvet=fread(portaserial,1,'uint16');
if(Tamvet~=N)
fprintf('O Arduino no recebeu corretamente o tamanho do vetor de
dados'); %ERRO3
end
%%
%-------------------------------------------------------------------------%
% ENVIO DO VETOR DE DADOS PARA O ARDUINO %
%-------------------------------------------------------------------------%
for k=1:1:length(u);
vetorIN = u(k);
if(k>Tamdados+TamGanho)
vetorIN = 0.11*vetorIN+1.65; % -15 a 15 0 ~
3.3 V
vetor(k) = round(((4095/3.3)*vetorIN)); % 0 ~ 3.3V 0 ~
4095
%-----------------------------------------------------%
else
vetor(k) = u(k);
end
%Tranforma em valor single float os parmetros do controlador

if((k>Tamdados)&&(k<(Tamdados+1)+TamGanho))
vetorf = single(vetor(k));
vetorFINAL = typecast(vetorf,'uint8');
for G=1:1:length(vetorFINAL)
fwrite(portaserial,vetorFINAL(G));
end
%Os outros valores valores tranforma em inteiros de 16 bits.

else
vetorf = uint16(vetor(k));
vetorFINAL = typecast(vetorf,'uint8');
fwrite(portaserial,vetorFINAL,'uint8')
end
end
%%
%-------------------------------------------------------------------------%
% RECEBIMENTO DO COMANDO ENVIADO PELO ARDUINO QUE TODOS %
% OS DADOS FORAM ENTREGUES %
%-------------------------------------------------------------------------%
a=tic;
while(portaserial.BytesAvailable<1)
65
b=toc(a);
if(b>1)
fprintf('O Arduino no conseguiu receber todos os dados');
fclose(portaserial);
delete(portaserial);
return;
end
end;
Flag2=fread(portaserial,1,'uint8');
if(Flag2==0)
fprintf('O Arduino no conseguiu receber todos os dados \n');
return
end
fprintf(portaserial,'s');
%%
%------------------------------------------------------------------------%%
% AQUISIO DOS DADOS %
%-------------------------------------------------------------------------%
k=1;
for k=1:1:NamostrasIN
a=tic;
while(portaserial.BytesAvailable<6) %Informar a quantidade de dados
chegou.
b=toc(a);
if(b>10)
fprintf('A quantidade de amostras esperadas no chegou');
return;
end
end
v1(k)=fread(portaserial,1,'uint16');
tambuffer2(k)=portaserial.BytesAvailable;
k=k+1;
end
%----------------------------------------------------%
%------------Fecha a comununicao Serial-------- ---%
%-----------------------------------------------------%
%
66
APNDICE- CDIGO NO ARDUINO

#include <DueTimer.h>
%--------------------------------------------------------------------------
----%
volatile uint16_t x,w,z;
double pos,vel;
volatile bool imprime=0;
uint16_t _contmaster=1;
char ch='0';
char Analizador;
String space =" ";
uint16_t v1,v2,v3=0;
uint16_t v1L,v1U,v2L,v2U,v3L,v3U=0;
%void monitoramento;
uint16_t Msig; %Bits Mais signoficativos
uint16_t Lsig; %Bits Menos significativos
uint16_t NvetLs=0;
uint16_t NvetMs=0;
double ts; %tempo de amostragem
uint16_t Namostras; %Nmero de amostras
uint16_t Nvet=0; %Tamanho do vetor de dados;

double VetGanhos[5];
uint16_t vetdados[40000];
uint16_t VetDados[4];
uint16_t P1,P2;
uint16_t Tamdados,TamGanho=0;
uint8_t Flag1;
uint16_t i=0;
%PID e Realimentao
double a0,a1,a2,a3,a4,b0,b1,b2,c0,c1,c2; %Parmetros da funo de

transferncia do PID.
double Kp,Ki,Kd; %Ganhos do controlador.
double Kvel,Kpos; %Ganhos de realimentao de
estados.
double u[3],T; %Sinal de controle e tempo
de amostragem
double A,B,C,D,E,F,G,H;
double SC;
double erro[3];
double y[3];
double saida;
uint16_t N;
double ref,m;
%Geral;
uint16_t h=0;
char lixo;
typedef union {
float floatingPoint;
byte binary[4];
}binaryFloat;
%--------------------------------------------------------------------------
----%
void SerialData(){
67
% Zera a tenso inicial

if(_contmaster==1){
SC=0;
analogWrite(DAC0,2047);
}
x=analogRead(A5);
z=analogRead(A7);
if(_contmaster >=Namostras){
Timer3.stop();
_contmaster=1;
}
if(P1==0){
if(P2==0){
analogWrite(DAC0,vetdados[_contmaster-1]);
}
else if(P2==1){
analogWrite(DAC1,vetdados[_contmaster-1]);
}
}
noInterrupts();
v1=x;v3=z;
if(P1!=0){
PID();
}
w=SC;v2=w;
v1L=(uint8_t)v1;v1U=(uint8_t)(v1>>8);
%Envia os valores amostrados para o Matlab
Serial.write(v1L);Serial.write(v1U);
interrupts();
_contmaster++;
}
%--------------------------------------------------------------------------
----%
void Start(){
Timer3.start(ts);
}
%--------------------------------------------------------------------------
-----%
void Decodifica(){
ts=VetDados[0];
ts=ts*1000;
Namostras=VetDados[1];
T = (ts/1000000);
%*******************************************************************%
%*******************PID-derivada da sida***************************%
%*******************************************************************%
if(P1==1){
68
Kp=VetGanhos[0];
Ki=VetGanhos[1];
Kd=VetGanhos[2];
N=VetGanhos[3];
if((Kd==0)&&(Ki==0)){ %P
a0=Kp;
}
else if((Kd==0)&&(Ki!=0)){ %PI
a0=Kp+Ki*T;
a1=-Kp;
a2=0;
}
else if((Kd!=0)&&(Ki==0)){ %PD
a0=(1+N*T);
a1=1;
b0=Kp+Kp*N*T;
b1=-Kp;
c0=-Kd*N;
c1=Kd*N;
A=a1/a0;B=b0/a0;C=b1/a0;D=c0/a0;E=c1/a0;
}
else{ %PID
b0=(1+N*T)*(Kp+Ki*T);
b1=Kp*(-N*T-2)-Ki*T;
b2=Kp;
a0=(1+N*T);
a1=-(-N*T-2);
a2=-1;
c0=-Kd*N;
c1=2*Kd*N;
c2=-Kd*N;
A=a1/a0;B=a2/a0;C=b0/a0;D=b1/a0;E=b2/a0;F=c0/a0;G=c1/a0;H=c2/a0;
}
}
%**************************************************%
%*****************PID-derivada do erro*************%
%**************************************************%
else if(P1==2){
Kp=VetGanhos[0];
Ki=VetGanhos[1];
Kd=VetGanhos[2];
N=VetGanhos[3];
if((Kd==0)&&(Ki==0)){ %P
a0=Kp;
}
69
else if((Kd==0)&&(Ki!=0)){ %PI

a0=Kp+Ki*T;
a1=-Kp;
a2=0;
}
a0=(N*T+1);
a1=-1;
b0=(Kp+N*T*Kp+Kd*N);
b1=-(Kp+Kd*N);
A=a1/a0;B=b0/a0;C=b1/a0;
}
else{ %PID
a0=(1+N*T);
a1=-(2+N*T);
a2=1;
b0=Kp*(1+N*T)+Ki*T*(1+N*T)+N*Kd;
b1=-(Kp*(2+N*T)+Ki*T+2*N*Kd);
b2=Kp+N*Kd;
A=(a1/a0); B=(a2/a0); C=(b0/a0); D=(b1/a0); E=(b2/a0);
}
}
%*********************************************************%
%****************Realimentao de estados*****************%
%*********************************************************%
else if(P1==3){
Kvel=VetGanhos[0];
Kpos=VetGanhos[1];
Ki=VetGanhos[2];
a0=Ki*T;
}
Start();
}
%--------------------------------------------------------------------------
---%
void VetorDados(){
uint8_t time1,time2,passou,k,j=0;
uint16_t Ls,Ms;
binaryFloat Ganho;
time1=millis();
while(Serial.available()<3){ % 1 byte -> lixo, 2 byte -> primeiro
valor.
time2=millis();
passou=time2-time1;
if(passou>1000){
%**ERRO1**%
%Envia um cdigo de erro ao Matlab informado que
%o tamanho do vetor de dados no foi recebido pelo Arduino
70
% Flag1=0;
% Serial.write(Flag1);
return;
}
}
lixo=Serial.read();
NvetLs=Serial.read();
NvetMs=Serial.read();
Nvet=NvetMs*256+NvetLs;
%Envia um cdigo informando que o tamnho do vetor de dados foi recebido

pelo Arduino
% Flag1=1;
% Serial.write(1);
%Envia o valor do tamanho do vetor de dados para o Matlab para
%ser conferido
Serial.write(NvetLs);
Serial.write(NvetMs);
%Coleta os valores do vetor de dados
%Serial.available()<2 --> Espera dois bytes chegarem,
%isto ,mais um valor de vetor para executar a leitura
%e no ter problema de ler e no ter nada no Buffer.
%*********************************************************************%
%*****************Loop de recebimento do vetor de dados***************%
%*********************************************************************%
for(i=0;i<Nvet;i++){
time1=millis();
while(Serial.available()<2){
time2=millis();
passou=time2-time1;
if(passou>1000){
%Se ocorrer erro na leitura de alguma possio do vetor,isto ,se o nmero
de dados que chegar
%no for o esperado o Matlab ser informado.
%** ERRO2** %
Flag1=0;
Serial.write(Flag1);
return;
}
}
Tamdados=4;
%******************************************************%
if(i>=0&&i<Tamdados){
Ls=Serial.read();
Ms=Serial.read();
VetDados[i]=Ms*256+Ls;
}
P1=VetDados[2];
P2=VetDados[3];
%******************************************************%
TamGanho=4; % Parmetro muito importate- Quantidade de valores do vetor de

ganhos.
%*******************************************************%
if(TamGanho!=0 && i>(Tamdados-1) && i<=(Tamdados-1)+TamGanho){
71
while(Serial.available()<4);
for(j=0;j<4;j++){
Ganho.binary[j] =Serial.read(); %7.4761e-27
}
VetGanhos[i-Tamdados]=Ganho.floatingPoint;
}
%********************************************************%
if(i>((Tamdados-1)+TamGanho)){
Ls =Serial.read();
Ms =Serial.read();
vetdados[i-(Tamdados+TamGanho)]=Ms*256+Ls; %vetdados =
entrada do sistema.
}
}
%*************************************************************************%
%*****************Fim do recebimento das informaes**********************%
%*************************************************************************%
Flag1=1;
Serial.write(Flag1);
}
void PID(){
if(_contmaster==1){
erro[0]=0;erro[1]=0;erro[2]=0;
u[0]=0;u[1]=0;u[2]=0;
y[0]=0;y[1]=0;y[2]=0;
}
erro[0] = erro [1]; % ek-2 = ek-1;
erro[1] = erro [2]; % ek-1 =ek;
erro[2] = vetdados[_contmaster-1] - v1; %Referncia - Sada
%****************************************************************%
%******************PID-derivada da sada*************************%
%****************************************************************%
if(P1==1){
y[0]=y[1];
y[1]=y[2];
saida=mapfloat(v1,0,4095,-15,15);
y[2]=saida;
u[0] = u[1];
u[1] = u[2];
if((Ki==0)&&(Kd==0)){ %P
u[2]=a0*erro[2];
SC=u[2]+2048;
}
else if((Kd!=0)&&(Ki==0)){
%PD
u[2]=A*u[1]+B*erro[2]+C*erro[1]+D*y[2]+E*y[1];
SC=u[2]+2048;
}
else if((Ki!=0)&&(Kd==0)){
%PI
u[2] = u[1] + a0*erro[2] + a1*erro[1];
SC=u[2]+2048;
}
else{
72
u[2] = A*u[1]+B*u[0]+C*erro[2]+D*erro[1]+E*erro[0]+F*y[2]+G*y[1]+H*y[0];
%PID
SC=u[2]+2048;
}
%SC=(int)SC;
if(SC>4095){
SC=4095;
}
if(SC<0){
SC=0;
}
}
%*******************************************************%
%****************PID-derivada do erro*******************%
%*******************************************************%
else if(P1==2){
u[0] = u[1];
u[1] = u[2];
if((Ki==0)&&(Kd==0)){ %P
u[2]=a0*erro[2];
SC=u[2]+2048;
}
else if((Ki!=0)&&(Kd==0)){ %PI
u[2] = u[1] + a0*erro[2] + a1*erro[1];
SC=u[2]+2048;
}
u[2]=-A*u[1]+B*erro[2]+C*erro[1];
SC=u[2]+2048;
}
else{ %PID
u[2] = -A*u[1]-B*u[0]+C*erro[2]+D*erro[1]+E*erro[0];
SC=u[2]+2048;
}
SC=(int)SC;
if(SC>4095){
SC=4095;
}
if(SC<0){
SC=0;
}
}
%************************************************************%
%***************Realimentao de estados********************%
%************************************************************%
else if(P1==3){
u[1] = u[2];
if(Ki!=0){
u[2] = u[1] + a0*erro[2]; %Com Integral do erro.
ref=u[2]+2048;
ref=mapfloat(ref,0,4095,-15,15);
}
else{
ref=vetdados[_contmaster-1]; %Sem Integral do erro.
ref=mapfloat(ref,0,4095,-15,15);
}
pos=x; %116; %0.5 -15/+15
vel=z; %225; %1.3 -15/+15
vel=mapfloat(vel,0,4095,-15,15);
73
pos=mapfloat(pos,0,4095,-15,15);
SC=ref-Kpos*pos-Kvel*vel; %Referncia - Kvel*vel- Kpos*pos.
%SC=SC+2048;
if(SC>15){
SC=15;
}
else if(SC<-15){
SC=-15;
}
SC=mapfloat(SC,-15,15,0,4095);
SC=int(SC);
SC=SC;
}
%***************************************************************%
if(P2==0){
analogWrite(DAC0,SC); % 0 a 4095
}
else if(P2==1){
analogWrite(DAC1,SC); % 0 a 4095
}
}
%********************************************************************%
%*******************Conversor de escalas*****************************%
%***********0~4095 para -15/15V ou -15/15V para 0 a 4095*************%
%********************************************************************%
double mapfloat(double var, double in_min, double in_max, double out_min,

double out_max)
{
m=(out_max-out_min)/(in_max-in_min);
return m*var-m*in_min+out_min;
}
void setup(){
analogReadResolution(12);
analogWriteResolution(12);
Serial.begin(115200);
Timer3.attachInterrupt(SerialData);
}
%--------------------------------------------------------------------------
----%
void loop(){
ch=Serial.read();
switch(ch){
case 'm':
VetorDados();
break;
case 's': %Depois que enviamos todas as informaes,
iniciamos a amostragem.
Decodifica();
break;
deafault:
break;
}
}
74

Plataforma de Aquisição de Dados, Monitoramento e Controle Utilizando Arduindo Due e Matlab

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Plataforma de Aquisição de Dados, Monitoramento e Controle Utilizando Arduindo Due e Matlab

Enviado por

Direitos autorais:

Formatos disponíveis

UNIVERSIDADE FEDERAL DO ESPRITO SANTO

LEONARDO LYRIO MARCONI

PLATAFORMA DE AQUISIO DE DADOS,

PLATAFORMA DE AQUISIO DE DADOS, MONITORAMENTO E

Parte manuscrita do Projeto de Graduao do aluno Leonardo Lyrio Marconi, apresentado

O presente trabalho descreve o desenvolvimento de uma plataforma de aquisio de dados,

Figura 1-Diagrama de blocos de um sistema amostrado ........................................................ 14

Tabela 1-Modelos de posio ................................................................................................. 43

CPU Central Processing Unit (Central de Processamento de Dados)

Na Universidade Federal do Esprito Santo, mais precisamente no Laboratrio de Controle do

A motivao desse projeto a criao de uma plataforma utilizando um hardware de baixo

1.3 Objetivo Geral e Objetivos Especficos

1.3.1 Objetivo Geral

Criar uma plataforma de aquisio de dados, monitoramento e controle em tempo real

1.3.2 Objetivos Especficos

Realizar a amostragem dos sinais das variveis de interesse em um tempo inferior

Realizar o controle em tempo real.

1.4 Estrutura do Trabalho

O captulo 1 apresenta a contextualizao deste trabalho e, alm de expor a motivao que

2.1 Sistemas de Controle

2.2 Sistemas de Controle Digital

Figura 1-Diagrama de blocos de um sistema amostrado

Fonte: Produo do prprio autor.

2.3 Controlador PID

Termo Derivativo: O termo derivativo serve para amortecer a resposta do sistema

Figura 2-Controlador PID

Fonte: IBRAHIM, (2006, p.231)

2.4 Controle por realimentao de estados

Outra estrutura de controle usual a realimentao de estados. Nela, ao invs de se realimentar

No sistema representativo do servoposicionador do kit didtico tem-se duas variveis de

Figura 3-Fluxograma da realimentao de estados

Fonte: Produo do prprio autor.

Figura 4-Fluxograma de realimentao de estados com integral do erro.

Fonte: Produo do prprio autor.

A funo de transferncia do sistema com a realimentao de estados e com a integral do erro

1 : Igual ao ganho da funo de transferncia do sistema de velocidade dividido pela

Existem vrios modelos de Arduino no mercado. A escolha depende das necessidades

As caractersticas mais importantes da placa Arduino Due so: (ARDUINO, 2015b)

Micro controlador AT91SAM3X8E

Tenso de entrada (recomendada) 7-12V

3.2 Circuitos Conversores de Sinais

3.2.2 Conversor de -15/+15V para 0/3.3 V

Figura 5- Circuito conversor de tenso da planta para o Arduino

Fonte: Produo do prprio autor.

O primeiro amplificador foi utilizando na configurao somador inversor, o qual possui a

Fonte: NILSON E RIEDEL(2003).

Substituindo os valores dos componentes da figura 5 na equao (5), o primeiro amplificador

T1 e T2 so potencimetros de preciso que so ajustados para obter a relao deseja. Na

01 = (1.65 + 0.11 ) (8)

Fonte: NILSON e RIEDEL (2003)

3.2.3 Conversor de 0.52/2.72 V para -15/+15V

Figura 8-Circuito conversor de tenso da planta para o Arduino

Fonte: Produo do prprio autor.

Nesse circuito foi utilizada a mesma quantidade de componentes. Os dois amplificadores

A sada do amplificador somador inversor dada pela equao (14).

E a sada do amplificador inversor dada pela equao (15).

T3 e T4 so potencimetros de preciso que so ajustados para obter a relao desejada. Na

Figura 9-Confeco do sistema de converso de sinais.

Fonte: Produo do prprio autor.

3.2.4 Ligao com o Arduino

Figura 10-Visal geral da plataforma de aquisio de dados, monitoramento e controle

Fonte: Produo do prprio autor.