bâbures-amores.

com
Vela, frutos do mar e mariscos!

2) Faça um sextante eletrônico com arduino (bússola de rolamento

de mão, gitômetro e um relógio também).
Muito interessante para hackers especializados em coisas de bricolage, o arduino oferece à venda microcontroladores pro-
gramáveis ​em linguagem C, C ++ , embelezados com uma rica comunidade da Internet operando em código aberto, resu-
mindo, é quase como a casa de Ali Baba, encontramos muitas coisas, não importa, tudo com tudo e tudo em um pouco de
tudo… Minha namorada me deu o starter kit de presente de natal, e ela já está mordendo os dedos (arduino = aspirador de
vida, de tempo e interações sociais, ou mesmo pessoais higiene nos casos mais avançados mas vamos em frente…) ! Nunca
tente, é uma armadilha, essa merda finalmente. O período de confinamento me permitiu ter tempo para dedicar um pouco
de tempo a ele, mantendo ao mesmo tempo uma certa dignidade.….

1. Arduinono

A besta , aqui temos o “básico” (quando você pluga tudo, tem que gritar UNO !!! Caso contrário, o programa não funciona ...
Ha ha desculpe, estou com vergonha):
O Arduino permite configurar circuitos eletrónicos em áreas como domótica, robótica, informática…Podemos por exemplo
criar um sistema de rega automática para plantas de jardim, ou detetores de movimento, ou até drones ! Um cara até fez
uma raquete de tênis barulhenta…(existem muitos exemplos no youtube) ou um dispositivo de armazenamento de
M&M's&M’s. O cérebro dessas placas é um microcontrolador atmega; os outros componentes (quartzo, ficha Jack, in-
terface USB…) são anexos. Resumindo, é muito útil para obter e armazenar dados, processar e também realizar uma ação
automática depende dos dados encontrados.

A placa Arduino processa dados analógicos e digitais (conversor CAN e CNA integrado), para depois processá-los e, em se-
guida, gerar dados analógicos ou dados digitais utilizáveis. O programa segue sempre mais ou menos o mesmo quadro gra-
matical “grosseiramente”:

passo 1 : declaramos as bibliotecas importadas (se necessário) para o pré-processador, constantes e tipos de variáveis ​glo-
bais (utilizadas ao longo do programa) utilizadas.

passo 2 : Escrevemos o loop “setup”. Estas instruções serão executadas apenas uma vez no início do programa. Em geral
neste loop declaramos as instalações básicas como o uso de terminais (entrada ou saída) ou a inicialização de certos compo-
nentes (monitor serial, tela LCD…).

passo 3: Cuidamos do loop “loop”: suas instruções serão repetidas “indefinidamente” até que o cartão seja parado ou reini-
ciado. loops “setup” e “loop” são um pouco equivalentes ao loop “main” para C e C++; sem eles nenhum programa que
funcione.

passo 4: após o loop “loop” escrevemos, se necessário, as funções que criamos e que serão essenciais para o bom funciona-
mento do programa. Bastará então “chamar” no loop loop ou configurar se necessário.

As variáveis ​escritas fora dos loops de configuração e loop são consideradas globais (você pode chamá-las a qualquer mo-
mento em qualquer lugar do programa), as outras locais (funcionam apenas em seu próprio loop, não em outro lugar).

Esses microcontroladores AVR (portanto, arquitetura Harvard : ao contrário de um ti, por exemplo, as variáveis ​e o código
das instruções a seguir não são armazenados no mesmo local) também são caracterizados por 3 memórias de trabalho:

Memória Flash, aquela que vai integrar o programa escrito e compilado no cartão utilizado. Esta memória é modificada
cada vez que um novo código é compilado no cartão. Basicamente, ele contém as instruções.
 Memória SRAM dinâmica que suporta variáveis. Ele é apagado e começa do zero toda vez que o cartão é reiniciado ou
parado.
Memória EEPROM também chamada de ROM, onde os dados são mantidos mesmo após o cartão ter sido parado e inici-
ado. Alguns modelos não possuem esse tipo de memória, mas falaremos sobre isso mais adiante.

De acordo com o microcontrolador usado, então teremos uma capacidade de trabalho diferente (voltaremos a isso mais
tarde…) e o microcontrolador será mais ou menos poderoso, mas falaremos sobre isso novamente:

Arduino nano: 32KB de memória flash, 2KB de memória SRAM e 1K de memória eeprom.
Arduino uno R3 : igual ao nano mas maior em tamanho, menos interessante para sistemas embarcados.
Arduino mega2560 : obtemos um nível superior com 256 KB de memória flash para 8 KB de memória SRAM e 4 Ko de
memória EEPROM. Maior e mais imponente de um outro lado.

Além disso, dependendo das diferentes opções, aparecem ou desaparecem cartões como o número de terminais analógicos,
a frequência de cálculo (8 ou 16 MhZ, se houver um oscilador de quartzo integrado ou não, o que aumenta a velocidade de
cálculo, bem como o consumo de energia) por exemplo… Então dependendo do tipo de projeto que queremos fazer, temos
que escolher o microcontrolador certo, fazemos uma pequena especificação ! Um pouco como planejar o presunto no purê
se você gosta do presunto no purê, ou o PQ, ralador de queijo e kinders no acampamento….Se nós gostamos de kinders no
acampamento é claro.

2. Nossa máquina de navegação n, projeto original .

meu dispositivo que eu queria fazer no início deveria calcular o ângulo de inclinação e o ângulo de inclinação do barco, o
rumo da bússola, a temperatura externa e a pressão atmosférica. Para tudo isto vamos precisar de vários componentes…

A. adornamento e inclinação: Use um acelerômetro ADXL335

Começando no pequeno mundo do arduino, percebo quando estou pesquisando sobre tutoriais em vídeo do youtube e ou-
tros artigos da web que é possível fazer um inclinômetro graças a este pequeno sensor capaz de captar acelerações em to-
das as 3 direções do espaço; então vejo o link óbvio: inclinômetro = gitômetro! Mas não muito bom em explorar os resulta-
dos obtidos pelos diferentes tutoriais, decido a partir da folha de dados e pdf da escola IUT de Toulon (Arduino /
m2206_dossiertechnique_inclinometre.pdf) programar eu mesmo, se possível, essa coisinha.

Navegando na net, aprendemos que o adxl335 funciona um pouco como um capacitor variável. Dentro há uma parte fixa e
uma parte móvel, então quando movemos a parte móvel, ela muda a capacidade, permitindo que o sensor calcule um ân-
gulo ou uma força aplicada sobre ela. Algo louco.

coisas mais usadas : 1 arduino uno, 1 potenciômetro, 1 tela lcd.

Conexões
Para a tela LCD, o plugue RS é conectado ao plugue 8 do arduino, plugue E no 9 e plugues D4, D5, D6 e D7 respectivamente
nos plugues digitais 4, 5, 6 e 7 do arduino. O terminal V0 é conectado ao potenciômetro (esta é a resolução da tela), o plug
led- é conectado ao terra e o led + terminal é conectado à alimentação de 5V através de um resistor de 220 ohms (led- e led +
luz de fundo da tela de gerenciamento). O terminal Vdd está conectado à fonte de alimentação de 5 V e o terminal Vss ao
terra. O resto dos terminais na tela LCD estão conectados ao terra.

Para o acelerômetro, Vcc deve ser conectado à fonte de alimentação 3,3 V do arduino, GND deve ser aterrado e os terminais
X, Y e Z devem ser conectados respectivamente aos terminais analógicos A2, A1 e A0 do arduino.

código do inclinômetro :

#include< LiquidCrystal .h>

LiquidCrystal lcd(8,9,4,5,6,7);

const int ax_z = A0;

const int axe_y=A1;
const int machado_x=A2;

intx=0;
int y=0;
int z = 0;

flutuação const tensão_zero=1,66;

sensibilidade flutuante constante = 0,3;

