2) Fabriquer un sextant électronique avec arduino (compas de relèvement, gitomètre, et horloge en option).

Très intéressant pour les hackers spécialistes en bidouillette bricoling, arduino propose à la vente des microcontrôleurs programmables en langage proche C, C++ , agrémenté d’une communauté internet riche fonctionnant en open source, bref c’est un peu la caverne d’Ali Baba on y trouve de tout, n’importe quoi, tout avec n’importe quoi et n’importe quoi dans un peu de tout… Ma copine m’a offert le kit débutant pour Noel, et elle s’en mord déjà les doigts (arduino=aspirateur de vie, de temps et d’interactions sociales, voire même d’hygiène corporelle dans les cas les plus poussés mais passons…) ! N’essayez jamais c’est un piège cette connerie en fait. La période de confinement m’a permit d’avoir le temps de m’y consacrer un peu tout en gardant en même temps une certaine dignité on va dire….

  1. Arduinono

La bébète , ici le modèle « basique » Uno (quand on a tout branché il faut crier UNO !!! Sinon le programme marche pas…Ha ha pardon j’ai honte):

Arduino permet de mettre en place des circuits électroniques dans des domaines comme la domotique, la robotique, l’informatique…On peut par exemple créer un système d’arrosage automatique de plantes de jardin, ou encore des détecteurs de mouvements, ou même des drones ! Un gars a même fabriqué une raquette de tennis qui crie à la place du joueur…(il y a plein d’exemples sur youtube) ou encore un trieur de M&M’s. Le cerveau de ces cartes est un microcontrôleur atmega; les autres composants (quartz, prise jack, interface USB…) sont annexes. Bref c’est très utile pour de la collecte d’infos, du traitement et aussi réaliser une action automatisée en retour selon les données enregistrées ou captées.

Une carte Arduino traite des données analogiques et numériques (convertisseur CAN et CNA intégré), pour ensuite les traiter puis fournir en sortie des données analogiques, ou numériques exploitables. Le programme suit toujours grosso-modo la même trame « grammaticale »:

Etape 1: on déclare les bibliothèques importées (si besoin) pour le préprocesseur, les constantes et les types de variables globales (exploitées tout le long du programme) en jeu.

Etape 2: On rédige la boucle « setup ». Ces instructions ne seront exécutées qu’une seule fois en début de programme. En général dans cette boucle on déclare les installations de base comme l’utilisation des bornes (en entrée ou en sortie) ou l’initialisation de certains composants (moniteur série, écran lcd…).

Etape 3: On s’occupe de la boucle « loop »: ses instructions seront répétées « en boucle » jusqu’à l’arrêt ou le reset de la carte. Les boucles « setup » et « loop » sont un peu l’équivalent de la boucle « main » pour le C et le C++; sans elles pas de programme qui fonctionne.

Etape 4: après la boucle « loop »on rédige au besoin les fonctions que l’on a crée et qui seront indispensables au bon fonctionnement du programme. Il suffira alors de les « appeler » dans la boucle loop ou le setup si besoin.

Les variables écrites en dehors des boucles setup et loop sont considérées comme globales (on peut les appeler à tout moment à n’importe quel endroit du programme), les autres locales (ne marchent que dans leur boucle, pas ailleurs).

Ces microcontôleurs de type AVR (donc architecture Harvard : contrairement à une ti par exemple les variables et le code des instructions à suivre ne sont pas stockées au même endroit) sont aussi caractérisés par 3 mémoires de travail:

  • Une mémoire flash, celle qui va intégrer le programme écrit et compilé dans la carte utilisée. Cette mémoire est modifiée à chaque compilation d’un nouveau code dans la carte. En gros elle contient les instructions.
  • Une mémoire dynamique SRAM qui prend en charge les variables. Elle s’efface et repart à zéro à chaque reset ou arrêt de la carte.
  • Une mémoire EEPROM appelée également mémoire morte, où les données sont conservées même après arrêt et mise en route de la carte. Certains modèles n’ont pas ce type de mémoire mais nous en reparlerons plus tard.

Selon le microcontrôleur utilisé, on aura donc une capacité de travail différente (on y reviendra plus tard…) et le microcontrôleur sera plus ou moins puissant mais nous en reparlerons :

  • Arduino nano : mémoire flash de 32Ko, 2Ko de mémoire SRAM et 1Ko de mémoire eeprom.
  • Arduino uno R3 : pareil que nano mais en petit, plus intéressant pour les systèmes embarqués du coup.
  • Arduino mega2560 : on tape un peu plus haut avec 256 Ko de mémoire flash pour 8 Ko de mémoire SRAM et 4 Ko de mémoire EEPROM. Plus gros et imposant par contre.

De plus selon les différentes cartes des options apparaissent ou disparaissent comme le nombres de bornes analogiques, la fréquence de calcul (8 ou 16 MhZ si il y a un oscillateur à quartz intégré ou pas ce qui augmente la vitesse de calcul tout comme la consommation d’énergie) par exemple… Donc selon le type de projet que l’on veut faire il faut choisir le bon microcontrôleur, on fait un petit cahier des charges quoi ! Un peu comme prévoir le jambon dans la purée si on aime le jambon dans la purée, ou le PQ, la râpe à fromage et les kinders au camping….Si on aime les kinders au camping évidemment.

2. Notre centrale de navigation, projet d’origine.

La centrale de nav que je voulais faire au départ était sensée indiquer l’angle de gite et de tangage du bateau, le cap compas, la température extérieure et la pression atmosphérique. Pour tout ça on va avoir besoin de différents composants…

A. Gite et tangage : Utiliser un accéléromètre ADXL335

Débutant dans le petit monde de l’arduino, je remarque en écumant les tutos youtube et autre qu’il est possible de fabriquer un inclinomètre grâce à ce petit capteur capable de détecter les accélérations dans les 3 directions de l’espace; du coup je me dis inclinomètre=gitomètre ! Mais peu doué pour exploiter les résultats obtenus par les différents tutos, je décide à partir du datasheet et du pdf de l’IUT de Toulon( Arduino/m2206_dossiertechnique_inclinometre.pdf) de programmer moi même, si possible, ce petit truc.

En furetant sur le net, on apprend que l’adxl335 fonctionne un peu comme un condensateur variable. A l’intérieur on trouve une partie fixe et une partie mobile, et en bougeant la partie mobile fait varier la capacité de l’accéléromètre de façon subtile, permettant de calculer un angle ou une force appliquée au composant. Un truc de fou.

Matos en jeu en plus: 1 carte arduino uno, 1 potentiomètre, 1 ecran lcd.

Branchements

Pour l’écran lcd, la borne RS est branchée sur la borne 8 de l’arduino, la borne E sur la 9, et les bornes D4, D5, D6 et D7 respectivement sur les bornes digitales 4, 5, 6 et 7 de l’arduino. La borne V0 est branchée sur le potentiomètre (c’est la résolution de l’écran lcd), la borne led- est reliée à la masse et la borne led+ est reliée à l’alimentation 5V via une résistance de 220 ohms (led- et led+ gèrent le rétroéclairage de l’écran). La borne Vdd est reliée à l’alimentation 5V et la borne Vss à la masse. Le reste des bornes de l’écran lcd sont reliées à la masse.

Pour l’accéléromètre, Vcc est à relier à l’alimentation 3,3 V de l’arduino, GND est à relier à la masse, et les bornes X, Y et Z sont respectivement à relier aux bornes analogiques A2, A1 et A0 de l’arduino.

Le code de l’inclinomètre simple:

#include<LiquidCrystal.h>
LiquidCrystal lcd(8,9,4,5,6,7);

const int axe_z=A0;
const int axe_y=A1;
const int axe_x=A2;

int x=0;
int y=0;
int z=0;

const float tension_zero=1.66;
const float sensibilite=0.3;



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

}

void loop() {
  x=analogRead(axe_x);
  y=analogRead(axe_y);
  z=analogRead(axe_z);

  float tension_x=(x/1024.0)*5.0;
  float tension_y=(y/1024.0)*5.0;
  float tension_z=(z/1024.0)*5.0;

  float Gx=(tension_x-tension_zero)/sensibilite;
  float Gy=(tension_y-tension_zero)/sensibilite;
  float Gz=(tension_z-tension_zero)/sensibilite;

  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=degrees(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(roulis);
  lcd.setCursor(0,1);
  lcd.print("t:");
  lcd.setCursor(2,1);
  lcd.print(tangage);
  lcd.setCursor(9,0);
  lcd.print("v:");
  lcd.setCursor(11,0);
  lcd.print(verticalite);
  
  
  

  delay(500);



}

Calibrage

Afin d’avoir une précision optimale, il est nécessaire de positionner l’accéléromètre bien parallèle à un plan bien droit, puis utiliser des règles à niveau. Il va falloir alors via la fonction Serial du moniteur série capter la tension de sortie quand un axe de l’accéléromètre est bien parallèle à celui de la force de gravité. On note ensuite la tension correspondante. Cette tension est la constante « tension_zero » dans le code tapé au-dessus (1,66 Volts dans mon cas). La sensibilité (300 mV) est fournie dans le datasheet du composant.

Avantages/limites

L’avantage numéro 1 de l’accéléromètre pour mesurer un angle, c’est sa simplicité de mise en place autant en branchements qu’en programmation; un brancos comme moi a pu le faire en (relativement…) peu de temps. L’inconvénient majeur, c’est qu’il est soumis aux forces qu’il rencontre et pas seulement celle de gravité, donc si il a un choc, ou si le bateau accélère ou ralentit, les données fournies sont faussées…Il reste intéressant pour faire un inclinomètre pour le bricolage à la maison par exemple, mais quand il est embarqué sur une personne ou un objet qui se déplace, c’est pas top (à moins de se déplacer en vitesse constante et tout droit tout le temps, mais bon…).

B. Gite et tangage: Utiliser un accéléromètre/gyrocompas mpu6050

Il combine l’accéléromètre et le gyrocompas (et la température aussi je crois mais ça j’ai pas creusé plus). Ce composé est très utilisé pour les drones car il permet de calculer l’assiette de l’engin en vol (qui subit des accélérations/ralentissements…), donc contrôler sa trajectoire. Du coup très intéressant pour notre projet…On en trouve aussi dans les portables pour gérer les changements d’écran (quand on tourne le portable, l’écran tourne également).

Le gyrocompas indique la vitesse angulaire de rotation autour des axes X, Y et Z. Qui dit vitesse dit dérivée de la position par rapport au temps, donc en intégrant ces vitesses nous pourront déterminer la position angulaire (à une constante près, c’est à dire la position initiale ou précédente à l’intégration pour être plus précis). Le petit problème c’est qu’à chaque intégration des données il y a une petite perte de précision qui se cumule à plus ou moins long terme selon la puissance de calcul disponible. Et à la fin le gyrocompas part en vrille totale, on appelle ça la dérive: c’est un peu quand on laisse tonton Roger parler à table complètement bourré après l’apéro, on part d’un sujet quelconque mais noble comme la philosophie existentialiste et cinq minutes après on dérive sur la levrette chez les esturgeons du Danemark. Pour corriger ça on mixe les données du gyrocompas avec celles de l’accéléromètre. En tout cas pour nous ça marche, pour tonton Roger un peu moins.

Branchements

Pour faire fonctionner et programmer ce composant, il y a cette page web qui est très bien :

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

Le code

Afin d’avoir l’angle de gite et l’angle de tangage du bateau j’ai donc utilisé deux gitomètres (un seul pourrait suffire mais pour le moment je ne suis pas assez bon pour programmer ça malgré quelques tentatives, mais on verra ça ensuite); pour cela j’ai utilisé le dernier code publié de la page web précédente. Attention il y a une petite coquille dans ce code aux lignes 11 et 12: pour les noms des variables il faut rajouter 1 à la fin (ça donne ax1,ay1,az1 et gx1,gy1,gz1) sinon le programme ne pourra pas calculer l’angle1 à la ligne 42 car il ne reconnaîtra pas les paramètres utilisés.

Après branchement et code légèrement modifié l’ensemble fonctionne très bien pour notre projet.

C.Pression/température: Le BME280

Le BME28O est un capteur capable de nous fournir la pression atmosphérique (c’est pourquoi on peut s’en servir pour bricoler un altimètre), la température et l’hygrométrie. Ce petit composant peut aussi permettre de fabriquer une petite station météo du coup (et merde encore une autre idée de projet, on s’en sort pas…).

Pour le code, les branchements et le reste c’est pareil j’ai utilisé tout ce que j’ai trouvé sur cette page web très bien expliquée:

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

D. Le cap: le GY-271

Ce composant va nous indiquer le cap. Et pi voilà. Pareil cette page :

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

explique très bien comment coder notre compas. En fait c’est toujours sur le même site, très bien fait et que j’ai outrageusement pillé comme un gros crevard.

E. Le bus I2C.

Comme on va utiliser plusieurs composants en même temps, on va utiliser le système de communication I2C entre eux et le microcontrôleur. L’avantage majeur de ce procédé c’est l’économie de branchements et de fils qui partent dans tout les sens; les composants seront tous branchés sur 4 fils communs: SDA où circule l’info, SCL qui indique la fréquence d’horloge pour que « l’orchestre » joue au même rythme, la masse et l’alimentation.

Premier bilan

Alors premiers trucs qui cassent un peu la boîte à bigorneaux je dois dire :

  • Le module BME280 fonctionne sur du 3,3 volts alors que le reste peut marcher sur du 5 volts au regard des datasheet, du coup il semblerait (je crois, mais pas sûr que ce soit ça) qu’en I2C ça marche pas bien (on dirait que les modules doivent avoir la même tension d’alimentation). Par contre en usage seul il marche très bien.
  • Le compas GY271 fonctionne pas bien…Il indique des caps comme si j’étais en forêt de Blair Witch c’est dire…Mon module est à priori un QMCL5883L, sauf que sur le composant je devrais voir DA 5883 alors que là j’ai DB 5883 marqué dessus …Je n’utilise peut-être pas la bonne bibliothèque. A moins que la raison de ce plantage soie ailleurs. Cependant il a l’air d’indiquer correctement le nord, c’est quand je m’en éloigne que ça se gâte mais bon y a pas que le Nord dans la vie.
  • J’avais prévu de faire tourner une arduino nano pour tout ça, sauf que mon modèle est une copie (mêmes capacités toutefois, c’est un modèle elegoo). Pour la faire reconnaître par l’IDE arduino, il faut télécharger le pilote CH340 et pour téléverser le code il faut sélectionner arduino nano et processeur atmega (old bootloader). En tout cas dans mon cas après ça a marché. C’est une carte elegoo. Le « bootloader » est une sorte de petit programme pré-installé dans la mémoire flash de la carte et qui facilite le compilage de notre code dans le microcontrôleur.

Du coup avec le labo, l’équipe, mon chat et le paquet de chips à côté de moi, brainstorming et nouveau projet :

Je me suis dit bon, le BME280 je me le garde pour plus tard histoire de faire un baromètre station météo, et je garde le compas (en espérer le faire marcher), les gyrocompas et faire un compas de relèvement/gitomètre. Et en potassant un peu j’ai vu qu’il existait des horloges externes arduino…En plus le gyro à l’air de me donne un angle assez précis avec peu de « bruit »….Donc si j’ai un angle assez précis et une trace du temps réel même quand l’arduino est éteint, je peut donc peut-être fabriquer un compas de relèvement/gitomètre/sextant « numérique » pour pas cher et en se creusant un peu l’éponge à idées.

3) Le sextant gitomètre compas chipolata

Pour ce projet, on va utiliser une carte arduino mega 2560, un seul gitomètre, un compas GY271, un ecran lcd avec module I2C, une horloge externe temps réel DS3231 (pratique car la pile est amovible!). Pour fabriquer le viseur je l’ai dégoté sur une vieille lunette astronomique, et les interrupteurs, les résistances et les diodes proviennent d’un vieux poste radio du fin fond de mon garage. On va ajouter aussi un clavier souple arduino à 16 touches.

a) un gitomètre pour obtenir la gite et le tangage

Pour notre projet nous allons devoir utiliser un seul gitomètre; pourquoi ? He bien lors de l’utilisation du système de communication en I2C, chaque composant relié a une adresse qui lui est propre. l’écran lcd utilisé peut en avoir plusieurs (ça dépend du type de circuit I2C employé avec l’écran et aussi son réglage avec les bornes cavalier), dans notre cas il est configuré avec l’adresse 0x27, le gitomètre ne peut en avoir que 2: 0x68 ou 0x69. Pour l’horloge externe, c’est aussi 0x68 et il n’y en a pas d’autre…

Du coup il va falloir configurer le gitomètre avec l’adresse 0x69 pour ne pas perturber les données de l’horloge fournies. Il existe un programme très utile appelé I2CSCAN facilement trouvable sur le net, capable de donner directement via le moniteur série les adresses des composants branchés ensembles en I2C.

Ne pas oublier: quand on change l’adresse du gitomètre de 0x68 à 0x69, on doit également brancher la borne ADO du composant sur l’alimentation. On change le branchement et le code également. Pour notre gitomètre voici le code de la page web http://gilles.thebault.free.fr/spip.php?article32 modifié pour également faire gite et tangage en même temps ; il y a 2 modifs à faire toutes simples au final. Quand on regarde le code pour un seul gyrocompas :

  • Ligne 8, ça donne: « MPU6050 accelgyro(0x69) »
  • la ligne 35, on change avec: »

Gite = 0.98 * (Gite + float(gy) * 0.01 / 131) + 0.02 * atan2((double)ax, (double)az) * 180 / PI;
Tangage = 0.98 * (Tangage + float(gx) * 0.01 / 131) + 0.02 * atan2((double)ay, (double)az) * 180 / PI; »

On change la variable angle par 2 variables gite et tangage, qu’il faudra déclarer en début de programme comme variables globales.

b) L’horloge externe

Pour la partie sextant il nous faut ce composant. Les formules de calcul de Jean Meeus sont essentiellement basées sur des fonctions travaillant avec la variable temps. Or lorsque la carte est hors tension, la trace de l’écoulement du temps est perdue. Il y a bien les fonctions millis() et micros() qui activent une horloge interne de la carte (timer), mais seulement quand elle est alimentée; de plus le stockage numérique de ce décompte est limité. L’horloge DS3231 garde une trace du temps grâce à une pile amovible, même quand notre circuit est ouvert.

