Le tracé de la courbe d’une analemme est une tâche complexe qui peut être effectuée avec une carte Arduino. Une analemme est une courbe tracée sur un graphique qui représente la position du soleil dans le ciel à un moment donné. La carte Arduino peut être utilisée pour calculer la position du soleil et tracer la courbe correspondante. Dans cet article, nous allons examiner en détail comment tracer une courbe d’analemme avec une carte Arduino et quels sont les avantages de cette méthode.
Tracé de la courbe d’une analemne calculée par une carte Arduino
1. Présentation
Ce programme montre les capacités de calcul tout de même assez étonnantes d’une simple carte Arduino en calculant une analemne du soleil (le programme ne fait que 5 ko!!). Une analemne est la trajectoire que fait dans le ciel la position du soleil à heure fixe et le résultat est une belle courbe en « 8 ». Ce programme, combiné à une motorisation adaptée, peut servir de base à la réalisation d’un « traqueur solaire ».
Une analemne solaire est en fait la combinaison sur un même graphique :
- de l’Equation du temps solaire : L’Equation du Temps correspond au décalage en minutes de la position du soleil par rapport à l’heure locale. Il existe une légère variation par rapport à l’heure locale due à l’excentricité de l’orbite terrestre et autres paramètres. Plus de détails ici (en anglais) : http://en.wikipedia.org/wiki/Equation_of_time
- de la déclinaison solaire
On fait calculer à la carte Arduino ces 2 valeurs pour chaque jour de l’année (365 valeurs calculés).
La courbe des valeurs reçues est tracée dans une interface graphique Processing côté PC programmée en grapheur X,Y. On utilise également le logiciel de calcul numérique Scilab pour vérifier la validité du calcul par Arduino.
Sur cette page, à la fois le programme SCITE, le programme Arduino et le programme Processing.
Ce programme utilise les fonctionnalités suivantes :
- la connexion série vers le PC
Voir également :
- Les fonctions mathématiques du langage Arduino
- Sur l’Equation du Temps du soleil :
- La page de wikipédia en anglais consacrée à l’Equation du Temps : http://en.wikipedia.org/wiki/Equation_of_time
- Une page très bien faite ici : http://pvcdrom.pveducation.org/SUNLIGHT/SOLART.HTM
- Sur la déclinaison solaire :
- la page Wikipédia sur la déclinaison du soleil (en anglais) : http://en.wikipedia.org/wiki/Declination
- une autre page très bien faite avec animations explicites (en anglais) : http://pvcdrom.pveducation.org/SUNLIGHT/DECLIN.HTM
2. Formule utilisée
2.1 Pour la déclinaison solaire :
Plusieurs possibilités existent. La formule de calcul de la déclinaison solaire que nous utiliserons est :
où :
où Jour est le jour courant de l’année (1er janvier = 1).
Voir également :
- la page Wikipédia sur la déclinaison du soleil (en anglais) : http://en.wikipedia.org/wiki/Declination
- une autre page très bien faite avec animations explicites (en anglais) : http://pvcdrom.pveducation.org/SUNLIGHT/DECLIN.HTM
2.2 Pour l’Equation du Temps (EOT) solaire :
Plusieurs possibilités existent. La formule de calcul de l’équation du temps (EOT) que nous utiliserons est :
où :
où Jour est le jour courant de l’année (1er janvier = 1).
Voir également :
- La page de wikipédia en anglais consacrée à l’Equation du Temps : http://en.wikipedia.org/wiki/Equation_of_time
- Une page très bien faite ici : http://pvcdrom.pveducation.org/SUNLIGHT/SOLART.HTM
3. Calcul préalable dans le logiciel Scilab
3.1 Courbe obtenue avec Scilab
3.2 Le script Scilab
A copier coller dans l’éditeur Scilab (depuis la console : Applications > Editeur ) puis lancer exécution (dans l’éditeur : Executer > charger dans Scilab ou raccourci CTRL + L )
// Script Scilab // courbe annuelle de la déclinaison solaire // par X. HINAULT - Aout 2010 ma_figure=scf(1); // crée une figure id=1 et la nomme ma_figure et la fait devenir la figure courante // paramétrage de la figure ma_figure.figure_name="Ma figure"; // nom de la figure ma_figure.figure_size=[600,600]; // fixe la taille de la figure en pixel ma_figure.figure_position=[10,10]; // fixe la position de la fenétre par rapport au coin supérieur gauche // initialisation clf(ma_figure); // efface la figure courante axes=ma_figure.children; // nomme les axes de la figures axes.grid=[0,0]; // grid = [colorX, color Y, color Z] - 0 pour noir -1 pas de grille axes.x_location="middle"; // positionnement de l'axe x - "middle" "top" "bottom" axes.y_location="left"; // positionnement de l'axe y - left, right, middle, origin //xgrid(); // ajoute la grille Day=1:1:365; // crée une série de valeur régulièrement espacée // calcul de la fonction BN=2*%pi/365; // calcul de y BN=BN*(Day-81); //--- calcul déclinaison DECL=23.75*2*%pi/360*sin(BN); // en radians //--- calcul de EOT ---- EOT=(9.87*sin(2*BN))-(7.53*cos(BN))-(1.5*sin(BN)); // tracés //plot(Day,BN,'r-'); // trace une courbe ligne rouge // plot(Day,EOT,'r-'); //plot(Day, DECL,'r-'); plot(EOT,DECL,'r-');
4. Matériel Nécessaire
4.1 L’espace de développement Arduino
- … pour éditer, compiler le programme et programmer la carte Arduino.
5. Instructions de montage
- Connexion série entre la carte Arduino et le PC (utilise les broches 0 et 1)
6. Le schéma théorique du montage
Le schéma théorique du montage
7. Le circuit du montage
Le schéma du montage à réaliser
8. Explication du programme Arduino
8.1 Structure globale du programme
Ce programme simple comprend :
- une entête déclarative
- une partie « configuration » qui ne sera exécutée qu’une fois (fonction setup( ) )
- une partie constituée d’une boucle sans fin que le programme répètera à l’infini ( fonction loop( ) ) : c’est le coeur du programme.
8.2 Déroulement du programme
Le programme se déroule de la façon suivante :
- Après avoir pris en compte les instructions de la partie déclarative,
- puis après avoir exécuté la partie configuration ( fonction setup( ) ),
- le programme bouclera sans fin ( fonction loop ( ) ), exécutant de façon répétée le code compris dans la boucle sans fin.
Le déroulement du programme
9. Détails du programme
- Le programme calcule pour les 365 jours de l’année les 2 valeurs Déclinaison Solaire et Equation du Temps selon les formules indiquées ci-dessus. Les valeurs de sortie sont adaptées par un coefficient multiplicateur à l’interface de sortie Processing et sont centrées dans la fenêtre Processing (600×600).
- La « clé » de ce programme est l’utilisation d’une seule valeur 32 bits (type long) pour transmettre à l’interface Processing les 2 valeurs X et Y via la connexion série. La valeur X est sur les 16 premiers bits, la valeur Y est sur les 16 bits de poids forts. La valeur 32 bits est construite dans une fonction dédiée côté Arduino et est décodée côté PC dans par l’interface Processing.
- Pour plus de précisions, se reporter aux commentaires présents dans les programmes ci-dessous.
10. Mise en oeuvre du programme
10.1 Fonctionnement
- Lancer l’exécution du programme processing
- Faire un reset sur la carte Arduino : le graphique apparaît.
La comparaison avec le graphique obtenu avec Scilab montre que la carte Arduino calcule très bien cette analemne.
11. Le programme complet en langage Arduino :
A copier/coller directement dans l’éditeur Arduino
// Copyright X. HINAULT – Créé le 21/08/2010
// www.mon-club-elec.fr
// Code sous licence GNU GPL :
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// — Que fait ce programme ? —
/* Envoie vers le PC des valeurs numériques en coordonnées X-Y
pour affichage dans grapheur X,Y Processing
envoie une valeur 32 bits avec X sur les 16 bits faibles et Y sur les 16 bits forts
trace une analemne = position du soleil dans le ciel au cours d’une année à heure fixe
*/
// — Fonctionnalités utilisées —
// Utilise la connexion série vers le PC
// — Circuit à réaliser —
// Connexion série entre la carte Arduino et le PC (utilise les broches 0 et 1)
//**************** Entête déclarative *******
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables…
// — Inclusion des librairies utilisées —
// — Déclaration des constantes —
const float pi=3.14159; // constante pi
const int nbre_jour_annee=365;
// — constantes des broches —
// — Déclaration des variables globales —
long unsigned outValue; // valeur envoyée vers Processing 32 bits
float valeurf; // variable pour calcul
int valeur; // variable pour envoi vers le PC
float yf_min, yf_max, yf_base, yf; // variables pour les ordonnées
float xf_min, xf_max, xf; // variables pour les abscisses
int y_min, y_max, y_base, y; // variables pour les ordonnées
int x_min, x_max, x; // variable pour les abcisses
//——— Déclaration utiles pour les calculs solaires —————–
float BN;
float Jour;
float DECL;
float EOT, EOT1,EOT2,EOT3;
// — Déclaration des objets utiles pour les fonctionnalités utilisées —
//**************** FONCTION SETUP = Code d’initialisation *****
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme
void setup() { // debut de la fonction setup()
// — ici instructions à exécuter au démarrage —
Serial.begin(115200); // initialise connexion série à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission
// ——- Broches en sortie ——-
// ——- Broches en entrée ——-
// ——- Activation du rappel au + interne des broches en entrée si nécessaire ——-
//—— initialisation des variables utilisées
valeurf=0.0;
valeur=0;
xf_min=0.0, xf_max=600.0, xf=0.0; // pour 600 valeurs
x_min=0, x_max=600, x=0;
yf_min=0.0, yf_max=600.0, yf_base=yf_max/2.0, yf=0.0; // échelle des y
y_min=0, y_max=600, y_base=y_max/2, y=0;
// Graphe 600 x 600 dans Processing
} // fin de la fonction setup()
// ********************************************************************************
//*************** FONCTION LOOP = Boucle sans fin = coeur du programme *************
// la fonction loop() s’exécute sans fin en boucle aussi longtemps que l’Arduino est sous tension
void loop(){ // debut de la fonction loop()
// — ici instructions à exécuter par le programme principal —
for (Jour=0; Jour<=nbre_jour_annee; Jour++) { // incrémente les abcisses de x_min à x_max
//—- calcul de BN —-
BN=2.0*pi/365.0;
BN=BN*(Jour–81.0);
//—- calcul de la déclinaison
// DECL=23.75*2*%pi/360*sin(BN); // calcul Scilab
DECL=sin(BN);
DECL=DECL*23.75*2.0;
DECL=DECL*pi/360.0;
//— calcul de EOT —-
//EOT=(9.87*sin(2*BN))-(7.53*cos(BN))-(1.5*sin(BN)); // calcul Scilab
EOT1=2*BN;
EOT1=sin(EOT1);
EOT1=9.87*EOT1;
EOT2=-7.53*cos(BN);
EOT3=-1.5*sin(BN);
EOT=EOT1+EOT2+EOT3;
//—– pour affichage sur PC ——–
//yf=BN*40.0; // adaptation au tracé Processing Y=400
//yf=DECL*200.0; // adaptation au tracé Processing Y=400
xf=EOT*15.0; // adaptation au tracé Processing X=600
yf=DECL*600.0; // adaptation au tracé Processing Y=600
x=xf; // passage au format int
y=yf; // passage au format int
x=x+(x_max/2); // pour dessin centré dans Processing
y=y+(y_max/2); // pour dessin centré dans Processing
calculOutValue(x,y); // calcul valeur 32 bits envoyée à Processing
Serial.println(outValue); // envoi valeur 32 bits codant X-Y vers Processing
delay(10); // pause entre chaque valeur
} // fin boucle for Jour
while(1); // stoppe loop
} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************
//*************** Autres Fonctions du programme *************
void calculOutValue ( int valeur_x, int valeur_y) { // fonction de calcul de la valeur 32 bits à envoyer à Processing
//— initialisation valeur envoyée vers Processing
outValue=0;
// — met y sur les bits de poids forts de la valeur 32 bits envoyée vers Processing
outValue=y;
outValue=outValue<<16; // Décalage 16 bits à gauche
// met x sur les bits de poids faible de la valeur 32 bits envoyée vers Processing
outValue=outValue+x;
}
// — Fin programme —
12. Le programme complet en langage Processing :
A copier/coller directement dans l’éditeur Processing
// Graphing sketch
// Ce programme reçoit des chaine de caractère ASCII
// depuis le port Série à 115200 bauds et les affiche sous forme de courbe
// chaque valeur reçue est au format 32bits avec les 16 bits poids faible pour X et 16 bits poids fort pour y
// lorsque les données sont suivies d’un retour de ligne
// Created 20 Apr 2005
// Updated 18 Jan 2008
// by Tom Igoe
//
// modifié par X. HINAULT – January 2010 – Aout 2010
// www.mon-club-elec.fr
*/
import processing.serial.*;
Serial myPort; // Variable Port Série
int xPos=1; // variable abscisse – x
int xPos0=9999; // variable mémorisation xPos n-1 – 9999 au debut
int yPos=1; // variable yPos – ordonnée
int yPos0=1; // variable yPos n-1
void setup () {
// initialise la fenêtre
// size(int(screen.width*0.9), int(screen.height*0.9));
// 90% de l’écran par défaut – régler au besoin –
// viser taille maxi en hauteur – taille fenêtre (x,y)
size(600,600); // initialise la fenetre à la taille L x h
// Liste tous les ports disponible et affiche le résultat
println(Serial.list());
// Le port utilisé est listé avec l’indice 0
// donc j’ouvre le port Serial.list()[0].
// A adapter si votre port est différent – cf liste qui s’affiche à l’exécution
myPort = new Serial(this, Serial.list()[0], 115200);
// ne génère aucun évènement Série tant qu’aucun caractère saut de ligne n’est reçu
myPort.bufferUntil(‘\n‘);
// initialise le fond de la fenêtre
background(255);// 0 = noir – 255 = blanc
quadrillage(25); // trace quadrillage avec maille voulue – cf fonction ci-dessous
}
void draw () {
// tout se passe dans la fonction SerialEvent car le programme reçoit des données
}
void serialEvent (Serial myPort) {
// mémorise la chaîne de caractères reçue
String inString = myPort.readStringUntil(‘\n‘);
if (inString != null) {
// enlève les espaces
inString = trim(inString);
// convertit la chaîne en valeur numérique
int inValue = int(inString);
// extraction de X à partir des 16ers bits = bits de poids faible
xPos=inValue & 65535; // met à 0 les 16 bits de poids fort sans modifier les bits de poids faible (255 = 0x00FF)
// extraction de Y à partir des 16 bits de poids forts
yPos=inValue>>16; // décale les 16 bits de poids forts vers les 16 bits de poids faible qui sont perdus de fait
// trace la ligne
stroke(0,0,255); // fixe la couleur utilisée pour le tracé en RVB
//—– affichage debug des valeurs utiles -debug ——
//print (« inValue= »+binary(inValue) + »(« +inValue+ ») » + » // « ); // affiche inValue au format binaire (debug)
//print (« xPos= »+binary(xPos) + »(« +xPos+ ») » + » // » ); // affiche X au format binaire dans la console (debug)
//println (« yPos= »+binary(yPos)+ »(« +yPos+ ») » ); // affiche Y au format binaire dans la console (debug)
if (xPos0==9999) { // au premier passage
point (xPos,height–yPos); // trace un seul point au premier passage
}
else {
line (xPos0,height–yPos0,xPos,height–yPos); // trace une ligne en tenant compte valeur reçue
}
xPos0=xPos; // mémorisation xPos n-1
yPos0=yPos; // mémorisation xPos n-1
// à la fin de l’écran revient au début
if (xPos >= width) {
xPos = 0;
xPos0=0; // pour retour de la trace sans ligne
background(255); // 0 pour noir – 255 pour blanc… réinitialise l’écran au début
}
} // fin while inString
} // fin serial Event
void quadrillage (int maille) {
stroke(0,255,0); // fixe la couleur utilisée pour le tracé en RVB
// lignes verticales
for (int i=1; i<=width/maille; i++) {
line (i*maille,height–1,i*maille,0); // trace une ligne verticale
}
// lignes horizontales
for (int i=1; i<height/maille; i++) {
if (i==height/2/10) stroke(255,0,0);else stroke(0,255,0); // fixe la couleur de la ligne médiane
line (0,height–(i*maille),width–1,height–(i*maille)); // trace ligne horizontale
}
}
