PONTIFÍCIA UNIVERSIDADE CATÓLICA DO PARANÁlaplima/ensino/tcc/concluidos/2011/banshee.pdf ·...

PONTIFÍCIA UNIVERSIDADE CATÓLICA DO PARANÁ

CURSO DE GRADUAÇÃO EM ENGENHARIA DE COMPUTAÇÃO

TIAGO AUGUSTO PERETTO

RELATÓRIO TÉCNICO FINAL

Projeto Banshee

CURITIBA

Dezembro de 2011

TIAGO AUGUSTO PERETTO

RELATÓRIO TÉCNICO FINAL

Projeto Banshee

Documento referente ao projeto

“BANSHEE” que deverá ser entregue

como avaliação final da disciplina

Projeto Final do 10º (décimo) período

de Engenharia de Computação da

Pontifícia Universidade Católica do

Paraná.

O projeto foi orientado pelo professor

Afonso Ferreira Miguel e o documento

será avaliado pelo professor Luiz

Lima.

Visto do professor orientador

Visto do professor da disciplina

Projeto Final

CURITIBA

Dezembro de 2011

SUMÁRIO

LISTA DE FIGURAS.............................................................................................. iv

LISTA DE TABELAS.............................................................................................. v

1. RESUMO....................................................................................................... 6

2. INTRODUÇÃO.............................................................................................. 6

3. DETALHAMENTO DO PROJETO................................................................ 9

3.1 Módulo Transmissor........................................................................ 9

3.1.1 Código embarcado......................................................................... 10

3.1.1.1 Fluxograma.................................................................. 11

3.2 Módulo Receptor............................................................................ 12

3.2.1 Código embarcado......................................................................... 13

3.1.1.1 A velocidade é conhecida............................................ 13

3.1.1.2 A distância entre transmissor e receptor pode ser

determinada................................................................................................ 13

3.1.1.3 O tempo de propagação pode ser determinado.......... 14

3.1.1.4 Fluxograma.................................................................. 17

4. PROCEDIMENTOS DE TESTE E VALIDAÇÃO DO PROJETO................ 18

4.1 Transdutores........................................................................ 18

4.2 Módulo Transmissor............................................................ 19

4.3 Módulo Receptor.................................................................. 20

4.3 Código embarcado: Cálculo de posição............................ 21

4.3.1 Resposta Teórica........................................................ 21

4.3.2 Resposta Prática........................................................23

5. CONCLUSÃO............................................................................................. 23

6. REFERENCIAS BIBLIOGRÁFICAS........................................................... 25

7. ANEXOS..................................................................................................... 26

7.1 Código do módulo transmissor.................................................... 26

7.2 Código do módulo receptor........................................................... 26

LISTA DE FIGURAS

Figura 1 – Esquema de funcionamento do GPS. Triangulação de sinais de

satélites.................................................................................................................... 6

Figura 2 – Equipamentos de visão artificial. Câmeras, controladores e

processadores......................................................................................................... 7

Figura 3 – Diagrama do projeto. Disposição dos transmissores e do receptor....... 8

Figura 4 – Arduino Duemilanove............................................................................. 9

Figura 5 – Circuito do módulo transmissor............................................................ 10

Figura 6 – Fluxograma do código do módulo transmissor..................................... 11

Figura 7 – Circuito do módulo receptor.................................................................. 12

Figura 8 – Sistema de coordenadas (x,y,z)........................................................... 14

Figura 9 – Diagrama que apresenta variação de x e y no cálculo dos

pontos.................................................................................................................... 15

Figura 10 – Diagrama de tempos com respectivas notações................................ 16

Figura 11 – Fluxograma do código do módulo receptor................................. 17

Figura 12 – Sinal de um transmissor ultrassom..................................................... 18

Figura 13 – Teste de distância: transmissores a 45, 90 e 120 cm.........................19

Figura 14 – Teste de distância: transmissores a 150, 180 e 200 cm.................... 19

Figura 15 – Teste de sincronização. Transmissores alinhados............................. 20