L’horloge doit tout d’abord être configurée pour régler le temps, ensuite elle pourra être insérée dans notre programme et notre montage. Pour ce faire j’ai honteusement pillé, sans vergogne, le code présent dans l’ouvrage « arduino: apprivoisez l’electronique et le codage ». Sur le site de gilles thebault (utilisé précédemment pour le mpu6050, et le compas) il y a aussi un programme fournit pour la faire fonctionner et la régler à la bonne heure, mais bon je vais pas tout le temps le dépouiller non plus!

c) Le clavier.

Pour l’exploiter on va utiliser la bibliothèque keypad. Il y a pas mal de tutos sur youtube ou le net qui expliquent son fonctionnement, un peu comme une matrice de contacts.

d) Le compas.

On veillera dans le boitier à ne pas le mettre trop près d’un élément perturbant au niveau électromagnétique pour ne pas faire trop dévier les données. J’ai utilisé d’autres compas cette fois avec le bon numéro sur le composant et là, ça marche !

e) Le big problème

A cette étape du projet tout les éléments fonctionnent ensemble via le bus I2C, la nomencalture du programme marche pas mal, et là c’est le drame : la carte arduino mega2560 comme la uno et la nano d’ailleurs, carburent avec des microcontrôleur avec 8Kb de SRAM (mémoire dynamique, celle des variables) ce qui limite la taille des variables manipulables par notre programme et la puissance de traitement.

Du coup voilà le pitch: on peut soit manipuler des décimaux (variable de type « float », tient sur 32 bits) avec 7 chiffres significatifs maximum (entier inclus, formant la mantisse en tout), ou alors des entiers positifs (variable de type « unsigned long ») où notre variable ne doit pas dépasser le nombre 4294967295. Pour notre plus grand malheur, sur ces cartes la variable « double » est équivalente à la « float » (« double » c’est aussi pour stocker un décimal mais avec 14 chiffres sur la mantisse. Pour la mantisse, voir wikipépé, la page sur la virgule flottante. La variable double tient sur 64 bits). Avec les équations de Jean Meeus ça va être un peu chiant vu qu’elles mobilisent des nombres avec pas mal de chiffres…Va falloir ruser pour garder un minimum de précision requise.

J’ai bien essayé de faire des variables « long long » ou « unsigned long long » ni vu ni connu je te fume pour stocker mes variables sur 64 bits, mais à chaque fois le compilateur tousse, me fait les gros yeux et me dit d’aller me faire vigoureusement entreprendre par une tribu de gorilles. Un peu comme un douanier impitoyable, quand je déclare pas bien mes variables il me recale…Il y a peut-être un moyen pour le faire mais je l’ignore, grand couillon que je suis. Va falloir trouver autre chose.

Partie 2: projet final

Bref, après toutes ces déconvenues et billevesées désapointantes passons aux choses sérieuses:

1) Matos

1 buzzer, un écran lcd, un module I2C, un mpu6050 gyrocompas, un GY271 compas magnétique, une horloge externe ds3231, une carte nano elegoo et une carte arduino due, une pile 9V, 1 diode, 1 interrupteur,un convertisseur logique 3,3V/5V, une breadboard, un viseur de lunette astro de récup, le filtre soleil qui va avec, du bois pour le boitier, nouilles chinoises et tablettes de chocolat lindt 85% à foison (pour l’équilibre mental de l’équipe).

Le buzzer va nous servir comme aide à la visée de l’astre (en-dessous de 2 degrés de gite, il couine), et ici on va utiliser une carte arduino due car elle est capable de manipuler des vraies variables double (comme la arduino zero) grâce à son processeur plus pointu (SAM3X8E ARM CortexM3, processeur 32 bits).

Pourquoi utiliser 2 cartes alors que la arduino due aurait suffit ? He bien en fait sur le net il y a peu de bibliothèques dispo pour cette carte car elle a un usage moins « grand public ». Du coup elle est plutôt réservée à des programmeurs expérimentés capables de rédiger du bas niveau proche du bit et des registres, voire capable de rédiger leurs propres bibliothèques…Je décide donc de contourner mes compétences limitées en programmation en utilisant la carte elegoo comme les « yeux » du projet (elle va capter les infos) et la arduino due comme le cerveau. Elle vont communiquer ensemble pour bosser, un peu comme Minus et Cortex, Arnold et Willy, Stone et Charden ou Jackie et Michel …Je dégage toute responsabilité dans le choix de votre duo préféré.

A. Problèmes principaux rencontrés

a) Serial.write ou Serial.print ?

Je croyais que les 2 c’était la même chose…Et bien non. Serial.print renvoie la valeur directement tandis que Serial.write envoie la valeur sous sa forme binaire.

b) Stocker les nombres saisis avec le clavier…J’en rêve encore la nuit

C’est bien expliqué sur le forum arduino, il faut rédiger un compteur et stocker l’ensemble dans un tableau de char via l’usage d’une boucle for, puis convertir la chaîne de caractères en variable (dans notre cas des entiers).

c) Convertir des boutons switch en boutons « permanents »…J’en pisse encore au lit la nuit.

il faut créer une variable intermédiaire puis l’évaluer avec des conditions, si elle remplit la ou les conditions on la mémorise dans une autre variable qui déclenchera le menu (dans notre cas prédatastate, datastate).

d) Faire communiquer 2 cartes différentes par la voie série…Pour envoyer et recevoir des données entre elles…J’en hurle d’effroi encore la nuit

A priori d’après les trucs vus sur le net on peut faire alternativement envoyer et recevoir des données entre cartes via une voie série…J’ai longtemps essayé avant de changer de technique; au début la nano envoyait bien les bonnes données à la due via une variable structure, la due faisait son taf et le renvoyait à la nano mais par contre la nano n’arrivait pas à recevoir correctement l’info. Comme j’utilisai juste une seule voie pour ces deux chemins de données, je me suis dit que ça devait être un problème de buffer pas vidé qui perturbe le signal (elle est pas mal cette excuse, hein ? ça sonne bien ça fait le gars qui gère) ou alors des variables envoyées qui devaient être réinitialisées mais même en vidant avec attention les buffers et en réinitialisant, ça marchait toujours pas.

Du coup j’ai configuré une seconde voie série sur la nano grâce à la bibliothèque softwareserial, j’ai maintenant les broches 11 et 12 qui me permettent de communiquer avec la due. Cette seconde voie enverra les résultats de la due à la nano. ça marche, mais ceux qui lorgneront mon code concernant la nano remarqueront mon « coup de triche inélégant » à la fin du programme…En effet au lieu de recevoir la variable azimut et intercept, mon bricolage m’envoie 3 valeurs: l’intercept, « -1 », et l’azimut. en supprimant le « delay » quand -1 s’affiche, ça passe!

e) Conversion des variables pour les fonctions trigonométriques

Il faut bien faire attention avec la bibliothèque maths, certaines variables doivent être converties en radians, d’autres en degrés sinon c’est le bordel.

B.Schéma du montage (fritzing).

Fritzing est une application et aussi un site qui permet de visualiser et faire visualiser ses montages électroniques, ses circuits… On peut également faire virtuellement sur leur plateforme un circuit puis leur passer en commande pour faire le circuit imprimé ce qui n’est pas inintéressant. Voilà le montage en espérant ne pas avoir fait de fautes d’étourderies:

Comme le schéma de montage comporte pas mal de branchements, et n’étant pas à l’abris d’avoir semé des coquilles, voici les points importants:

Number 1: cette ligne + et – est alimentée par la nano en 5 volts, bref la nano alimente tout les composants fonctionnant entre eux en I2C (écran, gyrocompas, compas magnétique, horloge).

Number 2: cette seconde ligne + et – est alimentée par la pile 9 volts; elle fournit le jus pour nos 2 cartes arduino.

Number 3: c’est le convertisseur logique 3,3 volts/5 volts. toutes les connexions de la arduino due doivent passer par lui sinon vous risquez de la cramer (elle n’accepte qu’une tension de 3,3 volts, pas plus) sauf l’alimentation via Vin. Pour chaque liaison série, il ne faut pas oublier d’inverser les Tx et Rx: la borne d’envoi d’une carte est la borne de réception de l’autre et inversement. Sinon la communication marche pas. Je précise car sur mon schéma il y a peut-être des coquilles à ce niveau là.

Number 4: pour le circuit d’alimentation des deux cartes j’ai ajouté une diode pour les protéger; comme ça si jamais la pile 9 volts est branchée à l’envers sur son support, elle ne grille pas la nano et la due, ce qui serait somme toute un peu balo…

C.La bête, et son fonctionnement.

Vous excuserez le design très « URSS vintage » mais le budget était limité hein…

Mode d’emploi:

  • Le menu est géré par les boutons A,B,C et D du clavier. A l’allumage, l’engin (on l’appellera Nono) bref Nono affichera toujours l’heure UTC. A active le gitomètre qui indique la gite et le tangage, B le compas de relèvement, C la droite de hauteur avec le Soleil et enfin D la droite de hauteur avec la Lune.
  • Pour les droites de hauteur, si le nombre à rentrer pour le point estimé est négatif (latitude sud par exemple), on écrit au clavier le nombre puis on appuie sur la touche « * ». Si le nombre est positif, pour enregistrer le nombre on appuie sur la touche « # ». Si un nombre est négatif, attention d’enregistrer également comme négatif les minutes.
  • Quand on veut fixer le soleil, dans mon viseur il y a un filtre astro pour ne pas se brûler la rétine. On vise l’astre. Si le buzzer sonne ça veut dire que l’assiette de Nono est pas mal (moins de 2 degrés). Ensuite, attendre 1 minute au moins avant d’appuyer le temps que le gyro se stabilise, et paf on appuie sur n’importe quel bouton du clavier (excepté ceux du menu) pour saisir l’astre et mesurer notre position.
  • Nono donne ensuite d’abord l’intercept en miles nautiques et puis l’azimut en degrés.

Attention! : avant usage ne pas oublier de calibrer le gyrocompas. Quand on fixe ou colle le gyro au fond de Nono (hum) il y a une perte de précision d’angle du coup comme pour l’inclinomètre simple on va se servir d’une règle à niveau et du bouton A (gite et tangage) pour identifier la correction de la variable « Tangage », très importante quand à la précision de la visée de l’astre (dans notre programme il s’agit de TangageInit). On appuie sur le bouton A, puis on met la règle à niveau posée sur le dessus de l’appareil parallèle au viseur; quand la bulle du niveau est au milieu on note l’angle de tangage affiché par Nono, puis on le rentre dans le programme « nono » comme valeur initiale de la variable tangageInit (en inversant le signe).

Attention2 ! : le boitier que vous voyez est provisoire; les 2 câbles que j’ai laissé dépasser permettent de continuer à modifier ou régler le programme sans avoir à tout démonter à chaque fois. Bref il n’est pas étanche….

D. Les codes (nano et due).

La carte « maitre » (arduino nano):

/*bibliothèques nécessaires au programme*/


#include <SoftwareSerial.h>//permet d'émuler une seconde voie série.

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

#include <MPU6050.h>// gyrocompas.

#include <LiquidCrystal_I2C.h>//ecran lcd en i2C.

#include <Keypad.h>//le clavier.

#include <Wire.h>//le bus I2C.

#include <MechaQMC5883.h>//le compas GY271(modèle QMC).

#include <math.h>//fonctions maths en supplément (trigo notamment).

/*variables globales compas */

MechaQMC5883 capteur;

     int mx, my, mz; // déclaration des variables sur les axes x, y, z
     float angle;



/*variables globales clavier (keypad)*/


const byte LIGNES = 4;
const byte COLONNES = 4;

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

Keypad keypad = Keypad( makeKeymap(keys), ligPins, colPins, LIGNES, COLONNES );


      char Clavier[4];// variables globales utilisées pour stocker les données du clavier (point estimé, hauteur oeil).
      int compteur = 0;


/*variables pour le menu des options A,B,C et D (change également les switchs du clavier en interrupteurs "classiques")*/

      char preDataState=0;// permet de gérer le menu gitomètre, compas de relèvement, heure utc et droites de hauteur.

      char DataState=0;// variable de transfert pour grossomerdo changer les switchs du keypad en interrupteurs "permanents".



/*variables globales ecran (liquidcrystal lcd)*/

LiquidCrystal_I2C lcd(0x27,16,2); //ecran lcd (adresse I2C,lignes, colonnes)

/*variables globales gyrocompas (mpu6050)*/


MPU6050 accelgyro(0x69); // changement d'adresse du gyrocompas de 0x68 (par défaut) à 0x69.

int16_t ax, ay, az;
int16_t gx, gy, gz;
uint8_t Accel_range;
uint8_t Gyro_range;
      float Gite = 0;
      float Tangage = 0;
      float GiteInit=-0.93;//permet d'étalonner le gyrocompas en gite.
      float TangageInit=-2.12;//permet d'étalonner le gyrocompas en Tangage (particulièrement important pour la précision du sextant).

/*variables horloge externe (ds3231)*/

#define ADRESSE_I2C_RTC 0x68 //adresse de l'horloge.
byte seconde,minute,heure,numJourSemaine,numJourMois,mois,annee;
String jourDeLaSemaine[8]={"","Dim","Lun","Mar","Mer","Jeu","Ven","Sam"};

/*variable buzzer*/

       const int BUZZER=10;

/*variables de calcul*/

       int LatDeg=333;//  variables du point estimé, initialisées à 333 (arbitraire) pour pouvoir rentrer le 0 comme valeur dans les calculs.
       int LatMin=333;
       int LonDeg=333;
       int LonMin=333;
       byte hauteurOeil=250;
       float estimeLat=0;
       float estimeLon=0;
       int Intercept=0;
       int Azimut=0;

       struct retour {
        int Intercept;
        int Azimut;
       };

       retour point;
       
  
    

void setup() {
  keypad.setDebounceTime(10);// cette instruction évite les problèmes de rebonds avec le clavier.
  Serial.begin(57600);//ouvre la première liaison série pour communiquer entre les 2 cartes.
  retourSerial.begin(57600);//ouvre la seconde liaison série.
  
  capteur.init();
  //capteur.setMode(Mode_Continuous,ODR_200Hz,RNG_2G,OSR_256);pour le compas magnétique.

  Wire.begin();// initialise la liaison I2C.

  
  

  /* setup ecran*/

  lcd.init();
  lcd.backlight(); 
  

  lcd.home();
  lcd.setCursor(3,0);
  lcd.print("navigogol");
  lcd.setCursor(0,1);
  lcd.print("on est ou ?");
  delay(3000);
  lcd.clear();
  
  

  /* setup gyrocompas */

  
  accelgyro.initialize();

  lcd.home();
  lcd.print("Test gyro ...");
  lcd.setCursor(0,1);
  lcd.print(accelgyro.testConnection() ? "gyro ok" : "gyro pas ok");
  delay(1000);
  lcd.clear();
  

  
  
  /*configuration du Buzzer */

  pinMode(BUZZER,OUTPUT);
  
  
  
}

