automodelo controlado por acelerÔmetro de … · coordenaÇÃo motora em crianÇas ... micro...
TRANSCRIPT
UNIVERSIDADE POSITIVO
NÚCLEO DE CIÊNCIAS EXATAS E TECNOLÓGICAS
CURSO DE ENGENHARIA DA COMPUTAÇÃO
MARCOS ANTONIO BRESSAN
AUTOMODELO CONTROLADO POR ACELERÔMETRO DE
CELULAR PARA TRATAMENTO DE REABILITAÇÃO DE
COORDENAÇÃO MOTORA EM CRIANÇAS
Trabalho de Conclusão de Curso.
Prof. Amarildo Geraldo Reichel
Orientador
Curitiba, novembro de 2011.
2
UNIVERSIDADE POSITIVO
Reitor: Prof. José Pio Martins
Pró-Reitor de Administração: Prof. Arno Antonio Gnoatto
Pró-reitor Acadêmico: Prof.ª Márcia Sebastiani
Coordenador do Curso de Engenharia da Computação: Prof. Leandro Henrique de Souza
3
Agradecimentos
A
Daiane
pela contribuição e encorajamento.
Ao pai, Antonio, pela contribuição.
À mãe, Verônica, pelo apoio.
Ao irmão, Julio, pelo apoio.
Professor Amarildo, pelas dicas e sugestões.
4
SUMÁRIO
LISTA DE ABREVIATURAS E SIGLAS ................................................................... 5
LISTA DE FIGURAS ..................................................................................................... 6
LISTA DE TABELAS .................................................................................................... 7
RESUMO ......................................................................................................................... 8
ABSTRACT .................................................................................................................... 9
1 INTRODUÇÃO .................................................................................................... 10
2 FUNDAMENTAÇÃO TEÓRICA ....................................................................... 11
2.1 Sensor de movimento ou acelerômetro ........................................................... 11
2.2 Microcontrolador.............................................................................................. 12
2.3 Módulo Bluetooth .............................................................................................. 13
3 DESENVOLVIMENTO ....................................................................................... 14
3.1 Especificação de Hardware .............................................................................. 14
3.2 Especificação de Firmware ............................................................................... 16
3.3 Especificação de Software ................................................................................ 18
3.4 Especificação de Comunicação ........................................................................ 21
4 TESTES E RESULTADOS ................................................................................. 24
4.1 Testes com crianças .......................................................................................... 25
4.2 Personalização para pacientes ......................................................................... 25
5 EVOLUÇÕES ....................................................................................................... 26
6 CONCLUSÃO ....................................................................................................... 24
REFERÊNCIAS ........................................................................................................... 28
ANEXO A <CÓDIGOS EM C PARA FIRMWARE> .............................................. 31
ANEXO B <CÓDIGO PYTHON PARA APLICATIVO> ...................................... 35
5
LISTA DE ABREVIATURAS E SIGLAS
1 MEMS – Micro electro-mechanical systems – Dispositivos eletromecânicos ..................... 11
2 MCU, µC, uC – Microcontroller Unit – Unidade microcontroladora ................................... 12
3 OS – Operation System – Sistema Operacional .................................................................... 14
4 PWM – Pulse-width modulation – Modulação de largura de pulso...................................... 14
6
LISTA DE FIGURAS
Figura 2.1.1: Celular Nokia N95 mudando a orientação da tela .................................... 12
Figura 2.3.1: Módulo Bluetooth AMB2300 ................................................................... 13
Figura 3.1.1: Sinais digitais em forma de pulso de onda quadrada ................................ 15
Figura 3.1.2: Hardware em versão final ......................................................................... 16
Figura 3.3.1: Passos de utilização do aplicativo ............................................................. 20
Figura 3.3.2: Valores capturados pelo aplicativo nos movimentos do aparelho celular 20
Figura 3.4.1: Circuito do microcontrolador MSP430F449 ............................................ 21
Figura 3.4.2: Diagrama em blocos do adaptador de comunicação entre o módulo
Bluetooth e o microcontrolador ...................................................................................... 22
Figura 3.4.3: Circuito adaptador de comunicação entre o módulo Bluetooth e o
microcontrolador ............................................................................................................ 22
7
LISTA DE TABELAS
Tabela 1: ID de controle dos dispositivos ...................................................................... 17
Tabela 2: Mensagens de controle ................................................................................... 17
8
RESUMO
Para o desenvolvimento de um projeto atraente para crianças que facilite o seu
aproveitamento no tratamento de coordenação motora é necessário que leve-se em
consideração as limitações de quem está passando pelo tratamento. Para isso, a idéia de
criar um equipamento mais atraente aos olhos infantis exige que ele tenha um sistema
mais prático e simples de controle. Sendo assim, é necessário transformar um
automodelo radiocontrolado em um aparelho de reabilitação controlado de forma
intuitiva por celular, da mesma forma como se controla um volante de automóvel. Para
isso foi necessário desenvolver um controle a partir do sensor de movimento do
aparelho celular capaz de simular um volante de automóvel que fosse capaz de conduzir
o aparelho com movimentos intuitivos e simples.
O aparelho celular com sensor de movimento substitui o controle remoto enviando
sinais para o automodelo rádio-controlado que se movimenta de forma intuitiva e
natural.
Palavras-Chave: Automodelo, crianças, radiocontrolado, sensor de movimento.
9
AUTOMODEL CONTROLLED BY PHONE ACCELEROMETER
DESIGNED FOR MOTOR SKILLS TREATMENT IN INFANTS
ABSTRACT
Developing an attractive project for children that would enhance their motor skills
treatment performance is essential considering their physical conditions. In order to
achieve that idea it would be necessary to build equipment more attractive to the
children’s eyes. Designing a radio-controlled car into a phone’s accelerometer-
controlled car would be more natural as it would control the car as if it were a real car
wheel. Starting to build it from an accelerometer inside a phone and building the
reception circuit will allow the phone to simulate a car wheel with intuitive and simple
movements. The phone replaces the original remote control sending signals to the
receiver that generates intuitive movements.
Keywords: Automodel, infants, radiocontrolled, accelerometer.
10
1 INTRODUÇÃO
O tratamento de reabilitação em coordenação motora é a capacidade de usar de
forma mais eficiente os músculos esqueléticos, também conhecidos como grandes
músculos. Ele visa o desenvolvimento da coordenação motora específica, responsável
pela realização de determinados movimentos, como chutar uma bola ou conduzir um
brinquedo. No desenvolvimento da coordenação motora em crianças é essencial que
haja um estímulo que desperte o interesse da criança em realizar determinado exercício
físico. O desenvolvimento de um automodelo controlado por acelerômetro de celular,
por ser um controle intuitivo e na forma de um brinquedo, procura despertar esse
interesse infantil ao desenvolvimento de exercícios de coordenação motora.
Este trabalho teve como objetivo o desenvolvimento de um sistema de controle
utilizando os acelerômetros de celular capaz de realizar os movimentos básicos de um
automodelo controlado. Para o desenvolvimento do projeto o sistema de controle
original por radiofrequência de um automodelo foi substituído por um controle com
comunicação via Bluetooth. O dispositivo de controle é composto por um celular com
conexão via Bluetooth e sensores acelerométricos internos. O módulo de recepção e
acionamento do automodelo é composto por um dispositivo de comunicação Bluetooth
e um microcontrolador que executa a interpretação dos comandos recebidos do celular e
coordena o acionamento dos motores. Neste componente são realizadas as ações de
controle de velocidade dos motores via modulação por largura de pulso – PWM,
proporcionais às intensidades de aceleração enviadas pelos acelerômetros do celular de
controle. O celular de controle utiliza sistema operacional Symbian OS.
11
2 FUNDAMENTAÇÃO TEÓRICA
O objetivo do trabalho é transformar um sistema rádio-controlado em um sistema
intuitivo por meio de um aparelho celular capaz de reproduzir movimentos naturais de
direção e sentido. Para o êxito do trabalho é necessário acrescentar ao sistema de sensor
de movimento do celular, um sistema microcontrolado capaz de interpretar e
transformar comandos enviados pelo acelerômetro em sinais reconhecíveis pelo
aparelho rádio-controlado. Esses sinais são enviados através de ondas de rádio para um
módulo Bluetooth fazendo a comunicação entre o celular e o microcontrolador. A
utilização de sensor de movimento e microcontrolador é fundamental para a realização
do projeto.
2.1 Sensor de movimento ou acelerômetro
O sensor de movimento, ou acelerômetro, é um instrumento para medir a aceleração.
Segundo a primeira Lei de Newton: “Todo corpo permanece em repouso até que
alguma força externa seja exercida sobre ele.” Já a segunda Lei de Newton define a
força aplicada como o produto da massa do corpo pela sua aceleração. Logo, medindo a
aceleração aplicada sobre um corpo (e seu peso), é possível determinar a força aplicada
sobre ele. (Halliday, 2004)
Um acelerômetro é um instrumento capaz de medir a aceleração sobre objetos. Ao
invés de posicionar diversos dinamômetros (instrumento de medição de força) em
lugares diferentes do objeto, um único acelerômetro calcula qualquer força exercida
sobre ele.
Para entender seu funcionamento, supoem-se um copo com água até a metade. Se o
copo for colocado sobre uma superfície plana e empurrado para frente, observa-se que a
água se move. Quanto mais forte for o movimento, mais a água se move. O
acelerômetro mede esse movimento através do ângulo que o líquido forma em relação
ao seu estado inicial e assim fornece a aceleração aplicada ao copo. (aXYZ 1.0.0, 2011)
O acelerômetro é outro componente que está se tornando um item de série nos novos
aparelhos celulares, como mostrado na figura 2.1. Existem vários tipos de
acelerômetros: os mais simples são dispositivos eletro-mecânicos (“micro electro-
mechanical systems” ou MEMS), que incluem uma série de estruturas similares a
agulhas, que detectam os movimentos, gerando as leituras que são então transmitidas ao
circuito principal. (Ville, 2009)
Muitas câmeras filmadoras utilizam acelerômetros para controlar a estabilização da
imagem.
12
Figura 2.1.1: Celular Nokia N95 mudando a orientação da tela com o sensor de
movimento. (http://www.nokia.com, 2011)
A aplicação mais usada para o sensor de movimento é a mudança da orientação da
tela ao girar o aparelho. Quase todos os aparelhos utilizam telas com orientação vertical,
mas, atividades como navegar na internet ou assistir vídeos, exigem uma tela com
orientação horizontal. Normalmente, é necessário ativar uma opção para alterar o modo
e com um acelerômetro isso pode ser feito automaticamente.
Essa tecnologia será fundamental para o desenvolvimento do projeto pois será
utilizado o celular para captar os movimentos do acelerômetro e transformá-los em
mensagens a serem enviadas ao receptor que efetuará a transformação dessas
mensagens em sinais digitais capazes de realizar os movimentos do automodelo.
2.2 Microcontrolador
Um microcontrolador é um computador dentro de um circuito integrado. É
conhecido como: µC, uC ou MCU (microcontroller unit – unidade microcontrolada).
Ele contém dispositivos de memória, centro de processamento e periféricos de entrada e
saída, sendo programáveis através de diferentes linguagens de programação.
Os microcontroladores são usados em produtos e aparelhos controlados
automaticamente. Exemplos de utilização do microcontrolador envolvem o motor de um
veículo, dispositivos médicos implantáveis, controles remoto, máquinas de café
expresso, ferramentas elétricas, brinquedos e outros sistemas embarcados (sistemas de
computador criados para realizar tarefas dedicadas e funções diversas). (Texas
Instruments, 2011)
Seu papel nesse projeto é essencial para que haja a movimentação dos motores
elétricos no automodelo. Ele será o responsável por captar os sinais enviados pelo
aparelho celular, também fará a transformação dessas mensagens em sinais digitais e
13
finalmente realizará a transmissão desses sinais para os motores que conduzirão o
automodelo de acordo com a posição do aparelho celular.
2.3 Módulo Bluetooth
Bluetooth é a tecnologia sem fio padrão para troca de dados em pequenas distâncias
por meio de ondas curtas de rádio na faixa de 2400 a 2480 MHz e com alto grau de
segurança. A utilização de um sistema Bluetooth é necessária para efetuar a
comunicação entre o aparelho celular com o sensor de movimento e o microcontrolador
responsável por gerar os sinais que fazem o controle do automodelo, uma vez que não
há ligação com fios. Na figura 2.3.1 pode ser visto o módulo Bluetooth utilizado no
projeto.
Figura 2.3.1: Módulo Bluetooth AMB 2300 da Amber Wireless (http://www.amber-
wireless.de, 2011)
A finalidade de um módulo de comunicação é estabelecer conexão entre o aparelho
celular e o receptor do automodelo de forma sem fio. A tecnologia Bluetooth foi a
escolhida por oferecer baixo custo e alcance suficiente.
14
3 DESENVOLVIMENTO
O projeto de criação de um automodelo, para tratamento de reabilitação de
coordenação motora em crianças, envolve o desenvolvimento de três partes distintas e
igualmente fundamentais. A primeira parte é o hardware responsável por gerar os sinais
elétricos que são reconhecidos pelo automodelo. A segunda envolve o desenvolvimento
de um software interpretador de movimentos do celular e transmissor desses sinais. A
terceira trata do desenvolvimento de um sistema de comunicação entre hardware e
software a fim de obter o resultado satisfatório de controle intuitivo do automodelo.
3.1 Especificação de Hardware
O desenvolvimento do projeto começou pela escolha do automodelo que teve o
hardware adaptado para o movimento com o aparelho celular. O modelo escolhido foi o
Cross Country Race, elétrico e com escala de 1:10.
O aparelho celular com acelerômetro definido foi o Nokia N95, que utiliza sistema
operacional Symbian OS. (http://www.nokia.com, 2011)
O microcontrolador selecionado foi o MSP430F449 montado em uma placa de
desenvolvimento da Olimex. (http://www.olimex.com, 2011). Esse microcontrolador foi
selecionado pela capacidade de memória flash igual a 61440 bytes.
Para a comunicação entre o aparelho celular e o microcontrolador foi usado o
módulo Bluetooth 2300 da Amber Wireless, baseado no módulo 2.0 de porta serial
LMX9830 da National Semiconductor, devido ao menor custo e com alcance de 20
metros. A escolha desse módulo deve-se a seu alcance e custo baixo.
Para mudar a forma de controle do automodelo, que originalmente utilizava um
controle remoto com ondas de rádio em frequência de 27,9 MHz, para uma forma de
controle com ondas de rádio Bluetooth foi necessário substituir o receptor original por
outro para receber os sinais vindos do aparelho celular.
Os sinais de controle enviados pelo microcontrolador ao motor e ao servo motor
(motor interno baseado em sistema de transmissão) são sinais PWM (Pulse-width
modulation – Modulação por largura de pulso). Para o controle dos movimentos do
automodelo é necessário enviar sinais digitais ao controle do motor. O sinal é enviado
em forma de onda quadrada para o motor, onde a largura da onda em nível alto ajusta o
ângulo de deslocamento do servo motor, e por consequência o movimento para a
esquerda e para a direita das rodas dianteiras. A figura 3.1.1 demonstra o processo.
15
Figura 3.1.1: Sinais digitais em forma de pulso de onda quadrada enviados em
milisegundos para o servo motor. Variando o valor do período, obtém-se a posição
desejada do motor.
As medições em osciloscópio no sistema receptor original do automodelo mostram o
período total como sendo de 20ms. Ao mudar a posição para a esquerda, o sinal captado
fica entre 1ms a 1,49 ms. Para a direita o sinal captado fica entre 1,51 ms e 2 ms. Para o
retorno ao ângulo inicial o valor medido foi de 1,5 ms, ou seja, para o automodelo
seguir reto em frente o sinal recebido pelo servomotor deve ser de 1,5 ms. Esses valores
devem ser gerados pelo microcontrolador e enviados para o novo sistema receptor a fim
de obter os mesmos resultados que o sistema de controle original.
Para a direção foram utilizados os valores máximos de -127 (esquerda) a 127
(direita), valores que são enviados através de mensagens do aparelho celular para o
receptor com módulo Bluetooth. A velocidade máxima utilizada é a de 35% da potência
do motor DC.
O desenvolvimento desse hardware proporcionará um novo receptor capaz de
receber sinais digitais vindos do aparelho celular com conexão Bluetooth. A figura 3.1.2
representa o projeto em fase final.
16
Figura 3.1.2: Hardware em versão final.
3.2 Especificação de Firmware
O microcontrolador necessita de uma programação interna em forma de estrutura de
dados chamada de firmware, que determina as funções a serem desempenhadas. Para o
desenvolvimento do firmware utilizou-se a linguagem de programação C, por ser
abrangente e de fácil entendimento. O Anexo A apresenta os códigos que compoem o
firmware.
A estrutura de comunicação do microcontrolador mantida pelo firmware com o
motor do automodelo segue o formato das mensagens enviadas em código binário (um
byte com oito bits).
Preamble Identificador Bluetooth Identificador mensagem Tamanho dos
dados Dados Checksum
Preamble: 1 Byte, sempre 0xFF, usado para identificar o começo
Identificador: 1 Byte, identifica o dispositivo, tabela 1.
17
ID da mensagem: 1 Byte, identifica a mensagem que o dispositivo manda ou recebe,
tabela 2.
TamanhoDados: 1 Byte, indica quantos bytes são enviados em seguida (0 – 255)
Dados: 0 – 255 Bytes
Checksum: 1 Byte, calculado realizando a soma do módulo 256 no pacote todo
Dispositivos usados
Tabela 1: ID de controle dos dispositivos
ID O que faz
3 Direção
4 Acelerador
Tabela 2: Mensagens de controle
ID dispositivo
ID mensagem
Descrição TamanhoDados
Dados
3 1 Direção 1 8-bit signed char
Complemento de 2
0: pra frente
+1 .. + 127: esquerda
–1 .. – 128: direita
4 1 Acelerador 1 8-bit signed char
Complemento de 2
0: pra frente
+1 .. + 127: frente
–1 .. – 128: tras
O controle do funcionamento do motor DC do automodelo necessita da geração de
sinais digitais em forma de pulso de onda quadrada. Os valores limites de operação do
Automodelo são gerados dentro do código de criação de sinal PWM. O seguinte pedaço
de código em linguagem C, descreve esses limites:
TBCCR0 = 600;
// motor 2
TBCCTL2 = OUTMOD_7;
TBCCR2 = 50;
// motor 1
18
TBCCTL1 = OUTMOD_7;
TBCCR1 = 50;
Esse pedaço de código realiza a função de geração de modulação de largura de pulso
e faz parte do conjunto de códigos que formam o firmware, responsável pelo
funcionamento do microcontrolador.
O valor de TBCCR0 é o valor da frequência de funcionamento dos servo motores
dividida pela frequência de clock. Na maioria dos casos, o alcance da frequência está
entre 40 e 60 Hz. Para o Automodelo, a frequência de funcionamento é de 50 Hz, ou
período de 20 ms. O valor de TBCCR0 foi obtido dividindo o a frequência de clock pela
frequência do servo motor.
O valor de TBCCR1 e TBCCR2 são os valores de movimento dos servo motores
para a realização dos movimentos para a direita ou esquerda, respectivamente.
O desenvolvimento dessa estrutura de dados permitirá que o microcontrolador
controle os motores do automodelo a partir dos sinais digitais, transformados das
mensagens recebidas do aparelho celular.
3.3 Especificação de Software
Os movimentos do aparelho celular são reconhecidos quando captadas as variadas
posições através de um software que faz a interpretação e o envio dos movimentos para
o hardware. Ao desenvolver o sistema de controle, foi escolhida a linguagem Python
por ser uma linguagem de programação linear e rápido aprendizado e com comandos
acessíveis.
Na utilização da interface do usuário do celular e outras funções para a interpretação
e funcionamento é necessário fazer a importação de determinadas funções do aparelho
através de chamadas no código fonte do software, entre elas:
• import appuifw é a função que permite a utilização da interface do sistema
operacional s60 do aparelho N95 da Nokia, dessa forma o utilizador do sistema pode
fornecer informações ao sistema, como por exemplo, procurar um módulo bluetooth
ativo para realizar a comunicação.
• import socket é a função responsável por ativar o sistema bluetooth para
reconhecimento e comunicação entre o aparelho celular e o automodelo.
• import audio é a função que permite utilizar o áudio do aparelho celular para
emitir algum som, caso necessário.
• import miso é a função que permite deixar aceso o visor do celular quando o
software é carregado, assim na ausência de luz externa, o utilizador pode verificar o
funcionamento do sistema sem precisar fechar e abrir novamente o aplicativo.
• import struct é a função responsável por formatar os dados em bytes a serem
enviados para o microcontrolador.
19
• import sensor é a função responsável por fazer a leitura do sensor de
movimento (acelerômetro) do aparelho celular e também armazenamento desses dados
em variáveis x, y e z que representam a posição atual do aparelho celular. A forma
como é feita a leitura é descrita a seguir:
def get_sensor_data(status):
global value_cache,cache_pos
value_cache[cache_pos][0] = status['x']
value_cache[cache_pos][1] = status['y']
value_cache[cache_pos][2] = status['z']
sensor_type = sensor.sensors()['Sensoraceleracao']
acc_sensor = sensor.Sensor(sensor_type['id'],sensor_type['categoria'])
acc_sensor.connect(get_sensor_data)
A forma como o celular envia a mensagem de movimento ao microcontrolador
precisa estar no formato de código binário, gerado da seguinte forma pela linguagem
Python:
checksum = (255+3+1+1+direcao)
msg = ubytecmd(255, 3, 1, 1)
msg += bytecmd(direcao)
msg += ubytecmd(checksum)
if usabluetooth == 1:
sock.send(msg)
Checksum é o comando verificador de integridade da mensagem a ser enviada. 255
representa o valor máximo que o microcontrolador recebe para o envio de sinal para o
servo motor, que realiza o movimento de aceleração ou direção. O número 3 representa
o comando de direção do Automodelo e na geração do comando de aceleração esse
valor seria representado pelo número 4.
O commando “msg” forma a mensagem no padrão de comunicação estabelecido
pelo dispositivo Bluetooth e o comando “sock.send” envia a mensagem através do
socket do celular conectado ao módulo Bluetooth.
Esses sinais gerados acima são enviados pelo celular através do módulo Bluetooth
para o microcontrolador que faz a sua interpretação através do firmware e efetua o
movimento desejado no Automodelo.
Através do desenvolvimento desse aplicativo é possível estabelecer a comunicação e
realizar os movimentos desejados. O aplicativo se encarrega de captar as posições do
aparelho celular e enviá-las ao microcontrolador. A figura 3.3.2 demonstra o processo
de captura dos valores das posições X, Y e Z para cada movimentação do aparelho, em
cada intervalo de 500ms. O Anexo B apresenta o código em Python representando o
aplicativo.
20
Figura 3.3.1: Passos de utilização do aplicativo.
Figura 3.3.2: Valores capturados pelo aplicativo nos movimentos do aparelho
celular.
21
3.4 Especificação de Comunicação
Para o envio de informações do celular para o microcontrolador é necessário um
padrão de comunicação sem fio confiável, de fácil aquisição e baixo custo. A tecnologia
Bluetooth foi a selecionada por satisfazer essas condições.
O circuito desenvolvido para efetuar a comunicação entre o microcontrolador e o
módulo Bluetooth, responsável pela comunicação com o celular é demonstrado na
figura 3.4.1:
Figura 3.4.1: Circuito do microcontrolador MSP430F449 (Texas Instruments, 2011).
22
O módulo Bluetooth precisa ser ligado ao microcontrolador através de uma
adaptação de hardware feita com uma placa de circuito impresso, como mostram as
figuras 3.4.2 e 3.4.3.
Figura 3.4.2: Diagrama em blocos do adaptador de comunicação entre o módulo
Bluetooth e o microcontrolador. O motor 1 controla as rodas dianteiras (esquerda ou
direita) e o motor 2 o sentido de rotação para frente ou para trás.
Figura 3.4.3: Circuito adaptador de comunicação entre o módulo Bluetooth e o
microcontrolador.
23
Após a implantação desse hardware de comunicação o aparelho celular é capaz de
identificar o módulo Bluetooth e efetuar a comunicação com o microcontrolador. Esse,
por sua vez, realiza os processos de movimentação dos motores do automodelo. Para os
controles de potência foram utilizados os originais do automodelo radiocontrolado.
24
4 TESTES E RESULTADOS
Testes foram realizados para identificar problemas de funcionamento, instalação e
condução do automodelo. As soluções encontradas para os problemas foram suficientes
para permitir o funcionamento satisfatório do projeto.
Inicialmente os testes realizados apresentaram resultados insatisfatórios com relação
à comunicação do aparelho celular com o módulo Bluetooth devido a impossibilidade
de testar previamente a comunicação entre o módulo e o microcontrolador sem a
implementação do software ter sido concluída. Após essa implementação foi detectada a
falha no recebimento dos dados pelo microcontrolador a partir do módulo Bluetooth
devido ao fornecimento insuficiente de energia para o funcionamento do módulo.
Quando o módulo estava sendo reconhecido e recebia os sinais do aparelho celular,
ele não enviava os dados recebidos de forma correta ao microcontrolador. Isso foi
corrigido com a implantação do interpretador de comandos que passou a fazer parte do
firmware. A partir dessa implantação, o microcontrolador passou a captar corretamente
os sinais enviados pelo aparelho celular.
Em geração de sinais digitais o microcontrolador funcionou de forma satisfatória. As
correções necessárias foram apenas realizadas nos valores de PWM a serem enviados
por sinais digitais para os motores. Para o controle de velocidade observou-se que em
baixas rotações o automodelo não apresenta boa resposta, sendo necessária a
implementação de um pequeno atraso para o melhor controle.
Para a comunicação entre o celular e o módulo Bluetooth funcionar em 100% das
tentativas, é necessário que a fonte de energia forneça para o módulo Bluetooth, valor
de tensão entre o mínimo de 2,9V e o máximo de 3,3V e corrente mínima de 65mA.
Mantendo essas condições de fornecimento de energia e a distância máxima de 20
metros exigida pelo fabricante. A comunicação não foi interrompida nos testes
realizados.
A busca pelo sinal do módulo Bluetooth feita pelo celular pode ser comprometida se
o ambiente possuir diversos módulos Bluetooth ativados, como em outros celulares e
aparelhos notebook. Nesse caso é necessário mais de uma tentativa para captar o sinal.
Nos testes realizados sob essas condições, o máximo de três tentativas foram exigidas.
O software do celular teve problemas para ser instalado por falta de atualização do
firmware do celular. Esse problema foi solucionado com a instalação de uma versão
mais recente disponível no website do fabricante.
O controle de velocidade apresentou resultados insatisfatórios por apresentar
sensibilidade na leitura dos sinais do aparelho celular. Os movimentos para a frente e
para trás estavam muito rápidos e dificultaram o controle. Para crianças com
necessidades especiais, esse problema se agrava impedindo o controle do automodelo.
A solução para o problema da velocidade foi reduzir os valores de sinais digitais
enviados pelo microcontrolador aos motores. Foi necessário o cálculo do valor PWM a
ser gerado baseado no valor de clock do automodelo. Esse valor, dividido pela
frequência de funcionamento do receptor, proporcionou encontrar o número correto a
ser enviado pelo microcontrolador aos motores. Dessa forma, foi melhorado o controle
sobre a velocidade.
25
4.1 Testes com crianças
Os testes em crianças com necessidade de tratamento de reabilitação de coordenação
motora serão feitos nas dependências da Clínica de Fisioterapia da Universidade
Positivo quando essa puder atender as crianças para esse tratamento. O teste será
conduzido e orientado pelo profissional que acompanha o tratamento.
Os testes com crianças sem problemas físicos foi realizado na presença do
desenvolvedor do projeto que ofereceu instrução passo a passo para a utilização do
aparelho. O resultado foi satisfatório devido ao interesse positivo e do rápido
aprendizado de funcionamento por parte da criança, proporcionado pela facilidade do
processo de abertura do aplicativo e movimentos necessários para movimentação do
automodelo.
4.2 Personalização para pacientes
Os testes em crianças com necessidade de tratamento de reabilitação de coordenação
motora necessitam ser trabalhados de forma individual, afinal cada paciente tem o seu
grau de dificuldade e precisa de um aparelho melhor adaptado para casos individuais. O
projeto precisa adaptar um aplicativo que estabeleça diferentes níveis de sensibildade
para controle, permitindo que todos os diferentes níveis de necessidade sejam atendidos
de forma satisfatória.
26
5 EVOLUÇÕES
Para o futuro, esse projeto passará por modificações e melhorias para satisfazer
diferentes públicos e diversas funcionalidades. Alguns casos envolvem melhorias a
curto, médio e longo prazo.
Inicialmente será adaptado um sistema de controle menos sensível e com maior
flexibilidade de adaptação para ser direcionado para crianças com diferentes níveis de
deficiência.
Posteriormente o objetivo será implementar controle em luvas adaptadas com
sensores de movimento para levar esse projeto a controlar máquinas pesadas e veículos.
Futuramente, dependendo da disponibilidade de redes de internet sem fio, deverá ser
implementado um controle de diversos equipamentos em longas distâncias controlados
por movimentos intuitivos.
Finalmente poderá ser implementado um sistema de controle de veículos de carga e
passageiros através da Internet.
27
6 CONCLUSÃO
A proposta de criação de um aparelho de reabilitação da coordenação motora para
crianças foi pensada a partir da necessidade de atrair as crianças para o tratamento. Um
aparelho com forma de brinquedo parece ser bastante atraente aos olhos infantis e o
desenvolvimento desse projeto tem como objetivo gerar essa atração pelo tratamento.
O método de desenvolvimento proposto foi transformar um automodelo
radiocontrolado em um modelo controlado por aparelho celular de forma intuitiva, isso
facilita o controle de forma a eliminar a dificuldade de entendimento de um processo
complexo presente em um controle remoto padrão, com diversos botões e comandos
que são demorados de serem assimilados por uma criança com dificuldades de
coordenação motora.
Esse trabalho proporcionou incorporar o conhecimento de novas linguagens de
programação. O estudo de microcontroladores e de tecnologia de radiofrequência ficou
mais aprofundado.
Todos os estudos foram determinantes para aumentar a capacidade de
desenvolvimento de hardware e software, objetivos absolutos da engenharia da
computação.
28
REFERÊNCIAS
GRIFFITHS, David; BARRY, Paul. A Learner’s Guide to Programming Using the
Python Language. O’Reilly Media Inc., Estados Unidos, 2009.
HALLIDAY, David; RESNICK, Robert; WALKER, Jearl. Fundamentals of
Physics. John Wiley and Sons, Estados Unidos, 2004.
TEXAS INSTRUMENTS. MSP430x4xx Family User’s Guide: Texas Instruments,
Estados Unidos, 2011.
DAVIES, John. MSP430 Microcontroller Basics. Elsevier Ltd., 2008.
LABAKI, Josué. Introdução a Python – Módulo A. Universidade Estadual Paulista
Julio de Mesquita Filho, 2009.
TOCCI, Ronald J.; WIDMER, Neal S.; MOSS, Gregory L.. Sistemas Digitais –
princípios e aplicações. 10ª Edição. São Paulo – Brasil: Pearson Prentice Hall, 2007.
BOYLESTAD, Robert L.; NASHELSKY, Louis. Dispositivos Eletrônicos e teoria
de circuitos. 8ª Edição. São Paulo – Brasil: Pearson Prentice Hall, 2004.
MOREIRA, Ana. Desafio de uma vida – Reabilitação motora. Portal da Saúde.
Disponível em: <http://reabilitacaomotora.blogspot.com/2011/01/reabilitacao-motora-o-
que-e.html>. Acesso em: 29 de Dezembro de 2010 as 22h51min.
aXYZ 1.0.0 USING XYZ AXES OF THE N95 ACCELEROMETER. Disponível
em:
<http://www.developer.nokia.com/Community/Discussion/showthread.php?120394-
announce-aXYZ-1.0.0-using-XYZ-axes-of-the-N95-accelerometer-!>. Acesso em: 12
de janeiro de 2011 as 14h18min.
29
HOW TO BLUETOOTH-ENABLE YOUR REMOTE CONTROLLED CAR.
Disponível em: <http://alex.seewald.at/BlueCar/>. Acesso em: 12 de janeiro de 2011 as
14h12min.
TEST INTERACTIVE PYTHON EXAMPLES. Disponível em:
<http://docs.python.org/library/doctest.html>. Acesso em: 14 de janeiro de 2011 as
8h46min.
A SIMPLE TEXT PARSE. Disponível em:
<http://www.dreamincode.net/code/snippet488.htm>. Acesso em: 25 de março de 2011
as 21h08min.
KAAJAKARI, Ville. Practical MEMS: Design of microsystems, accelerometers,
gyroscopes, RF MEMS, optical MEMS and microfluidic systems. Estados Unidos:
Small Gear Publishing, 2009.
HOW TO MAKE .PY TO .SYS FOR 3RD EDITION DEVICES. Disponível em:
<http://www.developer.nokia.com/Community/Wiki/How_to_make_py_to_sis_for_3rd
_Editon_devices>. Acesso em: 19 de abril de 2011 as 11h21min.
TRANSFER TEXT FROM ONE MOBILE TO OTHER MOBILE. Disponível em:
<http://sites.google.com/site/croozeus/socket_module>. Acesso em: 19 de abril de 2011
as 11h45min.
GET AVAILABLE SERVER CHANNEL. Disponível em:
<http://nullege.com/codes/search/socket.bt_rfcomm_get_available_server_channel>.
Acesso em: 25 de abril de 2011 as 2h10min.
BLUETOOTH PROGRAMMING STEP-BY-STEP. Disponível em:
<http://www.devshed.com/c/a/Python/Bluetooth-Programming-using-Python/2/>.
Acesso em: 20 de abril de 2011 as 10h14min.
DRIVING A DC MOTOR USING PWM. Disponível em:
<http://hades.mech.northwestern.edu/index.php/Driving_a_DC_Motor_using_PWM>.
Acesso em: 20 de abril de 2011 as 10h25min.
TYSON, Jeff. Como funcionam os brinquedos controlados por rádio. Disponível
em: < http://eletronicos.hsw.uol.com.br/brinquedos-radio-controlados.htm>. Acesso em:
2 de maio de 2011 as 20h18min.
30
PULSE WIDTH MODULATION. Disponível em:
<http://www.oreillynet.com/network/synd/2003/07/02/pwm.html>. Acesso em: 2 de
maio de 2011 as 20h36min.
REAR MOTOR DRIVE. Disponível em: <http://henrytherobot.com/?page_id=53>.
Acesso em: 8 de maio de 2011 as 10h16min.
31
ANEXO A <CÓDIGOS EM C PARA O FIRMWARE>
Abaixo encontram-se os códigos que formam a estrutura de dados firmware
gravados no microcontrolador. Primeiro aparece o código principal. Em seguida os
códigos de verificação de distância e finalmente o código de geração de sinais digitais.
#include <signal.h>
#include <io.h>
#include <msp430x44x.h>
#include "uart.h"
#include "mth.h"
int main()
{
WDTCTL = WDTPW + WDTHOLD; // desliga o watchdog
_BIS_SR(GIE); // habilita as interrupções globais
initUART0(); // inicializa o UART que é conectado ao módulo Bluetooth
initMortinha(); // ajusta a mortinha
initPWMGeneration(); // inicializa o timer para gerar o PWM para os servos
}
32
#include <signal.h>
#include <io.h>
#include <msp430x44x.h>
#include "mth.h"
void initMortinha()
{
// setup do timer básico - 2 Hz (0.5 ms)
BTCTL = 0x25;
IE2 |= 0x80;
P1DIR |= 0x8; //output - LED vermelho indica timeout
}
// timer básico expirou - desliga a geração de PWM
interrupt (BASICTIMER_VECTOR) onBasicTimerInterrupt(void)
//#pragma vector=BASICTIMER_VECTOR
//__interrupt void onBasicTimerInterrupt(void)
{
P1OUT &= ~0x8; // liga o LED vermelho
P2DIR &= ~0x0c; // P2.2 - P2.3 input (alta impedância) - nenhum PWM é gerado
}
// reseta o timer, outputs liga
void serveMortinha()
{
BTCNT2 = 0; // reseta o timeout
P1OUT |= 0x8; // desliga o LED vermelho
P2DIR |= 0x0c; // P2.2 - P2.3 output
}
33
#include <msp430x44x.h>
#include "pwm.h"
void initPWMGeneration()
{
unsigned int i, j;
// setup da geração do PWM
FLL_CTL0 |= XCAP18PF; // Configura load caps
P2DIR |= 0x0c; // P2.2 - P2.3 output
P2SEL |= 0x0c; // P2.3 - P2.3 opções TBx
TBCCR0 = 200; // Período PWM
// servo 1
TBCCTL1 = OUTMOD_7; // CCR1 reset/set
TBCCR1 = 18; // CCR1 ciclo do serviço do PWM
TBCTL = 0x0111; // SMCLK, modo up - letra D no mapa unicode
// servo 2
TBCCTL2 = OUTMOD_7; // CCR1 reset/set
TBCCR2 = 12; // CCR1 ciclo do serviço do PWM
// todas as saídas 0 para que o controlador do motor calibre, indicando com flash do
LED
TBCCR1 = ((((signed char)0) * 10) / 54) + 45;
TBCCR2 = ((((signed char)0) * 10) / 54) + 45;
for (j = 0; j != 20; j++)
{
P1OUT ^= 0x8; // liga o LED vermelho
for (i = 0; i != 0xFFFF; i++)
{
__no_operation();
}
34
}
}
void setServo(unsigned int no, signed char value)
{
switch (no)
{
case 1:
TBCCR1 = ((value * 10) / 54) + 45;
break;
case 2:
TBCCR2 = ((value * 10) / 74) + 45;
break;
default:
break;
}
}
35
ANEXO B < CÓDIGO PYTHON PARA O APLICATIVO>
# Automodelo
# v1.0 - 20.2.2011
# Desenvolvido por:
# Marcos Bressan @sigaieu
import appuifw # interface de usuario s60
import socket # bluetooth
import miso # deixa aceso o backlight //instalar o MISO
import struct # formatando saida de bytes
# funcao que manuseia o modulo bluetooth:
def bt_connect():
global sock
# cria socket do bluetooth
sock=socket.socket(socket.AF_BT,socket.SOCK_STREAM)
target=''# endereco do modulo Bluetooth movel
if not target:
# scaneia dispositivos bluetooth
address,services=socket.bt_discover()
print "Descoberto: %s, %s"%(address,services)
if len(services)>1:
choices=services.keys()
choices.sort()
# abre popup e mostra os modulos disponiveis para selecionar
choice=appuifw.popup_menu([unicode(services[x])+": "+x
for x in choices],u'Escolher porta:')
target=(address,services[choices[choice]])
else:
36
target=(address,services.values()[0])
print "Conectando a "+str(target)
# Offset para acrescentar ao (ou subtrair) valor de aceleracao dependendo do sinal
do carro- calibracao
acc_offset = 0
# Modo Debug : -1 = desativado, 1 = ativado
debug = -1
# Usar Bluetooth ou nao mandar dados: -1 = sem dados, 1 = bluetooth
usabluetooth = 1
# Modo grafico: -1 = desativado, 1 = ativado
desenhagrafico = 1
# Limite de velocidade: -1 = desativado, 1 = ativado
limitedevelocidade = 1
maxvelofrente = 35
maxveloreversa = -30
# Tamanho do ponteiro que mostra o valor da aceleracao (nao precisa ser maior que
10 acho)
tamanhoponteiro = 10
# Modo paisagem: -1 = retrato, 1 = paisagem
paisagem = 1
# Aceleracao invertida (homenagem ao Elinton): -1 = off, 1 = on
aceleracaoinvertida = -1
# Tamanho da tela: GRANDE mostra nomes das teclas, CHEIA a tela inteira
appuifw.app.screen='large'
# 1 = Usa sensor API oficial da Nokia(5500, N95 8GB, ...), -1 = Usa aXYZ (N95 <
FW20, N93i)
usar_sensor_api = 1
if usar_sensor_api == 1:
import sensor
ignora_max = 4 # Nao processar todos os valores -> vai dar pau no Bluetooth
else:
import axyz
ignora_max = 3
# Cuida dos dados do teclado
if keyboard.is_down(EScancodeRightSoftkey): # Vaza
37
exit_key_handler()
elif keyboard.pressed(EScancodeStar): # Ativa (desativa) tela de debug
debug *= -1
elif keyboard.pressed(EScancodeHash): # Ativa (desativa) modo paisagem
paisagem *= -1
elif keyboard.pressed(EScancode0): # Ativa (desativa) aceleracao invertida
aceleracaoinvertida *= -1
elif keyboard.pressed(EScancode3): # Ativa (desativa) o limite de
velocidade
limitedevelocidade *= -1
elif keyboard.pressed(EScancodeSelect): # Ativa (desativa) a parada de
emergencia
paradadeemergencia *= -1
raw_x = x
raw_y = y
raw_z = z
# Processa aceleracao e sentido
# Parada de emergencia
if paradadeemergencia == 1:
x = 0
y = 0
z = 0
# Modo de controle
if paisagem == -1: #retrato
steering = -x
acceleration = -y
else: #paisagem
steering = -y
acceleration = z
# Aceleracao invertida
if aceleracaoinvertida == 1:
acceleration = -acceleration
# Usa todo o alcance de -127 a 127
steering *= 3
acceleration *= 2
38
if (atualmodoaceleracao > -1) and (acceleration > 0): # Recebeu aceleracao
reversa mas ainda nao em modo reverso
acceleration = 0 # Manter aceleracao no 0 a partir daqui
atualmodoaceleracao -= 1 # Diminui aceleracao modo o
Decrement ate chegar a -1
elif (atualmodoaceleracao < 0) and (acceleration <= 0): # Recebeu aceleracao
dianteira mas ainda nao em modo dianteira
atualmodoaceleracao = 1 # Muda para dianteira
# Verifica valor maximo (multiplo g)
steering = crop_value(steering, -127, 127)
acceleration = crop_value(acceleration, -127, 127)
# Cuidar dos dados de aceleracao
# Chamar em intervalos regulares
def cuidar_dados_sensor(x,y,z):
global ignorar_dados, ignora_max
# Desenhando
# limpa a imagem
img.clear(0x000000)
global res_x, res_y
# Define o texto titulo mede para poder centralizar na tela
title_text = u" "
text_rect = img.measure_text(title_text,font='title')[0]
top_offset_y = -text_rect[1]
# Desenha o grid de fundo
# esquerda para direita
img.line((0, (res_y - top_offset_y) / 2 + top_offset_y, res_x, (res_y - top_offset_y)
/ 2 + top_offset_y),0x7f0000)
# de cima pra baixo
img.line((res_x / 2, top_offset_y, res_x / 2, res_y),0x7f0000)
# Define um ponto e soma na imagem, define seus: coordenada x e y atual, e cor e
tamanho
if paisagem == -1: #retrato
img.point((normalize_value(steering, -127, 127, 0 + tamanhoponteiro / 2, res_x
- tamanhoponteiro / 2), normalize_value(acceleration, -127, 127, top_offset_y +
tamanhoponteiro / 2, res_y - tamanhoponteiro / 2)), 0xff0000,width=tamanhoponteiro)
else: #paisagem
39
img.point((normalize_value(acceleration, -127, 127, 0 + tamanhoponteiro / 2,
res_x - tamanhoponteiro / 2), normalize_value(steering, -127, 127, top_offset_y +
tamanhoponteiro / 2, res_y - tamanhoponteiro / 2)), 0xff0000,width=tamanhoponteiro)
# Desenha o texto titulo
img.text((res_x / 2 - text_rect[2] / 2, -text_rect[1]),title_text,0xffff00,font="title")
# Debug: mostra dados numericos
if debug == 1:
img.text((5, 50),u"Eixo x: %d"%raw_x,0x0060ff)
img.text((5, 65),u"Eixo y: %d"%raw_y,0x0060ff)
img.text((5, 80),u"Eixo z: %d"%raw_z,0x0060ff)
img.text((5, 95),u"Acelerador: %d"%acceleration,0x0000ff)
img.text((5, 110),u"Envia acelerador: %d"%send_acceleration,0x0000ff)
img.text((5, 125),u"Volante: %d"%steering,0x0000ff)
img.text((5, 140),u"Offset de acelerador: %d"%acc_offset,0x0000ff)
img.text((5, 155),u"Paisagem: %d"%landscape,0x6000ff)
img.text((5, 170),u"Acelerador invertido:
%d"%inverted_acceleration,0x6000ff)
img.text((5, 185),u"Limite de velocidade: %d"%speed_limit,0x6000ff)
# desenhar outra vez a imagem
if desenhagrafico == 1:
handle_redraw(())
# Enviar somente alguns dados, senao o bluetooth nao aguenta (nth)
# e gerando excecoes que eu nao quero
ignorar_dados += 1
if ignorar_dados < ignora_max:
return
ignorar_dados = 0
global sock
global debug, paradadeemergencia, desenhagrafico, paisagem,
aceleracaoinvertida, limitedevelocidade, maxvelofrente, maxveloreversa
global ultimaaceleracao, ultimavirada, atualmodoaceleracao, acc_offset
# Enviar novas mensagens para o carro
# Construir mensagem de sentido (direita esquerda)
# so manda se o novo valor e diferente do antigo
if ultimavirada != steering:
ultimavirada = steering
40
# Construir mensagem de sentido
checksum = (255+3+1+1+steering) % 256 # checksum
#imprime "st: %i ck: %i"%(sentido,checksum)
msg = ubytecmd(255, 3, 1, 1)
msg += bytecmd(steering)
msg += ubytecmd(checksum)
if usabluetooth == 1:
sock.send(msg)
# Construir mensagem de aceleracao
# Somente envia se o novo valor for diferente do antigo ou se o carro esta
mudando de dianteiro para reverso
if (ultimaaceleracao != acceleration) or ((atualmodoaceleracao != 1) and
(atualmodoaceleracao != -1)):
ultimaaceleracao = acceleration
send_acceleration = acceleration
# Normaliza a aceleracao para os valores restritos se o limite de velocidade eh
ativado
if limitedevelocidade == 1:
if send_acceleration > 0:
# Reverso
send_acceleration = normalize_value(send_acceleration, 0, 64, 0,
maxveloreversa)
else:
# aceleracao Dianteira
send_acceleration = normalize_value(send_acceleration, -64, 0,
maxvelofrente, 0)
# Soma o offset da aceleracao para o valor enviado e ter certeza de que nao
excede o limite
send_acceleration = crop_value(send_acceleration + acc_offset, -127, 127)
checksum = (255+4+1+1+send_acceleration) % 256 # checksum
msg = ubytecmd(255, 4, 1, 1)
msg += bytecmd(send_acceleration)
msg += ubytecmd(checksum)
if usabluetooth == 1:
sock.send(msg)
41
# ------------------------------------------------------------------------------------------------
-
# Processamento diverso
# Deixar o visor aceso Lembrar de instalar o MISO
miso.reset_inactivity_time()
class Keyboard(object):
def __init__(self,onevent=lambda:None):
self._keyboard_state={}
self._downs={}
self._onevent=onevent
def handle_event(self,event):
if event['type'] == appuifw.EEventKeyDown:
code=event['scancode']
if not self.is_down(code):
self._downs[code]=self._downs.get(code,0)+1
self._keyboard_state[code]=1
elif event['type'] == appuifw.EEventKeyUp:
self._keyboard_state[event['scancode']]=0
self._onevent()
def is_down(self,scancode):
return self._keyboard_state.get(scancode,0)
def pressed(self,scancode):
if self._downs.get(scancode,0):
self._downs[scancode]-=1
return True
return False
# define uma funcao que redesenha a tela, nesse caso a imagem deveria
# ser desenhada de novo e de novo (usar a funcao .blit)
def handle_redraw(rect):
global img
canvas.blit(img)
def exit_key_handler():
global sock,usabluetooth,usar_sensor_api
# Desregistra para parar a aquisicao dos dados do sensor.
if usar_sensor_api == 1:
42
global acc_sensor
acc_sensor.disconnect()
else:
axyz.disconnect()
if usabluetooth == 1:
sock.close()
app_lock.signal()
appuifw.app.set_exit()
# Normaliza o valor para caber no tamanho especificado
# Requer a especificacao do maximo alcance anterior
def normalize_value(val,min_val,max_val,min_new,max_new):
# Certifica-se que o valor nao ultrapasse seu valor maximo ou minimo
val = crop_value(val, min_val, max_val)
# Normaliza o valor para que seja restringido ao novo alcance
# e usa todo o valor para o novo alcance no caso de ser usado todo o alcance
anterior.
return int(((float(val) - min_val) / (max_val - min_val)) * (max_new - min_new)
+ min_new)
def bytecmd(cmd,*args): # Argumentos sao bytes assinados
return struct.pack("b%db" % len(args), cmd, *args)
def ubytecmd(cmd,*args): # Argumentos nao sao bytes assinados
return struct.pack("B%dB" % len(args), cmd, *args)
# Recorta o valor entre o minimo e maximo
def crop_value(val,min_val,max_val):
if (val < min_val):
val = min_val
elif (val > max_val):
val = max_val
return val
def menu_about():
appuifw.note(u"Marcos Bressan, 2011 @sigaieu", "info")
def menu_exit():
exit_key_handler()
def get_sensor_data(status):
global value_cache,cache_pos
43
# Calcula a media para os dados do sensor oficial API
# o celu já faz alguma filtragem interna
value_cache[cache_pos][0] = status['data_1']
value_cache[cache_pos][1] = status['data_2']
value_cache[cache_pos][2] = status['data_3']
cache_pos += 1
if cache_pos == 5:
cache_pos = 0
cur_data = [0,0,0]
for i in range(5):
cur_data[0] += value_cache[i][0]
cur_data[1] += value_cache[i][1]
cur_data[2] += value_cache[i][2]
for i in range(3):
cur_data[i] /= 5
cuidar_dados_sensor(-cur_data[1]/5,-cur_data[0]/5,-cur_data[2]/5)
# Inicializa a aplicacao e inicia o sensor
appuifw.app.title = u"Automodelo"
appuifw.app.exit_key_handler = exit_key_handler
appuifw.app.menu = [(u"Sobre", menu_about),(u"Sair", menu_exit)]
keyboard=Keyboard()
if desenhagrafico == 1:
# Usa a visualizacao grafica
canvas=appuifw.Canvas(event_callback=keyboard.handle_event,
redraw_callback=handle_redraw)
# Estabelece o corpo do aplicativo como "canvas"
appuifw.app.body=canvas
else:
# Ajusta o controlador do teclado e nao desenha mais nada assim as mensagens
podem ser vistas no console
canvas=appuifw.Canvas(event_callback=keyboard.handle_event)
# cria uma imagem vazia (aparece como imagem branca)
res_x, res_y = sysinfo.display_pixels()
img=Image.new((res_x,res_y))
paradadeemergencia = -1 # Parada de emergencia e desativada
44
ultimaaceleracao = 0
ultimavirada = 0
ignorar_dados = 0
atualmodoaceleracao = 1 # 1... dianteiro, -1... reverso
# chama a funcao que controla a conexao bluetooth
if usabluetooth == 1:
bt_connect()
# media proxima
value_cache = [[0,0,0],[0,0,0],[0,0,0],[0,0,0],[0,0,0]]
cache_pos = 0
# conecta ao sensor
if usar_sensor_api == 1:
# Usa o Sensor API da Nokia
sensor_type = sensor.sensors()['Sensoraceleracao']
acc_sensor = sensor.Sensor(sensor_type['id'],sensor_type['categoria'])
acc_sensor.connect(get_sensor_data)
else:
# Usa modulo AXYZ
axyz.connect(cuidar_dados_sensor)
app_lock = e32.Ao_lock()
app_lock.wait()