Figura 16 – Sinal de um transmissor e sua respectiva representação no módulo

receptor.................................................................................................................. 21

Figura 17 – Resposta ao Arduino ao cálculo teórico............................................. 22

LISTA DE TABELAS

Tabela 1 – Resposta do algoritmo aos valores teóricos........................................ 22

1. RESUMO

A fim de atender a demanda de sistemas de orientação em espaços

reduzidos, o projeto propõe a utilização de sinais de ultrassom como parâmetro

para a determinação da posição de um objeto. Para tal resultado, utilizam-se três

transmissores e um receptor para comunicação e um sistema numérico para

cálculo da posição.

2. INTRODUÇÃO

Nos últimos anos, inúmeros projetos de automação doméstica tem sido

desenvolvidos para emular, através de robôs, ações comumente efetuadas por

seres humanos.

Um dos desafios para tal propósito é o desenvolvimento de sistemas de

orientação. O sistema de orientação mais empregado é o GPS (Global

Positioning System), mas, em ambientes reduzidos, tal técnica não pode ser

utilizada devido a limitações de ordem de precisão e tempo de resposta dos

produtos comerciais.

Figura 1 – Esquema de funcionamento do GPS. Triangulação de sinais de

satélites

Assim, surgiram outras soluções, como o desenvolvimento de projetos de

visão artificial e softwares de reconhecimento de imagens. Ora, com a tecnologia

cada vez mais avançada de câmeras e processadores que garantem a eficácia de

algoritmos complexos, um grande avanço pode ser detectado nessa área, embora

o custo para o emprego dessas técnicas ainda seja elevado.

Figura 2 – Equipamentos de visão artificial. Câmeras, controladores e

processadores

Por isso, este projeto propõe a utilização de sinais de ultrassom com caráter

periódico a fim de o módulo receptor posicionar-se no espaço em que está

alocado.

Utilizando três transmissores dispostos em um ambiente, cujo sincronismo

de transmissão é controlado por um microcontrolador Arduino, e um receptor que,

ao captar os sinais transmite-os para outro Arduino que, conhecendo o período

entre cada transmissão e a velocidade de propagação da onda sonora consegue

desenvolver um cálculo capaz de aproximar teoricamente o valor obtido.

O projeto apresenta uma solução de custo inferior, porém precisão superior

ao GPS em espaços reduzidos.

Figura 3 – Diagrama do projeto. Disposição dos transmissores e do receptor

Entre as aplicações possíveis estão o posicionamento de um produto em

uma planta industrial, um objeto que deseja-se encontrar em um ambiente ou

ainda, partindo-se do princípio que se conhece a posição de um móvel ao qual o

módulo receptor está acoplado, utilizar o sistema de posicionamento para transitar

com o objeto guiando-o através de comandos de coordenadas, por exemplo.

Ainda, é possível aplicar tal sistema em outras atividades onde sejam

necessárias as atividades de monitoramento e controle de objetos, produtos e

equipamentos.

O conteúdo deste documento está dividido em três itens. No primeiro deles,

no Detalhamento do Projeto, estão contidas as descrições dos módulos –

transmissor e receptor - e do código embarcado no microcontrolador. No item

Procedimentos de Teste e Validação do projeto serão apresentados os resultados

obtidos para cada módulo individualmente assim como o resultado final dos

módulos integrados .

Por último, será apresentada a conclusão sobre a realização deste projeto.

T T

T

Receptor

3. DETALHAMENTO DO PROJETO

3.1 Módulo Transmissor

O módulo transmissor é composto por um microcontrolador Arduino

Duemilanove e por três emissores de ultrassom.

Figura 4 – Arduino Duemilanove

O microcontrolador é responsável pelo sincronismo dos transmissores. Com

o código embarcado e com três de suas saídas conectadas à alimentação dos

emissores, permite-se controlar a transmissão periódica dos sinais de ultrassom.

O Arduino ativa uma das saídas por 100 milissegundos a cada segundo.

Desse modo, cada transmissor efetua um pulso na frequencia de 40khz