void loop() {
  
   /*variables globales utilisées dans le loop*/

  
   char key = keypad.getKey();//on stocke la touche pressée dans la variable key.
   
   

  /*mise en route des composants*/

    accelgyro.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
    Gite = 0.98 * (Gite + float(gy) * 0.01 / 131) + 0.02 * atan2((double)ax, (double)az) * 180 / PI;
    Tangage = 0.98 * (Tangage + float(gx) * 0.01 / 131) + 0.02 * atan2((double)ay, (double)az) * 180 / PI;

    

    Wire.beginTransmission(ADRESSE_I2C_RTC);//reception heure et date
    Wire.write(0);//positionne le pointeur de registre sur 00h
    Wire.endTransmission();
    Wire.requestFrom(ADRESSE_I2C_RTC,7);//accède aux données de l'horloge à partir du registre 00h
    seconde=bcdToDec(Wire.read()& 0x7f);
    minute=bcdToDec(Wire.read());
    heure=bcdToDec(Wire.read()&0x3f);
    numJourSemaine=bcdToDec(Wire.read());
    numJourMois=bcdToDec(Wire.read());
    mois=bcdToDec(Wire.read());
    annee=bcdToDec(Wire.read());

    capteur.read(&mx, &my, &mz);
    angle = degrees(atan2((double)mx, (double)my));

     if (angle>=0) {
       angle=360-angle;
  }
     else {
       angle=abs(angle);
  }

  /*codage du menu*/

  DataState=key;//on stocke la touche dans DataState.Permet de garder ensuite avec predatastate en mémoire la touche pressée après la loop.
    
    if (DataState=='A'||DataState=='B'||DataState=='C'||DataState=='D') {

      preDataState=DataState;//change les switch du keypad en interrupteurs "classiques". PreDataState sert à faire fonctionner le menu principal.
      key=0;
      
      lcd.clear();//dès qu'on presse une touche, efface rapidement l'écran. ça évite les bugs avec l'écran lcd.
      
    }

    

   
    

  switch (preDataState) {
    case 'A':// la touche A active le gitomètre.
    
       noTone(BUZZER);
       lcd.home();
       lcd.print("gite:");
       lcd.setCursor(7,0);
       lcd.print(Gite);
       lcd.setCursor(0,1);
       lcd.print("tangage:");
       lcd.setCursor(10,1);
       lcd.print(Tangage);
       delay(10);

       break;

       case 'B':// la touche B active le compas de relèvement.

       noTone(BUZZER);
       lcd.home();
       lcd.print("relevement:");
       lcd.setCursor(3,1);
       lcd.print(angle);
       delay(100);

       break;

       case 'C':// la touche C active le mode sextant(soleil).

       
       
       if (LatDeg==333 && LatMin==333 && LonDeg==333 && LonMin==333 && hauteurOeil==250) {
       
       lcd.home();
       lcd.print("point estime");
       lcd.setCursor(0,1);
       lcd.print("LatDeg:");
       

          if (key!=NO_KEY && key!='*' && key!='#') {
           Clavier[compteur++]=key;
           Clavier[compteur]='\0';// indique l'arrêt de la chaîne de caractères.
           lcd.setCursor(9,1);
           lcd.print(Clavier);
       }
          else if (key=='*') {
           LatDeg=atoi(Clavier);// convertit char en int.
           Clavier[4]={0};
           compteur=0;
           lcd.clear();
       }
          else if (key=='#') {
           LatDeg=atoi(Clavier)*-1;
           Clavier[4]={0};
           compteur=0;
           lcd.clear();
       }
       }
      else if (LatDeg!=333 && LatMin==333 && LonDeg==333 && LonMin==333 && hauteurOeil==250) {
       
       
       lcd.home();
       lcd.print("point estime");
       lcd.setCursor(0,1);
       lcd.print("LatMin:");
       lcd.setCursor(9,1);
       
       
          if (key!=NO_KEY && key!='*' && key !='#') {
            Clavier[compteur++]=key;
            Clavier[compteur]='\0';
            lcd.setCursor(9,1);
            lcd.print(Clavier);
       }

          else if (key=='*') {
           LatMin=atoi(Clavier);
           Clavier[4]={0};
           compteur=0;
           lcd.clear();
       }

          else if (key=='#') {
           LatMin=atoi(Clavier)*-1;
           Clavier[4]={0};
           compteur=0;
           lcd.clear();
       }
  
      }
      else if (LatDeg!=333 && LatMin!=333 && LonDeg==333 && LonMin==333 && hauteurOeil==250) {

       
       lcd.home();
       lcd.print("point estime");
       lcd.setCursor(0,1);
       lcd.print("LonDeg:");
       

          if (key!=NO_KEY && key!='*' && key!='#') {
           Clavier[compteur++]=key;
           Clavier[compteur]='\0';
           lcd.setCursor(9,1);
           lcd.print(Clavier);
       }

          else if (key=='*') {
           LonDeg=atoi(Clavier);
           Clavier[4]=0;
           compteur=0;
           lcd.clear();
       }

          else if (key=='#') {
           LonDeg=atoi(Clavier)*-1;
           Clavier[4]=0;
           compteur=0;
           lcd.clear();
       }
      }

      else if (LatDeg!=333 && LatMin!=333 && LonDeg!=333 && LonMin==333 && hauteurOeil==250) {

       
       lcd.home();
       lcd.print("point estime");
       lcd.setCursor(0,1);
       lcd.print("LonMin:");
       

          if (key!=NO_KEY && key!='*' && key!='#') {
           Clavier[compteur++]=key;
           Clavier[compteur]='\0';
           lcd.setCursor(9,1);
           lcd.print(Clavier);
       }

          else if (key=='*') {
           LonMin=atoi(Clavier);
           Clavier[4]={0};
           compteur=0;
           lcd.clear();
       }

          else if (key=='#') {
           LonMin=atoi(Clavier)*-1;
           Clavier[4]={0};
           compteur=0;
           lcd.clear();
       }
      }

       else if (LatDeg!=333 && LatMin!=333 && LonDeg!=333 && LonMin!=333 && hauteurOeil==250) {
       
       lcd.home();
       lcd.print("hauteur oeil:");
       

           if (key!=NO_KEY && key!='*' && key!='#') {
             Clavier[compteur++]=key;
             Clavier[compteur]='\0';
             lcd.setCursor(0,1);
             lcd.print(Clavier);
             }

           else if (key=='*' || key=='#') {
              hauteurOeil=atoi(Clavier);
              Clavier[4]={0};
              compteur=0;
              lcd.clear();
             }
             
      
             }

             
       


      else if (hauteurOeil!=250 && LatDeg!=333 && LatMin!=333 && LonDeg!=333 && LonMin!=333) {

        
        
       
         lcd.home();
         lcd.print("angle soleil:");
         lcd.setCursor(0,1);
         lcd.print(Tangage);
       
       
      if (key==NO_KEY) {
       
          if (Gite==constrain(Gite,0,2) ) {// facilite la précision de la visée. Si ça buzze c'est bon, on peut appuyer pour lancer la machine.
           tone(BUZZER,500);
       }
          else {
           noTone(BUZZER);
       }
          
          delay(100); 
      }
  
         
       else if (key!=NO_KEY) {
            noTone(BUZZER);
            lcd.clear();

            estimeLat=LatDeg+LatMin/60.00;
            estimeLon=LonDeg+LonMin/60.00;
            char astre='C';

           struct chiffres {// données à envoyer sous forme de variable structure.

             float Tangage;
             float estimeLat;
             float estimeLon;
             byte hauteurOeil;
             byte annee;
             byte numJourMois;
             byte mois;
             byte heure;
             byte minute;
             byte seconde;
             char astre;
             
        };

           chiffres data;

           data.Tangage=Tangage+TangageInit;
           data.estimeLat=estimeLat;
           data.estimeLon=estimeLon;
           data.hauteurOeil=hauteurOeil;
           data.annee=annee;
           data.numJourMois=numJourMois;
           data.mois=mois;
           data.heure=heure;
           data.minute=minute;
           data.seconde=seconde;
           data.astre=astre;
           
           
          
        
           Serial.write((byte *)&data, sizeof data);

           Serial.flush();
        
           

          delay(3000);
          
          
          
          while (retourSerial.available()>0) {
  
          retourSerial.readBytes((byte *)&point, sizeof point);

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

          
          
          
          
          lcd.home();
          lcd.print("inter et azim:");
          lcd.setCursor(0,3);
          lcd.print(Intercept);
          delay(4000);
          lcd.clear();
          lcd.home();
          lcd.print("caca chiant");
          lcd.setCursor(0,3);
          lcd.print(Azimut);
          lcd.clear();
          
          estimeLat=0,estimeLon=0,LatDeg=333,LatMin=333,LonDeg=333,LonMin=333,hauteurOeil=250;
          }
  
      }   
      }
       
         
          

       

      

       break;

       case 'D'://active le mode sextant(lune).

       if (LatDeg==333 && LatMin==333 && LonDeg==333 && LonMin==333 && hauteurOeil==250) {
       
       lcd.home();
       lcd.print("point estime");
       lcd.setCursor(0,1);
       lcd.print("LatDeg:");
       

          if (key!=NO_KEY && key!='*' && key!='#') {
           Clavier[compteur++]=key;
           Clavier[compteur]='\0';// indique l'arrêt de la chaîne de caractères.
           lcd.setCursor(9,1);
           lcd.print(Clavier);
       }
          else if (key=='*') {
           LatDeg=atoi(Clavier);// convertit char en int.
           Clavier[4]={0};
           compteur=0;
           lcd.clear();
       }
          else if (key=='#') {
           LatDeg=atoi(Clavier)*-1;
           Clavier[4]={0};
           compteur=0;
           lcd.clear();
       }
       }
      else if (LatDeg!=333 && LatMin==333 && LonDeg==333 && LonMin==333 && hauteurOeil==250) {
       
       
       lcd.home();
       lcd.print("point estime");
       lcd.setCursor(0,1);
       lcd.print("LatMin:");
       lcd.setCursor(9,1);
       
       
          if (key!=NO_KEY && key!='*' && key !='#') {
            Clavier[compteur++]=key;
            Clavier[compteur]='\0';
            lcd.setCursor(9,1);
            lcd.print(Clavier);
       }

          else if (key=='*') {
           LatMin=atoi(Clavier);
           Clavier[4]={0};
           compteur=0;
           lcd.clear();
       }

          else if (key=='#') {
           LatMin=atoi(Clavier)*-1;
           Clavier[4]={0};
           compteur=0;
           lcd.clear();
       }
  
      }
      else if (LatDeg!=333 && LatMin!=333 && LonDeg==333 && LonMin==333 && hauteurOeil==250) {

       
       lcd.home();
       lcd.print("point estime");
       lcd.setCursor(0,1);
       lcd.print("LonDeg:");
       

          if (key!=NO_KEY && key!='*' && key!='#') {
           Clavier[compteur++]=key;
           Clavier[compteur]='\0';
           lcd.setCursor(9,1);
           lcd.print(Clavier);
       }

          else if (key=='*') {
           LonDeg=atoi(Clavier);
           Clavier[4]=0;
           compteur=0;
           lcd.clear();
       }

          else if (key=='#') {
           LonDeg=atoi(Clavier)*-1;
           Clavier[4]=0;
           compteur=0;
           lcd.clear();
       }
      }

      else if (LatDeg!=333 && LatMin!=333 && LonDeg!=333 && LonMin==333 && hauteurOeil==250) {

       
       lcd.home();
       lcd.print("point estime");
       lcd.setCursor(0,1);
       lcd.print("LonMin:");
       

          if (key!=NO_KEY && key!='*' && key!='#') {
           Clavier[compteur++]=key;
           Clavier[compteur]='\0';
           lcd.setCursor(9,1);
           lcd.print(Clavier);
       }

          else if (key=='*') {
           LonMin=atoi(Clavier);
           Clavier[4]={0};
           compteur=0;
           lcd.clear();
       }

          else if (key=='#') {
           LonMin=atoi(Clavier)*-1;
           Clavier[4]={0};
           compteur=0;
           lcd.clear();
       }
      }

       else if (LatDeg!=333 && LatMin!=333 && LonDeg!=333 && LonMin!=333 && hauteurOeil==250) {
       
       lcd.home();
       lcd.print("hauteur oeil:");
       

           if (key!=NO_KEY && key!='*' && key!='#') {
             Clavier[compteur++]=key;
             Clavier[compteur]='\0';
             lcd.setCursor(0,1);
             lcd.print(Clavier);
             }

           else if (key=='*' || key=='#') {
              hauteurOeil=atoi(Clavier);
              Clavier[4]={0};
              compteur=0;
              lcd.clear();
             }
             
      
             }

             
       


      else if (hauteurOeil!=250 && LatDeg!=333 && LatMin!=333 && LonDeg!=333 && LonMin!=333) {

        
        
       
         lcd.home();
         lcd.print("angle lune:");
         lcd.setCursor(0,1);
         lcd.print(Tangage);
       
       
      if (key==NO_KEY) {
       
          if (Gite==constrain(Gite,0,2) ) {// facilite la précision de la visée. Si ça buzze c'est bon, on peut appuyer pour lancer la machine.
           tone(BUZZER,500);
       }
          else {
           noTone(BUZZER);
       }
          
          delay(100); 
      }
  
         
       else if (key!=NO_KEY) {
            noTone(BUZZER);
            lcd.clear();

            estimeLat=LatDeg+LatMin/60.00;
            estimeLon=LonDeg+LonMin/60.00;
            char astre='D';

           struct chiffres {// données à envoyer sous forme de variable structure.

             float Tangage;
             float estimeLat;
             float estimeLon;
             byte hauteurOeil;
             byte annee;
             byte numJourMois;
             byte mois;
             byte heure;
             byte minute;
             byte seconde;
             char astre;
             
          
        };

           chiffres data;

           data.Tangage=Tangage+TangageInit;
           data.estimeLat=estimeLat;
           data.estimeLon=estimeLon;
           data.hauteurOeil=hauteurOeil;
           data.annee=annee;
           data.numJourMois=numJourMois;
           data.mois=mois;
           data.heure=heure;
           data.minute=minute;
           data.seconde=seconde;
           data.astre=astre;
           

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

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

           Serial.flush();
        
       

          delay(3000);

           
          
          
          while (retourSerial.available()>0) {
  
          retourSerial.readBytes((byte *)&point, sizeof point);

          

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

          
          
          lcd.home();
          lcd.print("inter et azim:");
          lcd.setCursor(0,1);
          lcd.print(Intercept);
          delay(4000);
          lcd.home();
          lcd.print("caca chiant:");
          lcd.setCursor(0,1);
          lcd.print(Azimut);
          lcd.clear();
          estimeLat=0,estimeLon=0,LatDeg=333,LatMin=333,LonDeg=333,LonMin=333,hauteurOeil=250;
  }
      }

         
      }
       

       
          
      

   
      
         

       break;

       default:// affiche l'horloge UTC quand aucune touche du menu n'est pressée.

       noTone(BUZZER);
      lcd.home();
      lcd.print("date:");
      lcd.setCursor(7,0);
      lcd.print(numJourMois);
      lcd.setCursor(9,0);
      lcd.print("/");
      lcd.setCursor(11,0);
      lcd.print(mois);
      lcd.setCursor(13,0);
      lcd.print("/");
      lcd.setCursor(14,0);
      lcd.print(annee);
      lcd.setCursor(0,1);
      lcd.print("UTC:");
      lcd.setCursor(5,1);
      lcd.print(heure);
      lcd.setCursor(7,1);
      lcd.print("/");
      lcd.setCursor(8,1);
      lcd.print(minute);
      lcd.setCursor(10,1);
      lcd.print("/");
      lcd.setCursor(11,1);
      lcd.print(seconde);

    
      delay(100);
     

      break;
  }

      
      
  
}



byte bcdToDec(byte val){return((val/16*10)+(val%16));} //fonction qui change décimaux codés binaires en décimaux normaux.


La carte « esclave » (arduino due):

#include <math.h>//importe des fonctions trigonométriques indispensables pour nos calculs astro.

struct chiffres {// données reçues par la nano mises en variables globales.

  float Tangage;
  float estimeLat;
  float estimeLon;
  byte hauteurOeil;
  byte annee;
  byte numJourMois;
  byte mois;
  byte heure;
  byte minute;
  byte seconde;
  char astre;

};
chiffres data;

struct retour {
      int Intercept;
      int Azimut;
    };
retour point;    

float Tangage,estimeLat,estimeLon;
byte annee,numJourMois,mois,heure,minute,seconde,hauteurOeil;
char astre;
int Intercept,Azimut;