void setup() {
lcd.start(16,2);

loop void() {
x=analogRead(axe_x);
y = analogRead(ax_y);
z=analogRead(ax_z);

float tension_x=(x/1024.0)*5.0;
float tension_y=(e / 1024.0)*5.0;
float tension_z=(from / 1024.0)*5.0;

float Gx=(tensão_x-tensão_zero)/sensibilidade;
float Gy=(tensão_y-tensão_zero)/sensibilidade;
float Gz=(tension_z-tension_zero)/sensibilidade;

float carre_Gx=sq(Gx);
float carre_Gy=sq(Gy);
float carre_Gz=sq(Gz);

float norme_G=sqrt(carre_Gx+carre_Gy+carre_Gz);

float roulis=graus(asin(Gx/norme_G));
float tangage=degrees(asin(Gy / norme_G));
float verticalite=degrees(acos(Gz/norme_G));

lcd.print("r:");
lcd.setCursor(2,0);
lcd.print(rolo);
lcd.setCursor(0,1);
lcd.print("t:");
lcd.setCursor(2,1);
lcd.print(pitch);
lcd.setCursor(9,0);
lcd.print("v:");
lcd.setCursor(11,0);
lcd.print(verticalite);

atraso(500);
 }

calibração

Para obter a precisão ideal, é necessário definir o acelerômetro bem paralelo a um plano reto e, em seguida, usar regras de
nível. teremos que pegar via saída de tensão da função serial quando o eixo de um acelerômetro estiver bem paralelo ao
eixo da gravidade. Em seguida, escrevemos a tensão correspondente. Essa tensão é a constante “tension_zero” no código es-
crito logo acima (1,66 Volts no meu caso). A sensibilidade (300 mV) é fornecida no datasheet do componente.

Benefícios / limitações

A maior vantagem 1 deste dispositivo quando temos que considerar um ângulo, é a simplicidade nos links como na progra-
mação; um iniciante como eu conseguiu fazer isso em (relativamente...) pouco tempo. A grande desvantagem, este disposi-
tivo sofre forças que encontra e não apenas a gravidade; portanto, se sofrer um impacto, ou se o barco estiver acelerando
ou desacelerando, os dados fornecidos serão desperdiçados ... Continua sendo interessante fazer um inclinômetro para tra-
balhos de bricolage em casa por exemplo, mas quando está em uma pessoa ou objeto em movimento, não é eficiente (a me-
nos que você esteja se movendo em velocidade constante e em linha reta o tempo todo, mas bem…).

B. adornamento e inclinação: usando um acelerômetro/girobússola mpu6050

Ele combina o acelerômetro e o giroscópio (e a temperatura também, acho, mas não explorei dessa maneira). Este compo-
nente é amplamente utilizado para drones porque permite calcular o trim da embarcação em voo (sofrem
acelerações/desacelerações…), controlando assim a sua trajetória. Muito interessante para o nosso projeto…Eles também es-
tão dentro dos celulares para gerenciar as mudanças de tela (quando viramos o celular, a imagem da tela também gira).

o giroscópio é útil para indicar a velocidade angular em torno dos eixos X, Y e Z. a velocidade também é a posição da deri-
vada em relação ao tempo, portanto, integrando essas velocidades, poderemos determinar a posição angular (exceto por
uma constante, ou seja, a inicial ou posição anterior na integração para ser mais preciso). O pequeno problema é que a cada
integração de dados há uma perda de precisão que aumentará com o tempo. E no final o giroscópio enlouquece, chamamos
isso de drift: é um pouco quando deixamos o Tio Roger falar na mesa completamente bêbados após o aperitivo, partimos de
um assunto aleatório mas nobre como a filosofia existencialista e cinco minutos depois derivamos sobre a sexualidade do
salmão na Dinamarca. Para corrigir isso, misturamos os dados do giroscópio e do acelerômetro. Em todo caso, para nós fun-
ciona, para o tio Roger não.

Conexões

Para operar e programar este componente, existe esta página da web que é muito boa:

http://gilles.thebault.free.fr/spip.php?article32

O código

Para ter inclinação e ângulo de inclinação, usei dois giroscópios (apenas um pode ser suficiente, mas no momento não sou
bom o suficiente para programar isso, apesar de algumas tentativas, mas veremos isso a seguir); para isso, usei o último có-
digo publicado na página da web anterior. cuidado tem um pequeno erro nesse código nas linhas 11 e 12: para nomes de
variáveis ​devemos somar 1 no final (isso dá ax1, ay1, az1 e gx1, gy1, gz1) senão o programa não vai conseguir calcule o
ângulo1 na linha 42 porque não reconhecerá os parâmetros usados.

Após a conexão e o código ligeiramente modificado, esse material funciona muito bem para o nosso projeto.

C. Pressão/temperatura: O BME280
O BME28O é um sensor capaz de nos fornecer pressão atmosférica (é por isso que podemos usá-lo para fazer um altímetro),
temperatura e higrometria. Este pequeno componente também pode ser usado para fazer uma pequena estação de previsão
do tempo (maldito seja um projeto de outra ideia, nunca fugiremos…).

Para o código, conexões e tudo é o mesmo, usei tudo o que encontrei nesta página bem explicada:

http://gilles.thebault.free.fr/spip.php?article47

D. proa: o GY-271
Este componente nos dirá a bússola de rumo ou a bússola de direção. é isso. Mesma página :

http://gilles.thebault.free.fr/spip.php?article58

explica muito bem como codificar nossa bússola. Aliás está sempre no mesmo sítio, muito bem feito e que escandalosa-
mente saqueei como um grande ladrão.

E. O barramento I2C.

Como vamos utilizar vários componentes ao mesmo tempo, utilizaremos o sistema de comunicação I2C entre eles e o micro-
controlador. A grande vantagem deste processo é a economia de conexões e fios; os componentes serão todos conectados a
4 fios comuns: SDA por onde circula a informação, SCL que indica a frequência do clock necessária “para conseguir uma
"orquestra" sincronizada capaz de tocar junto e seguir o mesmo compasso, aterramento e alimentação.

primeiros resultados

então as primeiras coisas que quebram mexilhões devo dizer:

O módulo BME280 funciona com 3,3 volts enquanto as outras coisas podem rodar com 5 volts de acordo com o datasheet,
na verdade parece (eu acho, mas não tenho certeza) que em I2C não funciona bem (parece que os módulos devem ter a
mesma tensão de alimentação). do outro lado quando está funcionando sozinho está ok.
 A bússola GY271 não funciona bem…Indica rumos como se eu estivesse na floresta de Blair Witch, para se ter uma
ideia…Meu módulo está com um primeiro relógio um QMCL5883L, só que no componente devo ler DA 5883 enquanto
aqui tenho DB 5883 escrito nele … a biblioteca que eu usei não é adequada para isso, talvez. A menos que essa origem de
falha esteja esperando em outro lugar. No entanto, parece indicar o norte corretamente, é quando me afasto dele que es-
traga, mas ei, não é apenas o norte na vida.
Eu tinha previsto usar um arduino nano para esse trabalho, só que meu modelo é uma cópia (com as mesmas habilida-
des porém, esse é um modelo da marca elegoo). Para que seja reconhecido pelo arduino IDE, baixe o driver CH340 e para
fazer o upload do código selecione arduino nano e processador atmega (antigo bootloader). De qualquer forma, no meu
caso, depois disso, funcionou. Este é um tipo de cartão elegoo. o “bootloader” é uma espécie de pequeno programa pré-
instalado na memória flash do cartão e que facilita a compilação do nosso código no microcontrolador.

Assim, com o laboratório, a equipe, meu gato e o pacote de salgadinhos ao meu lado, brainstorming e novo projeto:

Eu disse a mim mesmo bom, o BME280 guardo para depois fazer um barômetro da estação de previsão do tempo, e guardo
a bússola (com um pouco de esperança de fazer funcionar), os giroscópios e faço uma bússola / gitômetro de mão. E ca-
vando um pouco o assunto, vi que havia componentes de relógios externos do arduino…Além disso, o giroscópio parece me
dar um ângulo bastante preciso com pouco “ruído”….Então, se eu tiver um ângulo bastante preciso e uma faixa de tempo
real mesmo quando o arduino está desligado, então talvez eu possa fazer uma bússola / gitômetro / sextante “digital” não
cara, apertando minha esponja de ideias.

3) O sextante gitômetro bússola chipolata

Para este projeto, vamos usar um arduino mega card 2560, um único sensor gitômetro, um sensor de bússola GY271, uma
tela LCD com módulo I2C, um relógio externo em tempo real DS3231 (útil porque a bateria é removível!). Para fazer o visor
encontrei em um telescópio antigo, e os interruptores, os resistores e os diodos vieram de um rádio antigo perdido no fundo
da minha garagem. Também adicionaremos um teclado arduino flexível com 16 escalas.

a) um gitômetro para obter o calcanhar e o passo

Para nosso projeto teremos que usar um único gitômetro; Por que ? Bem, quando estiver usando o sistema de comunicação
I2C, cada componente conectado tem seu próprio endereço. a tela lcd usada pode ter vários (depende do tipo de circuito I2C
usado com a tela e também sua configuração com os terminais do jumper), no nosso caso é configurado com o endereço
0x27, o gitômetro só pode ter 2: 0x68 ou 0x69. Para o clock externo também é 0x68 e não tem outro…

Assim teremos que configurar o gitômetro com o endereço 0x69 para evitar perturbações com os dados dos relógios forne-
cidos. Existe um programa muito útil chamado I2CSCAN facilmente encontrado na net., capaz de fornecer os endereços dos
componentes conectados entre si em I2C diretamente pelo monitor serial.

Não se esqueça: quando mudamos o endereço do gitômetro de 0x68 para 0x69, o terminal ADO do componente também
deve estar conectado à fonte de alimentação. Também alteramos a conexão e o código. Para o nosso gitômetro, aqui está o
código da página da web http://gilles.thebault.free.fr/spip.php?article32 modificado para exibir ao mesmo tempo o calca-
nhar e o passo; há 2 mudanças para fazer muito simples finalmente. Quando olhamos para o código de um único
giroscópio:

Linha 8, dá: “MPU6050 accelgyro(0x69)”

linha 35, mudamos com:”

Gite = 0,98 * (Gite + float(gy) * 0,01 / 131) + 0,02 * atan2((double)ax, (double)the) * 180 / PI;
Passo = 0,98 * (Pitch + float(gx) * 0,01 / 131) + 0,02 * atan2((double)ay, (double)the) * 180 / PI;”

Mudamos a variável de ângulo por 2 variáveis ​de salto e inclinação, que devem ser declaradas no início do programa como
variáveis ​globais.

b) O relógio externo

Para a parte do sextante, precisamos deste componente. As fórmulas de cálculo de Jean Meeus são essencialmente baseadas
em funções que trabalham com a variável tempo. Ou quando o cartão está desligado, a trilha do tempo é perdida. Existem
as funções millis() e micros() que ativam um relógio interno na placa (timer), mas somente quando ela é energizada; e o ar-
mazenamento digital disso é limitado. O relógio DS3231 marca o tempo graças a uma bateria removível, mesmo quando
nosso circuito está aberto.