sincronizado com a saída do Arduino. Após a transmissão dos três sinais, o

microcontrolador aguarda três segundos – tempo necessário para o cálculo e

visualização do resultado no módulo receptor – até que um novo ciclo seja

iniciado.

Figura 5 – Circuito do módulo transmissor

3.1.1 Código embarcado

O código embarcado no módulo transmissor serve como controlador das

transmissões dos emissores, dando a elas caráter periódico.

Utilizando a função delay() da biblioteca base do Arduino, inclui-se

facilmente os intervalos entre cada transmissão. O acionamento das portas de

saída é feito através da função digitalWrite(bit,level), tal que bit é a porta que

deseja-se ativar e level como o nível do sinal que deseja-se aplicar, HIGH (alto –

nível lógico 1) ou LOW (baixo – nível lógico 0).

O código completo embarcado no módulo transmissor encontra-se nos

Anexos.

3.1.1.1 Fluxograma

Figura 6 – Fluxograma do código do módulo transmissor

Inicio

Configura portas Ativa

TRANSMISSOR1

Aguarda 5

microssegundos

Desativa

TRANSMISSOR1 Aguarda 1

segundo

Ativa

TRANSMISSOR2

Aguarda 5

microssegundos

Desativa

TRANSMISSOR2 Aguarda 1

segundo

Ativa

TRANSMISSOR3

Aguarda 5

microssegundos

Desativa

TRANSMISSOR2

Aguarda 5

segundos

3.2 Módulo Receptor

O módulo receptor é constituído de um transdutor, que irá coletar os sinais

provenientes dos módulos transmissores, conectado a um microcontrolador

Arduino. É inerente ao transdutor a amplificação do sinal, o que resulta em um

sinal digital de qualidade.

Utilizando uma entrada digital do Arduino, permite-se verificar se a porta

está em nível lógico 1 ou 0 (verdadeiro ou falso – em eletrônica, nível alto ‘HIGH’

ou baixo ‘LOW’).

Quando um sinal é detectado, armazena-se o instante de tempo que o

evento ocorreu. Depois de recebidos os três pulsos, inicia-se o processo de

cálculo da posição baseado na diferença de tempo entre cada recepção.

Os valores das coordenadas obtidas são apresentados em um display do

tipo 16X2 (16 colunas x 2 linhas). Para a representação dos valores no dispay

utilizou-se as funções da biblioteca LiquidCrystal, contida no próprio pacote básico

do Arduino.

Figura 7 – Circuito do módulo receptor

3.2.1 Código embarcado

O código embarcado no módulo receptor é baseado em alguns

princípios básicos:

3.1.1.1 A velocidade é conhecida

A equação 20,04√T m/s descreve a velocidade de propagação

da onda longitudinal, tal que T é a temperatura absoluta do ambiente

em Kelvin.

Conforme fornecido pelo Simepar (Sistema Meteorológico do

Paraná), a temperatura média no verão de Curitiba é de 25ºC, o que

corresponde a 294,15K. Assim, admite-se que a velocidade de

propagação do sinal é de 343.7020667 m/s.

3.1.1.2 A distância entre transmissor e receptor pode ser

determinada

Em primeiro lugar deve ser determinada uma unidade para a

métrica. Neste projeto, a unidade adotada foi o metro. A escolha foi

feita para evitar conversões da unidade de velocidade.

A unidade de distância é importante pois é ela quem define a

variação ao qual o módulo receptor está submetido, além de servir

como parâmetro de um sistema de coordenadas.

Assim, adota-se um sistema de coordenadas cujo ponto (0,0)

está localizado sobre o transmissor T1, a sua direita encontram-se os

valores positivos de x, a sua frente os valores positivos de y e sobre

ele os valores positivos de z. Com base nisso utiliza-se a equação de

distância proveniente da Geometria Analítica para calcular a

distância entre transmissor e receptor.

d = √x²+y²+z² (1)

Tal que d é o vetor distância, e x, y e z são as coordenadas do

receptor.