void setup() {
  Serial.begin(57600);//ouvre la voie série entre la nano et la due.
  Serial1.begin(57600);//ouvre la voie série entre la due et la nano.

  
}
void loop() {
  
   if (Serial.available()) {// lecture du buffer de réception si il est plein.
    
    Serial.readBytes((byte *)&data, sizeof data);// lecture des données qui vont être stockées dans les variables globales.

   Tangage=data.Tangage;
   estimeLat=data.estimeLat;
   estimeLon=data.estimeLon;
   hauteurOeil=data.hauteurOeil;
   annee=data.annee;
   numJourMois=data.numJourMois;
   mois=data.mois;
   heure=data.heure;
   minute=data.minute;
   seconde=data.seconde;
   astre=data.astre;
   
  
   }
   while(Serial.available()>0) Serial.read();//vidage du buffer.
  
   
   /*Serial.print(Tangage);
   Serial.print("  ");
   Serial.print(estimeLat);
   Serial.print("  ");
   Serial.print(estimeLon);
   Serial.print("  ");
   Serial.print(hauteurOeil);
   Serial.print("  ");
   Serial.print(annee);
   Serial.print("  ");
   Serial.print(numJourMois);
   Serial.print("  ");
   Serial.print(mois);
   Serial.print("  ");
   Serial.print(heure);
   Serial.print("  ");
   Serial.print(minute);
   Serial.print("  ");
   Serial.print(seconde);
   Serial.print("  ");
   Serial.print(astre);
   Serial.print("  ");
   Serial.print(Intercept);
   Serial.print("  ");
   Serial.print(Azimut);
   Serial.println();*/
   
  int an=2000+annee;
  int m=mois;

  if (mois<=2) {
  an-=1;
  m+=12;
  }
  else {
    an=an;
    m=m;
  }
  
  int a=int(an/100);
  int b=2-a+int(a/4);

  double jJulien=long(365.25*an)+long(30.6001*(m+1))+(numJourMois+heure/24.0+minute/(24.0*60.0)+seconde/(24.0*60.0*60.0))+1720994.5+b;// calcul jour julien.
  double jJulien00h=long(365.25*an)+long(30.6001*(m+1))+numJourMois+1720994.5+b;//calcul jour julien à 00hUTC(permet de calculer TSMG).

  double T=(jJulien-2415020.0)/36525.0;// temps en siècles juliens(variable principales des équations de Jean Meeus).
  double T00h=(jJulien00h-2415020)/36525;//temps en siecles juliens à 00hUTC(permet de calculer TSMG).
  

  

    
    
  
  
  if (astre=='C') {
    
   
  double A=radians(153.23+22518.7541*T);//correction venus.
  double B=radians(216.57+45037.5082*T);//correction venus.
  double CD=radians(312.69+32964.3577*T);//correction jupiter.
  double D=radians(350.74+445267.1142*T-0.00144*sq(T));//correction lune.
  double E=radians(231.19+20.20*T);//inegalite de longue periode.
  double H=radians(353.40+65928.7155*T);//taille du slip de Mike Brant.

  double 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 moyenne du soleil.

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

  
  double M=358.47583+35999.04975*T-0.000150*sq(T)-0.0000033*pow(T,3);//anomalie moyenne du soleil.

  double M1=M-long(M)+long(M)%360;

  
  double e=0.01675104-0.0000418*T-0.000000126*sq(T);//excentricité de l'orbite terrestre.
  
  double C1=(1.919460-0.004789*T-0.000014*sq(T))*sin(radians(M1));//équation du centre du soleil.

  double C2=(0.020094-0.0001*T)*sin(radians(M1));

  double C3=0.000293*sin(3*radians(M1));

  double C=C1+C2+C3;

  double lonVraie=L1+C;//longitude vraie du soleil.

  double v=M1+C;//anomalie vraie du soleil.

  double R=((1.0000002*(1-sq(e)))/(1+e*cos(radians(v)))+0.00000543*sin(A)+0.00001575*sin(B)+0.00001627*sin(CD)+0.00003076*cos(D)+0.00000927*sin(H));//rayon vecteur du soleil en UA.

  double obliquite=23.452294-0.0130125*T-0.00000164*sq(T)+0.000000503*pow(T,3);//obliquité de l'écliptique.

  double declinaison=degrees(asin(sin(radians(obliquite))*sin(radians(lonVraie))));

  double ascensionDroite=degrees(atan2(cos(radians(obliquite))*sin(radians(lonVraie)),cos(radians(lonVraie))));

  if (ascensionDroite<0) {
    ascensionDroite+=360;
  }
  else {
    ascensionDroite+=0;
  }

  double refraction=0;//calcul de correction de la réfraction atmosphérique selon Jean Meeus.

  if (Tangage>15.0) {
       refraction+=(58.294*tan(radians(90-Tangage))-0.0668*pow(tan(radians(90-Tangage)),3))/3600;
    }

    else if (Tangage>=0.0 && Tangage<4.0) {
       refraction+=(sq(6.6176-1.9037*log(Tangage+1.4)))/60;
    }

    else if (Tangage>=4.0 && Tangage<=15.0) {
       refraction+=(sq(4.3481-0.9466*log(Tangage-1.4)))/60;
    }

    double Oeil=(1.76/sqrt(hauteurOeil))/60;//correction de la hauteur d'oeil.

    
    double tempsSidGreen=0.276919398+100.0021359*T00h+0.000001075*sq(T00h);//temps sidéral à greenwich en révolutions.
    double tempsSidGreenHeures=(tempsSidGreen-long(tempsSidGreen))*24;//temps sidéral à greenwich en heures.

    double instantUT=(heure+minute/60.0+seconde/3600.0)*1.002737908;
    double TSMG1=instantUT+tempsSidGreenHeures;//temps sidéral à greenwich à n'importe quelle heure UT.
    double TSMG=TSMG1-long(TSMG1)+long(TSMG1)%24;

    double Diametre=degrees(atan(695510.0/(R*150000000.0)));// calcul de l'erreur de demi-diamètre(inutile pour notre système de visée au final).

    double Parallaxe=(6371/(R*150000000.0))*cos(radians(Tangage-Oeil));

    double AHL1=(TSMG*15+360)-ascensionDroite+estimeLon;
    double AHL=AHL1-long(AHL1)+long(AHL1)%360;

    
    double hauteurCalculee=degrees(asin(sin(radians(estimeLat))*sin(radians(declinaison))+cos(radians(estimeLat))*cos(radians(declinaison))*cos(radians(AHL))));

    double Azimut=0;

    if (AHL>=180 && AHL<360) {
       Azimut+=degrees(acos((sin(radians(declinaison))-sin(radians(estimeLat))*sin(radians(hauteurCalculee)))/(cos(radians(estimeLat))*cos(radians(hauteurCalculee)))));
    }
    else {
       Azimut+=360-degrees(acos((sin(radians(declinaison))-sin(radians(estimeLat))*sin(radians(hauteurCalculee)))/(cos(radians(estimeLat))*cos(radians(hauteurCalculee)))));
    }

    double hauteurVraie=Tangage-refraction-Oeil+Parallaxe;// la correction de demi-diamètre est enlevée car là on vise le milieu de l'astre.
    
    double Intercept=(hauteurVraie-hauteurCalculee)*60;

    
    
   

    

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

    

   
    

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

    
    
    Serial1.write((byte *)&point,sizeof point);
    
    
    Serial1.flush();//cette instruction permet d'envoyer toutes les infos avant de passer à la suitre du programme.

    
  
    delay(500);
   
    



  }

  else if (astre=='D') {

    
  
  double omega1=259.183275-1934.1420*T+0.002078*sq(T)+0.0000022*pow(T,3);//longitude du noeud ascendant de la lune.

  double omega=omega1-long(omega1)+long(omega1)%360;

  double Lprim1=270.434164+481267.8831*T-0.001133*sq(T)+0.0000019*pow(T,3)+0.000233*sin(radians(51.2+20.2*T))+0.003964*sin(radians(346.56+132.87*T-0.0091731*sq(T)))+0.001964*sin(radians(omega));//longitude moyenne de la lune.

  double Lprim=Lprim1-long(Lprim1)+long(Lprim1)%360;
  
  double M1=358.475833+35999.0498*T-0.000150*sq(T)-0.0000033*pow(T,3)-0.001778*sin(radians(51.2+20.2*T));//anomalie moyenne du soleil.

  double M=M1-long(M1)+long(M1)%360;

  double Mprim1=296.104608+477198.8491*T+0.009192*sq(T)+0.0000144*pow(T,3)+0.000817*sin(radians(51.2+20.2*T))+0.003964*sin(radians(346.56+132.87*T-0.0091731*sq(T)))+0.002541*sin(radians(omega));//anomalie moyenne de la lune.

  double Mprim=Mprim1-long(Mprim1)+long(Mprim1)%360;

  double D1=350.737486+445267.1142*T-0.001436*sq(T)+0.0000019*pow(T,3)+0.002011*sin(radians(51.2+20.2*T))+0.001964*sin(radians(omega))+0.003964*sin(radians(346.56+132.87*T-0.0091731*sq(T)));//élongation moyenne de la lune.

  double D=D1-long(D1)+long(D1)%360;

  double F1=11.250889+483202.0251*T-0.003211*sq(T)-0.0000003*pow(T,3)+0.003964*sin(radians(346.56+132.87*T-0.0091731*sq(T)))-0.024691*sin(radians(omega))-0.004328*sin(radians(omega+275.05-2.3*T));//distance moyenne de la lune à son noeud ascendant.

  double F=F1-long(F1)+long(F1)%360;
  
  double e=1-0.002495*T-0.00000752*sq(T);

  double teta=Lprim+6.288750*sin(radians(Mprim))+1.274018*sin(radians(2*D-Mprim))+0.658309*sin(radians(2*D))+0.213616*sin(radians(2*Mprim))-0.185596*sin(radians(M))*e-0.114336*sin(radians(2*F))+0.058793*sin(radians(2*D-2*Mprim))+0.057212*sin(radians(2*D-M-Mprim))*e+0.053320*sin(radians(2*D+Mprim))+0.045874*sin(radians(2*D-M))*e+
  0.041024*sin(radians(Mprim-M))*e-0.034718*sin(radians(D))-0.030465*sin(radians(M+Mprim))*e+0.015326*sin(radians(2*D-2*F))-0.012528*sin(radians(2*F+Mprim))-0.010980*sin(radians(2*F-Mprim))+0.010674*sin(radians(4*D-Mprim))+0.010034*sin(radians(3*Mprim))+0.008548*sin(radians(4*D-2*Mprim))-0.007910*sin(radians(M-Mprim+2*D))*e-
  0.006783*sin(radians(2*D+M))*e+0.005162*sin(radians(Mprim-D))+0.005*sin(radians(M+D))*e+0.004049*sin(radians(Mprim-M+2*D))*e+0.003996*sin(radians(2*Mprim+2*D))+0.003862*sin(radians(4*D))+0.003665*sin(radians(2*D-3*Mprim))+0.002695*sin(radians(2*Mprim-M))*e+0.002602*sin(radians(Mprim-2*F-2*D))+0.002396*sin(radians(2*D-M-2*Mprim))*e
  -0.002349*sin(radians(Mprim+D))+0.002249*sin(radians(2*D-2*M))*sq(e)-0.002125*sin(radians(2*Mprim+M))*e-0.002079*sin(radians(2*M))*sq(e)+0.002059*sin(radians(2*D-Mprim-2*M))*sq(e)-0.001773*sin(radians(Mprim+2*D-2*F))-0.001595*sin(radians(2*F+2*D))+0.001220*sin(radians(4*D-M-Mprim))*e-0.001110*sin(radians(2*Mprim+2*F))
  +0.000892*sin(radians(Mprim-3*D))-0.000811*sin(radians(M+Mprim+2*D))*e+0.000761*sin(radians(4*D-M-2*Mprim))*e+0.000717*sin(radians(Mprim-2*M))*sq(e)+0.000704*sin(radians(Mprim-2*M-2*D))*sq(e)+0.000693*sin(radians(M-2*Mprim+2*D))*e+0.000598*sin(radians(2*D-M-2*F))*e+0.000550*sin(radians(Mprim+4*D))
  +0.000538*sin(radians(4*Mprim))+0.000521*sin(radians(4*D-M))*e+0.000486*sin(radians(2*Mprim-D));//longitude écliptique de la lune.

  double B=5.128189*sin(radians(F))+0.280606*sin(radians(Mprim+F))+0.277693*sin(radians(Mprim-F))+0.173238*sin(radians(2*D-F))+0.055413*sin(radians(2*D+F-Mprim))+0.046272*sin(radians(2*D-F-Mprim))+0.032573*sin(radians(2*D+F))+0.017198*sin(radians(2*Mprim+F))+0.009267*sin(radians(2*D+Mprim-F))+0.008823*sin(radians(2*Mprim-F))
  +0.008247*sin(radians(2*D-M-F))*e+0.004323*sin(radians(2*D-F-2*Mprim))+0.004200*sin(radians(2*D+F+Mprim))+0.003372*sin(radians(F-M-2*D))*e+0.002472*sin(radians(2*D+F-M-Mprim))*e+0.002222*sin(radians(2*D+F-M))*e+0.002072*sin(radians(2*D-F-M-Mprim))*e+0.001877*sin(radians(F-M+Mprim))*e+0.001828*sin(radians(4*D-F-Mprim))
  -0.001803*sin(radians(F+M))*e-0.001750*sin(radians(3*F))+0.001570*sin(radians(Mprim-M-F))*e-0.001487*sin(radians(F+D))-0.001481*sin(radians(F+M+Mprim))*e+0.001417*sin(radians(F-M-Mprim))*e+0.001350*sin(radians(F-M))*e+0.001330*sin(radians(F-D))+0.001106*sin(radians(F+3*Mprim))+0.001020*sin(radians(4*D-F))+0.000833*sin(radians(F+4*D-Mprim))
  +0.000781*sin(radians(Mprim-3*F))+0.000670*sin(radians(F+4*D-2*Mprim))+0.000606*sin(radians(2*D-3*F))+0.000597*sin(radians(2*D+2*Mprim-F))+0.000492*sin(radians(2*D+Mprim-M-F))*e+0.000450*sin(radians(2*Mprim-F-2*D))+0.000439*sin(radians(3*Mprim-F))+0.000423*sin(radians(F+2*D+2*Mprim))+0.000422*sin(radians(2*D-F-3*Mprim))
  -0.000367*sin(radians(M+F+2*D-Mprim))*e-0.000353*sin(radians(M+F+2*D))*e+0.000331*sin(radians(F+4*D))+0.000317*sin(radians(2*D+F-M+Mprim))*e+0.000306*sin(radians(2*D-2*M-F))*sq(e)-0.000283*sin(radians(Mprim+3*F));

  double W1=0.0004664*cos(radians(omega));
  double W2=0.0000754*cos(radians(omega+275.05-2.30*T));

  double beta=B*(1-W1-W2);//latitude écliptique de la lune.

  double Pi=0.950724+0.051818*cos(radians(Mprim))+0.009531*cos(radians(2*D-Mprim))+0.007843*cos(radians(2*D))+0.002824*cos(radians(2*Mprim))+0.000857*cos(radians(2*D+Mprim))+0.000533*cos(radians(2*D-M))*e+0.000401*cos(radians(2*D-M-Mprim))*e+0.000320*cos(radians(Mprim-M))*e-0.000271*cos(radians(D))-0.000264*cos(radians(M+Mprim))*e
  -0.000198*cos(radians(2*F-Mprim))+0.000173*cos(radians(3*Mprim))+0.000167*cos(radians(4*D-Mprim))-0.000111*cos(radians(M))*e+0.000103*cos(radians(4*D-2*Mprim))-0.000084*cos(radians(2*Mprim-2*D))-0.000083*cos(radians(2*D+M))*e+0.000079*cos(radians(2*D+2*Mprim))+0.000072*cos(radians(4*D))+0.000064*cos(radians(2*D-M+Mprim))*e
  -0.000063*cos(radians(2*D+M-Mprim))*e+0.000041*cos(radians(M+D))*e+0.000035*cos(radians(2*Mprim-M))*e-0.000033*cos(radians(3*Mprim-2*D))-0.000030*cos(radians(Mprim+D))-0.000029*cos(radians(2*F-2*D))-0.000029*cos(radians(2*Mprim+M))*e+0.000026*cos(radians(2*D-2*M))*sq(e)-0.000023*cos(radians(2*F-2*D+Mprim))
  +0.000019*cos(radians(4*D-M-Mprim))*e;//parallaxe de la lune.

  double R=(6378.14/sin(radians(Pi)));//distance entre le centre de la terre et de la lune en km.

  double obliquite=23.452294-0.0130125*T-0.00000164*sq(T)+0.000000503*pow(T,3);//obliquité de l'écliptique.


  
  
  double ascensionDroite=degrees(atan2((sin(radians(teta))*cos(radians(obliquite))-tan(radians(beta))*sin(radians(obliquite))),cos(radians(teta))));//ascension droite de la lune.

  if (ascensionDroite<0) {
    ascensionDroite+=360;
  }
  else {
    ascensionDroite+=0;
  }
  
  double declinaison=degrees(asin(sin(radians(beta))*cos(radians(obliquite))+cos(radians(beta))*sin(radians(obliquite))*sin(radians(teta))));//declinaison de la lune.

   

  double refraction=0;

  if (Tangage>15.0) {
       refraction+=(58.294*tan(radians(90-Tangage))-0.0668*pow(tan(radians(90-Tangage)),3))/3600;
    }

    else if (Tangage>=0.0 && Tangage<4.0) {
       refraction+=(sq(6.6176-1.9037*log(Tangage+1.4)))/60;
    }

    else if (Tangage>=4.0 && Tangage<=15.0) {
       refraction+=(sq(4.3481-0.9466*log(Tangage-1.4)))/60;
    }

    double Oeil=(1.76/sqrt(hauteurOeil))/60;

    
    double tempsSidGreen=0.276919398+100.0021359*T00h+0.000001075*sq(T00h);//temps sidéral à greenwich en révolutions.
    double tempsSidGreenHeures=(tempsSidGreen-long(tempsSidGreen))*24;//temps sidéral à greenwich en heures.

    double instantUT=(heure+minute/60.0+seconde/3600.0)*1.002737908;
    double TSMG1=instantUT+tempsSidGreenHeures;//temps sidéral à greenwich à n'importe quelle heure UT.
    double TSMG=TSMG1-long(TSMG1)+long(TSMG1)%24;

    double Diametre=degrees(atan(1750/R));//inutile pour notre système de visée au final.

    double Parallaxe=(6371/R)*cos(radians(Tangage-Oeil));

    double AHL1=(TSMG*15+360)-ascensionDroite+estimeLon;
    double AHL=AHL1-long(AHL1)+long(AHL1)%360;

    
    double hauteurCalculee=degrees(asin(sin(radians(estimeLat))*sin(radians(declinaison))+cos(radians(estimeLat))*cos(radians(declinaison))*cos(radians(AHL))));

    double Azimut=0;

    if (AHL>=180 && AHL<360) {
       Azimut+=degrees(acos((sin(radians(declinaison))-sin(radians(estimeLat))*sin(radians(hauteurCalculee)))/(cos(radians(estimeLat))*cos(radians(hauteurCalculee)))));
    }
    else {
       Azimut+=360-degrees(acos((sin(radians(declinaison))-sin(radians(estimeLat))*sin(radians(hauteurCalculee)))/(cos(radians(estimeLat))*cos(radians(hauteurCalculee)))));
    }

    double hauteurVraie=Tangage-refraction-Oeil+Parallaxe;
    
    double Intercept=(hauteurVraie-hauteurCalculee)*60;
  

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

     
   
    Serial1.write((byte *)&point,sizeof point);

    Serial1.flush();

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


  

  }


  
  retour point={0,0};

  chiffres data={0,0,0,0,0,0,0,0,0,0,0};

  Tangage=0,estimeLat=0,estimeLon=0,hauteurOeil=0,numJourMois=0,mois=0,heure=0,minute=0,seconde=0,astre=0,Azimut=0,Intercept=0,annee=0;
  


  }

   

E. Résultats, verdict de Nono

  1. Sur la Terre ferme

En testant Nono dans mon jardin (avec ce fonctionnement on a pas besoin de voir la ligne d’horizon donc c’est possible, par contre il faut connaitre son altitude), les fonctions gitomètre et compas fonctionnent bien. Pour la fonction C (droite de hauteur avec le Soleil) également; en prenant bien le temps de faire sa visée, on obtient une bonne précision pour un truc « home made ». En revanche la fonction D avec la Lune est beaucoup moins précise sans être catastrophique pour autant; va falloir l’améliorer. Cependant la visée reste délicate à faire par rapport à un sextant classique. Le moindre petit mouvement parasite nous fait perdre de la précision (surtout quand on appuie sur le bouton de saisie), et là c’est dans le jardin…En mer ça risque d’être plus délicat, à voir.

2. Sur mon bateau

Sans surprise, la visée reste faisable sur le bateau par temps calme. Quand ça bouge bien on perd aussitôt beaucoup de précision. Un essai par mer calme et à la cape m’a donné un point d’une précision de 13 Mn environ. Sur terre avec un bon étalonnage du gyrocompas on obtient environ la même précision sur les 2 points faits. Par contre la visée avec la Lune n’est pas encore assez précise, bien que les résultats ne soient pas complètement abberrants.

3. Conclusion

Par rapport à un sextant classique qui coûte cher et demande de faire des calculs à la table à carte après, ce système est nettement avantageux car on gagne du temps et du pognon; en plus on peut l’utiliser sans voir la ligne d’horizon en cas de brouillard où à la tombée de la nuit par exemple, donc aussi sur la terre ferme (à condition de savoir son altitude). Par contre quand la mer est agitée il est très difficile de viser l’astre et d’avoir les données du gyrocompas suffisamment stables pour obtenir une mesure précise.

4.prolongements possibles pour améliorer ce système

a. Faire mieux et moins cher

Ce système utilise deux cartes arduino dont la due qui coûte cher, or je pense qu’il est possible de faire bien mieux avec moins…Au moment où je termine d’écrire l’article, je viens de recevoir une carte raspberry pi zero. En bref, par rapport à une carte arduino, les raspberry pi se rapprochent plus du PC que du microcontrôleur. En plus cette carte ne coûte que 5 euros (voir kubii), 10 avec les frais de port…

