Embed Size (px)
Citation preview
PONTIFÍCIA UNIVERSIDADE CATÓLICA DO PARANÁ
ESCOLA POLITÉCNICA
CURSO DE ENGENHARIA DE COMPUTAÇÃO
ARTHUR AZEVEDO FERNANDES
FERNANDO DE SILLOS DE ANDRADE
RELATÓRIO TÉCNICO FINAL - EQUOTHERAPY MONITORING
ORIENTADOR:
GUILHERME NUNES NOGUEIRA NETO
_________________________________________
GUILHERME NUNES NOGUEIRA NETO
CURITIBA
4º BIMESTRE / 2019
RESUMO
O projeto a ser desenvolvido baseia-se em um equipamento capaz de
monitorar o movimento postural de um paciente com paralisia cerebral ou portador
de alguma deficiência motora, em que a prática de Equoterapia ajude a melhorar
seu equilíbrio. Diante disso se deu a ideia de desenvolvimento do projeto, no qual a
tecnologia a ser desenvolvida será capaz de monitorar o progresso do paciente
submetido à equoterapia, através de uma análise dos movimentos da cabeça e do
tronco. Com isso, será possível analisar os sinais obtidos, melhorando e
aperfeiçoando o aproveitamento dos ganhos da equoterapia, provendo evoluções
mais constantes ao paciente submetido ao tratamento. Para realização do projeto
serão utilizados microcontroladores do Raspberry PI e sensores, visando a extração
e manutenção dos sinais e dados sobre os movimentos corporais para análise de
profissionais da área.
Palavras chave: Projeto. Equoterapia. Monitoramento.
LISTA DE FIGURAS
Figura 1: Definições Equoterapia............................................................................................................2
Figura 2: Fluxograma...............................................................................................................................3
Figura 3: Diagrama de Blocos.................................................................................................................3
Figura 4: Módulo MPU6050.....................................................................................................................5
Figura 5: Esquema Elétrico da Placa GY521..........................................................................................5
Figura 6: Raspberry PI 3B+.....................................................................................................................7
Figura 7: Modelo Base da Estrutura........................................................................................................7
Figura 8: Cronograma............................................................................................................................11
Figura 9: Cronograma............................................................................................................................11
Figura 10: Gráfico de Gantt...................................................................................................................12
Figura 11: Gráfico de Gantt...................................................................................................................12
Figura 12: Tamanho de Arquivo............................................................................................................15
Figura 13: Amostras..............................................................................................................................15
Figura 14: Teste de uma hora com 115Hz de aquisição.......................................................................16
Figura 15: Teste de uma hora com powerbank “39,9 MB de dados obtidos” .......................................16
Figura 16: Gráficos de Saída MATLAB.................................................................................................17
Figura 17: Ficha do Paciente.................................................................................................................18
Figura 18: Pasta de Arquivos................................................................................................................18
LISTA DE TABELAS
Tabela 1: Riscos....................................................................................................................................19
SUMÁRIO
1 INTRODUÇÃO ...................................................................................................... 1
2 DETALHAMENTO DO PROJETO ......................................................................... 3
2.1 MÓDULO HARDWARE ................................................................................. 4
2.2 MÓDULO SOFTWARE.................................................................................. 8
2.3 CÓDIGOS ................................................................................................... 10
3 CRONOGRAMA .................................................................................................. 11
4 PROCEDIMENTOS DE TESTE E VALIDAÇÃO DO PROJETO.......................... 13
4.1 TESTES DE CAIXA PRETA E CAIXA BRANCA ......................................... 13
4.2 TESTES CONVENCIONAIS ........................................................................ 13
4.3 RESULTADOS DOS TESTES ..................................................................... 14
5 ANÁLISE DE RISCOS ........................................................................................ 19
6 CONCLUSÃO ...................................................................................................... 20
6.1 SUSTENTABILIDADE E IMPACTO AMBIENTAL ........................................ 21
REFERÊNCIAS ....................................................................................................... 22
ANEXO A - CÓDIGO PYTHON (RASPBERRY).......................................................24
ANEXO B - CÓDIGO MATLAB.................................................................................27
1
1 INTRODUÇÃO
A equoterapia consiste em um método terapêutico e educacional que utiliza
o cavalo dentro de uma abordagem multidisciplinar e interdisciplinar nas áreas de
Saúde, Educação e Equitação, buscando o desenvolvimento biopsicossocial de
pessoas portadoras de deficiência física e/ou mental ou que têm necessidades
especiais (GREVE; CASALIS; BARROS FILHO, 2001).
O parágrafo inicial cita e indica quem usufruirá do projeto e o porquê da
utilização dele. A desenvoltura junto a um recurso terapêutico é utilizada desde os
tempos de Hipócrates, como cita Gabriela Faleiros Liporoni e Ana Paula Rocha de
Oliveira em seu artigo “EQUOTERAPIA COMO TRATAMENTO ALTERNATIVO
PARA PACIENTES COM SEQÜELAS NEUROLÓGICAS”, podendo transformar algo
já benéfico em algo ainda maior para o grupo de pessoas que necessitam da
equoterapia.
A motivação para desenvolvimento deste projeto se baseia no que ele pode
acrescentar à vida das crianças e pacientes que o utilizarão no futuro, no que o
sistema poderá proporcionar, evoluções ainda maiores no tratamento da paralisia
cerebral ou em outros tipos de disfunção motora.
O problema a ser resolvido é importante, sendo que estudos demostram o
que a equoterapia já foi capaz de melhorar significativamente na vida de crianças
com paralisia cerebral (será mostrado posteriormente na seção de detalhamento do
problema). Com o desenvolvimento dessa tecnologia, a melhora postural poderá ser
ainda maior, sendo que o equipamento permitirá identificar movimentos em que a
criança ou paciente estará com menos equilíbrio. Após a análise de especialistas
será possível realizar mudanças no tratamento para que os pacientes consigam
responder melhor ao tratamento.
A tecnologia a ser desenvolvida utilizará de um microcontrolador, responsável
por interpretar os resultados enviados por sensores, o giroscópio e o acelerômetro,
enviando a um computador os dados, onde mostrará a movimentação do tronco e da
cabeça. O microcontrolador também irá guardar os resultados em sua memória para
fins de segurança.
2
Nos tópicos a seguir serão abordados o detalhamento, o cronograma, no qual
é citado o tempo gasto durante as fases exercidas, bem como a divisão básica das
atividades. Serão descritos os testes de validação do projeto (caixa preta e caixa
branca), testes convencionais, resultados obtidos, bem como seus eventuais riscos
de processo e a conclusão final sobre o projeto.
Figura 1 – Definições Equoterapia. (Fonte: Instituto Cisne).
3
2 DETALHAMENTO DO PROJETO
Os diagramas e fluxogramas a seguir exemplificam o eixo central de
funcionamento de todo o projeto a ser desenvolvido, bem como suas respectivas
análises individuais e técnicas de implementação que garantirão o correto
funcionamento do sistema.
Fluxograma:
Figura 2 – Fluxograma. (Fonte: Os autores, 2019).
Diagrama de blocos:
Figura 3 – Diagrama de Blocos. (Fonte: Os autores, 2019).
Bateria
Raspberry PI B+
Sensores
(Giroscópio e
Acelerômetro)
4
O projeto final será desenvolvido por uma junção de módulo software e
hardware que trabalharão simultaneamente coletando e armazenando os dados
necessários para a análise das sessões de equoterapia. Será detalhado nesta
sessão cada um de seus componentes utilizados, bem como códigos base e
estruturas pré-montadas que definirão o escopo de como todo o sistema será
formado. As definições se baseiam em métodos pré-existentes, moldados de forma
a se adaptarem a ideia do projeto.
O projeto não exigirá envio dos sinais via Wi-Fi em tempo real, sendo que
esses serão armazenados no próprio Raspberry e este possui um cartão de
memória com capacidade de armazenamento de até 64 GB. Após a sessão de
Equoterapia os dados poderão ser interpretados no próprio Raspberry ou mesmo no
computador que irá operar o “VNC” como será elucidado adiante nesta
documentação.
O cartão de memória apresenta uma velocidade de leitura de 80MB/s, sendo
mais do que suficiente para a aplicação do projeto. Os sinais obtidos pelos módulos
MPU6050 apresentam uma taxa de aquisição de dados de 200 amostras por
segundo, sendo 12 sinais enviados por ambos simultaneamente (Eixo Ax, Ay, Az
para a cabeça; Ax, Ay, Az para o tronco; Gx, Gy, Gz para a cabeça e Gx, Gy, Gz,
para o tronco). A velocidade de leitura do cartão é capaz de obter esses dados sem
problemas de perdas ou falhas.
2.1 MÓDULO HARDWARE
Conterá os sensores Giroscópio e Acelerômetro e Raspberry PI 3B+. Os
sensores descreverão a movimentação da cabeça e do tronco, enquanto o
Raspberry PI interpretará esses sinais e os enviará para um computador.
Os sinais serão transmitidos diretamente do Raspberry PI 3B+ para um
computador base, onde realizará os cálculos e interpetrações necessárias ao
conteúdo analisado. O armazenamento se dará por um cartão microSD, visando
análises posteriores, sendo que esses sinais futuramente poderão ajudar na
implementação de uma réplica de movimentos da terapia em ambientes fechados,
para casos em que pacientes não possam sair de alojamentos onde estão
confinados ou estejam impossibilitados de ter contato com cavalos.
5
Os equipamentos a ser utilizados serão descritos a seguir:
Figura 4 – Módulo MPU6050. (Fonte: Fazer lab).
Sensor Giroscópio e Acelerômetro módulo MPU6050 (figura 3): Esse módulo
apresenta no mesmo chip um acelerômetro e um giroscópio do tipo MEMS (Micro
Electro Mechanical Systems), sendo 3 eixos para cada tipo de sensor. Esses
sensores estarão colocados em uma placa, com GY-521 que possui um sensor de
temperatura, permitindo medições entre -40 a +85 ºC. A escolha desse módulo e
placa se deu pela precisão que ela é capaz de fornecer ao sistema, através de um
conversor AD de 16-bits para cada canal.
A tensão de operação se dá entre 3 a 5V, com comunicação I2C (Inter-
Integrated Cicuit). Essa é um tipo de comunicação que atua no tipo master-slave,
sendo a função do master em coordenar a comunicação. Esse tipo de comunicação
foi desenvolvido pela Philips.
A placa GY521 possui o esquema elétrico conforme a figura abaixo:
Figura 5 - Esquema elétrico da placa GY521 (Fonte: Flipeflop).
6
A escolha desses sensores se deu com base no que será necessitado no
projeto, visando monitorar o movimento da cabeça e do tronco do paciente,
interpretando os sinais fornecidos com praticidade.
Raspberry PI 3 B+: O Raspberry PI 3 B+ é um mini-CPU, com diversas
capacidades. Uma de suas possibilidades é a sua utilização em projetos
embarcados, que se enquadra no projeto a ser aqui desenvolvido. A escolha dele se
deu pela capacidade que oferece, no quesito de performance, em relação ao
Arduino. Este possui uma memória muito maior e uma velocidade de processamento
muito superior ao Arduino MEGA, por exemplo. O Raspberry PI é capaz de rodar
sistemas operacionais como Linux, Ubuntu e algumas versões de Windows.
Especificações técnicas do Raspberry PI 3 B+:
• Clock 1.4GHz;
• Memoria RAM: 1GB;
• Adaptador Wifi 802.11 b/g/n/AC 2.4GHz e 5GHz integrado;
• Bluetooth 4.2 BLE integrado;
• Slot para cartão micro SD;
• Alimentação 5V.
Essas encorpam as características principais para o desenvolvimento do
projeto. O clock e a memória serão necessários para a interpretação de modo muito
rápido dos sinais captados pelos sensores. O slot de cartão microSD é necessário
para armazenamento dos sinais em dados externos, sendo capaz de se utilizar um
cartão microSD com capacidade de até 256 GB. Isso é mais do que suficiente para
armazenar todos sinais captados com precisão durante toda uma sessão de
equoterapia.
7
Figura 6 – Raspberry PI 3 B+. (Fonte: Flipeflop).
Figura 7 – Modelo base da estrutura. (Fonte: Os autores, 2019).
8
2.2 MÓDULO SOFTWARE
Nele estará o presente o código responsável por converter esses sinais em
informação legível, que será mostrada em uma tela de computador. Será
desenvolvido na linguagem Python, utilizando o editor Geany do Linux (Raspbian).
Após os testes iniciais e análises mais profundas, acabou-se por decidir que
não será mais realizada uma operação de transferência em tempo real. Dessa forma
os dados serão armazenados no Raspberry durante a sessão de Equoterapia, sendo
que apenas após o término da mesma os dados obtidos serão interpetrados no
próprio Raspberry, e nele serão gerados os gráficos indicadores. Também será
produzido um outro código para Windows, possuidor da capacidade de análise dos
dados obtidos e armazenados no Raspberry.
Os sistemas operacionais e linguagens de programação utilizados no projeto
são:
✓ Windows e Raspberry (utilizados como parte de front-end) e Linux
(Raspbian): no Raspberry PI 3B+ serão utilizados para interpetração
dos sensores e elaboração dos sinais. O Windows poderá ser utilizado
para geração dos gráficos e interpetração dos sinais que serão
gravados no Raspberry após a Equoterapia. O Raspbian é um sistema
operacional baseado no Linux, feito para ser utilizado no Raspberry PI
para diversas aplicações.
✓ Python Shell (IDL3) e MATLAB: Ao instalar o sistema operacional
Raspbian, baseado no Linux, se obterá o IDL3, responsável por
carregar a interface de programação Python Shell. Nessa interface
será possível programar os softwares que interpretarão os sinais,
utilizando a linguagem de programação Python. O MATLAB será
utilizado para interpretar os sinais e gerar os gráficos dos sinais
armazenados em um arquivo de extensão “.csv”, que será enviado
após a sessão de Equoterapia para um computador, de forma que
consiga converter os resultados em gráficos, possibilitando o
entendimento dos instrutores que analisarão os resultados.
9
✓ VNC Viewer: é uma ferramenta que permite o controle remoto do
Raspberry a partir de outro computador. Este se utiliza da conexão
TCP/IP. O Raspberry já vem em seu sistema operacional com o VNC
instalado, sendo necessária apenas a instalação e configuração no
computador que servirá de controle. Foi escolhido tal mecanismo por
utilizar-se de menos capacidade processadora do Raspberry. Não se
fará necessário a criação de um código para envio de sinais via Wi-Fi
para o computador base, como será detalhado mais adiante na seção
de testes, devido a ocorrência de perda exacerbada na leitura dos
sinais. Colocar o envio por Wi-Fi acarretaria perdas mais consideráveis
de dados, fator crucial para a mudança realizada.
Para instalação do sistema operacional Raspbian se faz necessário o
download de uma imagem nos sites oficiais, sendo que a mesma deverá ser
extraída e inserida em um cartão microSD de capacidade e qualidade
correspondentes. O sistema será inserido no Raspberry PI e sua instalação ocorrerá
de forma automática.
Após a realização de diversos testes ficou decido que não será feito o envio
de dados via tempo real, sendo que os dados serão analisados no próprio Raspberry
PI, responsável também por gerar os gráficos para visualização dos dados. A
execução dos comandos a distância se dará utilizando o VNC viewer em um
computador base, responsável por observar o funcionamento dos sensores e do
GPS através de um executável gerado no Raspberry PI após o fim da Equoterapia.
Um arquivo “.csv” com os dados será gerado.
10
2.3 CÓDIGOS
Os códigos utilizados no desenvolvimento do produto (Python e MATLAB)
estarão presentes em anexo ao final deste documento. Abaixo segue um
pseudocódigo de nossa autoria, que avalia a interpetração dos sinais e testa os
sensores:
Leia (sensor1, sensor2) // envia um pulso para verificar funcionamento dos sensores.
Se sensor1 = 1
Escreva (“Sensor1 funcionando”) // Luz verde na tela.
Senão
Escreva (“Sensor 1 não está funcionando”) // Luz vermelha na tela
Fim-se
Se sensor2 = 1
Escreva (“Sensor2 funcionando”) // Luz verde na tela
Senão
Escreva (“Sensor 2 não está funcionando”) // Acender uma luz vermelha na tela
Fim-se
Se sensor 1 e sensor 2 = 1
Fim-se
InterpretaSinais (sensor1, sensor2) //Função em que estará os cálculos para interpretar os sinais.
enquanto eixo_cabeça > 45 ou eixo_corpo > 45
mostrarSinais (eixo_cabeça, eixo_corpo).
Fim-enquanto.
Se (eixo_cabeça < 45 ou eixo_corpo < 45)
Escreva (“Cuidado risco de queda”)
Fim-se
Pseudo código das funções:
InterpretaSinais (sensor1, sensor2) // Nessa parte constará o cálculo de conversão, onde será
convertido o sinal dos sensores em eixos geométricos.
Eixo_cabeça = // recebe o sinal do sensor 1 convertido em eixo.
Eixo_corpo = // recebe o sinal do sensor 2 convertido em eixo;
Fim InterpretaSinais.
MostrarSinais
// Será a parte de front-end em que serão mostrados os eixos na tela.
11
3 CRONOGRAMA
Abaixo encontram-se anexados o cronograma do projeto e seus gráficos de
Gantt, demonstrando graficamente as divisões de tarefas em relação ao tempo
utilizado durante o projeto.
Figura 8 – Cronograma. (Fonte: Os autores, 2019).
Figura 9 – Cronograma. (Fonte: Os autores, 2019).
12
Figura 10 – Gráfico de Gantt. (Fonte: Os autores, 2019).
Figura 11 – Gráfico de Gantt. (Fonte: Os autores, 2019).
13
4 PROCEDIMENTOS DE TESTE E VALIDAÇÃO DO PROJETO
4.1 TESTES DE CAIXA PRETA E CAIXA BRANCA
Teste em caixa preta:
Primeiro teste: Executar o programa e verificar se os sensores estão com o
sinal verde de confirmação, condição que indica o bom funcionamento.
Segundo teste: Verificar o funcionamento integral do sistema após
incrementação do colete e do capacete sobre o paciente na equoterapia.
Teste em caixa branca:
Primeiro teste: Verificação dos sinais enviados pelo Raspberry PI, se esses
estão consistentes e se não há envio de algum sinal de alerta.
Segundo teste: No Raspberry PI, enviar pulsos para verificar o funcionamento
dos módulos MPU 6050.
Terceiro teste: Verificação constante dos eixos, visando se esses passaram
do valor limite, além de indicar quando algum houver excedido esse limite, enviando
por fim um sinal de alerta nesta condição.
Quarto teste: Verificar o correto funcionamento dos sensores, emitindo um
sinal de alerta quando houver perda do sinal de algum deles.
4.2 TESTES CONVENCIONAIS
Teste 1: Sensores Acelerômetro e Giroscópio, junto com o Raspberry PI para
verificar a informação transmitida pelos sensores e verificar seus devidos
funcionamentos. Analisar os resultados e anotá-los para posteriormente fazer os
cálculos necessários.
Teste 2: Principal teste, teste com Raspberry PI, teste inicial para instalação
do sistema operacional que será o Linux (Raspbian). Após a instalação, utilizar o
Raspeberry PI como se fosse um mini-PC para instalar as ferramentas necessárias
ao desenvolvimento do software.
Teste 3: Teste de todo módulo hardware em conjunto no Raspberry PI, juntar
os dois programas desenvolvidos nos testes anteriores e verificar seu funcionamento
em conjunto aos sensores.
14
Teste 4: Montar um protótipo para prender o Raspberry PI em um colete junto
aos sensores alimentados por uma bateria, além dos sensores restantes serem
acoplados no capacete. Após essas etapas, verificar o funcionamento dos sensores
do Raspberry PI nessa configuração.
4.3 RESULTADOS DOS TESTES
Os testes realizados não apresentaram condições totalmente satisfatórias,
sendo que se fez necessária a remoção no escopo do projeto do envio em tempo
real e do módulo GPS, devido à perda de dados resultante durante a leitura do
sensor MPU6050.
Em um teste rodando a 200 amostras por segundo obteve-se um arquivo
“.csv” de 58 MB. Para obtenção desse arquivo foi mantido ligado o MPU6050 para
obtenção de amostras durante o período de 1 hora. Nesse período obteve-se perto
de 600.000 amostras, com uma perda de 16% do sinal total enviado. Após essa
análise foi implementada a realização de diversos testes visando a busca sobre
onde e o que poderia estar ocasionando a perda desses dados. Anteriormente já se
observou a existência de uma perda exacerbada de dados por parte do compilador,
realizando-se a troca do Thonny para o Geany, devido a este ser mais leve e mais
rápido na obtenção dos sinais. Ainda assim, como citado acima, perdeu-se um
aproximado de 16% dos sinais capturados. Nas semanas que se seguiram, os testes
de montagem do protótipo foram deixados de lado na busca da melhor forma de
obtenção dos sinais sem a perda de amostras, ou uma perda de menor porte, sendo
que o projeto consistiu em uma análise dos dados que necessitou de maior
aproximação à totalidade de consistência.
O melhor resultado obtido se deu em tamanho de 58MB em uma hora de
duração, com 200 hz e uma aquisição de 600.000 amostras, totalizando apenas
16% de perda total.
15
Figura 12 – Tamanho de arquivo. (Fonte: Os autores, 2019).
Figura 13 – Amostras. (Fonte: Os autores, 2019).
Mais testes foram realizados posteriormente, retirando-se todas as bibliotecas
que poderiam estar afetando o funcionamento ou recebimento dos dados. Foi
observado que diferente do teste em que se obteve 16% de perda, a frequência
máxima de aquisição se deu por 115 Hz. Logo decidiu-se posteriormente pela
realização da troca de códigos implementados na função de leitura, devido a esse
problema de módulo. Também se suspeitou do uso da função “append”, da
linguagem python, podendo esta ser responsável por parte da perda dos dados.
16
Figura 14 - Teste de uma hora com 115 Hz de aquisição. (Fonte: Os autores, 2019).
Figura 15 - Teste de uma hora com powerbank “39,9 MB de dados obtidos”.
(Fonte: Os autores, 2019).
17
O teste com powerbank se demonstrou eficaz, uma vez que este possui uma
capacidade de duração de até 4h com os módulos MPU6050 obtendo os dados
ativamente. Este pode durar ainda mais dependendo da qualidade do mesmo e da
sua respectiva capacidade, se utilizados modelos mais modernos e eficientes.
O uso do módulo GPS VK2828U7G5LFTTL antes previsto neste projeto foi
descartado devido à sua direta influência no decorrer da aquisição dos dados. Ao
ativar sua funcionalidade junto ao escopo, a aquisição dos dados não superou a
faixa de 60Hz, tornando obsoleta a pecisão desejada pelo escopo principal. Sua
funcionalidade, após análises e discussões aprofundadas se demonstrou sem
grande valor no produto, sendo que a sessão de equoterapia muitas vezes se dá por
percursos curtos e fechados, muitas vezes em ambientes preparados para tal.
Dessa forma a precisão de um módulo GPS seria ineficaz, uma vez que ele é
projetado para uma análise de grandes distâncias. O principal foco deste projeto se
deu pela análise dos dados emitidos pelos sensores detectores da postura, sendo o
GPS apenas uma ideia adicional sugerida. Dessa forma a remoção do módulo não
acarretou prejuízos significativos.
A utilização do software MATLAB para interpretação e construção de gráficos
para análises se deu de forma eficaz. O panorama das telas produzidas nos eixos
“XY”, “XZ” e “YZ” em relação ao “g” (gravidade), além do cálculo de suas respectivas
áreas pode ser conferido a seguir:
Figura 16 – Gráficos de saída MATLAB. (Fonte: Os autores, 2019).
18
Projetou-se também um arquivo de saída, com as informações inseridas
sobre cada paciente, sendo o mesmo gerado a cada sessão de equoterapia e
corretamente identificado com seus dados. A seguir observa-se o exemplo desse
arquivo:
Figura 17 – Ficha do paciente. (Fonte: Os autores, 2019).
Uma pasta contendo todos os arquivos produzidos em cada sessão também
será gerada, de forma a aglutinar todos os arquivos em um único local pré-
determinado, aprimorando dessa forma o conceito de organização do produto,
evitando perdas e possíveis conflitos.
Figura 18 – Pasta de arquivos. (Fonte: Os autores, 2019).
19
5 ANÁLISE DE RISCOS
Risco Severidade Ação Preventiva Ação de
Contingência
Perda de sinal dos
sensores MPU6050 Alta
Realizar diversos
testes, de forma a
melhorar a qualidade
dos sinais
Retirar a análise em
tempo real e
implementar a
interpretação dos
sinais após a obtenção
Atraso de chegada
dos materiais Alta
Monitoramento
semanal da entrega
dos materiais
Compra dos materiais
em lojas físicas
próximas
Dificuldade de
adaptação do
Raspberry com o
colete
Alta Compra de diferentes
tipos de colete
Testes semanais de
colocação do
Raspberry com o
colete adquirido
Má gestão do tempo Médio
Realizar o projeto
respeitando o
cronograma
Semanalmente,
verificar se as
atividades estão
dentro do cronograma
de realização do
projeto
Delay no recebimento
dos sinais enviados Alta
Realizar testes para
observar a melhor
forma de comunicação
entre o Raspberry PI e
o computador
Gravar os resultados
em uma memória e
analisá-los
posteriormente, não
em tempo real
Falhas no Raspberry
PI
Alta
Realizar testes
semanalmente com o
Raspberry PI
Em último caso
adquirir outro módulo
Mal funcionamento
dos sensores Baixo
Obter sensores de
diferentes marcas e
testá-los
Utilizar sensores de
outras marcas
Bateria não funcionar
corretamente Alta
Testar diferentes
baterias e montar a
configuração mais
eficaz
energeticamente
Utilizar energia
provinda da rede
elétrica disponível
Tabela 1 - Riscos. (Fonte: Os autores, 2019).
20
6 CONCLUSÃO
O projeto acima descrito se propõe a efetivar os ganhos em uma sessão de
equoterapia através da inserção de tecnologias, aliando a eletrônica física e a
computação programável. Os resultados esperados exigiriram um mínimo padrão
aceitável, sendo que o projeto final atendeu ao conceito básico de medição postural
no paciente avaliado.
A análise inicial de custos e tempo hábil de preparação e execução nos deu a
confirmação de que o projeto em si, pelo menos em seus requisitos mínimos, pode
ser executado em sua completude, sem a adição de complementos
potencializadores, conforme previsto anteriormente.
A aliança entre programação e hardware, neste projeto, acometeu a espinha
dorsal de todo o percurso trilhado pela graduação, permitindo uma aplicação teórica
e prática de conteúdos fundamentais ministrados. Um ótimo balanço final foi obtido,
analisando-se os pontos chave entre conhecimento adquirido e conhecimento
aplicado.
Em relação às etapas anteriores, o projeto seguiu o padrão esperado de custo
e tempo, apresentando obstáculos apenas no campo de obtenção de dados por
parte dos sensores, fator que ocasionou o postergar de algumas etapas
consecutivas, além da exclusão de itens antes previstos no escopo, como o módulo
GPS e o envio em tempo real. Essas etapas por sua vez, após alteradas, foram
executadas em completude ao final da resolução, produzindo um produto com o
mínimo desejado.
De modo geral o projeto seguiu seu cronograma sem eventuais atrasos
severos que poderiam causar algum dano maior ao fluxo principal de trabalho. As
etapas foram cumpridas e os resultados apresentados com exatidão.
Como futuras ampliações, o projeto permite que se insiram outros tipos de
sensores para aprofundamento de sua análise, como o GPS, além de poder ser
aplicado em outros ramos de grande importância, como a avaliação da postura em
atletas de altas performances nas mais diversas modalidades esportivas.
21
6.1 SUSTENTABILIDADE E IMPACTO AMBIENTAL
O conceito de sustentabilidade não se aplicou de forma severa neste projeto,
uma vez que os produtos utilizados foram mínimos. Uma única alternativa discutida
e de possível futura implementação se dá na parte de obtenção de energia. Energias
renováveis, como pequenas células solares podem ser acopladas ao sistema de
forma a fornecer a energia necessária para seu funcionamento. Evita-se assim a
utilização de fontes não-renováveis de energia.
A reciclagem dos materiais utilizados se faz possível, uma vez que os
produtos utilizados possuem compostos reutilizáveis em suas estruturas. O produto
desenvolvido não emite nem produz substâncias ou resíduos danosos ao meio
ambiente ou a seus utilizadores.
22
REFERÊNCIAS
1. EQUOTERAPIA COMO TRATAMENTO ALTERNATIVO PARA PACIENTES
COM SEQÜELAS NEUROLÓGICAS. UNIFRAN. Disponível em:
<http://publicacoes.unifran.br/index.php/investigacao/article/view/190/144
Capa>. Acesso em: 02 abr. 2019.
2. EQUOTERAPIA | instituto-cisne. Disponível em:
<https://www.institutocisne.org.br/equoterapia>. Acesso em: 25 ago. 2019.
3. FAZER LAB. Raspberry PI com módulo MPU-6050. Disponível em:
<https://fazerlab.wordpress.com/2016/09/19/raspberry-pi-com-modulo-mpu-
6050/>. Acesso em: 10 abr. 2019.
4. FILIPE FLOP. Acelerômetro e Giroscópio 3 Eixos 6 DOF MPU-6050.
Disponível em: <https://www.filipeflop.com/produto/acelerometro-e-giroscopio-
3-eixos-6-dof-mpu-6050/>. Acesso em: 02 abr. 2019.
5. FILIPE FLOP. Raspberry Pi 3 Model B. Disponível em:
<https://www.filipeflop.com/produto/raspberry-pi-3-model-b/>. Acesso em: 10
abr. 2019.
6. GITHUB. MPU6050. Disponível em:
<https://github.com/Tijndagamer/mpu6050>. Acesso em: 02 abr. 2019.
7. I2C – PROTOCOLO DE COMUNICAÇÃO – ARDUINOBR. ARDUINOBR.
Disponível em: <http://www.arduinobr.com/arduino/i2c-protocolo-de-
comunicacao/>. Acesso em: 10 abr. 2019.
8. KARLA MENDONÇA MENEZES. A Equoterapia no equilíbrio postural de
pessoas com Esclerose Múltipla. Revista Saúde (Santa Maria), Santa Maria,
Vol. 41, n. 1, p. 149-156, Jan/Jul 2015.
23
9. RASPBERRY PI. Schematics. Disponível em:
<https://www.raspberrypi.org/documentation/hardware/raspberrypi/schematics
/>. Acesso em: 20 jun. 2019.
24
ANEXO A – CÓDIGO PYTHON (RASPBERRY)
import smbus #import SMBus module of I2C
#from time import sleep, strftime, time #import
import numpy as np
import os
import csv
#import pandas as pd
x = []
y = []
x1 = []
y1 = []
x2 = []
y2 = []
x3 = []
y3 = []
Ax1 = []
Ay1 = []
Az1 = []
Ax44 = []
Ay44 = []
Az44 = []
Gx44 = []
Gy44 = []
Gz44 = []
Gx1 = []
Gy1 = []
Gz1 = []
PWR_MGMT_1 = 0x6B
SMPLRT_DIV = 0x19
CONFIG = 0x1A
GYRO_CONFIG = 0x1B
INT_ENABLE = 0x38
ACCEL_XOUT_H = 0x3B
ACCEL_YOUT_H = 0x3D
ACCEL_ZOUT_H = 0x3F
GYRO_XOUT_H = 0x43
GYRO_YOUT_H = 0x45
GYRO_ZOUT_H = 0x47
def MPU_Init():
bus.write_byte_data(Device_Address, SMPLRT_DIV, 7)
bus.write_byte_data(Device_Address, PWR_MGMT_1, 1)
bus.write_byte_data(Device_Address, CONFIG, 0)
bus.write_byte_data(Device_Address, GYRO_CONFIG, 24)
bus.write_byte_data(Device_Address, INT_ENABLE, 1)
def MPU_Init2():
bus.write_byte_data(Device_Address1, SMPLRT_DIV, 7)
25
bus.write_byte_data(Device_Address1, PWR_MGMT_1, 1)
bus.write_byte_data(Device_Address1, CONFIG, 0)
bus.write_byte_data(Device_Address1, GYRO_CONFIG, 24)
bus.write_byte_data(Device_Address1, INT_ENABLE, 1)
def read_raw_data1(addr):
high = bus.read_byte_data(Device_Address1, addr)
low = bus.read_byte_data(Device_Address1, addr+1)
value = ((high << 8) | low)
if(value > 32768):
value = value - 65536
return value
def read_raw_data(addr):
high = bus.read_byte_data(Device_Address, addr)
low = bus.read_byte_data(Device_Address, addr+1)
value = ((high << 8) | low)
if(value > 32768):
value = value - 65536
return value
bus = smbus.SMBus(1)
Device_Address = 0x68
Device_Address1 = 0x69
MPU_Init()
MPU_Init2()
print (" Leitura dos dados do Giroscopio e do Acelerometro")
filename = "/home/pi/Desktop/mpu3.csv"
try:
while True:
acc_x = read_raw_data(ACCEL_XOUT_H)
acc_y = read_raw_data(ACCEL_YOUT_H)
acc_z = read_raw_data(ACCEL_ZOUT_H)
acc_x1 = read_raw_data1(ACCEL_XOUT_H)
acc_y1 = read_raw_data1(ACCEL_YOUT_H)
acc_z1 = read_raw_data1(ACCEL_ZOUT_H)
gyro_x = read_raw_data(GYRO_XOUT_H)
gyro_y = read_raw_data(GYRO_YOUT_H)
gyro_z = read_raw_data(GYRO_ZOUT_H)
gyro_x1 = read_raw_data1(GYRO_XOUT_H)
gyro_y1 = read_raw_data1(GYRO_YOUT_H)
gyro_z1 = read_raw_data1(GYRO_ZOUT_H)
Ax = acc_x/16384.0
Ay = acc_y/16384.0
Az = acc_z/16384.0
26
Ax4 = acc_x1/16384.0
Ay4 = acc_y1/16384.0
Az4 = acc_z1/16384.0
Gx = gyro_x/131.0
Gy = gyro_y/131.0
Gz = gyro_z/131.0
Gx4 = gyro_x1/131.0
Gy4 = gyro_y1/131.0
Gz4 = gyro_z1/131.0
Ax1.append(Ax)
Ay1.append(Ay)
Az1.append(Az)
Gx1.append(Gx)
Gy1.append(Gy)
Gz1.append(Gz)
Ax44.append(Ax4)
Ay44.append(Ay4)
Az44.append(Az4)
Gx44.append(Gx4)
Gy44.append(Gy4)
Gz44.append(Gz4)
#temp += 0.005
#temp1.append(temp)
#print ('temp = %.2f' %temp, 'Gx=%.2f' %Gx, 'Gy=%.2f'
%Gy,'Gz=%.2f' %Gz,'Ax=%.2f g' %Ax, 'Ay=%.2f g' %Ay, 'Az=%.2f g' %Az)
#sleep(0.1)
except (KeyboardInterrupt):
with open(filename, "a") as log:
#Ax11 = np.array(Ax1)
ij = np.size(Ax1)
jk = 1
hj = 0
hj = ij
while jk != ij:
log.write("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10},{11}\n".format(str(
Ax1[jk]), str(Ay1[jk]), str(Az1[jk]), str(Gx1[jk]), str(Gy1[jk]),
str(Gz1[jk]),str(Ax44[jk]),str(Ay44[jk]),str(Az44[jk]),str(Gx44[jk]),str(Gy
44[jk]),str(Gz44[jk])))
jk = jk +1
#raise
27
ANEXO B – CÓDIGO MATLAB
function learquivo()
prompt1 = 'Digite o nome do diretorio: ';
str1 = input(prompt1,'s');
mkdir (str1);
prompt = 'Digite o nome do arquivo: ';
str = input(prompt,'s'); c = date; prompt5 = 'Digite o código do paciente: '; str5 = input(prompt5,'s');
prompt6 = 'Digite o código do terapeuta: '; str6 = input(prompt6,'s'); prompt9 = 'Digite a data de coleta '; str9 = input(prompt9,'s'); prompt10 = 'Digite a hora de coleta '; str10 = input(prompt10,'s'); prompt2 = 'Digite o nome do paciente: '; str2 = input(prompt2,'s'); prompt3 = 'Digite a data de nascimento do paciente: '; str3 = input(prompt3,'s'); prompt4 = 'Digite a condição do paciente: '; str4 = input(prompt4,'s'); prompt7 = 'Observações: '; str7 = input(prompt7,'s');
%x = input(prompt)
M = csvread(str);
X = length(M);
X1 = X / 3600;
Ax1 = M(:,1); Sax1 = std(Ax1); Meanax1 = mean(Ax1); MaxAx1 = max(Ax1);
Ay1 = M(:,2); Say1 = std(Ay1); Meanay1 = mean(Ay1); MaxAy1 = max(Ay1);
Az1 = M(:,3); Saz1 = std(Az1); Meanaz1 = mean(Az1); MaxAz1 = max(Az1);
28
Ax2 = M(:,7); Sax2 = std(Ax2); Meanax2 = mean(Ax2); MaxAx2 = max(Ax2);
Ay2 = M(:,8); Say2 = std(Ay2); Meanay2 = mean(Ay2); MaxAy2 = max(Ay2);
Az2 = M(:,9); Saz2 = std(Az2); Meanaz2 = mean(Az2); MaxAz2 = max(Az2);
Gx1 = M(:,4); SGx1 = std(Gx1); MeanGx1 = mean(Gx1); MaxGx1 = max(Gx1);
Gy1 = M(:,5); SGy1 = std(Gy1); MeanGy1 = mean(Gy1); MaxGy1 = max(Gy1);
Gz1 = M(:,6); SGz1 = std(Gz1); MeanaGz1 = mean(Gz1); MaxGz1 = max(Gz1);
Gx2 = M(:,10); SGx2 = std(Gx2); MeanGx2 = mean(Gx2); MaxGx2 = max(Gx2);
Gy2 = M(:,11); SGy2 = std(Gy2); MeanGy2 = mean(Gy2); MaxGy2 = max(Gy2);
Gz2 = M(:,12); SGz2 = std(Gz2); MeanaGz2 = mean(Gz2); MaxGz2 = max(Gz2);
f1 = figure ('Name','MPU6050 Acelerometro Tronco', 'NumberTitle',"off");
subplot(3,2,1) plot(Ax1,Ay1, 'o') xlabel('Ax1 (g)') xlim([-1.5 1.5]) ylabel('Ay1 (g)') ylim([-1.5 1.5]) title('Plano XY') [k,A] = boundary(Ax1,Ay1); hold on; plot(Ax1(k),Ay1(k));
29
A; subplot(3,2,3) plot(Ax1,Az1,'o') xlabel('Ax1 (g)') xlim([-1.5 1.5]) ylabel('Az1 (g)') ylim([-1.5 1.5]) title('Plano XZ') [k1,A1] = boundary(Ax1,Az1); hold on; plot(Ax1(k1),Az1(k1));
A1; subplot(3,2,5) plot(Ay1,Az1,'o') xlabel('Ay1 (g)') xlim([-1.5 1.5]) ylabel('Az1 (g)') ylim([-1.5 1.5]) title('Plano YZ') [k2,A2] = boundary(Ay1,Az1); hold on; plot(Ay1(k2),Az1(k2));
A2; subplot(3,2,2) plot(Gx1,Gy1, 'o') xlabel('Gx1 (graus/seg)') xlim([-1.5 1.5]) ylabel('Gy1 (graus/seg)') ylim([-1.5 1.5]) title('Plano XY') [k3,A3] = boundary(Gx1,Gy1); hold on; plot(Gx1(k3),Gy1(k3));
A3; subplot(3,2,4) plot(Gx1,Gz1,'o') xlabel('Gx1 (graus/seg)') xlim([-1.5 1.5]) ylabel('Gz1 (graus/seg)') ylim([-1.5 1.5]) title('Plano XZ') [k4,A4] = boundary(Gx1,Gz1); hold on; plot(Gx1(k4),Gz1(k4));
A4; subplot(3,2,6) plot(Gy1,Gz1,'o') xlabel('Gy1 (graus/seg)') xlim([-1.5 1.5]) ylabel('Gz1 (graus/s)') ylim([-1.5 1.5]) title('Plano YZ')
[k5,A5] = boundary(Gy1,Gz1); hold on; plot(Gy1(k5),Gz1(k5));
30
A5; saveas(gca, fullfile(str1, 'Cabeça'), 'fig'); saveas(gca, fullfile(str1, 'Cabeça'), 'jpeg');
f2 = figure ('Name','MPU6050 Giroscopio Head','NumberTitle',"off");
subplot(3,2,1) plot(Ax2,Ay2, 'o') xlabel('Ax2 (g)') xlim([-1.5 1.5]) ylabel('Ay2 (g)') ylim([-1.5 1.5]) title('Plano XY') [k6,A6] = boundary(Ax2,Ay2); hold on; plot(Ax2(k6),Ay2(k6));
A6; subplot(3,2,3) plot(Ax2,Az2,'o') xlabel('Ax2 (g)') xlim([-1.5 1.5]) ylabel('Az2 (g)') ylim([-1.5 1.5]) title('Plano XZ') [k7,A7] = boundary(Ax2,Az2); hold on; plot(Ax2(k7),Az2(k7));
A7; subplot(3,2,5) plot(Ay2,Az2,'o') xlabel('Ay2 (g)') xlim([-1.5 1.5]) ylabel('Az2 (g)') ylim([-1.5 1.5]) title('Plano YZ') [k8,A8] = boundary(Ay2,Az2); hold on; plot(Ay2(k8),Az2(k8));
A8; subplot(3,2,2) plot(Gx2,Gy2, 'o') xlabel('Gx2 (graus/seg)') xlim([-1.5 1.5]) ylabel('Gy2 (graus/seg)') ylim([-1.5 1.5]) title('Plano XY') [k9,A9] = boundary(Gx2,Gy2); hold on; plot(Gx2(k9),Gy2(k9));
31
A9; subplot(3,2,4) plot(Gx2,Gz2,'o') xlabel('Gx2 (graus/seg)') xlim([-1.5 1.5]) ylabel('Gz2 (graus/seg)') ylim([-1.5 1.5]) title('Plano XZ') [k10,A10] = boundary(Gx2,Gz2); hold on; plot(Gx2(k10),Gz2(k10));
A10; subplot(3,2,6) plot(Gy2,Gz2,'o') xlabel('Gy2 (graus/seg)') xlim([-1.5 1.5]) ylabel('Gz2 (graus/s)') ylim([-1.5 1.5]) title('Plano YZ')
[k11,A11] = boundary(Gy2,Gz2); hold on; plot(Gy2(k11),Gz2(k11));
A11; saveas(gca, fullfile(str1, 'Tronco'), 'fig'); saveas(gca, fullfile(str1, 'Tronco'), 'jpeg');
fid = fopen(fullfile(str1,'Ficha.txt'),'wb'); fprintf(fid,'-----------------------------Ficha Técnica-------------------
-------------------------------------------\n'); fprintf(fid,'Código do paciente : %s // Código do terapeuta : %s \n
',str5, str6); fprintf(fid,'Data da coleta : %s // Hora da coleta : %s \n ',str9, str10); fprintf(fid,'Nome : %s // Data de Nascimento : %s \n',str2, str3); fprintf(fid,'Condição do paciente : %s \n',str4); fprintf(fid,'Obervações : %s \n',str7); fprintf(fid,'-----------------------------Acelerometro Tronco-------------
-------------------------------------------------\n'); fprintf(fid,'Desvio padrão Acelerometro no eixo X : %f eixo Y : %f eixo Z
: %f\n',Sax1, Say1, Saz1); fprintf(fid,'Área no Acelerometro plano XY : %f plano XZ : %f plano YZ :
%f\n',A, A1, A2); fprintf(fid,'-----------------------------Giroscópio Tronco---------------
-----------------------------------------------\n'); fprintf(fid,'Desvio padrão no Giroscópio eixo X : %f eixo Y : %f eixo Z :
%f\n',SGx1, SGy1, SGz1); fprintf(fid,'Área no Giroscópio plano XY : %f plano XZ : %f plano YZ :
%f\n',A3, A4, A5); fprintf(fid,'-----------------------------Acelerometro Cabeça-------------
-------------------------------------------------\n'); fprintf(fid,'Desvio padrão Acelerometro no eixo X : %f eixo Y : %f eixo Z
: %f\n',Sax2, Say2, Saz2); fprintf(fid,'Área no Acelerometro plano XY : %f plano XZ : %f plano YZ :
%f\n',A6, A7, A8); fprintf(fid,'-----------------------------Giroscópio Cabeça---------------
-----------------------------------------------\n'); fprintf(fid,'Desvio padrão no Giroscópio eixo X : %f eixo Y : %f eixo Z :
%f\n',SGx2, SGy2, SGz2);
32
fprintf(fid,'Área no Giroscópio plano XY : %f plano XZ : %f plano YZ :
%f\n',A9, A10, A11); %fwrite(fid, ['Nome: ', str2]); %fwrite(fid, [' Idade: ', str3]); fclose(fid);
n = strcat( str1 , str5, '-' , c , '.csv'); copyfile (str, n); movefile (n , str1);
end
![PFC - Modelo Monografia[1]](https://img.document.onl/doc/110x75/5571fbd7497959916995ee5b/pfc-modelo-monografia1.jpg)