O relógio deve primeiro ser configurado para definir a hora, depois pode ser inserido em nosso programa e em nosso dispo-
sitivo. Para isso roubei vergonhosamente, sem vergonha, o código do livro “arduino: domesticar eletrônica e codificação”.
No site de Gilles thebault (anteriormente usado para mpu6050 e a bússola), também há um programa fornecido para operar
e configurá-lo no momento certo, mas, ei, também não vou despi-lo o tempo todo!

c) O teclado.

Para usá-lo, usaremos a biblioteca de teclados. Existem muitos tutoriais no youtube ou na net que explicam como funciona,
como uma matriz de contatos.

d) A bússola.

Tomaremos cuidado para não colocá-lo muito perto de um elemento eletromagnético perturbador para evitar o desperdício
de dados tanto quanto possível. Usei outras bússolas dessa vez com o número correto no componente e agora, funciona!

e) O grande problema

Nesta fase do projeto todos os elementos trabalham juntos via barramento I2C, o cronograma do programa funciona muito
bem, e paf aí vem a parede: a placa arduino mega2560 como a uno e a nano, roda com 8Kb SRAM brains (memória dinâ-
mica, área da variável) que limita o tamanho das variáveis ​usadas pelo nosso programa e cálculo de força.

Aí vem a piada: podemos manipular decimais (espécie de variável “float”, segura em 32 bits) com 7 números significativos
máximos (inteiro incluso, formando a mantissa ao todo), ou inteiros sem sinal (espécie de variável “unsigned long ”) onde
nossa variável não deve ultrapassar o número 4294967295. Para nosso maior infortúnio, nessas cartas a variável “double” é
equivalente ao “float” (“double” também é feito para armazenar um decimal mas com 14 números de mantissa. Para a
mantissa, consulte wikipépé, a página de ponto flutuante. A variável dupla contém 64 bits). Com as equações de Jean Meeus
vai ser um pouco chato porque usam números com muitos números…teremos que ser espertos para manter o mínimo de
precisão exigido.

Tentei fazer variáveis ​“long long” ou “unsigned long long” ninguém viu para armazenar minhas variáveis ​em 64 bits, mas
cada vez que o compilador grita, me mostra olhos grandes e me diz para ser fodido por uma tribo de gorilas. Mais ou menos
como um oficial alfandegário implacável, quando não declaro bem minhas variáveis, isso me falha ... Pode haver uma ma-
neira de fazer isso, mas não sei disso., burro que sou. Vou ter que encontrar outra coisa.

Parte 2: projeto final

Por fim, depois de todas essas decepções e desilusões vamos tentar conseguir algo além dessa confusão:

1) Equipamento utilizado

1 buzzer, tela lcd, módulo I2C, giroscópio mpu6050, bússola magnética GY271, relógio externo ds3231, cartão nano elegoo e
cartão due arduino, bateria 9v, 1 diodo by pass, 1 switch, 3.3V / Conversor lógico 5V, protoboard, visor astro de segunda
mão, filtro solar que acompanha, madeira para a caixa, macarrão chinês e chocolate lindt 85% ilimitado (para equilíbrio
mental da equipe).

O buzzer nos servirá de ajuda para a pontaria da estrela (abaixo de 2 graus de adornamento ele chia), e aqui usaremos um
arduino due card pois ele é capaz de lidar com variáveis ​reais duplas (como o arduino zero) graças ao seu processador mais
nítido (SAM3X8E ARM CortexM3, processador 32 bits).

Por que usar 2 cartões enquanto o Arduino devido seria suficiente? Bem, na verdade, existem poucas bibliotecas disponí-
veis para este cartão na rede porque ele é menos conhecido e usado “portanto, menos coisas de código aberto encontradas
nele”. Na verdade, é bastante reservado para programadores experientes capazes de escrever linguagens de baixo nível
perto do bit e registrar nomes, até mesmo capazes de escrever suas próprias bibliotecas… ” do projeto (ela obterá dados dos
sensores) e o arduino devido como o cérebro. Eles vão se comunicar juntos para trabalhar, assim como Minus e Cortex, Ar-
nold e Willy, Stone e Charden ou Jackie e Michel… Eu recuso toda a responsabilidade pela escolha de sua dupla favorita.
A. Principais problemas encontrados

a) Serial.write ou Serial.print?

Achei que os 2 eram a mesma coisa…Pois não. Serial.print retorna o valor diretamente enquanto Serial.write envia o valor
em formato binário.

b) Armazenar números inseridos com o teclado… ainda sonho com isso à noite

Está bem explicado no fórum do arduino, você tem que escrever um contador e armazenar o todo em uma cadeia de carac-
teres com um loop "for", depois converter a string em variável (no nosso caso, inteiros).

c) Converter switches em “escalas permanentes”... Eu ainda mijo na cama à noite.

você tem que criar uma variável intermediária e depois avaliá-la com condições, se ela atender à(s) condição(ões) nós a ar-
mazenamos em outra variável que acionará o menu (no nosso caso predatastate e datastate).

d) fazer um link 2 entre dois cartões diferentes…Para enviar e receber dados entre eles…ainda grito de pavor à noite

de olho nas coisas encontradas na net, normalmente é possível alternar o envio ou recebimento de mensagens ou variáveis ​
de um cartão para o outro graças a uma forma serial...Tentei muito antes de mudar de ideia; no início o nano enviava os da-
dos corretos para o devido através de uma variável de estrutura, o devido fazia seu trabalho e retornava para o nano mas
por outro lado o nano não conseguia receber as informações corretamente. Como usei apenas um canal para esses dois ca-
minhos de dados, disse a mim mesmo que deve ser um problema de buffer não esvaziado que atrapalha o sinal (essa des-
culpa não é nada ruim, não é? parece bom como um homem quem sabe do que está falando) ou enviou variáveis ​que tive-
ram que ser redefinidas, mas mesmo esvaziando cuidadosamente os buffers e redefinindo, ainda não funcionou.

Então configurei um segundo canal serial no nano graças a biblioteca softwareserial, agora tenho os pinos 11 e 12 que me
permitem comunicar com o devido. Este segundo canal enviará os resultados do due para o nano. funciona, mas as pessoas
que vão se concentrar no meu código sobre nano vão notar meu “método de trapaça deselegante” no final do programa…
Na verdade, em vez de receber o azimute e a variável de interceptação, meu DIY me envia 3 valores: primeiro, interceptar,
“-1” e o azimute. removendo o “atraso” quando -1 é exibido, funciona!

e) Conversão de variáveis ​para funções trigonométricas

Cuidado com a biblioteca de matemática, algumas variáveis ​devem ser convertidas em radianos, outras em graus senão fica
uma grande bagunça.

B. Esquema de montagem (com fritzing) .

Fritzing é um aplicativo e também um site que permite visualizar e exibir suas montagens eletrônicas, circuitos… Também
podemos fazer um circuito virtual na plataforma deles e depois encomendá-lo para obter um circuito impresso. Aqui está a
esperança do quadro sem erros:
Como o diagrama de montagem tem muitas ligações, e não sendo imune a deixar tretas, aqui vão os principais pontos a se-
rem observados:

Número 1 : esta linha + e – é alimentada pelo nano em 5 volts, o nano fornece energia para todos os componentes que funci-
onam no modo I2C (tela, giroscópio, bússola magnética, relógio).

Número 2 : esta segunda linha + e – é alimentada pela bateria de 9 volts; ele fornece o suco para nossos 2 cartões arduino.

Número 3: é o conversor lógico 3,3 volts / 5 volts. todas as conexões do arduino devido devem passar por ele, caso contrário,
você pode queimá-lo (o devido tipo só aceita tensão de 3,3 volts, não mais) exceto fonte de alimentação em Vin. Para cada
link serial, não se esqueça de inverter o Tx e o Rx: terminal emissor de um cartão é terminal receptor de outro. Caso contrá-
rio, a comunicação não funciona. Eu especifico isso porque no meu diagrama talvez haja piadas nesse nível.

Número 4: para a tensão de alimentação dos cartões adicionei um diodo by pass para proteger os cartões de um erro de
configuração da bateria; então se a pilha 9 volts for plugada de cabeça pra baixo no seu suporte, ela não queima nano e
due, o que seria um pouco chato…

C. A besta e como ela funciona.

Você vai desculpar a forma do design muito “URSS vintage” mas o orçamento era limitado eh…
Manual:

O menu é gerido pelos botões A,B,C e D do teclado. quando você liga, a máquina (vamos chamá-la de Nono) breve Nono
sempre exibirá a hora UTC. A ativa o gitômetro que indica a inclinação e o ângulo de inclinação, B o rumo da mão ou
bússola de proa, C a linha de posição com o Sol e finalmente D a linha de posição com a Lua.
Para linhas de posição, se os números usados ​para o ponto estimado forem negativos (latitude sul por exemplo), escreve-
mos o número no teclado e então pressionamos a tecla “*”. Se o número for positivo, para salvar o número, pressione a
tecla “#”. Se um número for negativo, tome cuidado para registrar também os minutos como negativos.
 Quando queremos olhar para o sol, no meu visor há um filtro astrológico muito importante para manter a retina saudá-
vel. Apontamos para a estrela. Se a campainha soar, significa que o trim do nono está equilibrado o suficiente (menos de
2 graus). depois disso, espere pelo menos 1 minuto antes de pressionar , tempo para o giroscópio estabilizar, e então você
pressiona qualquer botão do teclado (exceto os do menu) para pegar a altura da estrela e medir nossa posição.
Nono então primeiro dá a interceptação em milhas náuticas e depois o azimute em graus.