Cette carte est en fait un vrai petit ordinateur, avec des capacités de calculs accrues (mais pas de traitement de données analogiques contrairement à l’arduino par contre) et surtout…Une mémoire ! En effet dans mon projet il n’y a pas de calcul de la méridienne avec le soleil car je n’avais pas les moyens de stocker de l’info. Avec une mémoire interne, on peut je pense mémoriser les points mesurés afin d’interpoler une fonction déclinant le déplacement du soleil (une parabole) via une interpolation de Lagrange ou alors une autre technique, à voir (on a pas besoin d’avoir une courbe extrêmement précise, c’est le max de la courbe qui importe si en abcisses on a mis le temps et en ordonnées la hauteur angulaire du soleil). Cette mémoire interne permettra également de stocker les positions pour induire un menu, un historique de navigation par exemple, ou alors calculer une vitesse fond…

Enfin, cette carte peut intégrer un petite caméra…Vous voyez où je veux en venir ? (non, pas filmer les vestiaires des filles en catimini) toujours pas ? (pas faire la suite du film « the room » non plus pauvres fous) améliorer la visée de l’astre! Bon pour tout ça va falloir que je me mette au langage python…

b. La suite

Prochainement je prolongerai l’article en essayant d’avoir une meilleure précision avec la droite de hauteur de la lune, et aussi un meilleur usage du buzzer (avec par exemple un son plus grave quand le gyrocompas est stable pour faciliter la visée par exemple à voir…). Et évidemment, refaire une autre version améliorée avec python et raspberry pi ! Bon si vous avez noté des coquilles ou des améliorations possibles du projet surtout n’hésitez pas à partager en laissant un petit message ! En attendant, petite video explicative:

petite vidéo test pénardo dans le jardin

Programme ti89 pour se positionner avec des étoiles (partie 2)

Assez insatisfait par mon programme précédent sur le point d’étoiles, j’en ai donc fait un autre plus précis. Il comporte un menu de sélection avec différentes étoiles, classées par constellation. Pour le mettre au point j’ai repris le master en astrophysique déniché sur internet (http://userpages.irap.omp.eu/jleborgne/astrometrie.pdf), sauf que cette fois j’ai pris en considération les corrections au complet (précession, nutation, aberration de Bradley, parallaxe, réfraction, dépression de l’horizon). Pour ajouter une barre de menu j’ai pompé sur la page web suivante : https://openclassrooms.com/courses/creation-de-barres-de-menus-sur-ti89-92-et-v200.

Si vous voulez rajouter des étoiles ou des constellations supplémentaires dans la barre des menus c’est facile il suffit de suivre ce tuto très utile. Pour voir si ça fonctionne j’ai trouvé un pdf sur le net appelé « exercices astro 2016-navigation astronomique ». ça fonctionne pour l’exercice mais il faudra le tester en réel une ou deux fois dans de bonnes conditions à la prochaine navigation pour voir.

Voilà le programme, en espérant ne pas avoir fait de fautes d’étourderies en le recopiant (je me suis relu plusieurs fois ça devrait aller !) :

ba71793711a7254ea83a93dafaadb698-0 ba71793711a7254ea83a93dafaadb698-1 ba71793711a7254ea83a93dafaadb698-2 ba71793711a7254ea83a93dafaadb698-3 ba71793711a7254ea83a93dafaadb698-4 ba71793711a7254ea83a93dafaadb698-5 ba71793711a7254ea83a93dafaadb698-6 ba71793711a7254ea83a93dafaadb698-7 ba71793711a7254ea83a93dafaadb698-8 ba71793711a7254ea83a93dafaadb698-9 ba71793711a7254ea83a93dafaadb698-10

Si ça ne fonctionne pas correctement, n’hésitez pas à me laissez un petit message!

PS:Un visiteur du site a aimablement corrigé deux boulettes sur le programme que j’ai publié au-dessus:

– l’angle horaire local (variable ahl) : mod(tslo+xxx-lone,360)

– tslo (variable tslo) : il faut remplacer gg/36525 par ((gg-h/24-m/1440-s/86400)-2451545)/36525

Programme TI89 « maison » pour faire le point avec le soleil

Par rapport aux étoiles, c’est quand même plus intéressant de faire le point avec le soleil; la journée en général l’horizon est bien dégagé et facilement perceptible, rendant l’usage du sextant plus commode et précis dans ses résultats, avec une amplitude de temps d’usage plus grande . Comme pour le programme fait avec les étoiles, on va d’abord chercher à « transformer » toutes les données de notre temps de mesure (heures, minutes, secondes, mois, années) en un seul nombre. Ce dernier permettra ensuite le reste des calculs qui ne sont rien d’autre que des fonctions dépendant du facteur temps. Pour ce début de programme on aurait donc pu utiliser le même que pour celui avec les étoiles, mais pour rigoler, cette fois on va tenir compte du calendrier Grégorien, allez hop à la benne le calendrier Julien!

sextant_gps

1) Première partie: calculer le facteur temps selon le calendrier Grégorien

Rappel: dans le calendrier Julien l’année moyenne dure 365.25 jours, donc une année bissextile a lieu tout les 4 ans (2008, 2012, 2016, 2020…). Sur le calendrier cela se traduit par un jour supplémentaire en février tout les 4 ans (29 jours au lieu de 28).

Pour résumer, afin d’avoir une année de calendrier avec une durée plus proche de la réalité, soit la durée d’une année tropique (à peu prêt 365,2422 jours), le procédé de calcul a été amélioré afin de réduire légèrement dans la durée la grandeur d’une année Julienne. En effet dans le calendrier Grégorien une année moyenne dure 365,2425 jours. Pour en arriver là, on garde les caractéristiques du calendrier Julien, mais à chaque année séculaire on ne la considère comme bissextile que si elle est divisible par 400. Pour notre programmation on va donc considérer une année comme bissextile si elle a eu lieu 4 ans après une autre année bissextile. Ensuite pour les années séculaires donc divisibles par 100 on fait le tri et on les acceptera comme bissextiles si elles sont également divisibles par 400. Par exemple d’après le calendrier Grégorien 2000 et 2400 sont bissextiles, mais 2500 et 2600 ne sont pas bissextiles.

Voilà ce que ça donne pour notre début de programme:

programme-ti89-soleil-2

programme-ti89-soleil-1

 

 

On s’aide de la boucle « while » et de la fonction int(). La boucle « while » demande au programme d’effectuer un calcul temps qu’une ou plusieurs conditions n’ont pas été atteintes, et la fonction « int() » ne garde que la partie entière d’un nombre, par exemple int(2.7)=2. Le nombre en fin de page 2457388.5 correspond au jour julien le 01/01/2016 à 00h00.

2) Deuxième partie: calculer à partir du facteur temps la déclinaison et l’angle horaire du soleil.

Comme on l’a vu dans « programmer une ti89 pour la navigation », il existe différentes façon de calculer ces deux paramètres, plus ou moins précises sur une durée plus ou moins longue, avec également plus ou moins de difficultés…Pour avoir des résultats très précis sur une durée très longue, cela demande énormément de paramètres à prendre en conséquence, en plus les astres se comportent de façon chaotique sur des périodes très longues…On va donc pas trop s’emmerder avec tout ça et plutôt fixer des limites selon nos besoins, c’est à dire un programme pertinent à l’échelle d’une vie et assez précis pour faire un point potable en navigation et pas trop alambiqué à programmer!

a) L’angle horaire:

Si on considère les choses de la façon la plus simple, on part du principe que la terre tourne sur elle-même en 24 heures, donnant l’illusion d’un mouvement du soleil autour de la terre se déplaçant à la vitesse de 360°/24H=15° par heure, avec le passage du soleil au méridien de greenwich à 12H UTC. En partant de ce postulat il suffirait d’écrire une formule comme AHG=15*(l*24) pour calculer l’angle horaire à greenwich(AHG), avec comme donnée origine en facteur temps un midi au méridien de greenwich. Pour déterminer notre angle horaire local (AHL), il suffirait simplement de soustraire à AHG notre longitude estimée(G).

Pourtant c’est insuffisant, avec ce fonctionnement simple on se retrouve avec des écarts de plus de 3 degrés par rapport aux véritables données! En fait le mouvement apparent du soleil par rapport à la terre n’a pas une vitesse constante à cause tout d’abord de la forme elliptique de l’orbite terrestre (voir la première et deuxième loi de Kepler), et aussi à cause de l’axe de rotation de la terre incliné sur son orbite. Heureusement, les écarts se répètent de façon quasi identique d’années en années, permettant assez facilement de calculer les bonnes données à chaque fois. Pour cela on va utiliser ce qu’on appelle l’équation du temps. Comme le dit si bien notre copain wikipépé cette équation correspond à un instant donné à la différence entre le temps solaire moyen et le temps solaire vrai. Le temps solaire moyen c’est le calcul écris dans le paragraphe au-dessus (le soleil se déplace à vitesse constante) et le temps solaire vrai va être calculé grâce aux équations écrites par wikipépé (influence de l’ellipticité de l’orbite terrestre et influence de l’obliquité de la terre). Conformément au début de notre programme ça donne maintenant ça:

programme-ti89-soleil-2

La fonction mod() sert ici à obtenir un résultat toujours compris entre 0 et 360 degrés(cette fonction fournit le reste d’une division euclidienne selon un dividende et un diviseur choisit), sinon on se retrouverait avec des angles énormes qui n’ont pas de sens. On pourrait également utiliser la boucle « for » pour ça mais la calculatrice mettrait plus de temps à calculer. Il y a 180 après mod() car le programme débute à minuit le 1/1/2016 (voir première partie du prog), donc à cette heure l’angle horaire moyen du soleil avec greenwich fait 180 degrés(si le prog avait débuté à midi, on aurait pas rajouté 180 mais rien du tout).

Pour les équations du temps, les coefficients employés sont facilement identifiables:

357.5291=anomalie moyenne le 01/01/2000 à 12h.

0.98560028=c’est la vitesse angulaire de rotation moyenne de la terre autour du soleil entre le passage de 2 périhélies, donc il s’agit de 360 divisé par l’année anomalistique.

2451545=c’est le jour julien du 01/01/2000 à 12h.

1.9148; 0.02; 0.0003=Il s’agit simplement d’un changement des coefficients de l’équation du centre en degrés(il suffit de multiplier les coeff d’origine par 180/π). L’obtention de l’équation du centre est expliquée par wiki.

280.4665=C’est la valeur de la longitude écliptique le 01/01/2000 à 12h.

0.98564736=C’est la vitesse angulaire moyenne de rotation de la terre autour du soleil sur une année tropique, donc on trouve cette valeur en calculant 360/365.2421898.

-2.46569; 0.053; 0.0014=comme pour l’équation du centre il s’agit d’un passage des coefficients de l’équation en degrés.

soleil

b) La déclinaison

Comme on l’a vu dans « programmer une ti89 pour la navigation », il existe plein de façons différentes d’obtenir la déclinaison du soleil; en utilisant des méthodes avec plus ou moins de paramètres, donc plus ou moins de précision et aussi plus ou moins de difficultés à programmer l’ensemble… pas simple. On va donc éliminer des données. On ne tiendra pas compte de l’influence des planètes et de la Lune du système solaire sur nos calculs, seulement des lois de kepler appliquées au système terre/soleil, se sera déjà pas trop mal.

La formule la plus simple pour avoir la déclinaison est celle qui utilise la structure d’une fonction périodique simple (sinus, cosinus) comme celle de Desmond Fletcher:

D=23.45*sin(2π/365(284+j)) avec j jours juliens. Ici 23.45 correspond à l’amplitude de la fonction sinus, donc à la valeur absolue maximale que peut atteindre la déclinaison (aux solstices). 2π/365 correspond à la période de la fonction sinus, ici elle va donc se répéter tout les 365 jours. 284 est un déphasage de la fonction. Cette formule ne tient pas compte de l’ellipticité de l’orbite terrestre et considère son mouvement équivalent à la trajectoire d’un cercle. C’est la méthode la plus simple mais aussi la moins précise.

Pour la déclinaison une autre façon de faire consisterai à écrire une fonction périodique mais par morceaux, chaque morceau correspondant à une saison, donc une fonction en 4 parties (voir « programmer une ti89 pour la navigation »). Cette méthode fonctionne bien, est facile à faire car il suffit de connaitre les dates des solstices et des équinoxes pour l’année à venir, cependant son point faible est qu’elle ne fonctionne que pour une année. En effet d’une année à l’autre les heures de passage aux équinoxes et aux solstices changent en suivant une valeur moyenne, mais en réalité il y a des écarts de quelques minutes, et à la fin le cumul de ses différences provoque…De plus grosses différences!

Sur internet il est facile de trouver des formules pour la déclinaison données par l’IMCCE, fonctionnant à plus ou moins long terme. On peut aussi en déduire une à partir de l’équation du temps car on sait que:

sin(déclinaison)=sin(obliquité de l’écliptique)*sin(longitude vraie du soleil).

En effet, pour le prouver c’est un peu la même démonstration que celle employée avec le triangle rectangle sphérique (permet de trouver les formules pour l’azimut et la hauteur calculée d’un astre), comme j’ai un peu la flemme de la faire pour les curieux c’est très bien expliqué sur la page web suivante : https://sites.google.com/site/astronomievouteceleste/4—mouvement-du-soleil

à partir de tout ça on peut en déduire la formule de la déclinaison à écrire à la suite du début de notre programme:

programme-ti89-soleil-2

Donc pour la déclinaison, 3 lignes de programme seulement suffisent quand on connait AHG. Avant de poursuivre notre prog on va vérifier l’efficacité de tout ça grâce au site de l’IMCCE, histoire de voir si c’est suffisamment précis notre histoire.

Test

En prenant 10 valeurs différentes on obtient ça:

le 15/12/2019 à 14h22 : -23°16’13.91 »/36°44’27.88 »→-23°16’/17h31

le 2/11/2043 à 2h : -14°40’9.90 »/214°6’50.43 »→-14°40’/14h29

le 28/2/2055 à 16h47: -7°47’20 »/68°38’28.54 »→-7°47’/22h46

le 12/5/2128 à 5h06: 18°28’20.7 »/257°22’25.4 »→18°13’/3h18

le 7/07/2184 à 21h12: 22°17’33.11 »/136°34’51.76 »→22°23’/7h12

le 18/10/2079 à 23h10: -9°56’58.8 »/171°15’1.75 »→-9°57/13h35

le 13/6/2046 à 12h11: 23°14’12.71 »/2°42’14.74 »→23°14’/5h28

le 6/09/2033 à 18h55: 6°6’8.13 »/104°12’36.45 »→6°6’/11h03

le 1/03/2085 à 4h22: -7°19’47.17 »/242°27’31.56 »→-7°20’/22h51

le 19/02/2074 à 3h18: -11°10’21.23 »/226°4’8.9 »→-11°10’/22h12

à gauche c’est les résultats du prog en déclinaison et en angle horaire à greenwich, et à droite c’est ceux de la page web « calcul des éphémérides » de l’IMCCE en déclinaison et en ascension droite. A première vue c’est pas mal, on commence à perdre en précision de quelques minutes d’angle après 2080 sur la déclinaison  donc d’ici là on a le temps… On sait que l’ascension droite est l’angle entre le méridien du point vernal et celui d’un astre, mesuré vers l’est et exprimé en heures, et que c’est le complément à 360° de l’ascension verse. Or on a déjà trouvé la formule pour calculer le méridien du point vernal dans le programme pour se positionner avec les étoiles qui est la suivante :

100+5.5/60+(l-2451545-5843.5)*(360/365.2421898+360)-0.0524*16/(24*3600*36525)-0.0524*(l-2451545-5843.5)/(24*3600*36525)=angle point vernal. Donc en le calant à la suite dans notre prog ça donne:

programme-ti89-soleil-3

En refaisant le comparatif avec les ascensions droites trouvées sur l’IMCCE c’est pas mal. On peut dire que jusqu’à environ 2080 c’est précis, après un peu moins. On peut considérer que la partie éphémérides est OK pour la navigation. On va pouvoir passer à la suite c’est cool. Pour cette partie on aurait pu peut-être faire plus précis en intégrant certains des paramètres fixes utilisés en variables comme l’excentricité, la durée de l’année tropique et anomalistique, et l’angle d’inclinaison de la terre sur l’écliptique. Cependant pour nos besoins se sera suffisant je pense.

téléchargement

3) Calcul de l’intercept et de l’azimut vrai

 Maintenant que l’on a la déclinaison et l’angle horaire du soleil calculé à l’instant de la mesure, il va nous rester à définir la hauteur calculée (formule trigonométrique comme pour les étoiles), la hauteur vraie (c’est la hauteur instrumentale à partir de laquelle on va ajouter des corrections), et donc l’intercept et l’azimut vrai du soleil.

Les corrections à ajouter à la hauteur mesurée:

– La réfraction de la lumière (dépend de la hauteur de l’astre sur l’horizon).

– La parallaxe (dépend du rayon de la Terre, la distance Terre/Soleil et la hauteur de l’astre sur l’horizon).

– Le demi-diamètre du Soleil (environ 16 minutes).

– La hauteur de l’oeil d’observation par rapport au niveau de la mer.

– La collimation.

Le programme provisoire donne ça:

programme soleil()-1 programme soleil()-2 programme soleil()-3 programme soleil()-4 programme soleil()-5

Ce programme permet aussi de calculer des méridiennes, il suffit de taper 1 ou 2 si vous êtes dos au sud ou au nord quand vous observez le Soleil.

Attention: test !

J’ai vérifié son fonctionnement avec les pages web navastro (« navastro.free.fr/meridienne.htm » pour faire une méridienne et « navastro.free.fr/exos/exercices.htm » pour les droites de hauteurs). Les résultats diffèrent un peu mais ça reste assez potable et crédible. Un peu déçu, je creuse et remarque une erreur dans le programme du dessus; à la ligne de calcul de l’angle horaire local (ahl) au lieu d’avoir:

: mod(qq-rrr, 360)→ahl en fait c’est :mod(qq+rrr,360)→ahl

Et pour l’intercept au lieu d’avoir:

: hv-hc→in en fait c’est (hv-hc)*60→in

Le programme final qui fonctionne donne donc ça:

programme soleil()-1 programme soleil()-2 programme soleil()-3 programme soleil()-4 programme soleil()-5

En faisant ces modifs, ô miracle cette fois on trouve quasiment les mêmes résultats que navastro! Pfiou bon laissons le capitaine Haddock conclure avec philosophie…

téléchargement (1)

programme TI89 pour se positionner avec des étoiles (partie 1)

