Calcul des phases lunaires pour la date du jour

[Mindphazer]

Il faut également que le source Purebasic soit en UTF8 dans l'IDE (Fichier --> Format du fichier : Encodage UTF8)
Sur Windows, par défaut l'encodage est en UTF8, mais sur MacOS, par défaut c'est du texte brut me semble-t'il

[venom]

Oui bien-sûr. Tu as bien fait de préciser






@++

[PhM]

Nouvelle version optimisée du code.

J'ai retravaillé le code en utilisant des constantes pour qu'elles ne soient calculées qu'une seule fois ainsi qu'avec une structure de données pour LunarData. A cela s'ajoute une procédure unique pour les calculs du Soleil et de la Lune améliorant également la vitesse de traitement.

Je ne gagne pas en précision qui reste identique et plutôt bonne mais, en vitesse et clarté du code PB. A vous de juger...

Code : Tout sélectionner

; ----------- Calcul des phases lunaires pour la date du jour (Version optimisée) ---------------
;                Programme de contrôle : Stellarium (v25.2)
;           Version finale PhM - septembre 2025 - PB 6.21 (x64)
; ---------------------------------------------------------------------------

EnableExplicit

; ------------------ Constantes
#DegToRad = #PI / 180
#RadToDeg = 180 / #PI
Global Lunaison.f = 29.530588853    ; Longueur moyenne du mois synodique

; ------------------ Structures de données
Structure LunarData
  elongation.f
  distance.f
  anomaly.f
EndStructure

; ------------------ Déclaration des procédures

Declare.f JourJulien(annee, mois, jour, heure, minute, seconde)
Declare.f AgeLune(JD.f, *data.LunarData)
Declare.f IlluminationLune(JD.f, *data.LunarData)
Declare.s PhaseLune(age.f, illumination.f)
Declare.f CalculUTCOffset(annee, mois, jour)
Declare.s SaisonHoraire(offset.f)
Declare.f PositifMod360(f.f)

; ------------------ Date et heure locale avec correction automatique heure d'été/hiver

Global an = Year(Date())
Global mo = Month(Date())
Global jo = Day(Date())

Global UTCOffset.f = CalculUTCOffset(an, mo, jo)

Global heure = Hour(Date()) - UTCOffset
Global minute = Minute(Date())
Global seconde = Second(Date())

; ------------------ Boucle principale du programme ------------------

Define JD.f = JourJulien(an, mo, jo, heure, minute, seconde)

Define Lunar.LunarData
Define age.f = AgeLune(JD, @Lunar)
Define illumination.f = IlluminationLune(JD, @Lunar)
Define phase$ = PhaseLune(age, illumination)

; Affichage des résultats
MessageRequester("Observation lunaire du " + Str(jo) + "/" + Str(mo) + "/" + Str(an) + " (" + SaisonHoraire(UTCOffset) + ")",
                  "Heure locale : " + Str(heure + UTCOffset) + "h" + Str(minute) + "mn" + #LF$ +
                  "Âge lunaire : " + StrF(age, 2) + " jours" + #LF$ +
                  "Illumination : " + StrF(illumination, 2) + " %" + #LF$ +
                  "Phase : " + phase$)

End

; ------------------ Fonction utilitaire pour modulo 360 correct
Procedure.f PositifMod360(f.f)
  f = f - Int(f / 360) * 360
  If f >= 360 : f - 360 : EndIf
  If f < 0 : f + 360 : EndIf
  ProcedureReturn f
EndProcedure

; ------------------ Procédures de calculs

Procedure.f JourJulien(annee, mois, jour, heure, minute, seconde)
  Protected a, b, y, m
  y = annee
  m = mois
  
  If m <= 2
    y = annee - 1
    m = mois + 12
  EndIf
  
  a = y / 100
  b = 2 - a + a / 4
  Protected JD.f = Int(365.25 * (y + 4716)) + Int(30.6001 * (m + 1)) + jour + b - 1524.5
  JD = JD + (heure + minute / 60.0 + seconde / 3600.0) / 24.0
  
  ProcedureReturn JD
EndProcedure