Atenção! : antes de usar não se esqueça de calibrar o giroscópio. Quando fixamos ou colamos o giroscópio no fundo do
Nono (hum) há uma perda de angulação de precisão então assim como o inclinômetro usaremos uma régua de nível e um
botão A (calcanhar e pitch) para identificar a correção da variável “Pitch”, muito importante para o nosso relógio de sol ou
lua (em nosso programa é TangageInit). Apertamos o botão A, depois configuramos a régua de nível acima de Nono, para-
lela ao visor; quando a bolha da regra de nível está no meio, escrevemos o ângulo de inclinação exibido por Nono, então in-
serimos no programa “nono” como o valor inicial da variável tangageInit (invertendo o sinal).

Atenção2 ! : a caixa que você vê é temporária; os 2 cabos que deixei fora da caixa de madeira ajudam-me a mudar ou apa-
rar o programa sem retirar coisas. e não é a prova d'água....

D. Os códigos (nano e due).

cartão “mestre” (arduino nano):

/*bibliotecas necessárias para o programa */

#include < SoftwareSerial .h>//permite emular um segundo canal serial.

SoftwareSerial backSerial(11,12);// Rx=11 et Tx=12

#include < MPU6050 .h>// gyrocompass.

#include < LiquidCrystal_I2C .h>//tela LCD em i2C.

#include < Teclado .h>//o teclado.

#include <Wire.h>//o barramento I2C.

#include <MechaQMC5883.h>//a bússola GY271 (modelo QMC).

#include <math.h>//funções matemáticas adicionais (especialmente trigo).

/*variáveis ​globais da bússola */

Sensor MechaQMC5883;

int mx, meu, mz; // declaração de variáveis ​

nos eixos x, y, z
ângulo de flutuação;

/*variáveis ​globais do teclado (teclado)*/

byte const LINHAS = 4;

const byte COLUNAS = 4;

teclas de caracteres [LINHAS][COLUNAS] = {

{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'#', '0', '*', 'D'}
};
byte ligPins[LINHAS] = {5, 4, 3, 2};
byte colPins[COLUNAS] = {9 , 8, 7, 6};

Teclado teclado = Teclado ( makeKeymap(teclas), ligPins, colPins, LINHAS, COLUNAS );

Char Keyboard[4];// variáveis ​

globais usadas para armazenar dados do teclado (cálculo, altura dos olhos).
int contador = 0;

/*variáveis ​para o menu de opções A,B,C e D (também altera as opções do teclado para opções "clássicas")*/
 char preDataState=0;// permite que você gerencie o menu do gitômetro, bússola de direção, hora utc e linhas
de altura.

char DataState=0;// transfere a variável para grossomerdo altera os switches do teclado para os switches
"fingerboards permanentes".

/*variáveis ​globais da tela (lcd de cristal líquido)*/

LiquidCrystal_I2C lcd(0x27,16,2); //tela LCD (endereço I2C, linhas, colunas)

/*variables globales gyrocompas (mpu6050)*/

MPU6050 accelgyro(0x69); // Alteração do endereço do giroscópio 0x68 (por padrão) em 0x69.

int16_t machado, sim, o;

int16_t gx, gy, gz;
uint8_t Accel_range;
uint8_t Gyro_range;
flutuante Casa rural = 0;
flutuante Tangagem = 0;
float GiteInit=-0.93;//permite calibrar o giroscópio no gite.
float TangageInit=-2.12;//permite calibrar o giroscópio em Pitch (particularmente importante para a precisão
do sextante).

/*variáveis ​de relógio externo (ds3231)*/

#define ADDRESS_I2C_RTC 0x68 // endereço do relógio.

byte segundo,minuto,hora,numDayWeek,numDayMonth,mês,ano;
String jourDeLaSemaine[8]={"","Dim","Lun","Mar","Mais","Jogo","Amigo","Sam"};

/*campainha variável*/

const int BUZZER=10;

/*variáveis ​de cálculo */

 int LatDeg = 333;// variáveis ​
de ponto estimadas, inicializadas em 333 (arbitrário) para poder inserir o 0
como valor nos cálculos.
int LatMin=333;
int LonDeg=333;
int LonMin=333;
byte alturaOeil = 250;
float estimativaLat = 0;
float estimaLon=0;
int Interceptação=0;
int Azimut=0;

estrutura de volta {
interceptação int;
int Azimut;
};

de volta ao ponto;