Le point d’étoile fonctionne un peu comme un point à trois relèvements avec des amers, sauf que dans ce cas précis les relèvements sont remplacés par des droites de hauteur faites sur des étoiles. Pour que le point d’étoile soit précis il faut si possible utiliser des étoiles les plus éloignées possibles les unes des autres (dans l’idéal avec 120 degrés entre chaque étoile), et effectuer la mesure au sextant peu avant ou après le coucher du soleil pour pouvoir bien distinguer encore la ligne d’horizon. Il faut également éviter de choisir des étoiles trop proches de l’horizon à cause de la réfraction de la lumière (voir loi de Snell-Descartes). C’est difficile lors de l’emploi du sextant de »faire descendre l’étoile sur l’horizon » (on peut facilement confondre une étoile avec une autre à côté), c’est pourquoi il est plus simple de l’utiliser à l’envers (limbe vers le haut), c’est à dire de « faire monter l’horizon sur l’étoile » de son choix. Généralement on ne peut utiliser des étoiles que placées proche du point d’horizon où se couche le soleil, au-delà c’est chaud de bien distinguer de façon nette la ligne d’horizon pour avoir un angle précis.

Pour mettre en place ce petit programme j’ai utilisé en grande partie un mémoire de master en astrométrie (introduction aux coordonnées célestes, astrométrie, Jleborgne) provenant de l’université de Toulouse, trouvable facilement en pdf sur le net, et d’autres trucs glanés ici ou là.

1) Système de coordonnées, définitions, mouvements impliqués

a) Coordonnées célestes

coordonnées célestes

Le système utilise des coordonnées équatoriales; on va situer les astres selon leur position par rapport à l’équateur céleste qui n’est rien d’autre que la projection de l’équateur sur la sphère céleste. En fait c’est presque le même principe que pour se situer sur terre; pour positionner une étoile on va avoir:

L’ascension droite souvent symbolisée par la lettre alpha, angle mesuré sur l’équateur céleste entre le point Vernal et la perpendiculaire à l’équateur céleste passant par l’objet étudié. Le point d’origine est donc le point Vernal et l’angle se mesure vers l’Est, cet angle s’exprime le plus souvent en heures mais est facilement convertible en degrés (1 heure=15 degrés, 1 degré=60 minutes, 1 minute=60 secondes), en heure elle varie donc de 0 à 24 heures (soit 0 à 360 degrés).

La déclinaison souvent symbolisée par la lettre delta, angle mesuré perpendiculairement entre l’objet étudié et l’équateur céleste. Sa valeur peut monter au max à 90 degrés (-90 au pole sud et 90 au pole nord)et au minimum à 0 degrés (équateur). La déclinaison ressemble beaucoup à la latitude, elle est positive dans l’hémisphère Nord et négative dans l’hémisphère Sud.

Le point Vernal souvent représenté par gamma ou simplement la lettre g, est un peu plus subtil à se représenter. Sur la sphère céleste l’écliptique (plan comprenant la terre et le soleil) et l’équateur céleste se croisent en deux endroits appelés noeuds, le noeud descendant quand le soleil passe de l’hémisphère Nord au Sud, et le noeud ascendant quand il passe de l’hémisphère Sud au Nord, bref à l’équinoxe de printemps (entre le 19 et le 21 mars).Nous allons voir que ce point de référence n’est pas fixe. En effet les équinoxes se déplacent d’environ 50 » par an le long de l’écliptique vers l’ouest. L’angle horaire du point vernal (ou temps sidéral) se compte à partir du méridien de Greenwich et on l’écrit généralement ahso ou ahgγ. Le point vernal se déplace presque selon une vitesse constante, cette vitesse fait environ 15.04166 degrés. Nous verrons que pour fiabiliser notre programme il va falloir encore plus de précision.

Pour les coordonnées célestes les coordonnées J2000.0 servent de référence, soit les mesures prises le 1er janvier 2000 à midi pile dans le calendrier Grégorien. Si on tape le nom d’une étoile dans wikipédia par exemple, la plupart du temps les coordonnées indiquées à droite de la page sont celles mesurées à J2000.0, pour avoir les bonnes coordonnées selon le moment de la mesure, des corrections à appliquer à ces valeurs sont indispensables.

b) Le calendrier Julien, calendrier Grégorien

Importants à comprendre pour faire notre programme; le calendrier Grégorien est un peu une version customisée du calendrier Julien, l’origine est la même tout comme les divisions en mois et semaines. La différence sera dans le choix des années bissextiles. Pour le calendrier Julien, il y a simplement une année bissextile tout les 4 ans (2008, 2012, 2016…) et pour le calendrier Grégorien, plus précis il y a une année bissextile si d’autres conditions supplémentaires sont réunies. Dans notre cas les caractéristiques du calendrier Julien suffiront. Bref dans le calendrier il y a 12 mois remplis alternativement par 31 (janvier, mars, mai, juillet, août, octobre, décembre) ou 30 jours (avril, juin, septembre, novembre). Exception pour février avec 28 jours pour une année « normale » et 29 jours pour une année bissextile, on arrive donc à 365 jours pour une année classique et 366 jours pour une année bissextile, soit une moyenne annuelle de 365.25 jours avec le calendrier Julien. Cependant cette durée ne colle pas parfaitement avec la durée réelle d’une année…Donc il va falloir bricoler un peu tout ce merdier pour que ça marche à peu prêt ! Un vrai boulot d’horloger stakhanoviste un peu maniaque sur les bords….

c) Qu’entend-t-on par « année » ?

Une année dans le calendrier Julien fait 365.25 jours. Mais il existe d’autres façons de qualifier une année:

Année sidérale : révolution terrestre rapportée à un repère fixe. Elle dure environ 365 jours, 6 heures, 9 minutes et 10 secondes.

Année tropique : temps entre deux passages successifs du soleil dans la direction du point vernal. Cette durée va être primordiale pour notre programme, notamment dans le calcul de l’angle horaire du point vernal. Elle dure environ 365 jours, 5 heures, 48 minutes et 45.26 secondes à J2000.0. Pour notre siècle elle décroit d’environ 5.23 secondes.Il y a une formule pour calculer l’année tropique moyenne trouvable un peu partout sur le net, c’est :

Année tropico =365.24219052-61.56*10^(-6)*T-0.068*10^(-6)*T^2+263*10*(-9)*T^3+3.2*10^(-9)*T^4. En 2000 elle vaut 365.2421898 jours et en 2100 elle vaut 365.2421291582 jours. T est le temps écoulé en siècles Juliens depuis J2000.0.

Année anomalistique : temps entre deux passages successifs de la terre au périhélie. Elle dure à peu prêt 365 jours, 6 heures, 13 minutes et 53 secondes. Le périhélie c’est le moment où la Terre est la plus proche du Soleil (lois de Kepler), donc là où elle se déplace le plus vite.

d) Mouvements influant sur les coordonnées équatoriales

Pour notre plus grand malheur ces coordonnées ne sont pas stables (se serait trop simple), elles vont évoluer selon deux phénomènes cycliques appelés la précession et la nutation. La précession est due aux effets de marée sur la rotation de la terre. C’est un mouvement lent d’une période de 26000 ans environ mais de très grande amplitude car il peut monter jusqu’à 23.5 degrés environ (modifier la déclinaison d’un astre jusqu’à 23.5 degrés). La nutation due également à la marée a une période brève de 18.6 ans avec une amplitude faible comparativement à la précession : 9 secondes seulement. Du coup pour notre programmation, et aussi pour simplifier tout ça on peut négliger la nutation, on y perd un peu en précision mais bon…

On va utiliser ces formules pour le programme :

Précession générale=p=50.290966+0.0222226T » par an, T temps écoulé en siècles Juliens (36525 jours) depuis J2000.0.

-p=m*cos(E)+n*sin(E), E inclinaison moyenne de l’écliptique (23°26’21.448 » à J2000.0). m est la précession en ascension droite, n est la précession en déclinaison.

-p=5029.0966+2.22226T-0.000042T^2 » par siècle.

-m=4612.4362+2.79312T-0.000278T^2 » par siècle.

-n=2004.3109-0.85330T-0.000217T^2 » par siècle.

La précession donne à la Terre une sorte de mouvement de « balle liftée » par rapport au soleil. Elle provoque également un changement d’étoile polaire; actuellement c’est Polaris qui indique le Nord mais ce ne sera pas éternellement le cas.

d)  autres phénomènes impliquant des corrections

On va y trouver la réfraction atmosphérique bien sûr (loi Snell-Descartes), mais également l’aberration de Bradley, la parallaxe, la hauteur de l’observateur par rapport au niveau de la mer, l’erreur de demi-diamètre de l’astre observé. L’erreur de demi-diamètre de l’astre (voir droite de hauteur) est négligeable car une étoile c’est petit vu de notre position; on peut également ignorer la parallaxe en raison de l’éloignement important des étoiles, donc de sa valeur infime ici. On peut aussi s’en tamponner de l’aberration de Bradley…Heureusement on va quand même tenir compte du reste histoire que ça fonctionne un minimum !

Aberration de Bradley : ce phénomène existe à cause de la vitesse finie de la lumière (environ 300000 km/s dans le vide) et de la rotation de la terre autour du Soleil (environ 30 km/s, varie selon sa trajectoire elliptique). Cela provoque en une année une légère rotation de toutes les étoiles autour de leur « point moyen » sur la voûte céleste; en fait l’étoile n’est pas fixe mais tourne autour d’un tout petit cercle ou une ellipse. La différence entre la position moyenne et apparente de l’étoile est de 20.5 secondes… Ce qui est relativement peu donc pour le programme on peut s’en balancer.

aberration bradley

Cette différence entre position moyenne et apparente s’explique avec la formule présente dans le schéma ci-dessus : tan(alpha)=v/c ; or sur terre v=30 km/s environ et c=300000 km/s. Donc tan(alpha)=0.0001, donc alpha=0.00573°=20.6265 ».

Anecdotes :

.c’est difficile de se représenter ce phénomène mentalement, et comme on dit « un schéma synthétique vaut toujours bien mieux qu’un long discours un peu chiant », une analogie de situation peut-être bien pratique. Il y a l’analogie de Bradley lui même grâce à sa pratique de la voile sur la Tamise en observant un drapeau : ce dernier n’est ni dans le sens du vent, ni dans le sens de direction du bateau mais dans la composante vectorielle des 2. C’est pareil pour la position de l’étoile résultant de la composante vitesse de la Terre autour du Soleil avec la vitesse de la lumière.

. La parallaxe est utilisée comme outil pour savoir approximativement les distances d’éloignement de certains astres. Pour les étoiles les plus proches du système solaire la valeur de la parallaxe ne dépasse pas 1 seconde d’arc…Du coup on va pas trop s’embêter avec ça hein.

La correction de la réfraction atmosphérique varie selon la pression atmosphérique et la température ; sur wikipédia on nous donne une formule à employer quand on est au niveau de la mer, à pression atmosphérique constante de 1010 mbars avec une température de 10 °C. Cette formule, semblable d’ailleurs à celle du mémoire (c’est la même mais simplifiée) est la suivante :

R=(1.02/tan(Hv+10.3/(Hv+5.11)))/60 ; R est l’angle de réfraction en degrés, Hv est la hauteur vraie en mètres.

 La dépression apparente de l’horizon, due à la hauteur de l’observation par rapport au niveau de la mer est trouvable sur plusieurs pages du web avec la formule suivante :

D=(1.77*√(E))/60 , D abaissement de l’horizon en degrés et E élévation de l’oeil en mètres.

e) Comment mesurer la hauteur d’une étoile ?

C’est le même principe que la droite de hauteur avec le Soleil. C’est l’angle horaire du point vernal qu’il faut utiliser, il va nous permettre de déterminer l’angle horaire local ahl de l’étoile :

ahl = ahgy – g + AV (g est la longitude du point estimé e, AV est l’ascension verse).

L’ascension verse est l’angle entre le méridien du point vernal et celui d’un astre mesuré comme un angle horaire, vers l’ouest et sur 360 degrés; elle est utilisée en nav astro pour situer une étoile.

L’ascension droite est l’angle entre le méridien du point vernal et celui d’un astre, mesuré vers l’Est et exprimé en heures. C’est le complément à 360 degrés de l’ascension verse. Par exemple l’ascension verse en janvier 2016 pour Bételgeuse est de 270.985 degrés. Donc l’ascension droite sera égale à 360-270.985=89.015 degrés. En général quand on cherche la position d’une étoile sur le net elle est donnée en déclinaison et ascension droite, à J2000.0.

droite5Comme pour la droite de hauteur avec le soleil (voir droite de hauteur), les formules à intégrer pour les calculs sont les suivantes :

-sin (hc) = sin (L) * sin (D) + cos (L) * cos (D) * cos (AHL) ; hc est la hauteur calculée de l’astre, L la latitude du point estimé e, D la déclinaison de l’astre, et AHL c’est l’angle horaire local.

-cos (z^) = (sin (D) – sin (L) * sin (hc)) / (cos (L) * cos (hc)).

– Le relèvement calculé de l’astre est égal à z^ si 180°≤AHL<360°, et à 360-z^ si 0≤AHL<180°.

-L’intercept est la différence entre la hauteur vraie de l’étoile mesurée au sextant, et la hauteur calculée de l’étoile. Intercept = hv-hc. L’intercept s’exprime en milles.

Pour ceux qui sont toujours là et qui s’accrochent malgré tout, une petit aparté spirituel avant d’attaquer la suite :

croissant-et-chausson (Copier)

 

2) Notre programme

dubhé 1 (Copier)dubhé 2 (Copier)

 

 

Ce programme marche pour l’étoile Dubhé de la constellation de la Grande Ourse, mais il fonctionne également pour n’importe quelle étoile. Il suffit de remplacer les valeurs t (ascension droite de l’étoile le 01/01/16 à 00h00 utc) et  u ( déclinaison de l’étoile le 01/01/16 à 00h00 utc). Ce programme marche à partir du 01/01/2016 à 00h00 utc jusqu’à l’année 2100 qui n’est pas bissextile (mais que ce programme intègre comme telle, ce qui est faux).

1) partie 1, transformer la date et l’heure en un seul nombre exploitable (ligne 1/ligne 36).

Jusqu’à la ligne se terminant par , g (ligne 36), le programme va changer l’heure, les minutes, secondes, mois et année de la mesure en un seul nombre décimal qui dans le programme se nomme g. Pour déterminer les années bissextiles on utilise une fonction cosinus (une fonction périodique sinus aurait pu tout aussi bien faire l’affaire); cette fonction sera égale à 1 tout les 4 ans. Quand cette fonction ici appelée i = 1, on peut voir que e (nombre de jours selon les mois) change. La partie avec les « elseif » détermine le nombre de jours écoulés dans les mois depuis le 01/01 de l’année de la mesure jusqu’à l’instant de la mesure.

int(365.25*f) détermine le nombre d’année cumulées entre l’instant de la mesure  et le 01/01/2016. int() est une fonction qui ne garde que la partie entière d’un nombre, par exemple int(17.8)=17.

La ligne 35 réduit tout les paramètres de temps à la même unité (le jour), ils sont additionnés pour obtenir g. 2457388.5 (=2451545+5843.5) est le jour julien le 01/01/16 à 00h00.

2) partie 2, déterminer l’angle horaire du point vernal (ligne 37/ligne 45).

Ligne 37, 100+5.5/60 est l’angle horaire du point vernal ahso le 01/01/16 à 00h00 utc.

Aux lignes 37 et 38, grâce à g, on calcule ahso au moment de la mesure en décimal. On sait que le point vernal effectue en 24 heures plus de 360 degrés; pour avoir sa vitesse moyenne précise il suffit de diviser la distance effectuée (360 degrés de révolution entre 2 équinoxes successives en 1 an) par la durée mise par le point vernal. Cette durée correspond à l’année tropique moyenne longue de 365.2421898 jours. Donc (360/(365.2421898)+360)/24=15.0410686… Soit la vitesse moyenne environ du point vernal par heure (pour l’année 2000. Elle diminue très légèrement chaque année).

La durée de l’année tropique moyenne diminue actuellement environ de 5,24 secondes par siècle, -0.0524*16/(24*3600*36525) est donc le calcul de cette diminution de temps entre le 01/01/16 et 2016.

-0.0524*(g-2451545-5843.5)/(24*3600*36525) est le calcul de cette diminution de temps entre 2016 et l’instant de la mesure.

Entre les lignes 38 et 43, le programme donne la valeur de z (ahso) correcte, car avant ce passage z va rapidement être supérieur à 360.

z>DMS transforme les données décimales de z en données sexagésimales (degrés, minutes, secondes).

3) Partie 3, (ligne 46/ligne 76) calcul du relèvement calculé et de l’intercept.

Au début de cette étape on change les données sexagésimales du point estimé et de l’angle mesuré en donnée décimales exploitables pour les calculs. Dans le programme j’aurai aussi pu intégrer la collimation et l’excentricité du sextant employé mais je l’ai pas fait (c’est un mack 3…). Lignes 56 et 57 ce sont respectivement l’ascension droite puis la déclinaison de l’étoile Dubhé le 01/01/16. Ligne 58 à 61 on utilise les équations de la précession pour obtenir les coordonnées céleste de Dubhé à l’instant de la mesure. La ligne 62 calcule l’ascension verse de l’étoile au moment de la mesure, et…Et allez hop pour les irréductibles encore présent, petite pause contemplative ils le méritent bien ! (si ça peut en plus attirer plus de visiteurs sur le blog…)

beach-boat-fashion-girl-Favim.com-3934943 (Copier)

 

 

Alors on en était où… Ha oui ;

Le reste du programme reprend les formules vues au début. La fonction If utilisée entre la ligne 70 et la ligne 72 détermine l’azimut vrai. Et maintenant, utilisation test !

3) Test

Pour faire un point d’étoiles réussi on a besoin de plusieurs ingrédients :

-Un horizon clair et dégagé.

-Une montre bien calée sur l’heure du méridien de Greenwich.

-Une TI89, une calculatrice programmable ou des éphémérides.

-Un sextant ou un truc pour mesurer la hauteur des astres.

-Une carte hauturière.