Figura 8 – Sistema de coordenadas (x,y,z)

3.1.1.3 O tempo de propagação pode ser determinado

Através da equação t = l .

c

Onde:

l = Distância entre o receptor e o transmissor;

t = Variação de tempo entre a transmissão e a chegada

c = Velocidade de propagação da onda longitudinal.

Determina-se teoricamente o tempo necessário para o sinal

propagar-se do transmissor ao receptor.

Ainda, gravando em uma variável o instante de tempo (em

microssegundos – função micros()) em que ocorreu uma recepção e

obtendo as variações entre as recepções (subtração simples entre o tempo

da segunda recepção e o tempo da primeira recepção) procura-se, através

dos cálculos teóricos, a localização do receptor.

(0,0,0)

(0,y,0)

(x,0,0)

(0,0,z)

P=(x,y,z)

d

Ora, sabe-se que cada ponto no plano R³ (espaço

compreendido entre os vetores x, y e z) possui valores singulares de T1 e

T2 (variação entre primeira e segunda recepção = T1 e variação entre a

segunda e a terceira recepção = T2). Assim, a partir do ponto central (0.5,

0.5, 1) calcula-se os tempos T1 e T2 dos pontos a sua volta (inclusive os

valores do próprio ponto) e, encontrando-se um ponto cuja diferença entre

os valores calculados e teóricos seja mínima adota-se este ponto como o

mais próximo da localização real.

Figura 9 – Diagrama que apresenta variação de x e y no cálculo dos pontos

A fórmula utilizada para verificar o melhor resultado entre os pontos é

apresentada abaixo:

tempoParametro = (tempoCalculado2 + 1) – deltaReal (2)

tempoCalculado = | tempoParametro – tempoCalculado1 | (3)

Tal que:

tempoParametro = tempo usado como parâmetro – une tempo

teórico e tempo real;

tempoCalculado2 = tempo de propagação do sinal a partir de um

transmissor, segunda chegada;

deltaReal = intervalo de tempo entre recepções de dois sinais obtidos

através do receptor;

(x-∆,y-∆)

(x,y+∆)

(x+∆,y+∆)

(x+∆,y)

(x+∆,y-∆)

(x,y-∆)

(x-∆,y)

(x-∆,y+∆)

(x,y)

tempoCalculado = valor final usado como margem de erro;

tempoCalculado1 = tempo de propagação do sinal a partir de um

receptor, primeira chegada;

Os valores acima podem ser representados a partir da imagem

abaixo:

Figura 10 – Diagrama de tempos com respectivas notações

Os tempos de propagação são obtidos teoricamente utilizando a

expressão (1) e nas funções (2) e (3) são mostrados como

tempoCalculado1 e tempoCalculado2. O período é conhecido e deve ser

sincronizado no receptor caso haja alguma alteração no módulo

transmissor. O intervalo entre recepções é o valor obtido na prática e nas

funções acima é denominado de deltaReal.

Assim, utilizam-se valores teóricos e reais como parâmetro para

determinação da posição mais próxima da real.

No ponto onde a variação seja mínima, determina-se este como

melhor solução.

Por último, apresenta-se o resultado obtido em um display do

tipo 16X2, cuja implementação utilizou a biblioteca LiquidCristal do Arduino.

1 segundo = período

Tempo de propagação

Tempo de propagação

Intervalo entre recepções

3.1.1.4 Fluxograma

Figura 11 – Fluxograma do código do módulo receptor

Inicio Configura portas Configura

display

Aguarda recepção

Armazena tempo

Recepção Ok?

Aguarda recepção

Recepção Ok? Armazena

tempo

Recepção Ok? Aguarda recepção

Armazena tempo

S

N

N

S

N

S

Calcula posição

Apresenta resultado

4. PROCEDIMENTOS DE TESTE E VALIDAÇÃO DO PROJETO

4.1 Transdutores

Para efeitos de teste, conectou-se os transdutores (transmissor e

receptor) à alimentação de 5V CC para observar a amplitude e a frequência do