void setup() {
keyboard.setDebounceTime(10);// esta instrução evita problemas de salto com o teclado.
Serial .begin(57600);//abre o primeiro link serial para comunicação entre 2 cartões.
return Serial.start(57600);//abre o segundo link serial.

sensor.init();
//capteur.setMode(Mode_Continuous,ODR_200Hz,RNG_2G,OSR_256);para bússola magnética.

Wire.begin();// inicializa o link I2C.

/* configurar tela*/

lcd.init();
lcd.backlight();
 lcd.home();
lcd.setCursor(3,0);
lcd.print("navigogol");
lcd.setCursor(0,1);
lcd.print("onde estamos ?");
atraso(3000);
lcd.clear();

/* configurar girocompas */

accelgyro.initialize();

lcd.home();
lcd.print("Teste de giroscópio...");
lcd.setCursor(0,1);
lcd.print(accelgyro.testConnection() ? "gyro ok" : "cinto giroscópio aprox");
atraso(1000);
lcd.clear();

/*configuração do buzzer */

pinMode(BUZZER,OUTPUT);

loop void() {

/*variáveis ​globais usadas no loop */

 char key = keyboard.getKey();//armazenamos a tecla pressionada na variável key.

/*inicialização dos componentes*/

accelgyro.getMotion6(&ax, &ay, &the, &gx, &gy, &gz);

Gite = 0,98 * (Gite + float(gy) * 0,01 / 131) + 0,02 * atan2((double)ax, (double)the) * 180 / PI;
Passo = 0,98 * (Passo + float(gx) * 0,01 / 131) + 0,02 * atan2((duplo)ay, (duplo)the) * 180 / PI;

Wire.beginTransmission(ADRESSE_I2C_RTC);//hora e data de recepção

Wire.write(0);//configura o ponteiro do registrador para 00h
Wire.endTransmission();
Wire.requestFrom(ADRESSE_I2C_RTC,7);//acessar dados do relógio do registrador 00h
segundo = bcdToDec(Wire.read()& 0x7f);
minuto=bcdToDec(Wire.read());
hora = bcdToDec(Wire.read()&0x3f);
numJourSemaine=bcdToDec(Wire.read());
numJourMois=bcdToDec(Wire.read());
mês = bcdToDec(Wire.read());
ano = bcdToDec(Wire.read());

capteur.read(&mx, &my, &mz);

ângulo = graus(atan2((duplo)mx, (duplo)meu));

if (ângulo>=0) {
ângulo = ângulo de 360;
}
outro {
ângulo=abs(ângulo);
}

/*codificação do menu*/

DataState = key;//a chave é armazenada em DataState. Permite manter a tecla pressionada após o loop com
predatastate na memória.
 if (DataState=='A'||DataState=='B'||DataState=='C'||DataState=='D') {

preDataState=DataState;//muda os switches do teclado para switches "clássicos". PreDataState é usado para

operar o menu principal.
chave=0;

lcd.clear();//assim que uma tecla é pressionada, limpa rapidamente a tela. evita bugs com a tela lcd.

switch (preDataState) {
caso 'A':// tecla A ativa o gitômetro.

noTone(BUZZER);
lcd.home();
lcd.print("casa:");
lcd.setCursor(7,0);
lcd.print(Gite);
lcd.setCursor(0,1);
lcd.print("passo:");
lcd.setCursor(10,1);
lcd.print(Pitch);
atraso(10);

quebrar;

caso 'B':// tecla B ativa a bússola de orientação.

noTone(BUZZER);
lcd.home();
lcd.print("levantando:");
lcd.setCursor(3,1);
lcd.print(ângulo);
 atraso(100);

quebrar;

caso 'C':// tecla C ativa o modo sextante (sol).

if (LatDeg == 333 && LatMin == 333 && LonDeg == 333 && LonMin==333 && eyeHeight == 250) {

lcd.home();
lcd.print("estimativa de pontos");
lcd.setCursor(0,1);
lcd.print("Letão:");

if (chave!=NO_KEY && chave!='*' && chave!='#') {

Teclado[contador ++]=tecla;
Keyboard[counter]='';// indica o final da cadeia de caracteres.
lcd.setCursor(9,1);
lcd.print(Teclado);
}
else if (chave=='*') {
LatDeg = atoi(Teclado);// converte char para int.
Teclado[4]={0};
contador = 0;
lcd.clear();
}
else if (chave=='#') {
LatDeg = atoi(Teclado)*-1;
Teclado[4]={0};
contador = 0;
lcd.clear();
}
}
else if (Letão!=333 && LatMin == 333 && LonDeg == 333 && LonMin==333 && eyeHeight == 250) {

lcd.home();
 lcd.print("estimativa de pontos");
lcd.setCursor(0,1);
lcd.print("Latmin:");
lcd.setCursor(9,1);

if (chave!=NO_KEY && chave!='*' && chave !='#') {

Teclado[contador ++]=tecla;
Teclado[contador]='';
lcd.setCursor(9,1);
lcd.print(Teclado);
}

else if (chave=='*') {
LatMin = atoi(Teclado);
Teclado[4]={0};
contador = 0;
lcd.clear();
}

else if (chave=='#') {
LatMin = atoi(Teclado)*-1;
Teclado[4]={0};
contador = 0;
lcd.clear();
}

}
else if (Letão!=333 && LatMin!=333 && LonDeg == 333 && LonMin==333 && eyeHeight == 250) {

lcd.home();
lcd.print("estimativa de pontos");
lcd.setCursor(0,1);
lcd.print("LonDeg:");

if (chave!=NO_KEY && chave!='*' && chave!='#') {

Teclado[contador ++]=tecla;
 Teclado[contador]='';
lcd.setCursor(9,1);
lcd.print(Teclado);
}

else if (chave=='*') {
LonDeg = atoi(Teclado);
Teclado[4]=0;
contador = 0;
lcd.clear();
}

else if (chave=='#') {
LonDeg = atoi(Teclado)*-1;
Teclado[4]=0;
contador = 0;
lcd.clear();
}
}

else if (Letão!=333 && LatMin!=333 && LonDeg!=333 && LonMin==333 && eyeHeight == 250) {

lcd.home();
lcd.print("estimativa de pontos");
lcd.setCursor(0,1);
lcd.print("LonMin:");

if (chave!=NO_KEY && chave!='*' && chave!='#') {

Teclado[contador ++]=tecla;
Teclado[contador]='';
lcd.setCursor(9,1);
lcd.print(Teclado);
}

else if (chave=='*') {
LonMin = atoi(Teclado);
Teclado[4]={0};
 contador = 0;
lcd.clear();
}

else if (chave=='#') {
LonMin = atoi(Teclado)*-1;
Teclado[4]={0};
contador = 0;
lcd.clear();
}
}

else if (Letão!=333 && LatMin!=333 && LonDeg!=333 && LonMin!=333 && eyeHeight == 250) {

lcd.home();
lcd.print("altura dos olhos:");

if (chave!=NO_KEY && chave!='*' && chave!='#') {

Teclado[contador ++]=tecla;
Teclado[contador]='';
lcd.setCursor(0,1);
lcd.print(Teclado);
}

else if (chave=='*' || chave=='#') {

eyeHeight = atoi(Teclado);
Teclado[4]={0};
contador = 0;
lcd.clear();
}

}
 else if (altura dos olhos!=250 && Letão!=333 && LatMin!=333 && LonDeg!=333 && LonMin!=333) {

lcd.home();
lcd.print("ângulo do sol:");
lcd.setCursor(0,1);
lcd.print(Pitch);

if (chave==NO_KEY) {

if (Gite==constrain(Gite,0,2) ) {// facilita a precisão da mira. Se zumbir, está bom, você pode
pressionar para iniciar a máquina.
tom(BUZZER,500);
}
outro {
noTone(BUZZER);
}

atraso(100);
}

else if (chave!=NO_KEY) {
noTone(BUZZER);
lcd.clear();

estimadoLat = LatDeg + LatMin / 60,00;

estimadoLon = LonDeg + LonMin / 60,00;
char aster = 'C';

figuras de estrutura {// dados para enviar como variável de estrutura.

flutuar Tangage;
float estimaLat;
float estimaLon;
byte hauteurOeil;
 byte ano;
byte numJourMois;
byte mês;
byte hora;
byte minuto;
segundo byte;
char astre;

};

figuras de dados;

data.Tangage = Passo + TangageInit;

data.estimeLat = estimaLat;
data.estimeLon = estimeLon;
data.heightEye = heightEye;
data.annee = annee;
data.numJourMois = numJourMois;
data.mês = mês;
data.hora = hora;
dados.minuto = minutos;
dados.segundo = segundo;
data.astre = as estrelas;

Serial .write((byte *)&data, sizeof data);

Serial .flush();

atraso(3000);

while (retourSerial.available()>0) {
 retourSerial.readBytes((byte *)&ponto, tamanho do ponto);

Intercept=point.Intercept;
Azimut=ponto.Azimut;

lcd.home();
lcd.print("inter e azim:");
lcd.setCursor(0,3);
lcd.print(Interceptar);
atraso(4000);
lcd.clear();
lcd.home();
lcd.print("cocô cocô");
lcd.setCursor(0,3);
lcd.print(Azimut);
lcd.clear();

estimadoLat = 0, estimadoLon = 0, LatDeg = 333, LatMin = 333, LonDeg = 333, LonMin = 333, EyeHeight =
250;
}

}
}

quebrar;
 case 'D'://ativa o modo sextante(Lua).

if (LatDeg == 333 && LatMin == 333 && LonDeg == 333 && LonMin==333 && eyeHeight == 250) {

lcd.home();
lcd.print("estimativa de pontos");
lcd.setCursor(0,1);
lcd.print("Letão:");

if (chave!=NO_KEY && chave!='*' && chave!='#') {

Teclado[contador ++]=tecla;
Keyboard[counter]='';// indica o final da cadeia de caracteres.
lcd.setCursor(9,1);
lcd.print(Teclado);
}
else if (chave=='*') {
LatDeg = atoi(Teclado);// converte char para int.
Teclado[4]={0};
contador = 0;
lcd.clear();
}
else if (chave=='#') {
LatDeg = atoi(Teclado)*-1;
Teclado[4]={0};
contador = 0;
lcd.clear();
}
}
else if (Letão!=333 && LatMin == 333 && LonDeg == 333 && LonMin==333 && eyeHeight == 250) {

lcd.home();
lcd.print("estimativa de pontos");
lcd.setCursor(0,1);
lcd.print("Latmin:");
lcd.setCursor(9,1);
 if (chave!=NO_KEY && chave!='*' && chave !='#') {
Teclado[contador ++]=tecla;
Teclado[contador]='';
lcd.setCursor(9,1);
lcd.print(Teclado);
}

else if (chave=='*') {
LatMin = atoi(Teclado);
Teclado[4]={0};
contador = 0;
lcd.clear();
}

else if (chave=='#') {
LatMin = atoi(Teclado)*-1;
Teclado[4]={0};
contador = 0;
lcd.clear();
}

}
else if (Letão!=333 && LatMin!=333 && LonDeg == 333 && LonMin==333 && eyeHeight == 250) {

lcd.home();
lcd.print("estimativa de pontos");
lcd.setCursor(0,1);
lcd.print("LonDeg:");

if (chave!=NO_KEY && chave!='*' && chave!='#') {

Teclado[contador ++]=tecla;
Teclado[contador]='';
lcd.setCursor(9,1);
lcd.print(Teclado);
}

else if (chave=='*') {
 LonDeg = atoi(Teclado);
Teclado[4]=0;
contador = 0;
lcd.clear();
}

else if (chave=='#') {
LonDeg = atoi(Teclado)*-1;
Teclado[4]=0;
contador = 0;
lcd.clear();
}
}

else if (Letão!=333 && LatMin!=333 && LonDeg!=333 && LonMin==333 && eyeHeight == 250) {

lcd.home();
lcd.print("estimativa de pontos");
lcd.setCursor(0,1);
lcd.print("LonMin:");

if (chave!=NO_KEY && chave!='*' && chave!='#') {

Teclado[contador ++]=tecla;
Teclado[contador]='';
lcd.setCursor(9,1);
lcd.print(Teclado);
}

else if (chave=='*') {
LonMin = atoi(Teclado);
Teclado[4]={0};
contador = 0;
lcd.clear();
}

else if (chave=='#') {
LonMin = atoi(Teclado)*-1;
 Teclado[4]={0};
contador = 0;
lcd.clear();
}
}

else if (Letão!=333 && LatMin!=333 && LonDeg!=333 && LonMin!=333 && eyeHeight == 250) {

lcd.home();
lcd.print("altura dos olhos:");

if (chave!=NO_KEY && chave!='*' && chave!='#') {

Teclado[contador ++]=tecla;
Teclado[contador]='';
lcd.setCursor(0,1);
lcd.print(Teclado);
}

else if (chave=='*' || chave=='#') {

eyeHeight = atoi(Teclado);
Teclado[4]={0};
contador = 0;
lcd.clear();
}

else if (altura dos olhos!=250 && Letão!=333 && LatMin!=333 && LonDeg!=333 && LonMin!=333) {

lcd.home();
 lcd.print("ângulo da lua:");
lcd.setCursor(0,1);
lcd.print(Pitch);

if (chave==NO_KEY) {

if (Gite==constrain(Gite,0,2) ) {// facilita a precisão da mira. Se zumbir, está bom, você pode
pressionar para iniciar a máquina.
tom(BUZZER,500);
}
outro {
noTone(BUZZER);
}

atraso(100);
}

else if (chave!=NO_KEY) {
noTone(BUZZER);
lcd.clear();

estimadoLat = LatDeg + LatMin / 60,00;

estimadoLon = LonDeg + LonMin / 60,00;
char astr = 'D';

figuras de estrutura {// dados para enviar como variável de estrutura.

flutuar Tangage;
float estimaLat;
float estimaLon;
byte hauteurOeil;
byte ano;
byte numJourMois;
byte mês;
byte hora;
byte minuto;
segundo byte;
 char astre;

};

figuras de dados;

data.Tangage = Passo + TangageInit;

data.estimeLat = estimaLat;
data.estimeLon = estimeLon;
data.heightEye = heightEye;
data.annee = annee;
data.numJourMois = numJourMois;
data.mês = mês;
data.hora = hora;
dados.minuto = minutos;
dados.segundo = segundo;
data.astre = as estrelas;

while( Serial .available()>0) Serial .read();

Serial .write((byte *)&data, sizeof data);

Serial .flush();

atraso(3000);

while (retourSerial.available()>0) {

retourSerial.readBytes((byte *)&ponto, tamanho do ponto);

 Intercept=point.Intercept;
Azimut=ponto.Azimut;

lcd.home();
lcd.print("inter e azim:");
lcd.setCursor(0,1);
lcd.print(Interceptar);
atraso(4000);
lcd.home();
lcd.print("cocô cocô:");
lcd.setCursor(0,1);
lcd.print(Azimut);
lcd.clear();
estimadoLat = 0, estimadoLon = 0, LatDeg = 333, LatMin = 333, LonDeg = 333, LonMin = 333, EyeHeight =
250;
}
}

quebrar;

default:// exibe o relógio UTC quando nenhuma tecla de menu é pressionada.

noTone(BUZZER);
 lcd.home();
lcd.print("data:");
lcd.setCursor(7,0);
lcd.print(numDiaMês);
lcd.setCursor(9,0);
lcd.print("/");
lcd.setCursor(11,0);
lcd.print(mês);
lcd.setCursor(13,0);
lcd.print("/");
lcd.setCursor(14,0);
lcd.print(ano);
lcd.setCursor(0,1);
lcd.print("UTC:");
lcd.setCursor(5,1);
lcd.print(hora);
lcd.setCursor(7,1);
lcd.print("/");
lcd.setCursor(8,1);
lcd.print(minuto);
lcd.setCursor(10,1);
lcd.print("/");
lcd.setCursor(11,1);
lcd.print(segundo);

atraso(100);

quebrar;
}

}
 byte bcdToDec(byte val){return((val/16*10)+(val ));} //função que altera decimais codificados em binário para
decimais normais.

cartão “escravo” (arduino devido):

#include <math.h>//importa funções trigonométricas essenciais para nossos cálculos astronômicos.

figuras struct {// dados recebidos pelo nano colocados em variáveis ​

globais.

flutuar Tangage;
float estimaLat;
float estimaLon;
byte hauteurOeil;
byte ano;
byte numJourMois;
byte mês;
byte hora;
byte minuto;
segundo byte;
char astre;

};
figuras de dados;

estrutura de volta {
interceptação int;
int Azimut;
};
de volta ao ponto;

float Tangage,estimatedLat,estimado;
byte annee,numDayMonth,mês,hora,minuto,segundo,altura do olho;
char astre;
int Interceptação,Azimut;
void setup() {
Serial .begin(57600);//abre o caminho serial entre nano e due.
Serial1 .begin(57600);//abre o caminho serial entre due e nano.

}
loop void() {

if ( Serial .available()) {// lendo o buffer de recepção se estiver cheio.

Serial .readBytes((byte *)&data, sizeof data);// leitura dos dados que serão armazenados nas variáveis ​
globais.

Passo = dados.;
estimaLat = data.estimeLat;
estimeLon = data.estimeLon;
eyeHeight = data.heightOeil;
annee = data.annee;
numJourMois = dados.numJourMois;
mês = data.mês;
tempo = dados. tempo;
min = data.minuto;
segundo = dados.segundo;
as estrelas = data.astre;

}
while( Serial .available()>0) Serial .read();//vidade do seu buffer.

/*Serial.print(Pitch);
Serial.print(" ");
Serial.print(estimativaLat);
Serial.print(" ");
Serial.print(estimado);
Serial.print(" ");
Serial.print(altura dos olhos);
Serial.print(" ");
Serial.print(ano);
 Serial.print(" ");
Serial.print(numDiaMês);
Serial.print(" ");
Serial.print(mês);
Serial.print(" ");
Serial.print(hora);
Serial.print(" ");
Serial.print(minuto);
Serial.print(" ");
Serial.print(segundo);
Serial.print(" ");
Serial.print(estrela);
Serial.print(" ");
Serial.print(Intercept);
Serial.print(" ");
Serial.print(Azimut);
Serial.println();*/

int an = 2000 + ano;

int m = mês;

if (mes <=2) {
an-=1;
m+=12;
}
outro {
um=um;
m=m;
}

int a=int(an/100);
int b=2-a+int(a/4);

double jJulien=long(365.25*year)+long(30.6001*(m+1))+(numDayMonth + hour / 24.0 + minute

/(24.0*60.0)+second/(24.0*60.0*60.0))+1720994.5+b ;// Cálculo do dia Juliano.
double jJulien00h=long(365.25*year)+long(30.6001*(m+1))+numDayMonth + 1720994.5 + b;//cálculo do dia juliano às
00hUTC(permite calcular TSMG).

double T=(jJulien-2415020.0)/36525.0;// tempo em séculos Julianos(variável principal das equações de Jean

Meeus).
double T00h=(jJulien00h-2415020)/36525;//hora em séculos Julianos às 00hUTC(permite calcular TSMG).

if (estrela == 'C') {

duplo A=radianos(153.23+22518.7541*T);//correção venus.

duplo B=radianos(216.57+45037.5082*T);//correção venus.
duplo CD=radianos(312.69+32964.3577*T);//correção júpiter.
duplo D=radianos(350,74+445267,1142*T-0,00144*sq(T));//correção da lua.
double E=radianos(231.19+20.20*T);//desigualdade de período longo.
double H=radians(353.40+65928.7155*T);//Mike Brant's short size.

duplo
L=279,69668+36000,76892*T+0,0003025*sq(T)+0,00134*cos(A)+0,00154*cos(B)+0,00200*cos(CD)+0,00178*sin(E)+0,00179*sin
(D) ;//longitude média do sol.

duplo L1=L-long(L)+long(L)%360;

duplo M=358,47583+35999,04975*T-0,000150*sq(T)-0,0000033*pow(T,3);//average sun anomalia.

duplo M1=M-longo(M)+longo(M)%360;

double e=0.01675104-0.0000418*T-0.000000126*sq(T);//excentricidade da órbita da Terra.

double C1=(1.919460-0.004789*T-0.000014*sq(T))*sin(radianos(M1));//equação do centro do sol.

duplo C2=(0,020094-0,0001*T)*sin(radianos(M1));

duplo C3=0,000293*sin(3*radianos(M1));
 duplo C=C1+C2+C3;

double lonVraie=L1+C;//a verdadeira longitude do sol.

double v=M1+C;//verdadeira anomalia solar.

duplo R=((1,0000002*(1-sq(e)))/(1+e * cos(radianos(v)))+0,00000543*sin(A)+0,00001575*sin(B)+0,00001627*sin(CD

)+0,00003076*cos(D)+0,00000927*sin(H));//raio vetorial do sol em UA.

oblíquo duplo=23,452294-0,0130125*T-0,00000164*sq(T)+0,000000503*pow(T,3);//obliquidade da eclíptica.

dupla declinação=graus(asin(sin(radianos(oblíquo))*sin(radianos(reais))));

dupla ascensãoDroite=graus(atan2(cos(radianos(obliquito))*sin(radianos(reais)),cos(radianos(reais))));

if (ascensionDroite<0) {
ascensãoDroite + = 360;
}
outro {
ascensãoDroite + = 0;
}

double refraction=0;//Cálculo da correção da refração atmosférica de Jean Meeus.

if (Pitch>15.0) {
refração+=(58,294*tan(radianos(90-Pitch))-0,0668*pow(tan(radianos(90-Pitch)),3))/3600;
}

else if (Pitch>=0.0 && Pitch<4.0) {

refração+=(sq(6,6176-1,9037*log(Pitch + 1,4)))/60;
}

else if (Pitch>=4.0 && Pitch<=15.0) {

refração+=(sq(4,3481-0,9466*log(Pitch-1,4)))/60;
}

olho duplo =(1.76/sqrt(altura do olho))/60;//correção da altura do olho.

 double tempsSidGreen=0.276919398+100.0021359*T00h+0.000001075*sq(T00h);//tempo sideral em Greenwich em
revoluções.
double timeSidGreenHours =(tempsSidGreen-long(tempsSidGreen))*24;//hora sideral para Greenwich em horas.

double instantUT=(hora + minuto / 60,0 + segundo / 3600,0)*1,002737908;

double TSMG1=instantUT+tempsSidGreenHeures;//tempo sideral em Greenwich a qualquer hora UT.
duplo TSMG=TSMG1-longo(TSMG1)+longo(TSMG1)%24;

double Diametre=degrees(assign(695510.0/(R*150000000.0)));// cálculo do erro de meio diâmetro(inútil para o

nosso sistema de mira no final).

Paralaxe dupla=(6371/(R*150000000.0))*cos(radianos(Pitch-Eye));

duplo AHL1=(TSMG * 15 + 360)-ascensão reta + estima;

duplo AHL=AHL1-longo(AHL1)+longo(AHL1)%360;

double
hauteurCalculee=degrees(asin(sin(radians(estimatedLat))*sin(radians(declinaison))+cos(radians(estimatedLat))*cos(r
adians(declinaison))*cos(radianos(AHL))));

duplo Azimut=0;

if (AHL>=180 && AHL<360) {

Azimut+=degrees(acos((sin(radians(declinaison))-
sin(radians(estimatedLat))*sin(radians(heightCalculated)))/(cos(radians(estimatedLat))*cos(radians(heightCalculate
d)))) );
}
outro {
Azimut+=360-degrees(acos((sin(radians(declinaison))-
sin(radians(estimatedLat))*sin(radians(heightCalculated)))/(cos(radians(estimatedLat))*cos(radians(heightCalculate
d)) )));
}

double height True = Pitch-refraction-Eye + Parallax;// a correção de meio diâmetro é removida porque aqui
apontamos para o meio da estrela.

double Intercept=(altura True-height Calculado)*60;

 point.Intercept=int(round(Intercept));
point.Azimut=int(round(Azimut));

Serial .print(point.Intercept);
Serial .print(" ");
Serial .print(ponto.Azimut);
Serial .println();

Serial1 .write((byte *)&ponto,tamanhodo ponto);

Serial1 .flush();//esta instrução permite enviar todas as informações antes de ir para o programa.

atraso(500);

else if (estrela == 'D') {

 double omega1=259.183275-1934.1420*T+0.002078*sq(T)+0.0000022*pow(T,3);//longitude do nodo ascendente da lua.

ômega duplo=ômega1 longo(ômega1)+longo(ômega1)%360;

duplo Lprim1=270,434164+481267,8831*T-
0,001133*sq(T)+0,0000019*pow(T,3)+0,000233*sin(radianos(51,2+20,2*T))+0,003964*sin(radianos(346,56+132,87*T)
-0.0091731*sq(T)))+0.001964*sin(radianos(omega));//longitude média da lua.

duplo Lprim=Lprim1-long(Lprim1)+long(Lprim1)%360;

duplo M1=358,475833+35999,0498*T-0,000150*sq(T)-0,0000033*pow(T,3)-0,001778*sin(radianos(51,2+20,2*T));//average
sun anomaly.

duplo M=M1-longo(M1)+longo(M1)%360;

duplo
Mprim1=296,104608+477198,8491*T+0,009192*sq(T)+0,0000144*pow(T,3)+0,000817*sin(radianos(51,2+20,2*T))+0,003964*sin
(radianos(346,56+132,87*T) -0,0091731*sq(T)))+0,002541*sin(radianos(ômega));//anomalia média da lua.

duplo Mprim=Mprim1-longo(Mprim1)+longo(Mprim1)%360;

duplo D1=350,737486+445267,1142*T-
0,001436*sq(T)+0,0000019*pow(T,3)+0,002011*sin(radianos(51,2+20,2*T))+0,001964*sin(radianos(ômega))+0,003964
*sin(radians(346.56+132.87*T-0.0091731*sq(T)));//alongamento médio da lua.

duplo D=D1-longo(D1)+longo(D1)%360;

duplo F1=11,250889+483202,0251*T-0,003211*sq(T)-0,0000003*pow(T,3)+0,003964*sin(radianos(346,56+132,87*T-
0,0091731*sq(T)))-0,024691*sin( radians(omega))-0.004328*sin(radians(omega * T + 275.05-2.3));//distância média da
lua ao seu nodo ascendente.

duplo F=F1-longo(F1)+longo(F1)%360;

duplo e=1-0,002495*T-0,00000752*sq(T);

duplo teta=Lprim+6,288750*sin(radianos(Mprim))+1,274018*sin(radianos(2*D-
Mprim))+0,658309*sin(radianos(2*D))+0,213616*sin(radianos(2*Mprim) ))-0,185596*sin(radianos(M))*e-
0,114336*sin(radianos(2*F))+0,058793*sin(radianos(2*D-2 * Mprim))+0,057212*sin(radianos(2 *DM-Mprim))*e + 0,053320
* sin(radianos(2*D + Mprim))+0,045874*sin(radianos(2*DM))*e +
0,041024 * sin(radianos(A impressora tem-M))*e-0,034718*sin(radianos(D))-0,030465*sin(radianos(M + impressora
tem))*e + 0,015326 * sin(radianos(2*D -2*F))-0,012528*sin(radianos(2*F+Mprim))-0,010980*sin(radianos(2*F-
Mprim))+0,010674*sin(radianos(4*D-Mprim))+0,010034 *sen(radianos(3*Mprim))+0,008548*sen(radianos(4*D-2 *
Mprim))-0,007910*sen(radianos(M-Mprim+2*D))*e-
0,006783*sin(radianos(2*D+M))*e + 0,005162 * sin(radianos(Mprim-D))+0,005*sin(radianos(M+D))*e + 0,004049 *
sin(radianos(Mprim- M+2*D))*e + 0,003996 * sin(radianos(2*Mprim + 2 *
D))+0,003862*sen(radianos(4*D))+0,003665*sen(radianos(2*D-3 * Mprim))+0,002695*sin(radianos(2*A impressora tem-
M))*e + 0,002602 * sin(radianos(Mprim-2*F-2*D))+0,002396*sin(radianos(2*DM- 2*Mprim))*e-
0,002349*sin(radianos(Mprim + D))+0,002249*sin(radianos(2*D-2*M))*sq(e)-0,002125*sin(radianos(2*O impressora tem +
M))*e-0,002079*sin(radianos(2*M))*sq(e)+0,002059*sin(radianos(2*D-Mprim-2*M))*sq(e)-0,001773
*sin(radianos(Mprim+2*D-2*F))-0,001595*sin(radianos(2*F+2*D))+0,001220*sin(radianos(4*DM-Mprim))*e-0,001110
*sin(radianos(2*Mprim+2*F))
+0,000892*sin(radianos(Mprim-3 * D))-0,000811*sin(radianos(M+Mprim+2*D))*e + 0,000761 * sin(radianos(4*DM-
2*Mprim))*e + 0,000717 * sin(radianos(* M-2 que a impressora possui))*sq(e)+0,000704*sin(radianos(Mprim-2*M-
2*D))*sq(e)+0,000693*sin(radianos (M-2*Mprim+2*D))*e + 0,000598 * sin(radianos(2*DM-2*F))*e + 0,000550 *
sin(radianos(Mprim + 4 * D))
+0,000538*sin(radianos(4*Mprim))+0,000521*sin(radianos(4*DM))*e + 0,000486 * sin(radianos(2*Mprim-
D));//longitude eclíptica da lua.

duplo B=5,128189*sin(radianos(F))+0,280606*sin(radianos(Mprim+F))+0,277693*sin(radianos(Mprim-
F))+0,173238*sin(radianos(2*DF))+0,055413 *sin(radianos(2*D+F-Mprim))+0,046272*sin(radianos(2*DF-
Mprim))+0,032573*sin(radianos(2*D+F))+0,017198*sin(radianos(2 *Mprim+F))+0,009267*sen(radianos(2*D+Mprim-
F))+0,008823*sen(radianos(2*Mprim-F))
+0,008247*sin(radianos(2*DMF))*e + 0,004323 * sin(radianos(2*DF-
2*Mprim))+0,004200*sin(radianos(2*D+F+Mprim))+0,003372*sin (radianos(FM-2*D))*e + 0,002472 * sen(radianos(2*D+FM-
Mprim))*e + 0,002222 * sen(radianos(2*D+FM))*e + 0,002072 * sen (radianos(2*DFM-Mprim))*e + 0,001877 *
sin(radianos(F-M+Mprim))*e + 0,001828 * sin(radianos(4*DF-Mprim))
-0,001803*sin(radianos(F+M))*e-0,001750*sin(radianos(3*F))+0,001570*sin(radianos(Mprim-MF))*e-
0,001487*sin(radianos(F+D) ))-0,001481*sin(radianos(F+M+Mprim))*e + 0,001417 * sin(radianos(FM-Mprim))*e +
0,001350 * sin(radianos(FM))*e + 0,001330 * sin(radianos
(FD))+0,001106*sen(radianos(F+3*Mprim))+0,001020*sen(radianos(4*DF))+0,000833*sen(radianos(F+4*D-Mprim))
+0,000781*sen(radianos(Mprim-3*F))+0,000670*sen(radianos(F+4*D-2*Mprim))+0,000606*sen(radianos(2*D-
3*F))+0,000597 *sin(radianos(2*D+2*Mprim-F))+0,000492*sin(radianos(2*D+Mprim-MF))*e + 0,000450 *
sin(radianos(2*Mprim-F-2*D ))+0,000439*sen(radianos(3*Mprim-
F))+0,000423*sen(radianos(F+2*D+2*Mprim))+0,000422*sen(radianos(2*DF-3*Mprim))
-0,000367*sin(radianos(M+F+2*D-Mprim))*e-0,000353*sin(radianos(M+F+2*D))*e + 0,000331 * sin(radianos(F+4*D
))+0,000317*sin(radianos(2*D+F-M+Mprim))*e + 0,000306 * sin(radianos(2*D-2*MF))*sq(e)-0,000283*sin(radianos(
Mprim+3*F));

duplo W1=0,0004664*cos(radianos(ômega));
duplo W2=0,0000754*cos(radianos(ômega * T + 275,05-2,30));

double beta=B*(1-W1-W2);//latitude eclíptica da lua.

Pi duplo=0,950724+0,051818*cos(radianos(Mprim))+0,009531*cos(radianos(2*D-
Mprim))+0,007843*cos(radianos(2*D))+0,002824*cos(radianos(2*Mprim) ))+0,000857*cos(radianos(2*D +
Mprim))+0,000533*cos(radianos(2*DM))*e + 0,000401 * cos(radianos(2*DM-Mprim))*e + 0,000320 * cos (radianos(A
impressora tem-M))*e-0,000271*cos(radianos(D))-0,000264*cos(radianos(M + impressora tem))*e-
0,000198*cos(radianos(2*F-Mprim) )+0,000173*cos(radianos(3*Mprim))+0,000167*cos(radianos(4*D-
Mprim))-0,000111*cos(radianos(M))*e + 0,000103 * cos(radianos(4*D- 2 * Mprim))-0,000084*cos(radianos(2*Mprim-2 *
D))-0,000083*cos(radianos(2*D+M))*e + 0,000079 * cos(radianos(2*D + 2 *
Mprim))+0,000072*cos(radianos(4*D))+0,000064*cos(radianos(2*D-M+Mprim))*e-0,000063*cos(radianos(2*D+M-Mprim))* e +
0,000041 * cos(radianos(M+D))*e + 0,000035 * cos(radianos(2*A impressora tem-M))*e-0.000033*cos(radianos(3*Mprim-2
* D))-0,000030*cos(radianos(Mprim + D))-0,000029*cos(radianos(2*F-2*D))-0,000029*cos(radianos( 2*A impressora tem
+ M))*e + 0,000026 * cos(radianos(2*D-2*M))*sq(e)-0,000023*cos(radianos(2*F-2*D+Mprim))
+0,000019*cos(radianos(4*DM-Mprim))*e;//paralaxe da lua.