Pour ma part le jour de la mesure l’horizon n’était pas très net, et j’ai utilisé un vieux sextant mack 3 pour la faire du coup ça manque quand même un peu de précision. En plus la mesure s’est faite sur la Manche, donc la différence de hauteur d’eau due à la marée a pu aussi jouer sur cette précision.

Les conditions m’on permis d’effectuer 3 mesures, une sur Dubhé, une sur l’étoile polaire et une autre sur Alkaid (le bout du manche de la casserole sur la grande ourse). On reste donc malheureusement sur 3 étoiles très proches, mais ça donne déjà une petite idée malgré tout. Le point estimé e (choisit arbitrairement sur la carte) utilisé est de latitude 49°50′ Nord, et de longitude 1°5′ Est. Donc les coordonnées de e sont positives (latitude négative si Sud, longitude négative si Ouest).

Résultats:

.Pour Dubhé, la hauteur vraie est de 35°52′ relevée à 22h 32 min 52 secondes (heure locale, donc en UTC on enlève 2 heures) le 15/08/16. Le programme calcule ce résultat :

relèvement calculé = 325.5° ; intercept = -22.423 miles.

.Pour Polaris, la hauteur vraie est de 48°46′ relevée à 22h 35 min 2 secondes. Du coup on obtient :

relèvement calculé =359.007° ; intercept=-47.113 miles.

.Pour Alkaid, la hauteur vraie est de 44°31′ relevée à 22h 28 min 42 secondes. Donc ça donne :

relèvement calculé= 299.38 ° ; intercept=49.285 miles.

Donc en utilisant la carte, on part du point estimé e, puis pour chaque relevé on trace l’intercept ; du point e vers l’étoile si ce dernier est positif, et du point e vers la direction opposée à l’étoile si l’intercept est négatif. On peut ensuite tracer les droites de hauteur qui sont perpendiculaires aux intercepts afin de définir un triangle de positionnement. Alors le point obtenu nous situe environ à 80 km au sud de Fécamp (ma carte routière était trop petite pour tracer convenablement les droites  de hauteur)… Alors que les mesures ont été prises à Pourville près de Dieppe… Il faudrait refaire un point d’étoile avec un horizon plus net et un sextant à tambour peut-être, avec des étoiles bien distancées également.

Ce petit programme fonctionne bien pour corriger les coordonnées célestes des étoiles, pour l’angle horaire du point vernal il est précis à 1° prêt (ça fait une marge d’erreur de 0.3 % environ). Il se base sur une année tropique moyenne or elle change tout les ans selon un nombre important de paramètres tels que la vitesse de la Terre autour du Soleil qui change au périhélie et à l’aphélie avec les lois de Kepler, l’influence de la Lune et des autres planètes également. Autrement dit en réalité la vitesse du point vernal n’est pas complètement uniforme mais varie un peu.

Pour améliorer ce programme on pourrait inclure la collimation, l’excentricité du sextant, également faire en sorte d’avoir directement les coordonnées des points d’intersections des droites de hauteurs à voir…Pourquoi pas améliorer la précision du point vernal et tenir compte de la nutation, Bradley,l’âge du capitaine…

 

programmer une TI 89 (calculatrice) pour la navigation

Un truc  pratique pour éviter de galérer avec les calculs à faire pour la navigation, surtout quand la mer bouge et qu’on a une choucroute plus ou moins bien calée dans le bide qui ne demande qu’à sortir, probablement sur la carte pour dessiner une nouvelle île, ou alors dans la descente : programmer à l’avance une calculatrice, on économise le temps passé à l’intérieur du bateau, c’est moins chiant et en général on s’épargne plus facilement des relents pénibles.

Sur internet l’almanach du marin breton a publié des programmes à intégrer dans une TI83 pour la droite de hauteur, l’amplitude lever/coucher du soleil, et les arcs capables. Pour une TI89 ces programmes fonctionnent très bien, il y a juste une ou deux petites modifications à faire:

Sur le fichier, le symbole E n’a rien à voir avec la fonction exponentielle. C’est une sorte d’abréviation de l’écriture scientifique : E^2=100, E^3=1000…Et quand on tape ce symbole on ne note pas le ^ sur la calculette. Dans un programme il faut toujours à chaque fois indiquer la fin de la fonction « IF » par un « ENDIF » sinon la calculatrice va marquer « erreur syntaxe » un truc dans le genre. C’est pourquoi à la ligne 2 du paragraphe « mécanique céleste dans calendrier julien » la phrase ne se termine pas par « End » mais « Endif ». Dans le programme pour obtenir l’amplitude lever/coucher du soleil il faut rajouter les « Endif » manquants pour qu’il fonctionne.

En regardant un peu ces programmes, on peut en déduire d’autres comme la méridienne, la distance orthodromique, l’angle orthodromique, le calcul de sa distance par rapport à un amer de hauteur connue:

0001 (Copier)

0002 (Copier)

Pour le calcul de la déclinaison solaire, le programme du marin breton tient compte du mouvement elliptique de la rotation de la terre autour du soleil (partie: « mécanique céleste dans le calendrier julien ») qui influe sur l’évolution de la déclinaison le long de l’année, et part d’un point précis de localisation du soleil dans le temps. Cependant il existe une formule simplifiée pour déterminer la déclinaison du soleil ne tenant pas compte de tout ça et qui considère la trajectoire de l’orbite terrestre comme parfaitement circulaire (en réalité elle est quasiment circulaire, sa forme elliptique est vraiment très peu prononcée avec une excentricité de l’ellipse égale environ à 0.017. L’excentricité d’un cercle est de 0 pour se faire une idée). Cette formule, moins précise que celle exposée au début, est quand même bien pratique tout en étant aussi beaucoup plus simple!

Déclinaison=(23+26/60)*sin((360/365.256363)*(284+J))

Cette formule nous permet de faire un petit programme pour trouver une déclinaison solaire selon le jour, le mois, l’heure (pour l’année 2015 en la comparant au programme du marin breton la différence ne dépasse pas 1 degré vers mi octobre, pour le reste c’est assez précis) sans avoir à bord les éphémérides. Un second programme inspiré du premier permet d’avoir un calcul encore plus précis (on tient alors compte de l’ellipse) :

0001 (Copier)

0002 (Copier)

0003 (Copier)

Pour ces formules de la déclinaison on utilise une fonction sinus car si on met les jours de l’année en abscisse et les valeurs possibles de la déclinaison à l’année, sa forme représente le plus possible le phénomène. Avec une fonction cosinus se serait possible peut-être je pense j’ai pas essayé. Pour les paramètres d’une fonction sinus, c’est à dire comment la bidouiller pour changer sa période, son amplitude son point de départ c’est assez simple : on va prendre cet exemple : A*sin(B(x-H)). Le paramètre A règle l’amplitude de la fonction (valeur maxi et mini qu’elle peut atteindre), B règle la période car la période de la fonction sinus est égale à 360/B ( valeur absolue). Enfin le paramètre H règle le déphasage, par exemple la fonction y=sin x est une fonction impaire ayant pour centre de symétrie l’origine o, donc si x=0 alors y=0. Si maintenant on pose y=sin (x-3), alors y=o si x=3 donc on aura décalé la fonction sinus de 3 vers la droite sur les abscisses, on l’aura déphasé de 3 quoi.

 

1)Fabriquer un sextant pour que dalle

Pour s’initier à la navigation astronomique, on pense qu’il est indispensable d’acheter un sextant. Le premier prix pour cet instrument est le mark 3 qui coûte une soixantaine d’euros. Pour avoir des mesures plus précises de sa position, le tarif devient par la suite rapidement exponentiel…et inversement proportionnel à la motivation d’apprendre qui peut vite décliner. C’est vrai, pourquoi s’embêter à dépenser de l’argent et faire des calculs alors qu’avec le même prix on peut s’offrir un gps de bonne qualité? La petite méthode suivante permet non seulement de ne pas débourser plus de dix euros, mais en plus elle permet de mesurer des hauteurs d’étoiles sans avoir besoin de pouvoir distinguer l’horizon.

1)Matériel

Il suffit d’avoir sous la main un simple rapporteur en plastique, un fil long (un mètre, un mètre cinquante)et fin, un truc qui fait lest(un ou plusieurs gros écrous par exemple)et un morceau de bois ou de plastique long, bien droit et de section carrée. Un petit tube de colle forte nous permettra de coller le rapporteur et la pièce en bois ou plastique de la façon suivante:

sextant brico (Copier)

Il faut bien faire attention à coller le bord droit du rapporteur bien parallèle au morceau de bois.

Ensuite on fait passer le fil dans le petit trou central du rapporteur, on fait un nœud d’arrêt tout bête et au bout du fil on attache le lest(pour la photo j’ai mis une clé, tant qu’il y a un peu de poids le reste n’a pas d’importance).

sextant brico2 (Copier)

Ayé finit! On l’utilise de la façon suivante:

sextantbricolo

Plus le bout de bois est long, droit, et plus le fil est fin et le lest lourd, plus on gagne en précision. On peut aussi installer l’ensemble sur un trépied avec un axe pivotant pour rendre la lecture encore plus précise sans les tremblements pendant la mesure.

La mesure de la hauteur de l’astre se fait en retirant 90° de X:

sextantbricoli

2)Avantages/inconvénients

Cette méthode présente le net avantage de mesurer la hauteur d’un astre sans avoir besoin de distinguer l’horizon, on peut donc s’exercer en ville par exemple, la vue de l’étoile suffit. Par contre à bord d’un bateau la mer doit être d’huile et le bateau à l’arrêt pour l’utiliser, sinon le lest bouge et on ne pourra pas mesurer la hauteur. Pour fabriquer un sextant plus élaboré vous pouvez aller lire la page du site sur comment fabriquer un sextant électronique avec arduino.

La droite de hauteur

La méridienne est facile à mettre en place et ne nécessite pas beaucoup de calculs, par contre la droite de hauteur c’est un peu l’usine à gaz si on loupe une étape. Cependant cette méthode présente un avantage par rapport à la méridienne: on peut déterminer sa position à tout moment de la journée, il suffit de faire deux observations de la hauteur du soleil(au moins deux heures d’écart pour plus de précision). En cas de ciel partiellement couvert, la méthode de la droite de hauteur est une bonne alternative si à midi local le soleil se cache derrière les nuages.

1)Principe

La mesure d’une hauteur du soleil à un moment de la journée nous positionne sur un cercle à la surface du globe:

droite

Ce cercle C, lorsque l’on est dessus nous fait voir le soleil sous une hauteur précise. Cette hauteur appelée hauteur calculée(Hc) se calcule, elle dépend de notre position(que l’on estime, par exemple en prenant comme point estimé le dernier fait dans le livre de bord)et du moment de la journée(le pied de l’astre n’aura pas la même position)où l’on mesure Hv. Ensuite on compare Hc à Hv, la hauteur vraie c’est à dire celle mesurée par le sextant. Si Hv>Hc, alors on reporte le point vers le soleil, sinon c’est l’inverse. La différence entre Hv et Hc est l’intercept.

Pour la droite de hauteur il y a des conditions limites:

20°<Hv<80°

Intercept<30 Miles

-60°<latitude d’observation<60°

Sur la carte, Le cercle C où l’on voit le soleil sous la hauteur calculée se trace sous forme de droite car sur le globe c’est un grand cercle pouvant être réduit à l’état de droite sur une carte de moindre échelle. Le véritable cercle où l’on est(celui où l’on observe le soleil avec la hauteur Hv)se trouve grâce à l’intercept appelons le C2. C2 se matérialise aussi en droite, c’est la droite de hauteur.

droite2

I est l’intercept, en fait on fait un transfert de droite. Si Hv>Hc, on translate la droite C vers le soleil sous la forme de la droite C2, sinon c’est l’inverse. En pratique on ne trace pas C, l’intercept se trace à partir du point estimé sur la carte.

Donc pour une seule observation/mesure de la hauteur du soleil à un moment de la journée, nous pouvons nous positionner sur une droite. Pour avoir une position en latitude/longitude il va falloir faire une deuxième observation. Quand on aura tracé cette deuxième droite de hauteur qui en découle il suffira de translater C2 selon notre route fond entre les deux observations, l’intersection finale nous donnera notre position au moment de la deuxième observation.

2)Le vif du sujet

Le calcul de Hc demande un peu de trigonométrie(voir trigo) et un soupçon de produits scalaires, le mieux est de rentrer la formule dans une calculatrice programmable style ti89. Sinon la méthode pour la retrouver est la suivante: on considère le globe terrestre comme une sphère de rayon 1, et incluse dans un repère cartésien où l’origine est le centre de cette sphère(non non, n’allumez pas encore le gps ça va le faire!). B est notre position estimée, A est la position du pied de l’astre calculée au moment de la mesure de Hv, P est le Pôle Nord.
droite3

On obtient trois segments sphériques a, b et c. a=90°-D(déclinaison du soleil à l’instant de mesure de Hv), b=90°-Le(latitude de notre point estimé), c=90°-Hc.

AHL=AHG-G(angle horaire du soleil, angle entre le pied de l’astre et Greenwich, moins la longitude de notre point estimé).

Le but du jeu va être de mettre tout ça en équation pour déterminer Hc. Pour cela on va faire un produit scalaire des vecteurs 0A et OB(pfffiouuuuu…..).

droite4

On va utiliser notre repère cartésien pour définir ces vecteurs.

0A: Sur l’axe des X, OA=0. Sur l’axe des Y, OA= sin(a) et sur l’axe des Z OA=cos(a).

0B: Sur l’axe des X, OB=sin(b)*sin(AHL), sur l’axe des Y OB=sin(b)*cos(AHL) et sur l’axe des Z OB=cos(b).

Le produit scalaire de deux vecteurs dans un repère cartésien se fait en multipliant leurs coordonnées que l’on additionne, soit OA(X,Y,Z) et OB(X’,Y’,Z’):

XX’+YY’+ZZ’=0+sin(a)*sin(b)*cos(AHL)+cos(a)*cos(b)

On trouve aussi le produit scalaire en multipliant la norme des deux vecteurs par le cosinus de l’angle entre les deux(n’oublions pas que 0A=OB=1):

OA*OB*cos(c)=1*1*cos(c)=cos(c)

Conclusion: cos(c)=sin(a)*sin(b)*cos(AHL)+cos(a)*cos(b), donc:

cos(90°-Hc)=sin(90°-D)*sin(90°-Le)*cos(AHL)+cos(90°-D)*cos(90°-Le), donc:

sin(Hc)=cos(D)*cos(Le)*cos(AHL)+sin(D)*sin(Le)

Voilà pourquoi il vaut mieux noter directement la formule quelques parts…faire ça à la table à carte dans une mer mouvementée, après avoir mangé un cassoulet bien fournit, ça peut devenir un peu difficile!

Les ennuis ne sont pas terminés, nous avons Hv, Hc donc nous avons notre intercept. C’est bien gentil, mais comment tracer notre droite C sur la carte? il nous manque une donnée, l’azimut. L’azimut est l’angle entre le vertical du pôle Nord et le vertical de l’astre. On l’appelle Z(en gros c’est le relèvement exact du soleil par rapport à notre lieu d’observation). Pour le trouver on calcule d’abord Z’.

droite5

Pour trouver l’angle Z’ on reprend la formule vue un peu auparavant(formule de permutation circulaire): cos(c)=sin(a)*sin(b)*cos(AHL)+cos(a)*cos(b). Ce qui nous intéresse c’est l’angle Z’, donc: cos(a)=sin(b)*sin(c)*cos(Z’)+cos(c)*cos(b)

donc, cos(90-D)=sin(90-Le)*sin(90-Hc)*cos(Z’)+cos(90-Hc)*cos(90-Le), et du coup:

sin(D)=cos(Le)*cos(Hc)*cos(Z’)+sin(Hc)*sin(Le) et au final cos(Z’)=(sin(D)-sin(Le)*sin(Hc))/(cos(Le)*cos(Hc))

Une fois Z’ déterminé, pour trouver Z(le vrai azimut, soit le relèvement calculé du soleil)c’est simple:

Z=Z’ si c’est le matin(si le soleil est à l’Est), et Z=360°-Z’ si c’est l’aprèm(si le soleil est à l’Ouest).

Dès que l’on a l’intercept et l’azimut vrai, on peut alors tracer notre droite de hauteur à partir de notre point estimé de départ. L’azimut qui est le relèvement calculé du soleil nous donne la direction pour tracer l’intercept(intercept sera perpendiculaire à la droite de hauteur), l’intercept nous donne la distance entre la droite de hauteur et le point estimé, et aussi de quel côté on tracera la droite par rapport au point(vers le soleil, en s’éloignant du soleil).

droite6

Dans l’exemple, Pe est le point estimé de départ, Zv est l’azimut vrai. Dans ce cas ci Hv<Hc, c’est pourquoi l’intercept est de sens opposé au soleil.

Le mieux pour cette méthode est d’avoir une calculatrice programmable style texas instrument(ti89 c’est bien), pendant un temps l’almanach du marin breton incluait une feuille de programme à rentrer dans la calculette et bien pratique malgré deux ou trois erreurs à corriger. Je crois qu’il existe aussi des calculettes spéciales astro conçues pour ça. Le marin breton explique très bien cette méthode.

La méridienne

Cette technique de navigation permet de se positionner à l’aide du sextant, d’une calculatrice, d’un chronomètre et de papier millimétré. Elle demande cependant des conditions particulières:

.Avoir le ciel et l’horyzon bien dégagé(sans blague…)à l’heure de passage du soleil au méridien local. Le moment où le soleil sera le plus haut dans le ciel(une demi heure avant jusqu’à une demi heure après)en fait.

.L’angle entre le soleil et l’horyzon(la hauteur vraie Hv)doit être compris entre 20° et 80°, sinon on augmente l’imprécision à cause de la réfraction de la lumière(voir loi de Snell-Descartes). Plus les rayons de lumière traversent une couche d’atmosphère importante, plus ils vont avoir de chance d’être déviés, or plus Hv est petit, plus la couche à traverser augmente.

1)Le sextant

Contrairement à ses prédécesseurs(kamal, astrolabe), son jeu de miroirs qui réfléchit la lumière permet d’avoir un calcul de Hv bien plus précis, non perturbé par les mouvements de la mer. Le sextant peut s’identifier à une sorte de rapporteur capable de mesurer un angle(l’angle Soleil/observateur/horyzon).