sinal. Nesse teste, os três transmissores e o receptor apresentaram resultados

satisfatórios até a distância de dois metros, mais do que o valor máximo

necessário para o projeto (1,732m diagonal de um cubo de 1 metro de aresta).

Figura 12 – Sinal de um transmissor ultrassom

Figura 13 – Teste de distância: transmissores a 45, 90 e 120 cm

Figura 14 – Teste de distância: transmissores a 150, 180 e 200 cm

4.2 Módulo Transmissor

Cabe ao módulo transmissor enviar os sinais de maneira

sincronizada e adequada, respeitando os intervalos de tempo e garantindo

que o módulo receptor possa interpretar os sinais corretamente.

A imagem abaixo mostra os três transmissores alinhados enviando

os sinais a cada um segundo. Conforme apresentado, os tempos estão

sendo respeitados.

Figura 15 – Teste de sincronização. Transmissores alinhados

4.3 Módulo Receptor

Conforme pode-se concluir das imagens acima, o receptor consegue

capturar os sinais transmitidos a uma distância superior a requisitada pelo

projeto. Além disso, responde com tal amplitude que o microncontrolador é

capaz de interpretar o sinal pela sua entrada digital, como é apresentado

pela imagem abaixo:

Figura 16 – Sinal de um transmissor e sua respectiva representação no

módulo receptor

4.3 Código embarcado: Cálculo de posição

4.3.1 Resposta Teórica

Para testar a eficiência do algoritmo no cálculo da

posição, calculou-se teoricamente os intervalos de tempo T1 e T2 de

certas coordenadas e, aplicando os valores obtidos como resposta

como base de cálculo do algoritmo, esperou-se que o código fosse

capaz de realizar a operação inversa e retornar as coordenadas

utilizadas como parâmetro.

Ainda, utilizou-se a função millis() da biblioteca Time do

Arduino para calcular o tempo necessário para o algoritmo efetuar a

operação.

Figura 17 – Resposta ao Arduino ao cálculo teórico

A tabela abaixo apresenta os resultados obtidos pelo algoritmo

no cálculo da posição com base nos intervalos de tempo.

X Y X Y

0,01 0,01 0,24 0,24 0,06 0,169

0,15 0,15 0,24 0,24 0,03 0,172

0,25 0,25 0,24 0,24 0,00 0,17

0,30 0,70 0,25 0,75 0,02 0,161

0,45 0,90 0,40 0,60 0,19 0,081

0,62 0,43 0,68 0,32 0,00 0,123

0,71 0,88 0,77 0,77 0,03 0,171

0,99 0,99 1,00 1,00 0,01 0,292

0,04 0,167

TEÓRICO CALCULADOERRO TEMPO DE RESPOSTA

ALGORITMO DE CÁLCULO DE POSIÇÃO

Tabela 1 – Resposta do algoritmo aos valores teóricos

4.3.2 Resposta Prática

Com cada módulo funcionando a contento individualmente,

uniram-se eles a fim de testar efetivamente o funcionamento do

projeto.

Infelizmente, o resultado final não foi o esperado. Os intervalos

de tempo não condisseram com o valor teórico, e como o cerne do

projeto baseia-se nestes intervalos de tempo, o cálculo da posição

não pode ser realizado corretamente.

5. CONCLUSÃO

Em primeiro lugar, é importante ressaltar os grandes avanços obtidos após

a alteração dos componentes. Alterando o microncontrolador MSP430 pelo

Arduino obteve-se grande avanço não apenas na facilidade de programação, mas

também no tempo de resposta para o cálculo, na possibilidade da utilização de

bibliotecas próprias para utilização do display e em determinados comandos que

reduziram em muito o tempo gasto na resolução de problemas.

Ainda, a utilização de módulos de ultrassom prontos em substituição ao

modelo que estava sendo desenvolvido respondeu a outro grande avanço. O

circuito anteriormente proposto apresenta falhas graves de resposta, devido á

grande atenuação que ocorria e pela saturação, quando aumentava-se a

alimentação dos amplificadores para obter uma solução ao problema anterior.