; Procédure unique pour calculer Soleil et Lune
Procedure CalculateSolarLunar(JD.f, *lambdaS.Float, *lambdaL.Float, *M.Float, *Mp.Float, *L.Float, *D.Float)
  Protected T.f = (JD - 2451545.0) / 36525.0

  ; --- Soleil ---
  Protected M_val.f = 357.5291092 + 35999.0502909 * T - 0.0001536 * T * T
  M_val = PositifMod360(M_val)
  *M\f = M_val

  Protected Ls.f = 280.46646 + 36000.76983 * T + 0.0003032 * T * T
  Ls = PositifMod360(Ls)

  *lambdaS\f = Ls + 1.914602 * Sin(M_val * #DegToRad) - 0.004817 * Sin(2 * M_val * #DegToRad) - 0.019993 * Sin(3 * M_val * #DegToRad)
  *lambdaS\f = PositifMod360(*lambdaS\f)

  ; --- Lune ---
  Protected L_val.f = 218.3164591 + 481267.88134236 * T - 0.0013268 * T * T
  Protected T3.f = T * T * T
  Protected T4.f = T3 * T
  L_val = L_val + T3 / 538841 - T4 / 65194000
  L_val = PositifMod360(L_val)
  *L\f = L_val

  Protected Mp_val.f = 134.9633964 + 477198.8675055 * T + 0.0087414 * T * T
  Mp_val = Mp_val + T3 / 69699 - T4 / 147120000
  Mp_val = PositifMod360(Mp_val)
  *Mp\f = Mp_val

  Protected D_val.f = L_val - *lambdaS\f
  D_val = PositifMod360(D_val)
  *D\f = D_val

  ; --- Correction de longitude lunaire
  Protected correctionLune.f = 6.289 * Sin(Mp_val * #DegToRad) - 1.274 * Sin((2*L_val - *lambdaS\f) * #DegToRad) + 0.658 * Sin(2*(L_val - *lambdaS\f) * #DegToRad) + 0.214 * Sin(2 * D_val * #DegToRad)
  Protected lambdaL_val.f = L_val + correctionLune
  lambdaL_val = PositifMod360(lambdaL_val)
  *lambdaL\f = lambdaL_val
EndProcedure

Procedure.f AgeLune(JD.f, *data.LunarData)
  Protected lambdaS.f, lambdaL.f, M.f, Mp.f, L.f, D.f
  CalculateSolarLunar(JD, @lambdaS, @lambdaL, @M, @Mp, @L, @D)

  Protected diff.f = lambdaL - lambdaS
  If diff < 0 : diff + 360 : EndIf

  Protected age.f = diff / 360.0 * Lunaison

  ; --- CORRECTION DYNAMIQUE ---
  Protected v_corr.f = *data\anomaly
  If v_corr > 180 : v_corr = 360 - v_corr : EndIf
  v_corr = (v_corr - 90) / 90.0

  Protected correction_dynamique.f = 0.05 * v_corr
  age = age + correction_dynamique

  age = age - Int(age / Lunaison) * Lunaison
  If age < 0 : age + Lunaison : EndIf
  ProcedureReturn age
EndProcedure

Procedure.f IlluminationLune(JD.f, *data.LunarData)
  Protected lambdaS.f, lambdaL.f, M.f, Mp.f, L.f, D.f
  CalculateSolarLunar(JD, @lambdaS, @lambdaL, @M, @Mp, @L, @D)

  ; --- Soleil ---
  Protected rS.f = 149597870 * (1.00014 - 0.01671 * Cos(M * #DegToRad) - 0.00014 * Cos(2 * M * #DegToRad))

  ; --- Lune ---
  Protected F.f = 93.2720950 + 483202.0175233 * (JD - 2451545.0) / 36525.0
  F = PositifMod360(F)
  Protected beta.f = 5.128 * Sin(F * #DegToRad)

  ; --- Anomalie vraie de la Lune ---
  Protected ecc.f = 0.0549006
  Protected M_rad.f = Mp * #DegToRad
  Protected E.f = M_rad + ecc * Sin(M_rad) + (ecc * ecc / 2.0) * Sin(2.0 * M_rad)
  Protected tanHalfE.f = Tan(E / 2.0)
  Protected v.f = 2.0 * ATan(Sqr((1.0 + ecc) / (1.0 - ecc)) * tanHalfE)
  If v < 0 : v + 2.0 * #PI : EndIf
  *data\anomaly = v * #RadToDeg

  ; --- Distance Terre-Lune ---
  Protected rL.f = 382700.0 * (1.0 - ecc * Cos(v))
  rL = rL * (1.0 - 0.00029 * Cos((2*D - Mp) * #DegToRad) - 0.00019 * Cos(2*D * #DegToRad) + 0.00011 * Cos(Mp * #DegToRad) + 0.00009 * Cos((2*D + Mp) * #DegToRad) - 0.00005 * Cos(2*Mp * #DegToRad))
  *data\distance = rL

  ; --- Angle de phase i ---
  Protected cosElong.f = Cos(beta * #DegToRad) * Cos((lambdaL - lambdaS) * #DegToRad)
  If cosElong > 1 : cosElong = 1 : ElseIf cosElong < -1 : cosElong = -1 : EndIf
  Protected i.f = 180 - ACos(cosElong) * #RadToDeg
  i = i + 0.518 * Sin(2 * F * #DegToRad)
  If i < 0 : i = 0 : EndIf
  If i > 180 : i = 180 : EndIf

  ; --- Élongation ---
  Protected elong.f = lambdaL - lambdaS
  If elong < 0 : elong + 360 : EndIf
  *data\elongation = elong

  ; --- Illumination ---
  Protected k.f = (1 + Cos(i * #DegToRad)) / 2 * 100
  k = k - 0.55 * (1 - Cos(i * #DegToRad)) * (1 - Cos(beta * #DegToRad)) * 100
  k = k - 0.05
  If k < 0 : k = 0 : EndIf

  ProcedureReturn k
EndProcedure

Procedure.s PhaseLune(age.f, illumination.f)
  If illumination < 0.5
    ProcedureReturn "🌑 Nouvelle lune"
  ElseIf illumination < 5.0 And age < 7.4
    ProcedureReturn "🌒 Premier croissant"
  ElseIf illumination >= 48.0 And illumination <= 52.0 And age >= 7.4 And age <= 8.4
    ProcedureReturn "🌓 Premier quartier"
  ElseIf illumination > 52.0 And illumination < 99.5 And age < 15.8
    ProcedureReturn "🌔 Gibbeuse croissante"
  ElseIf illumination >= 99.5
    ProcedureReturn "🌕 Pleine lune"
  ElseIf illumination > 52.0 And illumination < 99.5 And age >= 15.8 And age < 22.2
    ProcedureReturn "🌖 Gibbeuse décroissante"
  ElseIf illumination >= 48.0 And illumination <= 52.0 And age >= 22.2 And age <= 23.2
    ProcedureReturn "🌗 Dernier quartier"
  ElseIf illumination < 5.0 And age >= 23.2
    ProcedureReturn "🌘 Dernier croissant"
  Else
    ; Cas de secours basé sur l'âge
    If age < 7.4
      ProcedureReturn "🌒 Premier croissant"
    ElseIf age < 8.4
      ProcedureReturn "🌓 Premier quartier"
    ElseIf age < 14.8
      ProcedureReturn "🌔 Gibbeuse croissante"
    ElseIf age < 15.8
      ProcedureReturn "🌕 Pleine lune"
    ElseIf age < 22.2
      ProcedureReturn "🌖 Gibbeuse décroissante"
    ElseIf age < 23.2
      ProcedureReturn "🌗 Dernier quartier"
    Else
      ProcedureReturn "🌘 Dernier croissant"
    EndIf
  EndIf
EndProcedure

Procedure.f CalculUTCOffset(annee, mois, jour)
  Protected dimancheMars, dimancheOctobre, i
  For i = 31 To 25 Step -1
    If DayOfWeek(Date(annee, 3, i, 0, 0, 0)) = 0
      dimancheMars = i
      Break
    EndIf
  Next
  For i = 31 To 25 Step -1
    If DayOfWeek(Date(annee, 10, i, 0, 0, 0)) = 0
      dimancheOctobre = i
      Break
    EndIf
  Next
  If (mois > 3 And mois < 10) Or (mois = 3 And jour >= dimancheMars) Or (mois = 10 And jour < dimancheOctobre)
    ProcedureReturn 2.0
  Else
    ProcedureReturn 1.0
  EndIf
EndProcedure

Procedure.s SaisonHoraire(offset.f)
  If offset = 2.0
    ProcedureReturn "Heure d'été : UTC+2"
  Else
    ProcedureReturn "Heure d'hiver : UTC+1"
  EndIf
EndProcedure

Pour tout vous dire, je ne travaille pas uniquement pour la beauté du code. Ce code est une première étape vers la construction d'une horloge à mots (WordClock) qui indiquera les phases de la Lune sur une Arduino Nano Every accompagnée d'un GNSS (LC76G) pour la date et l'heure multi réseau satellitaires (GPS/Galiléo/BeiDou,GLONASS) et d'un réseau de plusieurs centaines de leds WS2812B éclairant, tour à tour, au rythme de la minute, les mots en toutes lettres ainsi que les 8 cycles lunaires sur un panneau rétroéclairé.

Mais, c'est une autre histoire qui sort du cadre de ce forum PB et je ne vous embêterai pas avec cela ici.

[Mesa]

En France, nos impôts payent le site de l'observatoire de Paris, autant s'en servir pour vérifier les calculs:
https://ssp.imcce.fr/forms/phases

https://ssp.imcce.fr/forms

M.

[PhM]

Oui, merci Mesa,

Effectivement et, entre autres, beaucoup de sites donnent ces informations mais : mon application doit être autonome sans le recours à des ressources extérieures (api, web), ceci expliquant cela...

Donc, du calcul pur !

[PhM]

Bonjour,

Je vous avais dit que tout cela servirait à quelque chose, et bien, c'est fait, je suis en cours d'assemblage d'une horloge à mots (WordClock) qui indique les phases de la Lune sur une Arduino Nano R4 accompagnée d'un GNSS (LC76G) pour la date et l'heure multi réseau satellitaires (GPS/Galiléo/BeiDou,GLONASS) et d'un réseau de 370 leds WS2812B éclairant, tour à tour, au rythme de la minute, les mots en toutes lettres ainsi que les 8 cycles lunaires sur un panneau rétroéclairé en laiton. La luminosité est automatique et gérer grâce à un module TSL2591.

J'ai converti le programme PB en une bibliothèque Arduino (LunaPhases.h) pour la partie du calcul des phases lunaires rendant son interrogation plus transparente (getAgeLunaire, getIllumination, getPhase). Même les futures mises à jour sont faisables en accédant à l'Arduino en retirant une partie du cadre fixée par des aimants.

Les approvisionnement sont en court et voici quelques vues de la conception 3D :

[SPH]

Waouw ça a pas l'air de rigoler...

[venom]

Sympa comme hardware. Si je comprends en fonction des calcul et su retour de ton LunaPhases.h tu allumes tel ou tel led ?

Projet sympa belle réalisation même si pour le moment en 3D

Bonne continuation. Vivement le vrai projet terminé. Bon courage







@++

[SPH]

Quand tu auras fini de le construire, j'espère que tu nous fera une photo

[PhM]

Bonjour Venom,

Si je comprends en fonction des calculs et du retour de ton LunaPhases.h tu allumes tel ou tel led ? : Oui, c'est cela. L'heure et les minutes en cours et l'une des leds de la phase lunaire en cours en temps réel.

Projet sympa belle réalisation même si pour le moment en 3D : Certes, mais je t'assure que convertir le programme PB en librairie Arduino fonctionnelle était bien une action réelle et concrète ! A ce sujet, si cette librairie Arduino peut être utile à quelqu'un, contactez-moi en MP pour un envoi.

Bonjour SPH,

Quand tu auras fini de le construire, j'espère que tu nous fera une photo. Oui, pas de problème, mais, je ne pensai pas le faire étant donné que cela sort du thème de ce forum sur PureBasic.

Actuellement, je bataille avec le fournisseur d'impression 3D pour le châssis principal (noir) pour qu'il n'y ai pas de déformations ou un gauchissement suivant le matériau employé...

[venom]

J'ai jamais pensé a convertir un code pb en lib Arduino. Si a l'occasion tu as le temps de faire un petit tuto / explication je suis preneur

Même si j'ai une petite idée







@++

[PhM]

Venom, j'ai déjà fait ce tuto pour moi et pour plus tard car, à mon âge...

Convertir du code PureBasic en bibliothèque Arduino pour ce cas précis

Objectif :

Transformer un ensemble de fonctions PureBasic (ex : calculs astronomiques) en bibliothèque Arduino (LunaPhases) réutilisable dans un sketch Arduino.

Étape 1 : Analyser le code PureBasic

Ce que tu as :

Des fonctions comme AgeLune(), IlluminationLune(), JourJulien(), etc.
Des variables globales (à éviter dans une bibliothèque).
Des constantes, des calculs mathématiques, des formules astronomiques.

Ce qu’il faut garder :

Les algorithmes de calcul (ex : Jour Julien, longitude lunaire, illumination) de PB.
Les entrées/sorties claires : update(année, mois, jour, heure, minute, seconde) → getAgeLunaire(), getIllumination(), getPhase().

Étape 2 : Créer la structure de la bibliothèque Arduino

Arborescence :

LunaPhases/
├── src/
│ ├── LunaPhases.h
│ └── LunaPhases.cpp
├── keywords.txt
└── library.properties


Étape 3 : Créer LunaPhases.h

Code : Tout sélectionner

#ifndef LunaPhases_h
#define LunaPhases_h

#include "Arduino.h"

class LunaPhases_
{
  public:
    LunaPhases_();
    void update(long year, int month, int day, int hour, int minute, int second);

    float getAgeLunaire();
    float getIllumination();
    const char* getPhase();

  private:
    float _age;
    float _illumination;
    const char* _phase;

    // Méthodes privées
    double JourJulien(int year, int month, int day, int hour, int minute, int second);
    void CalculateSolarLunar(double JD, double* lambdaS, double* lambdaL, double* M, double* Mp, double* L, double* D);
    double PositifMod360(double x);
};

extern LunaPhases_ LunaPhases;

#endif

Étape 4 : Créer LunaPhases.cpp

Traduire les fonctions PureBasic en méthodes C++.
Adapter les types : Float PureBasic → float ou double Arduino.
Gérer les angles : Mod(x, 360) → PositifMod360(x).
Optimiser : utiliser double pour les calculs critiques, float pour les résultats.

Étape 5 : Gérer les différences de précision

PureBasic utilise Float (64 bits).
Arduino (ATmega) : float = 32 bits, double = 32 bits aussi (sur ATmega).
Pour plus de précision, utiliser double dans les calculs critiques, mais stocker les résultats en float.

Étape 6 : Gérer les bibliothèques Arduino

#include <math.h> pour sin, cos, acos, etc.
Ne pas redéfinir DEG_TO_RAD ou RAD_TO_DEG : déjà définies dans Arduino.h.

Étape 7 : Créer keywords.txt

LunaPhases KEYWORD1
getAgeLunaire KEYWORD2
getIllumination KEYWORD2
getPhase KEYWORD2
update KEYWORD2

Étape 8 : Créer library.properties

name=LunaPhases
version=1.0.0
author=PhM
maintainer=PhM
sentence=Bibliothèque pour calculer les phases lunaires
paragraph=Calcul de l'âge lunaire, illumination et nom de la phase
category=Data Processing
url=https://github.com/yourname/LunaPhases (reste éventuellement à faire)
architectures=*

Étape 9 : Tester la bibliothèque

Code : Tout sélectionner

#include <LunaPhases.h>

void setup() {
  Serial.begin(9600);
  LunaPhases.update(2025, 10, 29, 22, 0, 0);
  Serial.print("Age lunaire : ");
  Serial.println(LunaPhases.getAgeLunaire(), 2);
  Serial.print("Illumination : ");
  Serial.println(LunaPhases.getIllumination(), 2);
  Serial.print("Phase : ");
  Serial.println(LunaPhases.getPhase());
}

void loop() {}

Étape 10 : Optimiser et valider

Comparer les résultats avec le code PureBasic et Stellarium
Ajuster les calculs si nécessaire (erreurs d’arrondi).
Vérifier la consommation mémoire.

Résumé :

1 Analyser le code PureBasic
2 Créer l’arborescence de la bibliothèque
3 Écrire LunaPhases.h
4 Écrire LunaPhases.cpp
5 Gérer les types et précision
6 Inclure les bonnes bibliothèques
7 Créer keywords.txt
8 Créer library.properties
9 Tester dans un sketch Arduino
10 Valider et optimiser

Astuce finale et reflexion :

Tu peux tester les calculs sur un ordinateur avec un environnement C++ avant de les passer sur Arduino, pour valider les algorithmes.
Utilise des tableaux de tests (dates connues → résultats attendus) pour valider la précision notamment avec Stellarium. Il est d'ailleurs à noter, à ma grande surprise, que le microcontrôleur Arduino donnait des calculs au moins aussi précis que PB sur un PC x64 !

[Jacobus]

Bonjour PhM, beau travail!
Ce sera un bel objet que ce tableau des phases de la lune. Belle concrétisation de code informatique
As-tu envisagé des couleurs différentes/modifiables pour la façade en laiton ?
N'as-tu pas peur que si le tableau est affiché en pleine lumière, le laiton brillant ne permette une bonne visibilité des LED allumées ?