double R=(6378.14/sin(radianos(Pi)));//distância entre o centro da terra e a lua em km.

oblíquo duplo=23,452294-0,0130125*T-0,00000164*sq(T)+0,000000503*pow(T,3);//obliquidade da eclíptica.

dupla ascensãoDroite=degrees(atan2((sin(radians(tia))*cos(radians(obliquite))-
tan(radians(beta))*sin(radians(obliquite))),cos(radians(tia)))) ;//saída da lua certa.

if (ascensionDroite<0) {
ascensãoDroite + = 360;
}
outro {
ascensãoDroite + = 0;
}

dupla
declinação=graus(asin(sen(radianos(beta))*cos(radianos(oblíquo))+cos(radianos(beta))*sin(radianos(oblíquo))*sin(ra
dianos(tia))));/ /declinação da lua.

dupla refração=0;

if (Pitch>15.0) {
refração+=(58,294*tan(radianos(90-Pitch))-0,0668*pow(tan(radianos(90-Pitch)),3))/3600;
}

else if (Pitch>=0.0 && Pitch<4.0) {

refração+=(sq(6,6176-1,9037*log(Pitch + 1,4)))/60;
}

else if (Pitch>=4.0 && Pitch<=15.0) {

refração+=(sq(4,3481-0,9466*log(Pitch-1,4)))/60;
}

