Professional Documents
Culture Documents
UNIDADE EM GUABA
CURSO DE ENGENHARIA DE SISTEMAS DIGITAIS
GUABA
2012
GUABA
2012
AGRADECIMENTOS
Professora Dra. Letcia Vieira Guimares, minha orientadora, por todo o apoio,
pacincia e dedicao.
A minha amada filha, Yumi, pelo simples fato de existir e ser a razo da minha vida.
A minha esposa, Caroline, pelos puxes de orelha nos meus momentos de preguia,
por me motivar sempre e ainda por me ajudar na soldagem dos acelermetros nas
placas.
Aos colegas de curso, de trabalho e amigos, pelo apoio e sugestes dadas.
Ao ex-colega de curso, colega de trabalho e, acima de tudo, amigo, Leonardo
Bordignon Ceolin, com sua imprescindvel colaborao no projeto e manufatura das
PCBs dos acelermetros.
Aos meus pais, Jorge e Nara, um agradecimento especial, por todas as noites de
sono perdidas, dores de cabea que lhes causei e por terem dedicado grande parte
de suas vidas ao objetivo de me dar uma vida melhor do que a que puderam ter.
RESUMO
microcontrolada
responsvel
por
realizar
condicionamento
ABSTRACT
LISTA DE ILUSTRAES
Figura 1 - Sistema massa-mola..................................................................................17
Figura 2 - Estrutura bsica de um acelermetro.........................................................19
Figura 3 - Estrutura bsica de um acelermetro com a posio da massa e do
encapsulamento..........................................................................................................19
Figura 4 - Estrutura interna de um acelermetro capacitivo.......................................21
Figura 5 - Configurao comb-drive de um micro-acelermetro capacitivo...............22
Figura 6 - Material piezoeltrico antes (a) e durante (b) a aplicao de presso, a
qual gera uma tenso eltrica.....................................................................................23
Figura 7 - Diagrama de blocos de um microcontrolador.............................................24
Figura 8 - Estrutura interna da CPU............................................................................25
Figura 9 - Esquema bsico de uma memria de 16 posies....................................26
Figura 10 - Ossos da mo humana.............................................................................34
Figura 11 - Dedos da mo esquerda...........................................................................35
Figura 12 - Movimento de flexo e extenso do dedo indicador da mo direita........36
Figura 13 - Movimentos de aduo e abduo do dedo indicador da mo direita.....37
Figura 14 - Movimentos de pronao e supinao da mo direita.............................37
Figura 15 - Diagrama de blocos simplificado do projeto.............................................38
Figura 16 - Disposio dos acelermetros na luva (mo direita)...............................39
Figura 17 Vista superior e inferior do acelermetro MMA7260...............................42
Figura 18 - Pinagem do MMA7260 (viso do topo)...................................................43
Figura 19 - Sentido da acelerao em cada um dos eixos........................................44
Figura 20 - Acelerao esttica nos eixos do acelermetro MMA7260 em
posicionamentos diferentes.........................................................................................45
Figura 21 - Diagrama de conexes do acelermetro MMA7260QT...........................46
Figura 22 - PCB para o acelermetro MMA7260, vista superior (esquerda) e inferior
(direita).........................................................................................................................47
Figura 23: Arduino Uno...............................................................................................48
Figura 24 - Ambiente de Desenvolvimento Arduino....................................................49
Figura 25 - Pinagem do multiplexador CD4051B.......................................................50
Figura 26 - Setup para teste do acelermetro............................................................51
Figura 27 - Sinal observado no osciloscpio ao causar movimento em um dos eixos
do acelermetro...........................................................................................................52
LISTA DE TABELAS
Tabela 1 - Sinal digital com resoluo de 2 bits, correspondente a um sinal analgico
de 0 5 volts...............................................................................................................31
Tabela 2 - Resoluo por bit e valor mximo para uma faixa dinmica de 5V em
conversores de 8, 10 e 16 bits....................................................................................31
Tabela 3 - Descrio dos pinos do acelermetro MMA7260......................................42
Tabela 4 - Descrio dos pinos g-Select.....................................................................43
A/D Analgico/Digital
API Application Programming Interface
CI Circuito Integrado
CPU Central Processing Unit
EPROM Erasable Programmable Read Only Memory
EEPROM Eletrically Erasable Programmable Read Only Memory
GND Ground
I/O Input/Output
PCB Printed Circuit Board
PVDF Polyvinylidene Fluoride
PWM Pulse-Width Modulation
QFN Quad-Flat no-Leads
RAM Random Access Memory
ROM Read Only Memory
RS-232 Recommended Standard 232
SI Sistema Internacional de Unidades
UC Unidade de Controle
UCP Unidade Central de Processamento
ULA Unidade Lgica e Aritmtica
USB Universal Serial Bus
SUMRIO
1
INTRODUO...............................................................................................14
REFERENCIAL TERICO............................................................................16
2.1
ACELERAO...............................................................................................16
2.2
ACELERMETROS.......................................................................................16
2.2.1
Princpio de Funcionamento.......................................................................17
2.2.2
Estrutura de um Acelermetro....................................................................18
2.2.3
2.2.4
Tipos de Acelermetros...............................................................................21
MICROCONTROLADORES..........................................................................24
3.1
3.2
MEMRIA......................................................................................................25
3.2.1
3.2.2
3.2.3
3.2.4
Flash..............................................................................................................28
3.2.5
3.3
3.4
COMUNICAO SERIAL..............................................................................29
3.5
3.5.1
Faixa Dinmica.............................................................................................30
3.5.2
Resoluo.....................................................................................................30
3.5.3
Tempo de Converso...................................................................................32
3.5.4
Erro de Linearidade......................................................................................32
3.6
CLOCK...........................................................................................................33
3.7
TEMPORIZADOR...........................................................................................33
ANATOMIA DA MO.....................................................................................34
4.1
DEDOS...........................................................................................................35
4.2
MOVIMENTOS ARTICULARES.....................................................................35
4.2.1
4.2.2
Abduo........................................................................................................36
4.2.3
Aduo...........................................................................................................37
4.2.4
Pronao e Supinao.................................................................................37
DEFINIO DO PROJETO...........................................................................38
5.1
ESPECIFICAES INICIAIS.........................................................................38
5.2
METODOLOGIA.............................................................................................40
5.3
SELEO DE COMPONENTES...................................................................41
5.3.1
Acelermetro MMA7260...............................................................................41
5.3.2
Arduino..........................................................................................................47
Multiplexador CD4051B...............................................................................50
IMPLEMENTAO DO PROJETO...............................................................51
RESULTADOS OBTIDOS..............................................................................65
IMPLEMENTAES FUTURAS...................................................................68
CONCLUSO................................................................................................69
REFERNCIAS................................................................................................70
APNDICE A PROGRAMA TESTESERIAL.INO.............................................74
APNDICE B PROGRAMA TESTESERIAL2.INO...........................................75
APNDICE C PROGRAMA TESTESERIAL3.INO...........................................76
APNDICE D PROGRAMA TESTEACEL.INO................................................78
APNDICE E PROGRAMA TESTEACELANGULOS.INO...............................80
APNDICE F PROGRAMA ACELEROMETRO.INO.......................................82
APNDICE G CLASSE COMMUNICATOR.JAVA...........................................85
APNDICE H CLASSE HANDCUBE.JAVA.....................................................90
14
1
INTRODUO
15
O presente trabalho visa o emprego de acelermetros no desenvolvimento de
um perifrico de entrada em forma de luva, capaz de captar movimentos simples
feitos pela mo humana. Os sensores sero conectados uma interface
responsvel por tratar os sinais captados pelos sensores e envi-los a uma porta
serial do computador. No ser um objetivo deste trabalho definir uma aplicao
especfica para o dispositivo, pois a ideia desenvolver um perifrico que possa ser
usado nas mais diversas aplicaes possveis, seja em entretenimento, controle
remoto ou at mesmo em fisioterapia.
16
2
2.1
REFERENCIAL TERICO
ACELERAO
2.2
ACELERMETROS
17
2.2.1 Princpio de Funcionamento
(1)
18
a=
k
x
m
(2)
19
d 2 xm
dt
d ( x m x f )
+k ( x m x f )= F E ,
dt
(3)
20
A equao (3) pode ser simplificada, subtraindo d2xf /dt2 de ambos os lados:
d 2( xm x f )
dt 2
d ( x mx f )
d2 x f
+k ( x m x f )=m
+F E
dt
dt 2
(4)
d2x
dx
+ +kx= F ,
2
dt
dt
(5)
F =m
d2 xf
dt 2
F E =m x f F E
(6)
x=
x f
F /m
= 2
H ( s) x f
2
s + s0 / Q+0 s + s0 /Q+02
2
(7)
H ( s)
x
1
= 2
x f s +s 0 /Q+20
(8)
21
2.2.4 Tipos de Acelermetros
22
As placas ou eletrodos encontram-se em uma disposio conhecida como
comb-drive, pelo fato de assemelharem-se aos dentes de dois pentes intercalados
(figura 5).
23
2.2.4.3 Acelermetro Piezoeltrico
Figura 6 - Material piezoeltrico antes (a) e durante (b) a aplicao de presso, a qual gera uma
tenso eltrica.
Fonte: CALLISTER, 2002.
24
3
MICROCONTROLADORES
3.1
25
microcontrolador;
3.2
MEMRIA
26
Cada posio de memria possui um endereo nico, possibilitando sua
localizao. Dessa forma, toda vez que se deseja realizar uma operao sobre a
memria necessrio informar qual operao ser realizada (leitura ou escrita), em
qual endereo e, no caso da escrita, qual dado ser armazenado. Caso a operao
seja de leitura, o dado lido dever ser armazenado em algum local, como um
registrador do microcontrolador, para ser usado posteriormente. A figura 9 ilustra o
esquemtico simplificado de uma memria com 16 posies, com endereos de 0
15. Esto ilustradas na figura as linhas de dados, de endereo e de controle de
seleo da operao: leitura (read) ou escrita (write).
27
ser mantida somente enquanto o programa est em execuo. A seguir ser dada
uma descrio sobre cada um destes tipos de memria.
As memrias deste tipo permitem apenas a leitura dos dados, como o seu
prprio nome indica (Read Only Memory, ou seja, Memria Somente Leitura). Esta
memria possui seus dados gravados pelo fabricante e possui a vantagem de ter
baixo custo em relao s outras. Geralmente utilizada na fabricao em massa
de produtos finais, onde no necessria a alterao de cdigo.
Apesar das suas vantagens, as memrias ROM vem sendo amplamente
substitudas por memrias FLASH, por estas permitirem a modificao dos dados
mesmo em um produto final. Desta forma o fabricante pode disponibilizar correes
e atualizaes de firmware para o seu produto, podendo at mesmo incluir novas
funcionalidades.
28
um nmero limitado de vezes, sendo que este nmero varia entre cem mil e um
milho de vezes. Esta limitao se deve a deteriorao do chip de memria durante
o processo de apagamento os dados, o qual necessita de uma tenso eltrica mais
elevada.
3.2.4 Flash
A memria RAM caracterizada por ser uma memria voltil os dados nela
armazenados so perdidos quando no h alimentao eltrica nos seus circuitos.
Esta memria utilizada no microcontrolador para armazenar dados ao longo da
execuo do programa, tais como constantes e variveis.
3.3
29
receber e enviar dados para dispositivos externos. Um microcontrolador geralmente
possui vrias entradas e sadas, as quais correspondem a pinos do CI. Estes pinos
so agrupados em portas, geralmente em agrupamentos de 8 bits, podendo variar
de acordo com as caractersticas do microcontrolador.
Cada pino de uma porta pode ter seu fluxo de dados definido como de
entrada ou de sada. Pinos de entrada permitem a leitura de dados de sensores e
outros dispositivos externos ao microcontrolador, enquanto que pinos de sada
permitem o envio (escrita) de dados para atuadores e outros dispositivos.
As portas de entrada e sada podem ser digitais ou analgicas.
3.4
COMUNICAO SERIAL
3.5
30
oriundos de sensores que geram apenas sadas analgicas.
importante observar que um sinal digital apenas uma representao de
um sinal analgico. O sinal analgico contnuo no tempo, enquanto que o sinal
digital discreto. Se um sinal de tenso analgica varia de 0 a 5 volts, por exemplo,
esse sinal poder assumir infinitos valores dentro deste intervalo. J um sinal digital
equivalente poder apenas assumir alguns valores dentro deste intervalo. Isso
significa que sempre haver erro ou distores na converso de um sinal analgico
para digital.
As caractersticas de um conversor A/D que devem ser levadas em conta so
a faixa dinmica, a resoluo, o tempo de converso e o erro de linearidade.
3.5.2 Resoluo
31
mximo de tenso (5V) no pode ser representado. O valor mximo que se pode
representar, neste caso, dado por 1,25x(2-1)=3,75V. Sendo assim, as frmulas
para determinar resoluo de tenso por bit (Vres) para uma dada resoluo e o valor
mximo (Vmax) so, respectivamente:
V res =
V ent
2n
(9)
V max =V res(2 1) ,
(10)
Tabela 1 - Sinal digital com resoluo de 2 bits, correspondente a um sinal analgico de 0 5 volts.
bits
Tenso (V)
00
0,00
01
1,25
10
2,50
11
3,75
Tabela 2 - Resoluo por bit e valor mximo para uma faixa dinmica de 5V em conversores de 8, 10
e 16 bits.
Resoluo (bits)
Resoluo por bit (mV)
Valor Mximo (V)
19,531
4,980469
10
4,883
4,995117
16
0,076
4,999924
32
Conforme pode-se observar na tabela 2, quanto maior a resoluo do
conversor A/D, menor ser o degrau entre os valores representveis e mais prximo
estar o valor mximo representvel digitalmente do valor mximo do sinal
analgico. Dessa forma conclui-se que quanto maior a resoluo do conversor, mais
prximo o sinal digital estar do sinal analgico.
So encontrados na prtica conversores com resolues de 8 a 20 bits
(BONFIM, 2002).
33
3.6
CLOCK
3.7
TEMPORIZADOR
34
4
ANATOMIA DA MO
35
4.1
DEDOS
4.2
MOVIMENTOS ARTICULARES
Os
tipos
de
movimentos
possveis
so:
flexo,
extenso,
36
4.2.1 Flexo, Extenso e Hiperextenso
4.2.2 Abduo
37
4.2.3 Aduo
38
5
5.1
DEFINIO DO PROJETO
ESPECIFICAES INICIAIS
Quantidade de acelermetros;
39
um destes, enquanto que o sensor restante ficar posicionado sobre a mo. A figura
16 ilustra a disposio dos sensores sobre a luva.
At o presente momento, o autor considera que esta a melhor configurao
para os sensores. Os acelermetros posicionados nas falanges distais, ou seja, nas
extremidades dos dedos, tm por objetivo detectar os movimentos de flexo e
extenso dos mesmos (dobrar e esticar, respectivamente). J o acelermetro
posicionado no centro da mo visa captar os movimentos de flexo, extenso e
hiperextenso do punho, bem como os movimentos de pronao e supinao da
mo. Apenas com os testes ao longo do desenvolvimento prtico do projeto poderse- determinar se essa configurao realmente a mais adequada.
Quanto aos graus de liberdade do acelermetro, considera-se que os
acelermetros utilizados em cada dedo devero realizar medidas em 2 eixos
enquanto que o sensor posicionado sobre a mo necessitar de 3 eixos. Isso se
deve aos movimentos que se deseja detectar. No caso dos dedos, deseja-se
detectar apenas os movimentos de flexo e extenso, ignorando os movimentos de
aduo e abduo. Dessa forma o movimento a ser detectado ocorrer apenas em
dois eixos. Para o movimento da mo, sero detectados flexo, extenso,
hiperextenso, pronao e supinao. Sero ignorados os movimentos de desvio
ulnar e radial. Essa escolha foi tomada com a finalidade de reduzir o nvel de
complexidade do projeto.
40
Em relao ao microcontrolador a ser utilizado, desejvel que este possua
algumas caractersticas, a saber:
5.2
METODOLOGIA
Etapa
2: estudo
da
comunicao
entre
os acelermetros e
Realizao
de
testes
de
aquisio
de
dados
dos
41
computador (a princpio RS-232 ou USB).
5.3
SELEO DE COMPONENTES
42
N Pino
g-Select1
g-Select2
Vdd
Entrada de alimentao.
Vss
Entrada de terra.
12
Sleep Mode
13
Zout
14
Yout
15
Xout
Sada de tenso do eixo X.
Fonte: Traduo livre do autor da tabela 4 do Data sheet do Acelermetro.
43
g-Select2
Sensibilidade
1.5g
800mV/g
2g
600mV/g
4g
300mV/g
1
6g
Fonte: MMA7260QT Data sheet Rev 5.
200mV/g
44
Os pinos Zout, Yout e Xout exibem uma sada de tenso proporcional a
acelerao sofrida nos eixos Z, Y e X do acelermetro, respectivamente. Observa-se
na figura 19 os sentidos positivo e negativo em cada um dos eixos do acelermetro.
Isso significa que se o acelermetro for movimentado no sentido positivo do eixo x,
por exemplo, o valor de acelerao medido no acelermetro positivo, enquanto
que no sentido negativo, o valor ser, portanto, negativo.
Quando em repouso, o acelermetro sofre apenas a ao da acelerao da
gravidade. Os eixos do acelermetro MMA7260, quando em gravidade zero - ou
seja, formando um ngulo de 90 graus com a acelerao da gravidade -, exibem em
seus pinos de sada uma tenso de 1,65V, o que representa a metade do valor
mximo de tenso de sada nos eixos (3,3/2V). Quando sob ao direta da
gravidade, ou seja, quando encontram-se em paralelo com a acelerao da
gravidade, os eixos exibem uma tenso de 2,45V quando com o mesmo sentido, e
uma tenso de 0,85V quando com sentido contrrio gravidade, como pode-se
observar na figura 20.
45
sobre os eixos do acelermetro quando este rotacionado (movimento de rotao),
de forma que o acelermetro pode ser utilizado como um inclinmetro.
46
aproveitada, fez-se necessrio projetar uma. No prprio data sheet do acelermetro
encontra-se um diagrama de conexo para o mesmo, que pode ser utilizado como
guia para a criao da placa. Este diagrama est ilustrado na figura 21.
Com base nesse diagrama, foi projetada uma PCB para abrigar o
acelermetro. O projeto da placa no ser abordado no trabalho, pois no foi
realizado pelo autor. A placa j pronta pode ser observada na figura 22.
Com a placa pronta, foi necessrio soldar os componentes SMD (capacitores
e resistores) e o acelermetro. A placa foi projetada de forma que os componentes
ficaro embaixo do acelermetro. Isso foi feito com o intuito de deixar a PCB com o
menor tamanho possvel, uma vez que a placa dever ser posicionada sobre o dedo.
Devido ao tamanho da placa e ao fato de sua fabricao ser caseira,
possuindo apenas uma camada, fez-se necessrio a utilizao de jump wires na
placa.
O pino de Sleep Mode foi soldado diretamente ao Vcc, de forma que nunca
ser habilitado este modo;
47
Figura 22 - PCB para o acelermetro MMA7260, vista superior (esquerda) e inferior (direita).
5.3.2 Arduino
baseada
no
framework
open-source
Wiring,
no
ambiente
de
48
sero descritas a seguir.
6 entradas analgicas;
49
5.3.2.2 Ambiente de Desenvolvimento Arduino
50
A escolha do Arduino Uno deu-se devido ao seu baixo custo e simplicidade,
porm essa escolha acarretou uma modificao no projeto: o nmero de canais
menor que o numero de sinais de entrada dos eixos dos acelermetros. No entanto,
este problema pode ser resolvido com a utilizao de um multiplexador para
selecionar as sadas dos acelermetros que sero lidas.
51
6
IMPLEMENTAO DO PROJETO
52
Aps
teste,
assumindo
que
acelermetro
estava
funcionando
53
Figura 29 - Conexo do acelermetro com o Arduino (fios de GND e VDD ainda no soldados).
V res =
5
=0,0048828125 .
210
54
Multiplicando esse valor pela mdia dos valores encontrados nos pinos do
acelermetro temos para os eixos x e y
V x e y=
335+331+336+334+337
0,0048828125=1,6337890625 ,
5
e para o eixo z
V z=
492+498+503+496+500
0,0048828125=2,4306640625 .
5
55
Figura 30 - Dados recebidos do Arduino pelo programa Terminal, com o acelermetro em repouso.
56
Figura 31 - Dados recebidos do Arduino pelo programa Terminal, com o acelermetro sendo
movimentado e com o valor lido convertido em tenso.
57
Figura 32 - Grfico gerado pelo cdigo Processing relativo a tenso observada nas sadas dos
acelermetros.
acelermetros j fixado.
58
respectivamente. As sadas dos eixos x dos acelermetros dos dedos anelar e
mnimo foram conectadas ao multiplexador CD4051B, nos pinos 1 e 2 do mesmo,
sendo que a sada do multiplexador foi conectada ao pino analgico 0 do Arduino. A
varivel que representa o eixo x do acelermetro do polegar foi chamada de x1,
enquanto que a do indicador foi chamada de x2, e assim por diante, em referncia a
numerao utilizada na anatomia (polegar o dedo 1, indicador o 2, mdio o 3
etc.). Em seguida executou-se o cdigo e, com o auxlio do software Terminal,
verificou-se os dados recebidos da serial, com a finalidade de verificar se os dados
exibidos pelos demais acelermetros eram semelhantes ao do primeiro acelermetro
utilizado. O teste mostrou que os demais acelermetros mostravam os mesmos
valores nas mesmas condies impostas (repouso, movimento, acelerao sobre
um determinado eixo no sentido positivo/negativo etc).
Apesar de todos os testes realizados indicarem o funcionamento correto dos
acelermetros consoante as informaes disponveis no data sheet, os valores lidos
esto na forma de tenso, enquanto que deseja-se obter a acelerao nos eixos.
Portanto, necessrio realizar a converso desse valor para acelerao. O valor da
acelerao em g pode ser obtido dividindo-se o valor de tenso lido pela
sensibilidade do acelermetro (que no configurao de 1,5g de 800mV/g).
importante lembrar que os valores de tenso lidos do acelermetro so sempre
positivos, portanto necessrio subtrair destes o valor tenso lido em zero g, a fim
de se obter os valores positivos e negativos da acelerao. A frmula resultante
observada na equao 11.
g=
V OUT V OFFSET
S 1,5g
(11)
Onde:
g a acelerao observada em um eixo do acelermetro, medida em
unidades g;
VOUT a tenso de sada de um eixo do acelermetro, medida em volts (V);
VOFFSET a tenso de sada a zero g, medida em volts (V);
59
S1,5g a sensibilidade do acelermetro na configurao para 1,5g (medida em
mV/g).
O cdigo do Arduino foi ento modificado para realizar a converso da tenso
em acelerao, conforme a equao 11, podendo ser observado no apndice D. No
programa, a tenso VOFFSET obtida atravs de uma funo que calcula uma mdia
entre 50 amostras, sendo o clculo feito individualmente para cada eixo de cada
acelermetro. A leitura dos valores de acelerao pelo programa Terminal para os
acelermetros pode ser observada na figura 34.
60
61
posicionado sobre a mo, excluindo-se o eixo z, utilizando o eixo x para captar os
movimentos de flexo e extenso e o eixo y para os movimentos de pronao e
supinao. Para obter-se o angulo de inclinao de um eixo do acelermetro em
funo da acelerao da gravidade, calcula-se o arco seno sobre o valor de
acelerao experimentado no eixo [12]:
=arcsin (
V OUT V OFFSET
)
S 1,5
(12)
62
tridimensional da mo.
Para a modelagem da mo foi utilizado o software de modelagem Blender, o
qual foi escolhido por ser open source e gratuito. Usando o Blender e, com o auxlio
de tutoriais em vdeo na internet ([29], [30] e [31]), foi criado o modelo de uma mo,
o qual est ilustrado na figura 38. Aps a criao do modelo necessrio que o
mesmo seja exportado para o formato utilizado pelo jMonkey. Vrias tentativas de
exportar o modelo foram realizadas, mas no se obteve sucesso, pois o modelo no
era corretamente exportado, faltando sempre o esqueleto necessrio para fazer a
movimentao. As falhas talvez possam ser relacionadas a falta de familiaridade
com este tipo de software, porm optou-se por uma soluo mais simples: utilizar
um dos modelos tridimensionais j existentes no jMonkey.
63
para o programa desenvolvido no jMonkey, ser necessrio estabelecer uma
comunicao serial com o Arduino atravs da linguagem Java. Portanto o software
deve ser dividido em pelo menos duas camadas: a camada grfica, a qual ser
responsvel por exibir o objeto tridimensional neste caso um cubo e traduzir os
valores recebidos em movimentos do mesmo; a camada de comunicao,
responsvel por estabelecer uma comunicao atravs da porta serial a qual o
Arduino est conectado, lendo os dados enviados por este e enviando-os para a
camada grfica. Para satisfazer esse requisito, foram criadas duas classes Java: a
classe HandCube, que utiliza a API do jMonkey para exibir um cubo tridimensional
na tela, e a classe Communicator, que utiliza a API RXTX para comunicao serial.
O diagrama de classes da aplicao pode ser observado na figura 39.
64
O cdigo do Arduino foi mais uma vez modificado, para permitir a
comunicao com o programa desktop. Algumas das mudanas realizadas foram a
diminuio do delay entre os ciclos de leitura dos dados dos dados dos
acelermetros, alm de remover os textos que eram enviados juntos com estes
dados para fins de debug. O cdigo resultante encontra-se no apndice F. As
classes da implementao do programa grfico que executar no desktop,
Communicator e HandCube, encontram-se no apndice G e H, respectivamente.
65
7
RESULTADOS OBTIDOS
66
Movimento de flexo do dedo 1 (polegar) faz com que o cubo vermelho gire
para cima, enquanto que a extenso deste mesmo dedo faz com que este
cubo gire para baixo.
Movimento de flexo do dedo 2 (indicador) faz com que o cubo verde gire
para cima, enquanto que a extenso deste mesmo dedo faz com que este
cubo gire para baixo.
Movimento de flexo do dedo 3 (mdio) faz com que o cubo azul gire para
cima, enquanto que a extenso deste mesmo dedo faz com que este cubo
gire para baixo.
Movimento de flexo do dedo 4 (anelar) faz com que o cubo amarelo gire
para cima, enquanto que a extenso deste mesmo dedo faz com que este
cubo gire para baixo.
Movimento de flexo do dedo 5 (mnimo) faz com que o cubo rosa gire para
cima, enquanto que a extenso deste mesmo dedo faz com que este cubo
gire para baixo.
Movimento de flexo da mo faz com que o cubo branco gire para cima,
enquanto que a extenso faz com que este cubo gire para baixo.
67
horrio.
Na figura 42, pode-se observar o programa HandCube em execuo, com os
cubos em movimentao.
68
8
IMPLEMENTAES FUTURAS
Projetar uma PCB mais elaborada, que permita que o acelermetro seja
soldado diretamente na mesma, sem adaptaes, afim de reduzir erros.
69
9
CONCLUSO
70
REFERNCIAS
71
[10] CARNEIRO, Felipe Marcus. Levantamento Bibliogrfico das Tecnologias
dos Acelermetros Comerciais. 19f. Trabalho de Graduao (Graduao em
Engenharia Mecnica) - Departamento de Mecnica Computacional, Faculdade de
Engenharia Mecncia, Universidade Estadual de Campinas, Campinas.
[11] CESAR FILHO, Bento Alves Cerqueira. Microcontrolador Bsico. Disponvel
em: <http://pt.scribd.com/doc/8339182/Microcontrolador-Basico>.
Acesso em: 26 jun. 2011.
[12] CLIFFORD, Michelle; GOMEZ, Leticia. Measuring Tilt with Low-g
Accelerometers.
Disponvel em: <http://www.freescale.com/files/sensors/doc/app_note/AN3107.pdf>.
Acesso em: 9 jun. 2011.
[13] DUC, Tan Tran. Modeling and Simulation of the Capacitive Accelerometer:
Diploma Thesis. Nordestedt, Alemanha: GRIN Verlag, 2005.
[14] FIGUEIREDO, Lgia J. et al. Aplicaes de Acelermetros. 2007. 13f.
Monografia (Instrumentao e Aquisio de Sinais) Lisboa, Portugal, 2007.
FRADEN, Jacob. Handbook of Modern Sensors: Physics, Designs, and
Applications. 4. ed. Nova Iorque: Springer, 2004.
[15] HALLIDAY, David; RESNICK, Robert; WALKER, Jearl. Fundamentals of
Physics. 8. ed. LTC, 2009
[16] KAAJAKARI, Ville. Practical MEMS: Analysis and design of microsystems.
Small Gear Publishing, 2009.
[17] Freescale Inc. MMA7260QFS Rev 0. Disponvel em:
<http://www.freescale.com/files/sensors/doc/fact_sheet/MMA7260QFS.pdf >. Acesso
em: 3 abr. 2011.
[18] Freescale Inc. MMA7260QT Data Sheet Rev 5. Disponvel em:
<http://www.freescale.com/files/sensors/doc/data_sheet/MMA7260QT.pdf>. Acesso
72
em: 26 abr. 2011.
[19] GRANDI, C. et al. Orientaes para elaborao e apresentao de trabalhos e
relatrios acadmicos. Porto Alegre: UERGS, 2010. 96 p.
73
[29] THOMAZINI, Daniel; ALBUQUERQUE, Pedro Urbano Braga de. Sensores
Industriais: Fundamentos e Aplicaes. 7. ed. So Paulo: rica, 2010.
[30] Tutorial Blender 2.59 - Mo Parte 1. Disponvel em:
<http://www.youtube.com/watch?v=NfjNg_fZ73o>. Acesso em: 27 mai. 2012.
[31] Tutorial Blender 2.59 - Mo Parte 2. Disponvel em:
<http://www.youtube.com/watch?v=c4DNMffXW3M>. Acesso em: 27 mai. 2012.
[32] Tutorial Blender 2.59 - Bone Mo Parte 3. Disponvel em:
<http://www.youtube.com/watch?v=pUQxknts0rw>. Acesso em: 27 mai. 2012.
74
APNDICE A PROGRAMA TESTESERIAL.INO
/* TesteSerial
* Teste de leitura de eixos do acelerometro.
*
*/
// Pinos analogicos conectados aos eixos do acelerometro
int x = A5;
int y = A4;
int z = A3;
void setup() {
Serial.begin(9600); // Seta o baud rate da comunicacao serial
}
void loop() {
// Leitura dos
float xValue =
float yValue =
float zValue =
75
APNDICE B PROGRAMA TESTESERIAL2.INO
/* TesteSerial2
* Teste de leitura de eixos do acelerometro,
* convertendo os dados lidos para tensao em volts.
*/
// Pinos analgicos conectados aos eixos do acelermetro
int x = A5;
int y = A4;
int z = A3;
// Resolucao do conversor
const double vRes = 5.0 / 1024.0;
void setup() {
Serial.begin(9600); // Seta o baud rate da comunicao serial
}
void loop() {
// leitura dos valores dos pinos analgicos
double xValue = analogRead(x);
double yValue = analogRead(y);
double zValue = analogRead(z);
// Obtm o valor em Volts do sinal lido
double xVoltage = xValue * vRes;
double yVoltage = yValue * vRes;
double zVoltage = zValue * vRes;
// Escreve os dados na serial
Serial.print("x = ");
Serial.print(xVoltage);
Serial.print(" V (");
Serial.print(xValue);
Serial.println(")");
Serial.print("y = ");
Serial.print(yVoltage);
Serial.print(" V (");
Serial.print(yValue);
Serial.println(")");
Serial.print("z = ");
Serial.print(zVoltage);
Serial.print(" V (");
Serial.print(zValue);
Serial.println(")");
// Delay alto para possibilitar visualizao dos valores
delay(1000);
}
76
APNDICE C PROGRAMA TESTESERIAL3.INO
/* TesteSerial3
* Teste de leitura de eixos do acelerometro,
* convertendo os dados lidos para tensao em volts.
*/
// Pinos analogicos conectados aos eixos do acelerometro
int x = A5;
int y = A4;
int z = A3;
int x1 = A2;
int x2 = A1;
// Resolucao do conversor
const double vRes = 5.0 / 1024.0;
void setup() {
Serial.begin(9600); // Seta o baud rate da comunicacao serial
}
void loop() {
// Leitura dos valores dos pinos analogicos
double xValue = analogRead(x);
double yValue = analogRead(y);
double zValue = analogRead(z);
double x1Value = analogRead(x1);
double x2Value = analogRead(x2);
// Obtm o valor em Volts do sinal lido
double xVoltage = xValue * vRes;
double yVoltage = yValue * vRes;
double zVoltage = zValue * vRes;
double x1Voltage = x1Value * vRes;
double x2Voltage = x2Value * vRes;
// Escreve os dados na serial
Serial.print("x = ");
Serial.print(xVoltage);
Serial.print(" V (");
Serial.print(xValue);
Serial.println(")");
Serial.print("y = ");
Serial.print(yVoltage);
Serial.print(" V (");
Serial.print(yValue);
Serial.println(")");
Serial.print("z = ");
Serial.print(zVoltage);
Serial.print(" V (");
Serial.print(zValue);
Serial.println(")");
Serial.print("x1 = ");
Serial.print(x1Voltage);
Serial.print(" V (");
Serial.print(x1Value);
Serial.println(")");
Serial.print("x2 = ");
Serial.print(x2Voltage);
77
Serial.print(" V (");
Serial.print(x2Value);
Serial.println(")");
78
APNDICE D PROGRAMA TESTEACEL.INO
/* TesteAcel
* Teste de leitura de eixos do acelerometro,
* convertendo os dados lidos para acelerao em g.
*/
const float ZOUT_1G = 850.0;
const float V_OFFSET = 1650.0;
// Tenso em mV em Zout a 1G
// Tenso em mV em a 0G
79
pinMode(yaxis,INPUT);
pinMode(zaxis,INPUT);
pinMode(x1axis,INPUT);
pinMode(x2axis,INPUT);
// Programa principal
void loop()
{
// Leitura dos valores dos pinos analgicos
x = analogRead(xaxis);
y = analogRead(yaxis);
z = analogRead(zaxis);
x1 = analogRead(x1axis);
x2 = analogRead(x2axis);
// Converte o valor lido
float gx = (x * MV_RES float gy = (y * MV_RES float gz = (z * MV_RES float gx1 = (x1 * MV_RES
float gx2 = (x2 * MV_RES
para g
xOffset) / SENSIBILITY;
yOffset) / SENSIBILITY;
zOffset) / SENSIBILITY;
- x1Offset) / SENSIBILITY;
- x2Offset) / SENSIBILITY;
valores
}
80
APNDICE E PROGRAMA TESTEACELANGULOS.INO
/* TesteAcelAngulos
* Teste de leitura de eixos do acelerometro,
* convertendo os dados lidos para angulos em graus.
*/
const float ZOUT_1G = 850.0;
const float V_OFFSET = 1650.0;
// Tenso em mV em Zout a 1G
// Tenso em mV em a 0G
81
// em bps
// Configura os pinos para entrada
pinMode(xaxis,INPUT);
pinMode(yaxis,INPUT);
//pinMode(zaxis,INPUT);
pinMode(x1axis,INPUT);
pinMode(x2axis,INPUT);
// Programa principal
void loop()
{
// Leitura dos valores dos pinos analgicos
x = analogRead(xaxis);
y = analogRead(yaxis);
//z = analogRead(zaxis);
x1 = analogRead(x1axis);
x2 = analogRead(x2axis);
// Converte o valor lido para g
gx = (x * MV_RES - xOffset) / SENSIBILITY;
gy = (y * MV_RES - yOffset) / SENSIBILITY;
//gz = (z * MV_RES - zOffset) / SENSIBILITY;
gx1 = (x1 * MV_RES - x1Offset) / SENSIBILITY;
gx2 = (x2 * MV_RES - x2Offset) / SENSIBILITY;
// Calcula o arco seno e envia os dados pela serial
Serial.print("xMao =");
Serial.print((int)(asin(gx) * RAD_TO_DEG));
Serial.println();
Serial.print("yMao =");
Serial.print((int)(asin(gy) * RAD_TO_DEG));
Serial.println();
//Serial.print("zMao =");
//Serial.print((int)(asin(gz) * RAD_TO_DEG));
//Serial.println();
Serial.print("xDedo1 =");
Serial.print((int)(asin(gx1) * RAD_TO_DEG));
Serial.println();
Serial.print("xDedo2 =");
Serial.print((int)(asin(gx2) * RAD_TO_DEG));
Serial.println();
82
APNDICE F PROGRAMA ACELEROMETRO.INO
/* Acelerometro
* Le dados do acelermetro, convertendo-os para graus
* e enviando pela serial.
*/
const float V_OFFSET = 1650.0;
// Tenso em mV em a 0G
const int N_AM = 50; // numero de amostras
// pinos digitais para seletor do mux
const int s0 = 8;
const int s1 = 9;
const int s2 = 10;
// Entradas analgicas conectadas aos pinos dos acelermetros
const int xaxis = A5; // Eixo x do acelermetro do punho
const int yaxis = A4; // Eixo y do acelermetro do punho
const int x1axis = A2; // Eixo x do acelermetro do dedo 1 (polegar)
const int x2axis = A1; // Eixo x do acelermetro do
// dedo 2 (indicador)
const int x3axis = A0; // Eixo x do acelermetro do dedo 3 (mdio)
const int x4x5axis = A3;
const float MV_RES = 5000.0 / 1024.0; // resoluo do conversor,
// em mV
const float SENSIBILITY = 800.0; // Sensibilidade do acelerometro
// a 1,5g, em milivolts/g
// Offset de tenso em zero g
float xOffset, yOffset, x1Offset, x2Offset, x3Offset,
x4Offset, x5Offset;
// Valores lidos dos pinos analgicos
float x, y, x1, x2, x3, x4, x5;
// Acelerao nos eixos (em g)
float gx, gy, gx1, gx2, gx3, gx4, gx5;
/* Calcula a media entre 50 amostras
* de um eixo para calcular o offset. */
float AccelAdjust(int axis)
{
float acc = 0.0, readValue = 0.0;
int j;
for (j = 0; j < N_AM; j++)
{
readValue = analogRead(axis);
acc = acc + ((readValue * 5000) / 1024.0);
delay(11); //nmero primo para evitar ciclos de leitura
}
return acc / N_AM;
}
// Configurao dos pinos, do baud rate e
// clculo do erro dos acelermetros
void setup()
83
{
// Seta baudrate para 9600
Serial.begin(9600); // Seta o baud rate da comunicacao
// serial, em bps
// Configura pinos para sada
pinMode(s0, OUTPUT);
pinMode(s1, OUTPUT);
pinMode(s2, OUTPUT);
// Configura os pinos para entrada
pinMode(xaxis,INPUT);
pinMode(yaxis,INPUT);
pinMode(x1axis,INPUT);
pinMode(x2axis,INPUT);
pinMode(x3axis,INPUT);
pinMode(x4x5axis,INPUT);
// Programa principal
void loop()
{
// Leitura dos valores dos pinos analgicos
x = analogRead(xaxis);
y = analogRead(yaxis);
x1 = analogRead(x1axis);
x2 = analogRead(x2axis);
x3 = analogRead(x3axis);
// Seleciona pino do dedo 4
// (seleciona entrada 6 do MUX)
digitalWrite(s0, LOW);
digitalWrite(s1, HIGH);
digitalWrite(s2, HIGH);
delay(10);
x4 = analogRead(x4x5axis);
// Seleciona pino do dedo 5
// (seleciona entrada 4 do MUX)
digitalWrite(s0, LOW);
digitalWrite(s1, LOW);
digitalWrite(s2, HIGH);
84
delay(10);
x5 = analogRead(x4x5axis);
// Converte o valor lido para g
gx = (x * MV_RES - xOffset) / SENSIBILITY;
gy = (y * MV_RES - yOffset) / SENSIBILITY;
gx1 = (x1 * MV_RES - x1Offset) / SENSIBILITY;
gx2 = (x2 * MV_RES - x2Offset) / SENSIBILITY;
gx3 = (x3 * MV_RES - x3Offset) / SENSIBILITY;
gx4 = (x4 * MV_RES - x4Offset) / SENSIBILITY;
gx5 = (x5 * MV_RES - x5Offset) / SENSIBILITY;
/* Calcula o arco seno, envia
* entre o dado de cada eixo,
* nova linha */
Serial.print((int)(asin(gx) *
Serial.print("\n");
Serial.print((int)(asin(gy) *
Serial.print("\n");
Serial.print((int)((asin(gx1)
Serial.print("\n");
Serial.print((int)((asin(gx2)
Serial.print("\n");
Serial.print((int)((asin(gx3)
Serial.print("\n");
Serial.print((int)((asin(gx4)
Serial.print("\n");
Serial.print((int)((asin(gx5)
Serial.print("\n");
85
APNDICE G CLASSE COMMUNICATOR.JAVA
package henriquetcc2.serialcom;
import
import
import
import
import
import
import
import
import
import
import
import
import
gnu.io.CommPort;
gnu.io.CommPortIdentifier;
gnu.io.PortInUseException;
gnu.io.SerialPort;
gnu.io.SerialPortEvent;
gnu.io.SerialPortEventListener;
java.io.IOException;
java.io.InputStream;
java.io.OutputStream;
java.util.ArrayList;
java.util.Enumeration;
java.util.HashMap;
java.util.TooManyListenersException;
int serialCount = 0;
float aax;
float aax1;
float aax2;
float aax3;
float aax4;
float aax5;
float aay;
String data = "";
86
return aax1;
}
public float getAax2() {
return aax2;
}
public float getAax3() {
return aax2;
}
public float getAax4() {
return aax2;
}
public float getAax5() {
return aax2;
}
public float getAay() {
return aay;
}
/** Procura pelas portas seriais e coloca as portas no
* ArrayList comPorts */
public void searchForPorts() {
ports = CommPortIdentifier.getPortIdentifiers();
while (ports.hasMoreElements()) {
CommPortIdentifier curPort =
(CommPortIdentifier) ports.nextElement();
}
/** Conecta porta selecionada */
public void connect() {
// Porta inserida hardcoded "COM3"
String selectedPort = (String)comPorts.get(1);
selectedPortIdentifier =
(CommPortIdentifier)portMap.get(selectedPort);
CommPort commPort = null;
try {
//Retorna um objeto do tipo CommPort
CommPort = selectedPortIdentifier.open(
"TigerControlPanel", TIMEOUT);
// feito um cast no objeto CommPort para SerialPort
serialPort = (SerialPort)commPort;
//Seta a flag conectado
setConnected(true);
87
//Logs
System.out.println(selectedPort +
" opened successfully.");
}
catch (IOException e) {
// Falha na abertura
System.out.println("I/O Streams failed to open. (" +
e.toString() + ")");
return successful;
}
}
/** Inicia o eventListener para saber quando houver dados
* para serem lidos */
public void initListener() {
try {
serialPort.addEventListener(this);
serialPort.notifyOnDataAvailable(true);
}
catch (TooManyListenersException e) {
System.out.println("Too many listeners. (" +
e.toString() + ")");
}
}
/** Desconecta da porta serial e fecha os streams */
public void disconnect() {
try {
serialPort.removeEventListener();
serialPort.close();
input.close();
output.close();
setConnected(false);
}
88
catch (Exception e)
{
System.out.println("Failed to close " +
serialPort.getName() + "(" + e.toString() + ")");
}
}
final public boolean getConnected()
{
return bConnected;
}
public void setConnected(boolean bConnected)
{
this.bConnected = bConnected;
}
/** Evento disparado quando h dados na serial */
@Override
public void serialEvent(SerialPortEvent evt) {
if (evt.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
try {
// L o stream de input
byte singleData = (byte)input.read();
/* Pega o dado caso no seja um caracter de nova
* linha */
if (singleData != NEW_LINE_ASCII) {
data += new String(new byte[] {singleData});
}
else {
if (!(data.isEmpty() || data.equals(""))) {
switch(serialCount) {
case 0:
aax = Float.parseFloat(data);
serialCount++;
break;
case 1:
aay = Float.parseFloat(data);
serialCount++;
break;
case 2:
aax1 = Float.parseFloat(data);
serialCount++;
break;
case 3:
aax2 = Float.parseFloat(data);
serialCount = 0;
break;
case 4:
aax1 = Float.parseFloat(data);
serialCount = 0;
break;
case 5:
aax1 = Float.parseFloat(data);
serialCount = 0;
break;
case 6:
aax1 = Float.parseFloat(data);
serialCount++;
break;
}
89
data = "";
}
}
}
catch (Exception e) {
//Erro ao ler o dado da serial
System.out.println("Failed to read data. (" +
e.toString() + ")");
}
}
}
90
APNDICE H CLASSE HANDCUBE.JAVA
package heriquetcc2;
import
import
import
import
import
import
import
import
import
com.jme3.app.SimpleApplication;
com.jme3.material.Material;
com.jme3.math.Vector3f;
com.jme3.scene.Geometry;
com.jme3.scene.shape.Box;
com.jme3.math.ColorRGBA;
com.jme3.math.Quaternion;
com.jme3.system.AppSettings;
henriquetcc2.serialcom.Communicator;
91
* Cria um objeto communicator para estabelecer
* comunicao.
* Cria os cubos que sero exibidos na tela. */
@Override
public void simpleInitApp() {
communicator = new Communicator();
communicator.searchForPorts();
communicator.connect();
if (communicator.getConnected() == true) {
if (communicator.initIOStream() == true) {
communicator.initListener();
}
}
Box
Box
Box
Box
Box
Box
92
rootNode.attachChild(finger4);
rootNode.attachChild(finger5);
tpf;
tpf;
* tpf;
* tpf;
* tpf;
* tpf;
* tpf;