Além disso, havia muito consumo de energia e a necessidade de diversas fontes

de alimentação para fornecer a tensão eficaz para cada tipo de componente era

inconveniente.

Por conta disso, perdeu-se uma quantidade generosa de tempo buscando

soluções para esses problemas, que foram resolvidos quando optou-se pela

alteração quase total dos elementos do projeto.

O projeto na configuração atual apresenta grandes melhorias em relação ao

layout anterior, embora, no teste final, os resultados tenham-se apresentados

insatisfatórios.

Como descrito anteriormente, os intervalos de tempo recebidos não

condizem com o esperado valor teórico. Isto implica na impossibilidade do

algoritmo resolver adequadamente o cálculo.

A princípio, acreditou-se que o erro estava no fato do código ser baseado

em pulling e, por isso, o intervalo de tempo entre cada verificação na porta de

entrada implicava em perda de precisão. Assim, buscou-se introduzir a técnica de

interrupção, de forma a diminuir a margem de erro na recepção dos sinais.

No Arduino, existe uma função denominada attachInterrupt() que pode ser

configurada para ser ativada a cada rampa de subida, de descida ou de alteração

no estado de uma porta de entrada. Esta função, quando ativada, seria

responsável por armazenar o instante de tempo entre cada recepção, visto que

cada rampa de subida geraria uma interrupção.

De fato, acreditou-se que a utilização desta função resolveria o problema, já

que durante os anos a utilização de interrupções foi vastamente explorada e com

diversos cases de sucesso. Mas, por conta de características intrínsecas ao

receptor e ao Arduino, esta opção acabou sendo descartada na fase de testes ao

gerar interrupções mesmo quando não havia dados sendo coletados.

Outra proposta foi de reduzir os períodos de ativação do sinal e dos

intervalos entre cada transmissão, a fim de reduzir a margem de erro que tempos

na ordem de milissegundos poderiam gerar. Infelizmente os testes acabaram

mostrando que o receptor não interpretava pulsos muito velozes dos

transmissores e ainda, a faixa de ativação que é interpretada está na casa dos

100 milissegundos. Por conta disso, novamente optou-se por utilizar um período

de 100 milissegundos e um segundo entre cada transmissão. Este último poderia

ser reduzido, mas para efeitos de facilidade de cálculo manteve-se este tempo.

Além disso, mostrou-se que o Arduino, mesmo com a utilização de variáveis

de 4 bytes (double e float), “cortava” os valores e reduzia a precisão. Por conta

disso, modificou-se o código afim de utilizar os valores em microssegundos (que

poderiam ser armazenados em variáveis do tipo unsigned long, sem perda de

dados) para que a precisão pudesse ser elevada. Ainda assim, os resultados

foram insatisfatórios pois, agora utilizando valores de ordem maior os erros, além

de permanecerem, ainda foram propagados.

Essas entre outras intempéries minaram a conclusão total do projeto, e

embora muitos problemas tenham sido solucionados ao longo do caminho este

último, e mais importante, não pode ser resolvido.

Mesmo com tudo isso, o saldo do projeto é positivo, visto que foram

incluídos conhecimentos em programação em dois processadores, conhecimentos

de eletrônica e outros conhecimentos gerais, como o de geometria, por exemplo.

6. REFERÊNCIAS BIBLIOGRÁFICAS

Barone M.Jr., Álgebra Linear, 3a ed. IME-USP,1988.

Fossen, Thor I., Guidance and Control of Ocean Vehicles, University of Trondheim,

Noruega. John Wiley & Sons, 1994.

Gribbon, K.T., Johnston, C.T., Bailey, D.G., A Real-time FPGA Implementation of a

Barrel Distortion Correction Algorithm with Bilinear Interpolation, Proceedings of

Image and Vision Computing New Zealand, Palmerston North, New Zealand, pp

408-413, Novembro, 2003.

Nippon Ceramic, <www.nicera.co.jp>, Acesso em 23 de dezembro de 2004.