olho duplo =(1,76/sqrt(altura do olho))/60;

double tempsSidGreen=0.276919398+100.0021359*T00h+0.000001075*sq(T00h);//tempo sideral em Greenwich em

revoluções.
double timeSidGreenHours =(tempsSidGreen-long(tempsSidGreen))*24;//hora sideral para Greenwich em horas.

double instantUT=(hora + minuto / 60,0 + segundo / 3600,0)*1,002737908;

double TSMG1=instantUT+tempsSidGreenHeures;//tempo sideral em Greenwich a qualquer hora UT.
duplo TSMG=TSMG1-longo(TSMG1)+longo(TSMG1)%24;

double Diametre=degrees(assign(1750/R));//inútil para o nosso sistema de mira no final.

Paralaxe dupla=(6371/R)*cos(radianos(Pitch-Eye));

duplo AHL1=(TSMG * 15 + 360)-ascensão reta + estima;

duplo AHL=AHL1-longo(AHL1)+longo(AHL1)%360;

double
hauteurCalculee=degrees(asin(sin(radians(estimatedLat))*sin(radians(declinaison))+cos(radians(estimatedLat))*cos(r
adians(declinaison))*cos(radianos(AHL))));

duplo Azimut=0;

if (AHL>=180 && AHL<360) {

Azimut+=degrees(acos((sin(radians(declinaison))-
sin(radians(estimatedLat))*sin(radians(heightCalculated)))/(cos(radians(estimatedLat))*cos(radians(heightCalculate
d)))) );
}
outro {
Azimut+=360-degrees(acos((sin(radians(declinaison))-
sin(radians(estimatedLat))*sin(radians(heightCalculated)))/(cos(radians(estimatedLat))*cos(radians(heightCalculate
d)) )));
}