méridienne

La verticale du fil à plomb indique la hauteur Hv de l’astre. Evidemment en mer avec le mouvement des vagues c’est moins efficace!

Un sextant se présente de la façon suivante:

970px-Marine_sextant_fr_svg

Le grand miroir renvoie la lumière sur le petit miroir. Le petit miroir est fixe et le grand est solidaire de l’alidade. Dans la lunette on doit voir le bas de l’astre aligné sur l’horyzon, du coup pour cela on bouge l’alidade. On bouge donc le grand miroir de façon à obtenir cet alignement. Il suffit de lire ensuite la hauteur trouvée sur le limbe. La hauteur lue ici est la hauteur instrumentale, pour avoir la hauteur vraie il y a des modifications à apporter qu’on verra après. Les sextants les moins perfectionnés n’ont pas de tambour mais un vernier à la place(mack 3), la mesure se lit comme sur un pied à coulisse dans ce cas. On trouve des sextants à tout les prix, en plastique, en laiton…plus c’est cher et plus on y gagne en précision de mesure.

2)Méthode

Tout d’abord on règle sa montre le plus précisément possible à l’heure U.T(heure au méridien de Greenwich). Le mieux est d’en avoir une au préalable toujours réglée sur cette heure. Il va falloir ensuite déterminer à peu près l’heure de passage du soleil au zénith de l’endroit où l’on se trouve. La méthode la plus simple consiste à prendre le compas de relèvement et relever le Soleil. En effet, on sait que le soleil indique le Sud quand il est au zénith local(hémisphère Nord)et le Nord dans l’hémisphère Sud. Quand le relèvement indiqué se rapproche de plus en plus de 180°(hémisphère Nord), on commence à faire des mesures de hauteur à intervalles régulier.

méridienne2

 à chaque mesure de la hauteur on note la hauteur instrumentale et l’heure exacte qui lui correspond.

 

 

 

Quand le Soleil arrive au zénith, la hauteur ne varie plus et il va se stabiliser pendant un moment. Quand il est stable on règle à l’avance le sextant sur la dernière mesure observée quand le soleil était encore ascendant. Ensuite on regarde par la lunette du sextant le soleil, on va le voir progressivement descendre, en même temps on déclenche le chronomètre(noter l’heure U.T au moment où on le déclenche). Au moment où l’on voit le bord inférieur du Soleil « toucher » l’horizon, on stoppe le chrono, on déduit U.T trouvée à ce moment, et on la note. On refait pareil pour l’avant dernière hauteur mesurée quand le soleil montait, etc…

La hauteur du Soleil à son zénith est facile à déterminer car l’astre marque un temps d’arrêt à ce moment là. C’est cette hauteur qui va nous permettre de trouver notre latitude, en revanche tout le bidouillage vu en haut va nous aider à déterminer notre longitude.

Déterminer la hauteur vraie Hv

La hauteur instrumentale indiquée par le limbe de notre sextant n’est pas exactement la hauteur vraie, il faut y ajouter des corrections pour obtenir Hv. Il y a la collimation(ou erreur instrumentale, elle est indiquée dans le boîtier du sextant), les quatre corrections d’angles(voir corrections d’angle)que l’on trouve dans les éphémérides et la correction calendaire pour le Soleil(change tout les mois, visible aussi dans les éphémérides). La différence entre la hauteur instrumentale et la hauteur vraie n’est pas énorme, mais plus c’est précis, mieux c’est!

Déterminer la latitude

On prend Hv quand le Soleil était culminant, et on calcule Dz. C’est facile, Dz=90°-Hv. La latitude est alors facile à déterminer, L=D+/-(90°-Hv). C’est + si l’observation se fait pôle Nord dans le dos, et – avec le pôle Sud dans le dos(D est la déclinaison du Soleil au moment de la mesure, voir « la sphère céleste »).

Déterminer la longitude

La longitude se trouve en théorie facilement; avec la rotation de la terre le Soleil se déplace d’Est en Ouest autour du globe(référentiel terrestre)à une vitesse d’environ 15°/heure(la terre tourne sur elle même en 24 heures et a une circonférence de 360°). Donc en sachant l’heure exacte à laquelle le Soleil est au zénith, et connaissant l’heure U.T on peut facilement la déterminer. Or quand on regarde le Soleil il marque un temps d’arrêt quand il culmine, donc il est difficile de trouver une longitude précise. Pour la trouver on reprend le petit graphique que l’on a fait au début, celui où l’on a noté chaque mesure de hauteur prise avec l’heure correspondante quand le soleil montait, et quand il descendait. On prend une mesure d’angle(de préférence la moins proche du zénith pour être plus précis), et les heures correspondantes(disons T1 et T2) à l’instant de la montée et de la descente pour cette même mesure de hauteur. L’heure de culmination du Soleil est alors égale à T= (T1+T2)/2. Notre longitude se calcule alors de la façon suivante: longitude=(T-Tpass)*15°/heure(les éphémérides indiquent la vitesse de passage du soleil qui peut varier légèrement selon la date, voir V dans « la sphère céleste »). Tpass est l’heure de passage du soleil au méridien de Greenwich.

Remarque: utiliser les filtres coloré du sextant pour ne pas s’abîmer les yeux. On peut au fur et à mesure de l’observation enlever progressivement quelques filtres pour avoir une vision plus nette des bords du soleil. Le meilleur endroit pour effectuer les mesures se trouve près du mât, c’est là où l’on trouve un peu de stabilité si on est remué par les vagues.

Remarque: La collimation peut aussi se déterminer en observant simplement à travers la lunette l’horizon, en alignant juste l’image de l’horizon dans la lunette et en regardant la mesure correspondante sur le limbe, on obtient cette erreur instrumentale.

 

 

 

La sphère céleste

Autrefois on pensait la sphère céleste comme une sphère solide où les étoiles étaient accrochées, et qui tournait autour de la terre qu’elle contenait un peu comme des poupées russes. On sait maintenant que cette sphère n’existe pas, et que le mouvement des corps célestes dans le ciel d’Est en Ouest est dû à la rotation de la terre sur elle-même. On va quand même garder le concept de sphère pour se situer dans le ciel.

1)Les lignes célestes

Elles correspondent aux lignes placées sur le globe terrestre, ce n’est que leur projection. L’équateur céleste est la projection dans le ciel de l’équateur terrestre, pour les pôles célestes c’est le même principe. L’écliptique de la sphère céleste est le trajet apparent du soleil dans sa course annuelle.

sphère

Comme on a pu le voir dans le petit paragraphe « se positionner et s’orienter sans gps ni calculatrice », la course du soleil en un an oscille entre le tropique du cancer et du capricorne environ(23°26’N le 21 juin, 23°26’S le 22 décembre). Pour un observateur à Paris cela se traduit par un soleil plus haut sur l’horyzon en été qu’en hiver, l’écliptique est mobile le long de l’année et est la cause principale des saisons, des journées plus ou moins longues.

2)Repères utilisés

La déclinaison d’un astre(étoile, soleil…) correspond à sa latitude sur la sphère terrestre. L’ascension droite  correspond à sa longitude. Ces coordonnées sont prises à partir du pied de l’astre, point d’intersection entre la droite qui passe au centre de la terre et de l’astre, et la tangente à la sphère.

sphère2

La déclinaison va de 90° Sud à 90° Nord en passant par l’équateur(O°). Les valeurs Nord sont précédées par un + et les valeurs Sud -. L’ascension droite tourne le long de l’équateur céleste dans le sens inverse des aiguilles d’une montre, on la compte en heures, minutes, secondes.

3)Pour la navigation

Pour la navigation, le terme ascension droite change, on parle plutôt d’angle horaire. Cet angle est celui entre le méridien d’origine(Greenwich)et le cercle horaire de l’astre.

sphère3

On trouve les coordonnées célestes du soleil, de la lune, de pleins d’étoiles et des planètes sur les éphémérides nautiques. Pour tout les jours et les heures de l’année on peut savoir la position d’un astre.

4)Les éphémérides

.Le soleil

ça se présente comme ça:

sphère4

Les éphémérides sont basées sur l’heure au méridien de Greenwich(U.T). La petite lettre d est la variation de la déclinaison par heure, AHv0 est l’angle horaire du soleil à 0 heures U.T, V est la vitesse angulaire de la rotation de la terre par rapport au soleil(environ 15°/heure en moyenne), T pass est l’heure de passage(U.T) du soleil au méridien de Greenwich. La déclinaison donnée est celle du soleil à 0 heures U.T(on l’appellera D0).

D0 est positif du printemps jusqu’à l’automne(car au-dessus de l’équateur céleste)et négatif de l’automne au printemps(car en-dessous de l’équateur céleste). d est positif du printemps à l’été et de l’automne à l’hiver(car dans ces deux cas de figure D0 augmente), et négatif quand D0 diminue(de l’été à l’automne et de l’hiver au printemps). L’angle AHvp correspond à l’angle horaire du soleil à l’instant de l’observation, il se calcule donc.

Sachant tout ça, pour connaître la position du soleil à l’instant d’observation(t)il suffit d’appliquer ces formules:

Déclinaison=D0+d*t

AHvp=AHv0+V*t

Remarque: en observant cette page d’éphémérides on voit que la déclinaison est quasi-nulle le 23 septembre, c’est l’équinoxe d’automne. à cet instant le pied de l’astre du soleil est sur l’équateur céleste.

La règle des quatre 21: aux équinoxes(20 mars, 23 septembre environ), D0=0 environ. Aux solstices(21 juin et 22 décembre grosso modo), D0=+23°26′ et -23°26′ respectivement.

.Les étoiles

C’est presque la même chose, mais pour l’angle horaire l’origine va changer. On utilise cette fois l’angle horaire du point vernal, sa vitesse de déplacement est constante et fait 15°2′,5. Le point vernal est le point d’intersection entre l’écliptique et l’équateur céleste, celui où le soleil passe de l’hémisphère Sud au Nord(nœud ascendant). L’angle horaire de l’étoile par rapport au méridien de Greenwich se trouve de cette façon:

angle horaire=AHGy+AV

AHGy est l’angle horaire du point vernal compté à partir du méridien de Greenwich.

AV est l’ascension verse de l’étoile, comptée à partir du point vernal vers l’Ouest.

5)Ce qu’on trouve sur la sphère céleste

Comme on l’a vu dans « se positionner et se repérer… » , selon la latitude où l’on se trouve la sphère céleste va bouger différemment. Dans l’hémisphère Nord les étoiles vont tourner dans le sens anti-horaire autour de Polaris, dans l’hémisphère Sud dans le sens horaire autour du pôle Sud céleste identifiable grâce à la croix du Sud. Au pôles les étoiles suivent des trajets parallèles à l’horyzon et sont circumpolaires(ne se lèvent pas, ne se couchent pas). A l’équateur les deux pôles célestes se trouvent à l’horyzon et  toutes les étoiles se lèvent et se couchent. Aux latitudes intermédiaires certaines étoiles sont circumpolaires, d’autres non.

sphère5

Pour une étoile de Déclinaison D et une latitude de l’observateur L:

(90°-L)<D, étoile visible toute la nuit

D<-(90°-L), étoile non visible

-(90°-L)<D<(90°-L), étoile visible sur une certaine durée(non circumpolaire)

La nuit, l’écliptique se repère grâce aux douze constellations du zodiaque(on peut ajouter Ophiucus donc treize en fait)et aussi avec les planètes du système solaire(car elle sont aussi comprises dans le plan de l’écliptique). Les constellations du zodiaque sont le Bélier, le Taureau, les Gémeaux, le Cancer, le Lion, la Balance, la Vierge, le Verseau, le Capricorne, le Sagittaire, le Scorpion, les Poissons. Les planètes visibles sont Vénus, Mars et Jupiter.

L’équateur céleste peut être identifiable grâce à la constellation d’Orion, l’étoile Mintaka(située entre la géante rouge Bételgeuse et la géante bleue Rigel)qui en fait partie est située quasiment sur l’équateur céleste.

sphère6

P.A.M.S veut dire pléiades, aldébaran, les 3 mages et Sirius car elles sont quasiment alignées.

Les étoiles scintillent, les planètes ne scintillent pas. L’étoile la plus brillante est Sirius dans la constellation du grand chien. La planète la plus brillante est Vénus.

Les planètes: Vénus et Jupiter sont les objets les plus lumineux après le Soleil et la Lune, ils se déplacent par rapport au reste du fond étoilé. Les planètes bougent à travers les constellations du zodiaque. Vénus est visible jusqu’à trois heures avant ou après le coucher du Soleil(car cette planète est proche de lui, Mercure n’est pas visible car trop près du Soleil). Vénus n’est jamais plus haute que 46° par rapport à l’horyzon.

Se positionner et s’orienter sans gps ni calculatrice

Aujourd’hui avec l’emploi du gps la navigation a été considérablement facilitée, on peut à tout moment connaitre sa position à quelques mètres près. C’est cependant toujours marrant et ludique de savoir s’orienter aussi avec le ciel, à condition évidemment de ne pas être gêné par les nuages!

1)Le soleil

La course du soleil par rapport à la terre est simple, la journée il se lève environ à l’Est et se couche environ à l’Ouest(il se lève à l’Est et se couche à l’Ouest aux équinoxes, le reste du temps ce n’est pas exact), et à l’année le soleil oscille entre les 2 tropiques. Au solstice d’été le soleil se situe au zénith du tropique du cancer(à une latitude d’environ 23°26’N)et au solstice d’hiver il est proche du zénith du tropique du capricorne(latitude 23°26’S). Aux équinoxes le soleil est proche du zénith de l’équateur. Petit schéma!

s'orienter1

(c’est pas vraiment les beaux arts, mais bon…)

 

 

 

 

Durant la journée le soleil décrit une parabole inversée dans le ciel, il atteint son point culminant à midi(le midi local du lieu d’observation). Par exemple si  un observateur a une montre réglée en heure UT(heures du méridien de Greenwich)il verra normalement le soleil culminer à midi si il est situé à Greenwich. Si ce même observateur se place dans un endroit à l’Est de Greenwich le soleil culminera plus tôt, et si il va à l’Ouest du méridien de Greenwich cette observation se fera plus tard.

On peut donc déduire une méthode pour trouver le Sud ou le Nord à 5° ou 10° près, valable dans les zones tempérées(entre 23°26′ et 66°34′ Sud ou Nord):

.Mettre sa montre en heure UT.

.Dans l’hémisphère Nord on oriente l’aiguille des heures vers le soleil et le Sud est indiqué par la bissectrice de l’angle formé entre cette aiguille et la direction du 12. Dans l’hémisphère Sud le principe est identique mais c’est le chiffre 12 du cadran de la montre qui doit être pointé vers le soleil, le Nord se trouve à mi-chemin entre le 12 et l’aiguille des heures(dans les deux cas on n’utilise pas la grande aiguille des minutes).

La montre fait ici office de boussole en quelques sorte(si vous avez une montre à affichage digital c’est foiré).

Remarque: dans les régions tempérées à midi local le soleil indique le Sud dans l’hémisphère Nord et le Nord dans l’hémisphère Sud.

2)L’étoile polaire(Polaris pour les intimes)

Dans l’hémisphère Nord il y a une étoile bien pratique pour trouver le Nord et aussi sa latitude, c’est l’étoile polaire. Sur la voûte céleste c’est la seule étoile quasiment immobile. On la trouve facilement car elle est située entre la grande ourse et la constellation de Cassiopée. Petit schéma!

s'orienter 2En observant la casserole de la grande ourse, si on utilise le bord opposé au manche(les étoile Dubhé et Mérak), il sufit de multiplier par 5 la distance entre ces deux étoiles tout en conservant leur alignement pour tomber sur Polaris, donc le Nord.

 

 

En utilisant un sextant et en faisant une mesure de la hauteur de Polaris sur l’horyzon, on obtient sa latitude sur la surface du globe(après plusieurs essais la marge d’erreur entre ma latitude réelle et celle trouvée par cette méthode n’a jamais dépassé 30 minutes, après cette marge peut varier jusqu’à 1° je crois). Petit schéma!

s'orienter3

Ici, l’angle Bêta=90°-L, donc Alpha=180°-(90°+Bêta). Donc Alpha=L=latitude. Polaris étant très éloignée de nous(on peut considérer quasi à l’infini), ses rayons de lumière reçus depuis la terre sont donc parallèles.

 

 

 

 

3)La lune

Si la Lune se lève après minuit(quand elle décroît), le côté éclairé par le soleil se situera à l’Est; si elle se lève avant le coucher du soleil le côté éclairé sera à l’Ouest(quand elle croît). Un petit moyen mnémotechnique: « dans l’hémisphère Nord, la Lune ment. Dans l’hémisphère Sud elle ne ment pas. » Cela veut simplement dire que sous nos latitudes lorsque la Lune croît elle forme un D, et quand elle décroît elle forme un C. Attention, schéma!

s'orienter 4(je tiens à remercier l’école maternelle de mon bled pour me fournir en schémas!)

 

 

 

 

Remarque: quand la Lune est en croissant, si on prolonge l’alignement des deux extrémités du croissant par une droite, l’intersection de cette dernière avec l’horyzon donne environ le Sud.

4)Les étoiles

Comme on l’a vu précédemment sur la voûte céleste seul l’étoile polaire est relativement fixe(dans l’hémisphère Nord). La terre tournant sur elle-même, on a donc l’illusion dans notre référentiel terrestre que c’est toute la voûte céleste qui tourne autour de l’étoile polaire dans le sens inverse des aiguilles d’une montre(la voûte tourne dans le sens horaire dans l’hémisphère Sud). On peut donc en déduire dans l’hémisphère Nord que:

.Si on voit une étoile bouger vers la droite elle nous indique environ le Sud

.Si on voit une étoile bouger vers la gauche c’est le Nord

.Si elle monte c’est l’Est

.Si elle descend c’est l’Ouest

(dans l’hémisphère Sud c’est l’inverse)

En fait au fur et à mesure de la nuit les étoiles vont tourner autour de l’étoile polaire de la façon suivante:

nuit-des-etoiles-2013-4