Santos, A. O. et al., Sensor ultra-sônico para determinação de posição de modelo

em escala reduzida em tanque de provas, Congresso da Sociedade Brasileira de

Engenharia Naval (Sobena), 2004.

Tannuri, E. A., Morishita, H. M., Lago, G. A., Veras, V. L. M., Critical analysis of

control and filtering algorithms used in real dynamic positioning systems, 24nd

International Conference on Offshore Mechanics and Arctic Engineering, OMAE,

2005.

Véras, V.L.M., Simulação e Análise de Sistema de Posicionamento Dinâmico, XIX

Congresso Pan-Americano de Engenharia Naval, Transporte Marítimo e

Engenharia Portuária XIX COPINAVAL, Guayaquil, Equador, 2005.

7. ANEXOS

7.1 Código do módulo transmissor

int TRANSMISSOR1=13;



void setup(){

pinMode(TRANSMISSOR1, OUTPUT);



}

void loop(){

digitalWrite(TRANSMISSOR1, HIGH); // sets the LED on

delay(100);

digitalWrite(TRANSMISSOR1, LOW); // sets the LED off

delay(1000); // waits for a second


delay(100);


delay(1000); // waits for a second


delay(100);


delay(5000); // waits for five seconds

7.2 Código do módulo receptor

#include <Time.h>

#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

//posicao inicial

float bx=0.5, by=0.5;

//velocidade de propagação do sinal em microssegundos

//Com a temperatura média de Curitiba no verão

double v=343.7020667;

//variação de valor aceitável de posicão

float delta=0.01;

//variação aceitável de tempo

float deltaT=0.001;

//Variaveis para calculo de variação do tempo

double x=0,y=0;

//Vetor de variação de tempo

double menor[9];

//Menor valor do vetor

double m;

//Indice do vetor cujo menor valor está alocado

int n;

double T1, T2;

float parametro=0;

void setup(){

lcd.begin(16, 2);

Serial.begin(9600);

pinMode(7, INPUT);

}

void loop(){

PEGAPOSICAO:

lcd.setCursor(0, 0);

lcd.print(" ");


lcd.print("START");

bx=0.5, by=0.5;

x=0,y=0;

double temp, first;

double tempos[3];

PRIMEIRA_RECEPCAO:

if(!digitalRead(7))

goto PRIMEIRA_RECEPCAO;

else{

tempos[0]=micros();

first=tempos[0];

}

SEGUNDA_RECEPCAO:

if(!digitalRead(7))

goto SEGUNDA_RECEPCAO;

else{

temp=micros();

if((first+1500000) < temp){

tempos[0]=temp;

first=tempos[0];


}

else{

if((temp-first) > 100000){

tempos[1]=temp;

}

else


}

}

TERCEIRA_RECEPCAO:

if(!digitalRead(7))

goto TERCEIRA_RECEPCAO;

else{

temp=micros();

if((tempos[1]+1500000) < temp){

tempos[0]=temp;

first=tempos[0];


}

else{

if((temp-tempos[1]) > 100000){

tempos[2]=temp;

}

else

goto TERCEIRA_RECEPCAO;

}

}

tempos[0] = tempos[0]/1000000;



T1 = (tempos[1] - tempos[0]);

T2 = (tempos[2] - tempos[1]);


lcd.print(" ");


lcd.print("T1=");

lcd.print(T1);


lcd.print(" ");


lcd.print("T2=");

lcd.print(T2);

delay(3000);

if(T1 == T2)

goto IMPRIMEPOSICAO;

parametro=(calculaTempo1(bx,by,v,T1) +

calculaTempo2(bx,by,v,T2));

CALCULAPOSICAO:

x=calculaTempo1(bx,by+delta,v,T1);

y=calculaTempo2(bx,by+delta,v,T2);

menor[0]=(x+y);

/*lcd.setCursor(0, 0);

lcd.print(" ");


lcd.print("1=");

lcd.print(menor[0]);*/

x=calculaTempo1(bx-delta,by+delta,v,T1);

y=calculaTempo2(bx-delta,by+delta,v,T2);

menor[1]=(x+y);


lcd.print(" ");


lcd.print("2=");

lcd.print(menor[1]);

delay(2000);*/

x=calculaTempo1(bx-delta,by,v,T1);

y=calculaTempo2(bx-delta,by,v,T2);

menor[2]=(x+y);


lcd.print(" ");


lcd.print("3=");


x=calculaTempo1(bx-delta,by-delta,v,T1);

y=calculaTempo2(bx-delta,by-delta,v,T2);

menor[3]=(x+y);


lcd.print(" ");


lcd.print("4=");


delay(2000);*/

x=calculaTempo1(bx,by-delta,v,T1);

y=calculaTempo2(bx,by-delta,v,T2);

menor[4]=(x+y);


lcd.print(" ");


lcd.print("5=");


x=calculaTempo1(bx+delta,by-delta,v,T1);

y=calculaTempo2(bx+delta,by-delta,v,T2);

menor[5]=(x+y);


lcd.print(" ");


lcd.print("6=");


delay(2000);*/

x=calculaTempo1(bx+delta,by,v,T1);

y=calculaTempo2(bx+delta,by,v,T2);

menor[6]=(x+y);


lcd.print(" ");


lcd.print("7=");


x=calculaTempo1(bx+delta,by+delta,v,T1);

y=calculaTempo2(bx+delta,by+delta,v,T2);

menor[7]=(x+y);


lcd.print(" ");


lcd.print("8=");


delay(2000);*/

x=calculaTempo1(bx,by,v,T1);

y=calculaTempo2(bx,by,v,T2);

menor[8]=(x+y);


lcd.print(" ");


lcd.print("9=");


m=menor[0];

for(int i=0;i<9;i++){

if(menor[i]<m){

m=menor[i];

n=i;

}

}

if(n == 0){

by+=delta;

}

else if(n == 1){

bx-=delta;

by+=delta;

}

else if(n == 2){

bx-=delta;

}

else if(n == 3){

bx-=delta;

by-=delta;

}

else if(n == 4){

by-=delta;

}

else if(n == 5){

bx+=delta;

by-=delta;

}

else if(n == 6){

bx+=delta;

}

else if(n == 7){

bx+=delta;

by+=delta;

}

else if(n == 8){


}

if(((calculaTempo1(bx,by,v,T1) +

calculaTempo2(bx,by,v,T2))) < deltaT){

goto CALCULAPOSICAO;

}

else


IMPRIMEPOSICAO:

//IMPRIMEPOSICAO


lcd.print(" ");


lcd.print("X=");

lcd.print(bx);

lcd.print(" Y=");

lcd.print(by);

delay(2000);

goto PEGAPOSICAO;

}

double calculaTempo1(float x, float y, double v, double T1){

//TRÊS DIMENSÕES

double distanciaA = sqrt((x*x)+(y*y)+1);

double tempoA = (distanciaA/v);

//TRÊS DIMENSÕES

double distanciaB = sqrt(((1-x)*x)+(y*y)+1);

double tempoB = (distanciaB/v);

double tempo=(tempoB+1)-T1;

tempo = fabs(tempo-tempoA);

return tempo;

}

double calculaTempo2(float x, float y, double v, double T2){

//TRÊS DIMENSÕES

double distanciaB = sqrt(((1-x)*x)+(y*y)+1);

double tempoB = (distanciaB/v);

//TRÊS DIMENSÕES

double distanciaC = sqrt(((1-x)*x)+((1-y)*y)+1);

double tempoC = (distanciaC/v);

double tempo=(tempoC+1)-T2;

tempo = fabs(tempo-tempoB);

return tempo;

}

PONTIFÍCIA UNIVERSIDADE CATÓLICA DO PARANÁlaplima/ensino/tcc/concluidos/2011/banshee.pdf ·...

Documents

Transcript of PONTIFÍCIA UNIVERSIDADE CATÓLICA DO PARANÁlaplima/ensino/tcc/concluidos/2011/banshee.pdf ·...