altura dupla True = Pitch-refraction-Eye + Parallax;

double Intercept=(altura True-height Calculado)*60;

point.Intercept=int(round(Intercept));
point.Azimut=int(round(Azimut));

Serial1 .write((byte *)&ponto,tamanhodo ponto);

Serial1 .flush();

while( Serial1 .available()) Serial1 .read();

 }

ponto de retorno ={0,0};

dados ={0,0,0,0,0,0,0,0,0,0,0};

Pitch = 0, estimaLat = 0, estimaLon = 0, eyeHeight = 0, numDayMonth = 0, mês = 0, hora = 0, minuto = 0, segundo

= 0, estrela = 0, Azimute = 0, interceptação = 0, ano = 0;

E. Resultados, veredicto de Nono

1. No chão

Ao testar o Nono no meu jardim (com o dispositivo do Nono não precisamos ver a linha do horizonte, então é possível, por
outro lado, você precisa saber sua altitude), as funções do gitômetro e da bússola funcionam bem. Para a função C (linha de
posição com o Sol) também; ao reservar um tempo para mirar, você obtém uma boa precisão para algo “feito em casa”. Por
outro lado, a função D com a Lua é bem menos precisa sem ser catastrófica por tudo isso.; terá que melhorar. No entanto, o
objetivo permanece mais difícil de fazer em comparação com um sextante clássico. O menor movimento parasitário nos faz
perder a precisão (principalmente quando você aperta o botão enter), e lá é só no jardim…No mar pode ser mais delicado,
talvez.

2. No meu barco
Sem surpresa, apontar permanece bastante fácil no barco em tempo calmo. quanto mais altas forem as ondas e suas
frequências, maior será a perda de precisão. Um teste de mar calmo e cabo me deu um ponto de precisão de 13 minutos. Em
terreno com uma boa calibração do giroscópio obtemos aproximadamente a mesma precisão nos 2 pontos realizados. Por
outro lado, mirar com a Lua ainda não é suficientemente preciso, embora os resultados não sejam completamente
aberrantes.

3. Conclusão

Comparado com um sextante convencional que é caro e requer cálculos na tabela de cartas depois, este sistema é clara-
mente vantajoso porque economiza tempo e dinheiro; além disso, pode ser usado sem ver a linha do horizonte em caso de
neblina ou ao anoitecer, por exemplo, também no solo (desde que você conheça sua altitude). Por outro lado, quando o mar
está agitado, é muito difícil apontar para a estrela e ter os dados do giroscópio suficientemente estáveis ​para obter uma me-
dição precisa.

4.possíveis extensões para melhorar este sistema

a. Faça melhor e mais barato

Este sistema usa duas placas arduino, e o preço de vencimento é caro., mas acho que é possível fazer muito melhor com me-
nos…Ao terminar de escrever este artigo, acabei de receber uma placa raspberry pi zero. Resumindo, em comparação com
uma placa arduino, o raspberry pi está mais próximo do PC do que do microcontrolador. Além disso este cartão custa ape-
nas 5 euros (ver kubii), 10 com portes de envio…

Este cartão é realmente um pequeno computador, com capacidades de cálculo aumentadas (mas sem processamento de da-
dos analógicos ao contrário do arduino por outro lado) e especialmente…Uma memória! De fato no meu projeto não há cál-
culo do meridiano com o sol porque não tinha coisas para armazenar informações. Com a memória interna, poderíamos ar-
mazenar pontos de posição para desenhar uma função capaz de descrever o movimento do sol (uma parábola) por meio de
uma interpolação de Lagrange ou outra técnica, talvez (não precisamos ter uma curva extremamente precisa, acho, é o má-
ximo da curva que importa se no eixo x definimos o tempo e no eixo y a altura angular do sol). Esta memória interna tam-
bém permitirá que as posições sejam armazenadas para induzir um menu, um histórico de navegação por exemplo, ou cal-
cular uma velocidade de fundo…

Finalmente, este cartão pode integrar uma pequena câmera…Você entende o que quero dizer? (não, não filmar os vestiários
das meninas rapidamente) ainda não? (não fazer o segundo capítulo de um filme de “o quarto” por favor) melhore a ponta-
ria da estrela! por tudo isso, vou ter que começar a aprender a escrever python…

b. Próxima Etapa

Em breve irei estender o artigo tentando ter uma maior precisão com a linha de posição da lua, e também melhor aprovei-
tamento do buzzer (com por exemplo um som mais baixo quando o giroscópio está estável para facilitar a mira talvez…). E
obviamente, faça uma outra versão melhorada com python e raspberry pi! Bom, se você notou algum erro ou possível me-
lhoria do projeto, especialmente não hesite em compartilhar deixando uma pequena mensagem! Aguardando, pequeno ví-
deo explicativo:

VID 022
 pequeno vídeo de teste de penardo no jardim

 16 de julho de 2020  harry tutle  meu pequeno barco-laboratório , Navegação Celestial

3 pensamentos sobre “2) Faça um sextante eletrônico com arduino (bússola, gitômetro e um
relógio também).”

TUAL Ludovic
21 de janeiro de 2021 às 19h 26min

Salut , hiper interessante . j'ai eu l'idee il y à quelques jour de tunné une paire de lunette d'Eclipse pour réalisé .. exactement
ce que tu décris Mais pour un use à terra , randonnée .

J'aurais des questions pour toi si tu as de la dispo !

Like

harry tutle 
5 de fevereiro de 2021 às 19h04min

Saudações , misericórdia! Pas de problème pour les questions hésite pas .

Like
 harry tutle 
6 de fevereiro de 2021 às 18h 52min

Si tu veux pour les question tu peux les envoyer sur babure.amore@gmail.com au fait . para + !

Like

Este site usa Akismet para reduzir o spam. Saiba como seus dados de comentários são processados .

Orgulhosamente desenvolvido com WordPress