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
3.2
Fluxograma.................................................................. 11
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
4.
3.1.1.3
O tempo de propagação pode ser determinado.......... 14
3.1.1.4
Fluxograma.................................................................. 17
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.
T
T
Receptor
T
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.
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
Inicio
Configura portas
Ativa
TRANSMISSOR1
Aguarda 5
microssegundos
Aguarda 1
segundo
Desativa
TRANSMISSOR1
Ativa
TRANSMISSOR2
Aguarda 5
microssegundos
Desativa
TRANSMISSOR2
Aguarda 1
segundo
Ativa
TRANSMISSOR3
Aguarda 5
microssegundos
Desativa
TRANSMISSOR2
Aguarda 5
segundos
Figura 6 – Fluxograma do código do módulo transmissor
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.
(0,0,z)
d
(x,0,0)
(0,0,0)
(0,y,0)
P=(x,y,z)
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.
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.
(x,y+∆)
(x-∆,y+∆)
(x+∆,y+∆)
(x,y)
(x-∆,y)
(x+∆,y)
(x-∆,y-∆)
(x+∆,y-∆)
(x,y-∆)
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;
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:
Tempo de propagação
Intervalo entre recepções
1 segundo = período
Tempo de propagação
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.
3.1.1.4
Fluxograma
Inicio
Configura
display
Configura portas
S
Armazena
tempo
Aguarda
recepção
Recepção Ok?
N
S
Aguarda
recepção
Recepção Ok?
Armazena
tempo
N
S
Armazena
tempo
Recepção Ok?
Aguarda
recepção
Calcula posição
N
Apresenta
resultado
Figura 11 – Fluxograma do código do módulo receptor
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.
ALGORITMO DE CÁLCULO DE POSIÇÃO
TEÓRICO
X
0,01
0,15
0,25
0,30
0,45
0,62
0,71
0,99
CALCULADO
Y
0,01
0,15
0,25
0,70
0,90
0,43
0,88
0,99
X
0,24
0,24
0,24
0,25
0,40
0,68
0,77
1,00
Y
0,24
0,24
0,24
0,75
0,60
0,32
0,77
1,00
ERRO
TEMPO DE RESPOSTA
0,06
0,03
0,00
0,02
0,19
0,00
0,03
0,01
0,04
0,169
0,172
0,17
0,161
0,081
0,123
0,171
0,292
0,167
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;
int TRANSMISSOR2=12;
int TRANSMISSOR3=11;
void setup(){
pinMode(TRANSMISSOR1, OUTPUT);
pinMode(TRANSMISSOR2, OUTPUT);
pinMode(TRANSMISSOR3, 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
digitalWrite(TRANSMISSOR2, HIGH);
// sets the LED on
delay(100);
digitalWrite(TRANSMISSOR2, LOW);
// sets the LED off
delay(1000);
// waits for a second
digitalWrite(TRANSMISSOR3, HIGH);
delay(100);
digitalWrite(TRANSMISSOR3, LOW);
delay(5000);
7.2
// sets the LED on
// sets the LED off
// waits for five seconds
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.setCursor(0, 0);
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];
goto SEGUNDA_RECEPCAO;
}
else{
if((temp-first) > 100000){
tempos[1]=temp;
}
else
goto SEGUNDA_RECEPCAO;
}
}
TERCEIRA_RECEPCAO:
if(!digitalRead(7))
goto TERCEIRA_RECEPCAO;
else{
temp=micros();
if((tempos[1]+1500000) < temp){
tempos[0]=temp;
first=tempos[0];
goto SEGUNDA_RECEPCAO;
}
else{
if((temp-tempos[1]) > 100000){
tempos[2]=temp;
}
else
goto TERCEIRA_RECEPCAO;
}
}
tempos[0] = tempos[0]/1000000;
tempos[1] = tempos[1]/1000000;
tempos[2] = tempos[2]/1000000;
T1 = (tempos[1] - tempos[0]);
T2 = (tempos[2] - tempos[1]);
lcd.setCursor(0, 0);
lcd.print("
");
lcd.setCursor(0, 0);
lcd.print("T1=");
lcd.print(T1);
lcd.setCursor(0, 1);
lcd.print("
lcd.setCursor(0, 1);
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.setCursor(0, 0);
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.setCursor(0, 1);
lcd.print("
");
lcd.setCursor(0, 1);
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.setCursor(0, 0);
lcd.print("
");
lcd.setCursor(0, 0);
lcd.print("3=");
lcd.print(menor[2]);*/
x=calculaTempo1(bx-delta,by-delta,v,T1);
y=calculaTempo2(bx-delta,by-delta,v,T2);
menor[3]=(x+y);
/*lcd.setCursor(0, 1);
lcd.print("
");
lcd.setCursor(0, 1);
lcd.print("4=");
lcd.print(menor[3]);
delay(2000);*/
x=calculaTempo1(bx,by-delta,v,T1);
y=calculaTempo2(bx,by-delta,v,T2);
menor[4]=(x+y);
/*lcd.setCursor(0, 0);
lcd.print("
");
lcd.setCursor(0, 0);
lcd.print("5=");
lcd.print(menor[4]);*/
x=calculaTempo1(bx+delta,by-delta,v,T1);
y=calculaTempo2(bx+delta,by-delta,v,T2);
menor[5]=(x+y);
/*lcd.setCursor(0, 1);
lcd.print("
");
lcd.setCursor(0, 1);
lcd.print("6=");
lcd.print(menor[5]);
delay(2000);*/
x=calculaTempo1(bx+delta,by,v,T1);
y=calculaTempo2(bx+delta,by,v,T2);
menor[6]=(x+y);
/*lcd.setCursor(0, 0);
lcd.print("
lcd.setCursor(0, 0);
lcd.print("7=");
");
lcd.print(menor[6]);*/
x=calculaTempo1(bx+delta,by+delta,v,T1);
y=calculaTempo2(bx+delta,by+delta,v,T2);
menor[7]=(x+y);
/*lcd.setCursor(0, 1);
lcd.print("
");
lcd.setCursor(0, 1);
lcd.print("8=");
lcd.print(menor[7]);
delay(2000);*/
x=calculaTempo1(bx,by,v,T1);
y=calculaTempo2(bx,by,v,T2);
menor[8]=(x+y);
/*lcd.setCursor(0, 0);
lcd.print("
lcd.setCursor(0, 0);
lcd.print("9=");
lcd.print(menor[8]);*/
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){
goto IMPRIMEPOSICAO;
}
if(((calculaTempo1(bx,by,v,T1)
calculaTempo2(bx,by,v,T2))) < deltaT){
goto CALCULAPOSICAO;
}
else
goto IMPRIMEPOSICAO;
IMPRIMEPOSICAO:
//IMPRIMEPOSICAO
lcd.setCursor(0, 1);
lcd.print("
");
lcd.setCursor(0, 1);
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;
}