Amélioration de la librairie adafruit RA8875
https://github.com/MarScaper/Adafruit_RA8875
Le tactile a été revu avec une fifo circulaire afin de réaliser une moyenne glissante pour limiter le bruit...
Enjoy folks! :)
Booster son code avec la librairie Arduino GPIO
On passe ainsi de 17,58us à 2,042us pour un changement d’état d’une sortie. Cela représente un gain de 8,6x! Et en plus l’écriture du code est allégée. Ce serait dommage de s’en priver. A vous de voir... ;)
L'écran tactile de mes rêves...
Sur la base de cette écran, mon idée est de réaliser une raquette de commande qui ressemble un peu à une console de jeux portable en format paysage. L’écran est piloté par un Arduino Due 32 bits ARM afin d’offrir plus de liberté qu’une carte Arduino MEGA. Avec 84Mhz et 96Ko de SRAM le Due est l’Arduino le plus puissant du moment. Je vais pouvoir faire des folies!
Après la Nintendo Switch voici la naissance de l’Astro Switch... ;)
La puce GPS de l’ancien prototype va être réimplantée dans la raquette...
Un aperçu de l’adaptation de l’abaque numérique de l’EM-10 calé sur les données de la puce GPS (lumière bleue à l’intérieur du boitier)...
Balade Lunaire de ce weekend...
Un plaisir avec la nouvelle électronique... :)
https://www.youtube.com/watch?v=nbDmOniDnqo
Et la mosaïque issue de la séance... :)
Mosaïque de 8 clichés.
5D Mk III - CN 212 Takahashi à F/12,4 - Réducteur F/9.9 - EM-10 MKS
400 Iso - 8 x 900 images - 1/200s en vidéo Raw.
Zoom vidéo Magic Lantern 3x.
Lien vers la full: >>>> ici <<<<
Contrôler la fréquence d'un Arduino...
Voici une manip que je trouve géniale et qui a été proposée par ChristopheFr sur le forum français d’arduino.cc. Son idée permet de contrôler très simplement la fréquence réelle de fonctionnement des cartes Arduino et compatibles. Et cela sans aucun matériel complexe! Il suffit de télécharger le logiciel gratuit Processing.
Dans l’éditeur arduino, on copie/colle le sketch suivant et on l’upload sur la carte:
void setup()
{
Serial.begin(115200);
}
void loop()
{
static uint32_t t = micros();
while (micros() - t < 16000000);
t += 16000000;
Serial.write('1'); // envoi un octet sur le port série toutes les 16 secondes
}
Et dans l’éditeur Processing, on utilise le code suivant:
import processing.serial.*;
Serial Port;
int t1,t2;
void setup()
{
int i;
Port = new Serial(this, "COM7", 115200); // remplacez COM7 par le port occupé par l'Arduino, sinon bug!
t1 = millis();
while(true)
{
while(Port.available() > 0)
{
i = Port.read();
t2 = millis();
println(256000000 / (t2-t1) + "KHz"); // affiche la fréquence du quartz de l'Arduino en KHz toutes les 16 secondes (la première mesure n'est pas fiable).
t1 = t2;
}
delay(1);
}
}
void draw()
{
}
C’est terminé! On lance l’exécution du code sur Processing et on patiente.
Testé chez moi avec la MKS MINI V2.0 Makerbase et une carte Arduino MEGA de chez SUNFOUNDER:
- La SUNFOUNDER tourne à 15996KHz (avec +-1 KHz de variation entre les mesures).
- La MKS MINI est parfaitement calibrée à 16000KHz.
J’ai ensuite testé en chauffant les cartes avec un sèche cheveux:
- La carte SUNFOUNDER perd quasi instantanément 10Khz et elle descend encore un peu pour se stabiliser autour des 15983Khz au bout de quelques minutes. - La MKS MINI ne bronche pas et reste parfaitement stable à 16000KHz. Voilà qui confirme la MKS MINI comme un excellent choix pour mon projet. Sa fréquence est conforme et elle ne souffre pas de dérive en fonction de la température ambiante. :) Moralité: attention aux cartes choisies pour un usage en astronomie. Si possible, vérifiez bien dans les specs qu’elles sont équipées de Quartz. Moi je me suis fait berner de visu avec la SUNFOUNDER qui est équipée de résonateurs céramiques en boitier métallique ressemblant à un boitier de Quartz (merci à al1fch pour l’info). Lien vers le topic original lancé par ChristopheFr: Mesurer la fréquence d'un Arduino avec Processing
Timer hardware ou les 55 cycles manquant...
Je ne sais pas pour vous mais c’est plus fort que moi: Quand quelque chose ne se passe pas comme prévu j’ai besoin de comprendre le « pourquoi? ». Lors de l’écriture de la librairie RunLoop pour Arduino, j’avais constaté à l’époque un décalage sur les timers hardware entre la période demandée par le programme et la périodicité réellement constatée en sortie avec l’analyseur logique.
Le problème c’est que toutes les librairies testées avaient le même décalage que moi: un peu plus de 3us!!! Cela peut paraitre ridicule vu de loin mais pour des fréquences dépassant le KHz, l’erreur est de plus en plus problématique si l’on a besoin de précision. Hors en astronomie, pour le pilotage des moteurs pas à pas, la précision est de rigueur. A l’époque, j’avais donc intégré ce décalage dans RunLoop en l’estimant de manière empirique autour des 3,3us.
Et voilà qu’aujourd’hui, je viens de tomber sur l’excellentissime blog de Bill Grundmann! Si vous lisez l’anglais, c’est par ici que cela se passe:
The overhead of Arduino Interrupts
Pour résumer: il a étudié le phénomène à l’oscilloscope et décortiqué le code assembleur de la librairie Arduino. Et effectivement, la levée d’interruption entraine un surcout de 55 cycles! Soit 55*0,0625 = 3,4375us précisément!!! Hors faute de le savoir, les librairies qu’on trouve sur le net n’en tiennent pas compte. Et bim!
J’ai donc le plaisir de vous annoncer que je viens d’en profiter pour affiner encore un peu plus le code de RunLoop et de le publier sur mon github. Un test à 20Khz, montre maintenant une périodicité quasi parfaite à +-40ns près d’après l’analyseur logique (hors avec ses 12MS/s max on est dans la limite de précision d’échantillonnage donc même pas sûr que la variation résiduelle soit réelle).
Note: en toute logique, le phénomène constaté n’est présent que pour des timers hardware levant une interruption au niveau logiciel. Je ne pense pas qu’un usage en PWM soit concerné.
Veni, vidi, vici et big up à Bill! :)
Démo d'avancement du goto prédictif...
L'ATmega2560 de la MKS MINI au taquet...
Interprétation de la mesure à l’analyseur logique:
Le code exécuté dans l’interruption en elle même prend 3,375us (remise à zéro du compteur du timer comprise) avec une périodicité d’à peine 8us soit plus de 123 000 impulsions par seconde!!! On arrive ici à la limite extrême en se limitant à un seul moteur. En prenant un peu de marge cela signifie qu’en déplacement bi moteurs (A.D. et déclinaison en simultané) pour du goto on peut sans complexe espérer atteindre les 50Khz avec encore un peu de temps CPU pour le reste du programme.
Pour atteindre de telles performances, le code des interruptions moteur a été réduit à sa plus simple expression (comptage de pas + envoi impulsion moteur). Toutes les fonctions d’écriture -digitalWrite()- ont été optimisées avec l’excellente librairie Arduino-GPIO. Enfin, la gestion des accélérations/décélérations, changement de direction, activation/désactivation moteur, ont été dévolues à un timer dédié servant de « modulateur de fréquence » comme le montre cette capture...
Les avantages:
- Le fonctionnement des moteurs à vitesse constante est très peu gourmand en temps processeur.
- Cela ouvre la porte pour faire sans souci du goto en microstepping 1/16 là où d’autres projets sont contraints de basculer à la volée en 1/2 pas voire même en fullstep pour tenir la cadence.
- L’intégration du rattrapage de jeu et la correction d’erreur périodique pourront se faire au niveau du timer d’accélération sans impacter les performances des interruptions moteur.
TeenAstro utilise la librairie Ephemeris
Si comme moi vous êtes amateur du système FS2 conçu et commercialisé par Astro Electronic, l’hommage ne vous aura pas échappé... :)
Personnellement, j’utilise encore un FS2 sur la monture ZX4 Trassud supportant mon Mewlon 250. Bien que vieillissant, il est reste très agréable à l’usage... :)
Donc pour faire simple, TeenAstro c’est le FS3 que beaucoup ont longtemps attendu. En se basant sur une version modifiée du code du projet OnStep, Charles s’est lancé dans l’aventure de créer un kit reprenant le concept de simplicité et d’efficacité du FS2 mais mis au goût du jour.
Et pour les calculs d’éphémérides et conversions astronomiques c’est ma librairie Ephemeris qui s’y colle. Cela fait plaisir de la voir utilisée sur un beau projet comme ça! :)
Vous pouvez découvrir tous les détails et avancées de TeenAstro dans cette discussion initiée par Charles sur le forum webastro.net...
https://www.webastro.net/forums/topic/158652-teenastro-une-variante-onstep-en-kit/
Démo gestion des moteurs pas à pas du télescope
https://www.youtube.com/watch?v=dwV1hC2yCYI
Le résultat est sans appel en terme de performances mais aussi de simplicité de code. L’ajout du rattrapage de jeu et la modulation de fréquence pour la correction d’erreur périodique devrait être une partie de plaisir par la suite. :)
Dans l’immédiat, je travaille maintenant sur le goto car j’en ai besoin pour d’autres projets. Mon idée serait de ne pas compter les pas à la volée en regardant si on est pas trop loin mais plutôt de créer un modèle mathématique permettant de déterminer le temps de déplacement nécessaire à la milliseconde près pour chaque axe. L’idée est séduisante sur le papier mais dans les faits cela demande beaucoup de précision.
Affaire à suivre...
Contrôle de l'accélération et estimation des pas pour le goto
Reprenons l’exemple d’une accélération comme celle que j’utilise pour ma monture...
Dans la réalité, pour obtenir un tel résultat, je dois progressivement augmenter la fréquence des pas moteur de 0 à 100% de la vitesse souhaitée. Le graphique ci-dessous montre des paliers de 0.1s d’accélération pour passer de 0 à 400Hz (vitesse solaire de ma monture avec micro stepping de 1/16) en 2 secondes.
Astuce: Après avoir étudié la question, j’ai fait le choix sur Arduino d’utiliser le Timer 0 pour gérer les accélérations/décélérations/inversions de mes moteurs. Il faut savoir que ce timer matériel est notamment utilisé par les fonctions delay(), millis() et micros() sur Arduino. On peut néanmoins l’utiliser pour peu de ne pas modifier sa fréquence (calée à 1ms ) en le programmant pour lever une seconde interruption sur la même base de temps...
// Timer0 is already used for millis() - we'll just interrupt somewhere
// in the middle and call the "Compare A" function below
OCRA = 0xAF;
TIMSK |= _BV(OCIE0A);
Le nombre de timers matériels étant très limités sur une carte Arduino (seulement 4 timers sur Uno et 6 timers sur les cartes MEGA) c’est donc un luxe non négligeable de ne pas en monopoliser un juste pour le timing des variations de vitesse. Sur ma MKS MINI, il me reste donc 5 timers matériels soit la possibilité de piloter les 4 drivers de moteur pas à pas avec une grande précision.
A la fin de mon accélération, j’aurais donc théoriquement parcouru la somme des pas des paliers de mon graphique soit... 201 pas. Et le goto dans tout cela? Et bien le comptage de pas c’est la base bien sûr car comme dans la vie: pour savoir où l’on va, il faut savoir d’où l’on vient! -je suis d’humeur littéraire aujourd’hui. Profitez, c’est cadeau.- On peut donc évaluer de façon assez précise, au niveau logiciel, le temps nécessaire pour atteindre un point donné et s’épargner l’achat de couteux encodeurs de position.
Aujourd'hui c'est optimisation...
Et bien oui mais non. Il n’y a pas que la puissance qui compte. Un Arduino ne fait pas grand chose mais il le fait bien. C’est un véritable environnement temps réel. Bien maîtrisé, il est capable de piloter des entrées/sorties avec une régularité et une finesse que n’atteindra jamais un puissant PC qui lui est certes très performant mais qui doit faire beaucoup de choses à la fois (sans même qu’on le sache).
Dans le cadre de moteurs pas à pas par exemple, la régularité est primordiale. La capture ci-dessous montre les pulsations de chaque pas moteur en ascension droite et déclinaison sur mon projet. La précision obtenue est supérieure à la micro seconde.
Voilà c’était la pensée du jour. Je retourne à mon optimisation de code pour grappiller de précieux cycles d’horloge. Au passage, si vous codez sur Arduino de manière un peu avancée, je vous recommande de tester l’excellente librairie Arduino-GPIO de Mikael Patel: https://github.com/mikaelpatel/Arduino-GPIO. Elle permet de remplacer notamment les fonctions digitalRead() et digitalWrite() de la librairie Arduino par des accès hyper optimisés.
Saturne et Mars au CN-212
CN-212 à F/D 12,4 + Barlow 2x + 5D MKIII. Shoot en mode vidéo RAW Magic Lantern et zoom 3x. Traitement avec MLVToMovie, AS2 et Registax 6.
D’ailleurs pour rappel, si vous êtes sur Mac, sachez que j’ai mis à dispo des versions Mac d’AS2, Registax 6 et même Iris...
http://mlvtomov.eliotis.com/goodies/index.html
MKS MINI sous les étoiles
Aperçu de la courbe d’accélération de type sinusoïdale...
Comme le montre le graphique, on obtient un démarrage et un arrêt très doux offrant un bon amortissement de l’inertie du télescope. Pour plus d’infos, voir cet ancien billet: Accélération/décélération: Sinus or not Sinus?
MKS MINI aux commandes...
https://www.youtube.com/watch?v=ckrY5U3mfkkLe projet a bien évolué depuis ses débuts. Simplifions, simplifions, simplifions! Reste à intégrer une led d’éclairage pour le viseur polaire, prévoir une connectique pour le câble de la motorisation de la mise au point et ajouter la deuxième connectique DB-9 pour la future télécommande tactile. A partir de là on sera pas mal niveau matériel côté monture.
Test motorisation mise au point du CN-212
Vref pour MKS MINI V2.0
I = Vref / 0.8.
Documentation Makerbase:
Traduction:
« 1. Algorithme actuel du driver 4988: i = vref /0.8.
Vref par défaut est environ 0.8v.
Le courant par défaut est 1.0A. Le courant maximal est 2.0A. »
Source: https://github.com/makerbase-mks/Datasheet/blob/master/Chinese%20datasheet/MKS%20MINI%20V2.0%20数据手册.pdf
Motorisation de la molette de mise au point du CN-212
- ne pas toucher au tube: le système ne doit nécessiter aucun perçage.
- facile à monter/démonter en quelques secondes et sans outils dans le noir en cas de besoin.
- on doit pouvoir continuer à utiliser la molette en manuel.
- cela ne doit pas dénaturer le télescope. :)
On mélange tout ça avec OpenSCAD et -quelques prototypes plus tard- abracadabra...
Le concept est simple. La platine est solidarisée via le porte oculaire. Et un manchon, ajouré pour accueillir l’axe moteur, vient s’enficher sur la molette de mise au point.
Le tour est joué...
Voilà qui devrait être parfait pour boucler la boucle en complément du contrôle de la monture.
C'est reparti... :)
Donc on récapitule:
- revoir l’électronique de la monture pour qu’elle soit plus simple à concevoir et pourquoi pas encore moins chère?
- déporter l’écran dans une raquette déportée.
- prévoir de piloter la mise au point.
Ok on en est donc là ou presque puisque j’ai déjà avancé sur la question vous vous en doutez. :) Concernant l’électronique, je pense avoir trouvé mon bonheur avec une carte pour imprimante 3D que je vais hacker pour mon usage: la MKS Mini V2.0 Makerbase.
Elle a tout pour me plaire:
- basée sur un Arduino MEGA dans la continuité de mon projet.
- dimensions relativement compactes.
- 4 drivers 4988 afin de piloter à la fois les deux moteurs pas à pas du télescope et potentiellement deux autres périphériques.
- technologie éprouvée puisque dérivée de la Mks standard équipant nombre d’imprimantes 3D DIY.
- tout petit prix: à peine plus de 20€ avec les frais de port sur aliexpress.com.
Il n’en fallait pas plus pour me lancer sur cette piste!
Je vous présente donc mon nouveau prototype déjà installé en bonne place sur ma monture (merci l’impression 3D)... :)
La manette SEGA a été conservée et j’ai prévu un second port DB9 pour la raquette de contrôle qui exploitera l’ancienne carte Arduino équipée de l’écran tactile. Ce dernier s’occupera de l’intelligence (base de donnée, GPS, GOTO, abaque polaire) et la carte Mks s’occupera des moteurs et du PEC.
Sunny: de la réalité à la simulation
Sunny: le petit traqueur solaire
Plutôt cool, non? :D
TEVO Tarantula - Benchy 3D
Jolly 3D printing torture test / 0,2mm par couche.
Montage de la TEVO Tarantula
Autant le dire tout de suite, la documentation papier est juste totalement insuffisante. il faut s’armer de patience et de tutos vidéo glanés sur YouTube pour s’en sortir sans trop de soucis.
Le montage en lui même n’est pas trop complexe pour peu de bien prendre son temps.
Et voilà la bête terminée...
Moment de vérité: le premier print…
J’avoue que pour une première je suis assez bluffé.
Plus qu’à prendre le temps d’apprivoiser la bête et d’améliorer sa structure.
Imprimante 3D
En attendant son arrivée de Chine, autant lui préparer son vivarium… :)
Platine d'adaptation EM10/trépied Meade
A partir de là, le modèle 3D a été réalisé par mes soins sous OpenSCAD en prenant les cotations au pied à coulisse sur la monture et le trépied…
Puis la fabrication a été laissée au bon soin d’un ami disposant d’une imprimante 3D (25h d’impression tout de même! Merci Richard! :) )…
Avancement de l’impression...
Et voici la platine finale mise en place sur le trépied Meade...
Installation de la monture: comme papa dans maman… :)
Pas de doute, ça a de la gueule… :)
Reste à prévoir la tige filetée de remplacement de l’écarteur d’origine. Elle viendra solidariser la monture avec le trépied en passant par le trou central du dessous.
Si cette platine vous intéresse, j’ai mis le STL à disposition sur thingiverse.com…
>>>> Adapter for Takahashi Mount with Meade Field Tripod <<<<
Carte postale étoilée depuis le col de Gleize
Aperçu bibliothèque C++ ScreenView (2)
- Captures réalisées avec la fonction de capture d’écran intégrée à ScreenView. -
Aperçu bibliothèque C++ ScreenView
Elle a pour but de faciliter la conception et la gestion d'interfaces graphiques avec un écran tactile sur Arduino. Elle sera compatible avec les écrans exploitant la librairie Adafruit.
Dans les grandes lignes la bibliothèque permettra:
- Mise à dispo de composants graphiques de base (label, boutton, slider, image BMP 16 bits et 24 bits, conteneurs, etc).
- Agencement hiérarchique des composants graphiques.
- Rafraichissement optimisé pour ne mettre à jour que les zones modifiées.
- Le tactile de la bibliothèque d'Adafruit a été amélioré pour gérer le touch down, touch move et touch up.
- Possibilité de réaliser des captures d'écran en bmp vers carte micro SD (pratique pour faire de la doc).
- Un mode "vision de nuit" est intégré d'origine pour les projets astro. :D
Compter un peu plus de 7€ pour l'écran 400x240 sur volumerate.com. De quoi relayer dans un tiroir les écrans LCD 16x2. :D
Un nouveau pied, c'est le pied!
Merci au passage à mon copain Fabrice qui m’en a fait cadeau! Un trépied massif flambant neuf dans son emballage cela ne se refuse pas! :D
Premier ciel pour l'EM-10 Arduino Takahashi
Mise en place des moteurs au fond du logement de la monture...
Le prototype à l’oeuvre sous les étoiles...
Le bon vieux CN-212 semble apprécier son nouvel habit lumière… ;)
En prime une vidéo de démonstration…
https://www.youtube.com/watch?v=LHpEZYp4NEY
Amélioration de l'écran tactile TFT 400x240
Un coup de Dremel plus tard, on récupère l’accès aux entrées/sorties A6 à A15 et 14 à 21…
Côté PCB, pas de problème pour la découpe puisque aucune piste ne passe par là. Il faut juste faire attention à ne pas toucher l’écran avec la mini scie circulaire du Dremel.
L’amélioration est très intéressante car on récupère l’accès à 18 entrées/sorties! Dans mon cas, l’accès aux liaisons séries 1, 2 et 3 va être tout particulièrement utile. Je vais ainsi pouvoir connecter la puce GPS et la puce Bluetooth en hardware. :)
Et pour finir un aperçu du prototype actuel démonté et placé sur un support bricolé et décoré avec ma fille (on ne voit pas bien sur la photo mais il y a des planètes et des étoiles dessinées)…
Pour rappel, le lien vers l’écran TFT 240x400 (7,31€):
http://www.volumerate.com/product/open-smart-touch-screen-expansion-shield-w-touch-pen-for-arduino-450238
La monture prend vie...
Voici les premières captures officielles…
Et une mini vidéo…
https://www.youtube.com/watch?v=h8L5rXhS2R0
La maquette de travail ressemble à ceci...
Test d'un écran tactile TFT 400x240
http://www.volumerate.com/product/450236
Par rapport au Kuman K60 2.8’’, j’aime:
- Ecran plus grand.
- Résolution de 400x240 contre 320x240 pour le Kuman.
- Meilleur contraste et meilleur angle de vue que le Kuman. On l’aperçoit sur la photo, le Kuman vire vite au bleuté dans les noirs dès qu’on est pas dans l’axe.
- Affichage plus rapide (environ 2x) que ce soit en dessin vectoriel ou lors du chargement de bitmaps depuis une carte micro SD.
- L’écran chauffe moins que le Kuman.
- On dispose d’une sonde de température LM75 intégrée.
- Malgré le gain en taille, ce modèle n’occulte pas les ports supérieurs du Mega...
Maj du 25/06 : le nouvel écran permet aussi l’accès au buffer d’affichage contrairement au Kuman. Il m’est ainsi possible de faire des captures d’écran en bmp sur la carte micro SD… :)
Ebauche de viseur polaire (mode nuit à gauche et mode jour à droite).
Avancée du cablage du proto V1...
- perçage de quelques trous dans le support afin de passer des serre-câbles et fixer le câble de la manette.
- fixation du Arduino avec des visseries qui vont bien.
- coup de cutter sur l’Arduino Mega afin de couper la liaison vers le polyfuse (alimentation 5v) de l’entrée USB.
- repiquage de l’alimentation 5v sur le régulateur UBEC du circuit de puissance.
- câblage d’un interrupteur marche/arrêt.
Pour le proto, je préfère garder un cordon d’alimentation et le repiquer sur le régulateur 5v plutôt que de câbler le arduino directement dessus. Je peux ainsi travailler sur le Arduino en le branchant à une simple alim 5v (vu qu’il n’y a plus d’alimentation par USB) sans alimenter les moteurs lorsque ce n’est pas nécessaire aux développements.
Installation d'un Arduino Mega et d'un LCD
Accélération/décélération: Sinus or not Sinus?
Soit t un nombre réel compris entre [0,1] représentant le temps d’accélération.
La réponse f(t) est un nombre réel compris entre [0,1] qui représente la vitesse du moteur en pourcentage.
Le graphique ci-après montre:
- Une accélération linéaire.
- Une accélération sinusoïdale parfaite.
- Une accélération sinusoïdale partielle.
La vitesse par accélération linéaire vaut:
f(t) = t
C’est la forme la plus simple. L’accélération est une simple fonction linéaire sur toute la plage. L’accélération est donc constante…
La vitesse par accélération sinusoïdale complète vaut:
f(t) = (sin(t*pi-pi*0.5)+1)*0.5
L’accélération est douce au départ, maximale en 0,5 et vient se radoucir sur la fin...
La vitesse par accélération sinusoïdale partielle vaut:
f(t) = sin(((2*t+1)*pi-pi)*0.25)
L’accélération est maximale au départ et vient se radoucir ensuite...
L’idéal va être des les mettre en oeuvre sur le terrain pour voir le ressenti en terme de confort d’utilisation.
Sega c'est plus fort que Taka...
Pour les amateurs du genre, le code est dispo sur mon github. Plus de détails ici…
Premier prototype de boitier côté moteurs
Installé en lieu et place de l’ancien boitier de commande Takahashi, il intègre à l’intérieur l’électronique de puissance et en façade un support destiné à accueillir ensuite un Arduino Mega…
Pour l’instant j’utilise un modèle Uno avec réplication des ports pour me faciliter la connexion avec l’analyseur logique Saelae (non présent sur les photos).
Niveau Arduino, c’est dans l’immédiat très light avec le câblage du moteur d’ascension droite (Step, Direction, Enable) ainsi que du moteur de déclinaison (Step, Direction, Enable) et pour finir le câblage du microstepping (MS1, MS2, MS3) afin de gérer la résolution du microstepping à la volée pour les tests.
Derrière le Uno, à l’intérieur du boitier, on aperçoit la platine de puissance présentée précédemment.
Cablage de l'electronique de puissance de l'EM-10 Taka.
Cablage de l'electronique de puissance de l'EM-10 Taka (suite).
L'analyseur de précision de moteur pas à pas est au taquet!
A titre d’illustration, voici les graphiques X/Y de l’évolution de la position de l’étoile noire centrale (cerclée en rouge dans l’analyseur) sur une période de rotation complète de la mire…
L’effet de sinusoïde est ici tout simplement lié au fait que mon « étoile noire » n’est pas parfaitement centrée sur l’axe moteur. Lors d’une rotation complète, elle oscille donc en horizontale et verticale car elle tourne autour de l’axe avec une amplitude max de l’ordre de 3,5 pixels si on ne prend pas en compte la dérive (le pied photo qui se tasse légèrement notamment en vertical sur le second graph). 3,5 pixels, c’est ridicule me direz vous et cela donne un très bon ordre de grandeur de la précision atteinte. On peut estimer le bruit résiduel à environ 0,05 pixel à peine!
Une fois toutes les positions des mires précisément analysées sur un peu plus d’une période, l’idée est d’analyser la variation de la position angulaire des mires externes par rapport à la vitesse de référence théorique (25Hz soit en sortie d’axe moteur 0,75° de déplacement chaque seconde). Et voici le résultat brute pour mon moteur…
Erratique? Pas tant que cela et même loin s’en faut. Pour s’en convaincre, exportons les données vers l’analyseur d’erreur périodique PECPrep…
Et là: magie du spectacle. L’analyse de fréquence détecte et supprime toutes les fréquences. L’erreur résiduelle relève de l’encéphalogramme plat… :)
Notre signal mesuré est donc parfaitement reproductible. Cerise sur le gâteau, reprenons la table d’engrenages que j’avais calculé il y a quelques semaines…
En y regardant de plus près, presque toutes les fréquences proposées par PECPrep sont clairement identifiables à la seconde près par rapport à ma table…
Voilà qui valide on ne peut mieux le concept de l’analyseur!
Dans les faits, l’analyseur va être un outil particulièrement précieux pour la mise au point de l’algorithme de correction d’erreur périodique avec le Arduino. Je pourrais ainsi contrôler la qualité du correcteur sur des données réelles sans sortir de chez moi. :D
Idéalement, il serait même intéressant de pouvoir faire cela en temps réel et non sur une séquence vidéo enregistrée. A méditer pour les prochaines nuits blanches…
Dans le colimateur de l'analyseur...
Encore quelques détails à améliorer mais cela valide l’analyseur de précision. Le concept fonctionne pas mal. Dommage que le 5D Mk III monte très vite en température et génère un bruit de lecture marqué même à 100Iso. Cela limite la précision des mesures. Avec une vraie CCD le principe deviendrait redoutable.
L'analyseur de moteur pas à pas livre ses premiers chiffres...
- Période de rotation de la sortie moteur: 7,98min (7min 59s) soit 9,98min/dent au niveau de la vis roue dentée de 144 dents)
- Fréquence des pas moteur: 25,063Hz en Fullstep.
- Vitesse angulaire du télescope (tenant compte de la démultiplication supplémentaire de 0,8 et de la roue dentée de 144 dents): 15,04’’/s.
Conclusion rapide: ça cartonne! La vitesse sidérale est quasi parfaite.
Seule ombre au tableau pour le banc d’essai, les vibrations du moteur viennent noyer la précision de mesure sidérale instantanée…
Ce qui me fait dire que ce n’est pas du bruit lié à l’analyse c’est que, quand on y regarde de plus près, ce fameux « bruit » est identique pour chacune des 4 mires périphériques. Je pense que le passage en micropas 1/16 avec la nouvelle électronique devrait solutionner cette incertitude.
Chose intéressante tout de même, le repère centrale rouge semble moins impacté. Du fait de son léger décentrage, ses positions x/y génèrent une légère sinusoïde qui semble laisser entrevoir les « crans » d’une sous période...
Avec un peu de chance, il s’agit de la fameuse sous période d’environ 1,28m que j’ai imputé à l’engrenage 4 de la démultiplication.
Enquête à suivre.
Ebauche d'analyseur de précision de moteur pas à pas
Le moteur et sa mire sont mis en place sur un meuble avec un éclairage…
Dans l’axe à quelques mètres, je mets l’appareil photo en mode vidéo RAW sous Magic Lantern. Je réalise une vidéo sur un peu plus d’un tour complet d’engrenage (période de 8min dans mon cas).
La vidéo RAW MLV est ensuite transférée sur le Mac et convertie en mov sans perte avec le logiciel MLVToMovie que j’ai codé il y a quelques temps pour faire de l’imagerie planétaire.
Reste à analyser la vidéo. J’ai travaillé aujourd’hui sur le suivi des « étoiles noires «. - Ouha!!! Ca claque dit comme ça!!! :D - Il reste à extrapoler les données pour déterminer la vitesse de rotation à un instant t.
L’ébauche du logiciel en action avec incrustation en « presque » réalité augmentée…
La suite au prochain épisode. Je vais faire dormir un peu les neurones pour ce soir.
Platine de test de précision de moteur pas à pas
Voici le résultat...
Le concept est totalement inspiré d’une expérience menée par DBlatte (Christophe), pour caractériser la précision de ses moteurs pas à pas, et présentée sur le forum d’astrosurf…
De la précision des moteurs pas à pas
Reste à y coller une mire d’étoiles, mettre en place un setup de prise de vue et le traitement des données qui va bien derrière. :)
Réglage de drivers A4988 StepStick
http://reprap.org/wiki/StepStick
Voici les formules:
Imax = Vref/(8*Rcs) ou reformulé pour Vref: Vref = 8*Imax*Rcs
Avec:
- Vref: tension de référence du potentiomètre.
- Imax: tension maximale globale.
- Rcs: résistance de référence = 0,2 ohm pour les StepStick.
L’intensité max (par bobine) en fullstep peut être calculée par la formule:
Imax = √( (I bobine1)^2 + (I bobine2)^2 )
Comme l’intensité est la même dans les deux bobines:
Imax = √( (I bobine)^2 + (I bobine)^2 )
Imax = √( 2*(I bobine)^2 )
Imax = √2 * I bobine
Imax = 1,4142 * I bobine
En d’autres termes et pour faire simple: en fullstep les bobines sont alimentés à 70% seulement. Cela est dû au fait que le driver n’a pas de mode fullstep dédié. Il se cale simplement sur sa table de microstepping. Un graphique parle plus que de longs discours…
Dans le cadre de mes moteurs pas à pas unipolaires 6 fils (24 pas / 1v / 2 ohms), nous laissons les fils communs (fils rouge) non connectés pour utiliser les moteurs en mode bipolaires...
L’intensité en fullstep biphasé est de 0,354A (70% d’Imax) par bobine.
En appliquant les formules, cela nous donne:
Imax =1,4141*0,354
Imax = 0,500A -> le max que peuvent supporter les bobines de mes moteurs en unipolaire.
et par richochet:
Vref = 8*0,354*0,2
Vref = 0,801v
Il suffit donc de régler Vref à 0,8v (Attention: ce calcul peut être différent en fonction de la résistance Rcs du driver utilisé: StepStick, Pololu, etc).
Seule ombre au tableau, le moteur dispose d’un peu moins de couple en fullstep. Je préfère néanmoins rester sur ce réglage et réduire la vitesse max à 40x/45x la vitesse sidérale au lieu de 50x (la perte de couple se fait sentir et le moteur débraye au bout d’un moment en charge à 50x). En contrepartie, cela me permet de basculer en micropas ce qui donne beaucoup plus de fluidité et moins de vibrations aux moteurs.
Cablage de l'electronique de puissance de l'EM-10 Taka (suite)
Pour les premiers tests, j’ai utilisé le moteur avec la démultiplication hors service et une alimentation stabilisée. Comme ça aucun risque. L’ensemble est pour l’instant piloté avec un Arduino Uno…
D’un point de vue électronique, rien de bien sorcier sur la platine: en bas un régulateur 12V pour alimenter les moteurs en puissance, un condensateur pour absorber les pics de tension lors des démarrages, un second régulateur UBEC pour l’alimentation 5v de la partie logique et enfin en haut avec leur radiateur les deux drivers A4988…
Vue arrière avec câblage, une led pour l’éclairage du viseur polaire et un potentiomètre de réglage...
Cela peut paraitre un peu touffu car j’ai aussi câblé le microstepping pour une gestion logicielle en temps réel ainsi que l’activation/désactivation des drivers (Enable) pour limiter la conso lorsque les moteurs seront à l’arrêt mais rien de bien sorcier dans les faits...
Cablage de l'electronique de puissance de l'EM-10 Taka
Premier test d’un des drivers A 4988 en ascension droite. Rien ne crame… C’est bon signe… ;)
Le temps de mettre tout ça en forme et un article détaillé va venir sur les calculs pour la calibration des drivers avec les moteurs pas à pas d’origine.
Moteur P43GH démonté
De gauche à droite: le couvercle du carter, le moyeu avec son aimant permanent, les deux bobines de cuivre, le carter du bloc moteur avec son axe pour accueillir le moyeu...
Le moteur entièrement clos avec sa démultiplication. Un léger coup de Dremel a été nécessaire pour désolidariser les pattes de la démultiplication…
Démultiplication retirée. On aperçoit le capot du carter…
Retrait du capot. Au milieu, le moyeu en place. C'est en fait un simple aimant qui va tourner en fonction des phases.
Moyeu retiré. On aperçoit 6 petites ailettes qui servent de "ressort" et évitent ainsi que le moyeu ne frotte sur le fond du carter lorsqu'il tourne...
Et voici les petites plaques en métal des phases du moteur. C'est elles qui vont se polariser lorsque le courant passe dans les bobines (parties blanches)…
Sur le principe, cela fonctionne comme ceci…
Moteur a six pas et quatre phases soit 24 pas complets (Source: wikipedia).
Bilan: tout est en parfait état côté moteur. Reste à voir si je peux lui faire une attelle avec un nouvel engrenage en impression 3D pour la pièce cassée de la démultiplication pour le rendre à nouveau opérationnel.
Démultiplication motorisation EM10 USD (suite)
Je constate que cette sous période est confirmée par des mesures de Christophe Demeautis avec une autre EM10 USD sur son site. Ce serait donc un phénomène récurrent avec le modèle USD...
La périodicité est un indice important. Une telle période est incompatible avec les engrenages externes (pignons moteur et pignon roue dentée) car elle est bien trop rapide. Il faut donc s’y coller côté démultiplication.
Partie un peu fastidieuse: le comptage des dents de chaque engrenage et des arbres. Pour me simplifier la tâche, j’ai opté pour de la photo macro de chaque engrenage. Voici un photo montage (engrenage masqués ajoutés en transparence) avec le comptage des dents…
Calcul de contrôle avec le logiciel Soulver pour 500 rotations (logiciel très pratique pour poser ce genre de calculs):
rotation_engrenage_moteur = 500 // 500 rotations
// Mouvement de dents
engrenage_moteur = rotation_engrenage_moteur × 10 // = 5 000 dents
engrenage_1 = engrenage_moteur/30 × 10 // = 1 666,6666666667 dents
engrenage_2 = engrenage_1/40 × 10 // = 416,6666666667 dents
engrenage_3 = engrenage_2/40 × 18 // = 187,5 dents
engrenage_4 = engrenage_3/30 × 10 // = 62,5 dents
engrenage_5 = engrenage_4/25 × 20 // = 50 dents
// Rotations des engrenages
rotation_engrenage_1 = engrenage_moteur/30 // = 166,6666666667 rotations
rotation_engrenage_2 = engrenage_1/40 // = 41,6666666667 rotations
rotation_engrenage_3 = engrenage_2/40 // = 10,4166666667 rotations
rotation_engrenage_4 = engrenage_3/30 // = 6,25 rotations
rotation_engrenage_5 = engrenage_4/25 // = 2,5 rotations
rotation_engrenage_6 = engrenage_5/50 // = 1 rotation
L’arbre moteur doit donc bien faire 500 tours pour un seul tour en sortie soit une démultiplication de 1/500. On est bon par rapport aux spécifications constructeur.
Reste à déterminer la périodicité de chaque engrenage pour recoupement avec l’erreur périodique de la monture. Il faut alors extrapoler sur 10min (période complète de la vis sans fin à vitesse solaire de référence). Avant toute chose, il nous faut le nombre de pas effectués en 10min soit: 25Hz*60*10 = 15 000 pas. Etant donné que nous somme en vitesse sidérale pour les mesures d’EP, le nombre de pas est en fait un peu plus élevé si l’on veut être précis: 15 041,068733 soit un ratio de 1,002738 que nous appliqueront en fin de calcul.
pas = 15000 // 15000 pas pour un tour de vis sans fin (si tout va bien ;) )
pas_moteur = 24 // Nombre de pas du moteur pour un tour complet
rotation_engrenage_moteur = pas/pas_moteur // = 625 rotations
// Mouvement de dents
engrenage_moteur = rotation_engrenage_moteur × 10 // = 6 250 dents
engrenage_1 = engrenage_moteur/30 × 10 // = 2 083,3333333333 dents
engrenage_2 = engrenage_1/40 × 10 // = 520,8333333333 dents
engrenage_3 = engrenage_2/40 × 18 // = 234,375 dents
engrenage_4 = engrenage_3/30 × 10 // = 78,125 dents
engrenage_5 = engrenage_4/25 × 20 // = 62,5 dents
engrenage_sortie_moteur = engrenage_5/50 × 36 // 45 dents
// Rotations des engrenages
rotation_engrenage_1 = engrenage_moteur/30 // = 208,3333333333 rotations
rotation_engrenage_2 = engrenage_1/40 // = 52,0833333333 rotations
rotation_engrenage_3 = engrenage_2/40 // = 13,0208333333 rotations
rotation_engrenage_4 = engrenage_3/30 // = 7,8125 rotations
rotation_engrenage_5 = engrenage_4/25 // = 3,125 rotations
rotation_engrenage_6 = engrenage_5/50 // = 1,25 rotations
rotation_vis_sans_fin = rotation_engrenage_6 × 36/45 // = 1 rotation de la vis sans fin (Oufff!!! On est bon!)
Nous voici à l’heure du bilan. Avec 7,8125 rotations (soit 7,83389 rotations rapporté à la vitesse sidérale) notre coupable semble tout indiqué: c’est l’engrenage 4 le fautif (gear_4 sur la photo) à la jonction entre engrenage alliage et engrenage plastique. La bonne nouvelle, c’est que nous avons maintenant une connaissance très précise de la sous période: 10 min / 7,8125 rotations / 1,002738=1,276506min. La moins bonne, c’est que cette erreur n’est pas sous multiple de l’erreur périodique principale ce qui va la rendre plus délicate à intégrer dans la correction PEC. Mais dans notre malheur, il y a une bonne chose à y regarder de plus près: 15000/7,8125 = 1920 pas. En d’autres termes: la sous période se reproduit tous les 1920 pas entiers.
Pour terminer, voici l’extrapolation de toutes les périodes incluant rotation complète des engrenages (effet potentiel de voilage) et les changements de dents (effet potentiel d’erreur d’usinage des dents)…
Veni, vidi, vici pour cette étape. :D
Démultiplication motorisation EM10 USD
Qu’à cela ne tienne! Je me suis mis en quête d’un moteur hors service d’EM10 USD sur les forums astro. Et pour mon plus grand plaisir, Rémi Petitdemange d’Optique Unterlinden (importateur de la marque Takahashi) a répondu présent et m’a envoyé gracieusement un moteur pour étude. Un big big merci Rémi! ;)
Dès réception, la dissection a donc commencé…
Il y a plus qu’à compter tout ça et voir ce qu’il en ressort…
Affaire à suivre.
Début de prototypage de la partie puissance
A terme les composants seront positionnés vers l’intérieur de la monture pour minimiser l’épaisseur de la façade.
Pour l’instant tout n’y est pas encore. En bas nous avons un régulateur (qui va être remplacé par un modèle plus haut de gamme) et le bouton de mise en marche. Au milieu un condensateur pour amortir les pointes de surtension. Et en haut les deux drivers de moteur pas à pas A4988.
D’ailleurs au passage, voici un article très intéressant qui fait la part belle au A4988…
http://hackaday.com/2016/08/29/how-accurate-is-microstepping-really/
Il reste un peu de place sur le pcb pour la led du viseur polaire, un régulateur pour abaisser la tension 12v à 5V pour l’alimentation du Arduino de la raquette de commande, un connecteur vers la raquette. Je me tâte aussi à installer les connectiques ST4 et l’USB directement sur la monture. Cela éviterait les câblages externe sur la raquette. Réflexion à poursuivre… :)
Présentation vidéo de l'analyseur logique 24MHz 8CH Saleae...
Analyseur logique Saleae à moins de 15€
Le clone est parfaitement compatible avec le logiciel proposé par Saleae qui est on ne peut plus simple d’usage. Mon Mac adore et moi tout autant...
Du coup, je me suis amusé à pousser mon Arduino dans ses retranchements juste pour le fun histoire de voir si l’analyseur suivait. Aucun problème, le Arduino décroche bien avant lui. 8Mhz semble sa limite (optimisation max avec suppression du loop et écriture direct sur les ports d’entrées/sorties) soit 0,125us*2 = 0,250us de largeur de période d’impulsion. Largement de quoi faire clignoter une led quoi… Lol
La mesure de gauche (0,25us) montre le rebouclage de la boucle infinie while.
On voit encore mieux en dézoomant: 16 périodes du fait de la redondance de code dans la boucle sur 3,875us puis un trou lié au rebouclage…
Et voici un lien vers le code source pour les curieux…
arduino_max_blink.zipJe pense que j’en ferais un article détaillé à l’occasion car cela va être un outil précieux pour une calibration optimale de mes moteurs pas à pas par rapport à la vitesse sidérale.
Edit: non en fait on peut encore mieux faire et monter à 8Mhz par période. On en reparle un peu plus tard. :)
De drôles d'oeufs de pâques
Le fait que les moteurs d’origine soient finalement alimentés en 12v simplifie grandement les choses. Du coup, vu le coût modique, j’ai acheté un lot de cinq (moins de 10€ l’ensemble avec radiateurs inclus). Cela m’en fait deux en plus pour le prototypage et un encore en sus pour par exemple piloter un moteur de mise au point. :)
Lien ebay...
http://www.ebay.fr/itm/252826447862?ul_noapp=true
Article étude mécanique et électronique de l'EM10 USD
http://em10-usd-arduino-takahashi.eliotis.com/etude-em10-takahashi/index.html
Sky Catalog dispo sur mon Github
Et pour en savoir plus c’est par ici…
http://em10-usd-arduino-takahashi.eliotis.com/librairies-arduino/skycatalog/index.html
Mesures de l'électronique de l'em-10 USD
Je reviendrais dans un prochain billet sur le câblage mais première chose importante constatée: les moteurs 1Volt / 2 Ohms sont en fait alimentés en… 12 volts!!!
Voilà qui explique sans doute la phrase d’avertissement dans la documentation d’origine de Takahashi. Je cite:
« Attention: une sollicitation prolongée (plus d’une minute en continu) des déplacements en vitesse rapide 50 X peut endommager le circuit électronique de votre monture. »
Deuxième mesure intéressante, la période des impulsions en vitesse sidérale au niveau d’une bobine du moteur unipolaire en AD est de 6,244Hz.
Le calcul suivant nous permet de déterminer l’erreur résiduelle:
// Mesures
FrequenceBobine = 6,244 Hz
FrequencePas = FrequenceBobine × 4 = 24,976 Hz
// Caractéristiques moteur
NombreDePasMoteur = 24 pas
Demultiplication = 1/500 = 0,002
VitesseMoteur = 60 × FrequencePas / NombreDePasMoteur × Demultiplication = 0,12488 tr/min
// Engrenages intermédiaires
NombreDeDentsEngrenageMoteur = 36 dents
NombreDeDentsEngrenageVisSansFin = 45 dents
DémultiplicaitionEngrenages = NombreDeDentsEngrenageMoteur/NombreDeDentsEngrenageVisSansFin = 0,8
// Vis sans fin
VitesseVisSansFin = VitesseMoteur × DémultiplicaitionEngrenages = 0,099904 tr/min
NombreDeDentsRouteDentéeAD = 144 dents
// Vitesse sidérale monture
PeridodeVitesseSideraleMonture = NombreDeDentsRouteDentéeAD/VitesseVisSansFin = 1 441,38 min
// Vitesse sidérale parfaite : 23h56m04s
PeriodeVitesseSideraleParfaite = 23*60+56 + 4/60 = 1 436,07 min
// Erreur (ratio théorie/pratique)
(1-PeridodeVitesseSideraleMonture/PeriodeVitesseSideraleParfaite) × 100 = -0,37%
A noter que si l'on prend une « vitesse sidérale parfaite » arrondie à 24h, l’erreur résiduelle tombe à -0,096%. Il est donc probable que les ingénieurs de Takahashi se soient simplifiés la tâche à l’époque.
Régulateur Foxnovo HOBBYWING 3A UBEC 5V
Nouvelle librairie SkyCatalog en cours de dev
Une fois les fichiers d’export générés, j’ai ensuite traité les données pour les transformer en une arborescence de fichiers et ne conserver que les données utiles. Ce travail devrait donner lieu à une nouvelle librairie Arduino baptisée SkyCatalog et complétant Ephemeris.
Arduino sous Xcode
A noter que si vous recherchez un template dédié pour la dernière version d’Xcode, jetez un oeil à embedXcode:
http://embedxcode.weebly.com
Pour ma part, j’ai préféré opter pour du configuré maison car embedXcode ne supporte que la dernière version 8 d’Xcode voire au mieux 7 au moment d’écrire ces lignes. J’avoue que j’en ai marre de cette marche forcée imposée par Apple pour pousser à migrer sur leur dernier système d’exploitation poussif à souhait.
Mais revenons à nos moutons. Plutôt que d’opter pour des makefiles, je me contente de piloter l’ide Arduino à partir d’Xcode 4 (OS X 10.7.5 oblige) et d’un projet custom. C’est plutôt aisé puisque l’IDE Arduino propose tout ce qu’il faut pour l’accès en ligne de commande. Voir la doc officielle…
https://github.com/arduino/Arduino/blob/master/build/shared/manpage.adoc
Je peux ainsi lancer la compilation et l’upload...
…tout en éditant mon projet avec « code completion » et toutes les joyeusetés qu’on attend d’un environnement de travail productif.
Pour l’affichage de la liaison série, j’ai opté pour CoolTerm que je pilote par AppleScript à partir d’Xcode (lancement, connexion/déconnexion, effacement, affichage en avant plan à la fin du transfert). L’ensemble est beaucoup plus robuste et agréable que la console du logiciel Arduino…
Bref c’est maintenant que du bonheur pour bosser! <3 <3 <3
Ephemeris fait des petits...
La raquette de commande est entièrement réalisée en matériaux de récupération. Pas mal non? :D
Plus d’infos sur le blog de Bram… :)
http://zoelen.net
Librairie RunLoop dispo sur mon Github
http://github.com/MarScaper/runloop
La librairie est compatible avec le gestionnaire de librairie de l’IDE Arduino et fournie avec quelques exemples d’usage. Et en voici une illustration concrète dans le projet:
Buzzer, led, télécommande infra rouge, écran LCD et GPS fonctionnant de concert.
Run Loop Library: une boite à outil pour Arduino
Dénommée RunLoop, elle permettra:
- la facilitation des traitements parallèles via un « run loop » (une boucle d’exécution) à multi-niveaux hiérarchiques.
- la gestion des timers logiciels.
- la gestion de tous les timers matériels du Arduino (dont les 3,4,5 dispo uniquement sur le Mega).
- les notifications asynchrones via paradigme de délégation.
- une gestion 100% C++.
Test en grandeur réelle du coucher du Soleil
L’estimation avec Ephemeris était de 18m42m17s. Manque de bol des nuages en bord d’horizon ont limité la précision de la mesure. Dernier rayon photographié à 18h41m12s…
Zoom sur la zone centrale de la photographie...
Il nous reste à vue d’oeil un « demi soleil » à une 1 minute et 5s du dernier rayon estimé. On est vraiment pas mal du tout niveau précision si l’on fait abstraction des nuages. :)
PolarisFinder dispo dans Ephemeris
https://github.com/MarScaper/ephemeris/tree/master/examples/PolarisFinder
Abaque numérique pour le viseur polaire de l'EM10
La monture, équipée d’usine d’un viseur polaire, était accompagnée d’un abaque en carton permettant de déterminer facilement l’endroit où placer l’étoile polaire en fonction du jour et de l’heure…
Après près de 20 ans de bons et loyaux services à coup de lampe rouge dans l’obscurité j’ai décidé de lui fabriquer un successeur numérique digne de ce nom!
Le concept est simple: un arduino, un écran TFT et un puce Bluetooth. Dès que l’on approche l’ensemble à quelques centimètres de la raquette de commande, la liaison Bluetooth s’établie automatiquement et les infos (localisation sur la Terre, date, heure, altitude) du module GPS de la raquette sont rapatriées. Le Arduino calcule alors le positionnement de la polaire et affiche l’abaque numérique. Et voici le résultat à côté du logiciel Polaris Finder proposé par Optique Unterlinden sur PC…
Pour le calcul de l’angle de l’étoile polaire c’est on ne peut plus simple: j’utilise ma librairie Ephemeris. La longitude est celle du lieu d’observation et par contre pour la latitude on se place au pole Nord c’est à dire à +90°. Notre pôle céleste est alors parfaitement au dessus de notre tête et la polaire va réaliser sa ronde autour durant la nuit. Connaissant ses coordonnées équatoriales, on calcule ses coordonnées horizontales avec la librairie ce qui nous donne son angle en azimut. Le tour est joué.
En langage programmeur cela donne quelque chose comme ces quelques lignes…
La classe à Dallas non?!? ;)
Système solaire embarqué et opérationnel! :)
Ephemeris dans le gestionnaire de bibliothèque Arduino
Librairie à télécharger ici…
http://github.com/MarScaper/ephemeris
Le matin vient de se lever...
Coordinates of Solar system objects (10/4/2014 19:21:0)
_____________________________________
Sun
R.A: 01h17m00s.65
Dec: 08d08'00".12
Azi: 292.30d
Alt: -8.08d
Rise: 5h10m16.53s
Set: 18h34m40.20s
Dist: 1.002 AU
Diam: 31.93'
_____________________________________
Et cela fonctionne pour le Soleil, Mercure, Venus, notre Lune, Mars, Jupiter, Saturne, Uranus, Neptune et avec en bonus une méthode publique permettant d’estimer l’heure de lever/coucher de n’importe quel astre pour peu de connaitre ses coordonnées en ascension droite (ex: galaxies, etc).
Librairie à télécharger ici…
http://github.com/MarScaper/ephemeris
Fly me to the Moon avec Ephemeris
Coordinates of Solar system objects (10/4/2014 19:21:0)
_______________
Earth's Moon
R.A: 09h56m34s.76
Dec: 07d40'11".96
Azi: 154.47°
Alt: 46.27°
Dist: 401178.68 Km
Diam: 30.13'
_______________
Les calculs sont basés sur les termes périodiques ELP2000 mis en forme dans le fichier d’entête « ELP2000.h ».
Librairie à télécharger ici…
http://github.com/MarScaper/ephemeris
Librairie Ephemeris dispo sur mon Github
http://github.com/MarScaper/ephemeris
Elle est conçue avant tout pour le Arduino Mega mais codée pour rester multiplateforme. On peut ainsi obtenir les coordonnées équatoriales (R.A/Dec), les coordonnées horizontales (Alt/Az), la distance en AU et le diamètre apparent des planètes du système solaire ainsi que du Soleil pour une date et un lieu donné.
Il ne manque que la Lune que j'attaque dans la foulée. :)
VSOP87 exit pour les Arduinos de base (Uno, etc)
Seule ombre au tableau, la théorie VSOP87, malgré qu’elle soit tronquée, demande un peu plus de 29Ko rien que pour le stockage des thermes permettant le calcul des coordonnées héliocentriques. Exit donc la compatibilité avec les Arduinos de base en l’état. De même, le stockage des données dans la mémoire flash (PROGMEM) est impératif pour le Arduino Mega car ses 8Ko de SRAM sont insuffisant.Coordinates for Mars (10/04/2014 19:21:00)
R.A: 13h10m55s.10
Dec: -4d54'45".09
Azi: 111.50°
Alt: 11.62°
Dist: 0.62 AU
Diam: 15.13"
Bien sûr on pourrait trouver des subterfuges si c’était vraiment nécessaire:
- utiliser la méthode de calcul de base présentée dans l’ouvrage mais elle est peu précise car elle ne tient pas compte des interaction entre les planètes.
- stocker les termes VSOP87 dans des fichiers sur une carte SD avec accès à la volée.
- stocker les termes VSOP87 dans une mémoire flash annexe en utilisant la librairie SPIFlash.
Dans mon cas, je vais me borner à mon besoin. Autant exploiter le Arduino Mega.
Conception de la librairie Ephemeris pour Arduino
Les algorithmes sont développés sur la base de l’ouvrage de Jean Meeus et découpés en une classe C++ Calendar pour les calculs de dates et une classe C++ Ephemeris pour ce qui concerne les calculs d’éphémérides à proprement parlé.
L’idée est de faire quelque chose d’assez léger et adapté aux possibilités d’un Arduino.
Ecran déporté de débogage via Bluetooth
Et voici le résultat en vidéo…
https://www.youtube.com/watch?v=Eh7B9osfDkk
Note pour plus tard: plus j’y pense et plus je me dis qu’à terme cela pourrait être assez classe d’avoir un petit écran d’abaque numérique pour le viseur polaire. On allume l’écran. On l’approche de la monture. Il se connecte en Bluetooth et à partir des informations GPS nous affiche automatiquement l’emplacement de la polaire dans le réticule.
Calculs des éphémérides planétaires
J’ai donc maintenant de quoi m’amuser pour calculer les éphémérides (Soleil, Lune, planètes) avec mon Arduino. L’application des formules proposées par Jean Meeus n’est pas très complexe en soit pour peu d’être méthodique car chaque étape des calculs est bien détaillée. Là où cela se complique un peu c’est qu’il va falloir jongler avec un microcontrôleur « simple précision » hors certains calculs nécessitent une précision plus importante.
Intégration du GPS dans le projet
Et pour le fun, je me suis même amusé à animer les ondes qui émanent de l’icône de localisation pendant qu’on patiente. :)
Nouveau prototype nomade pour le dev...
Il suffit d’ouvrir le coffret, de le brancher et hop c’est parti pour les devs...
Le prototype en l’état est maintenant quasi complet et constitué des éléments opérationnels suivant:
- Arduino Mega.
- Ecran LCD 16x2.
- Buzzer.
- Led de mise en veille.
- Capteur de température/humidité DHT 11 (qui sera remplacé à terme par un DHT22 pour plus de précision).
- Puce GPS qui remplace l’ancienne horloge.
- Lecteur micro SD en remplacement du premier lecteur SD trop encombrant.
- Puce bluetooth pour la connection sans fil avec un ordi, un ipad ou un iPhone.
Voici une vue côté câblage interne...
Amélioration des performances de l'écran TFT
https://www.youtube.com/watch?v=Tjh4EQe2xGI
Optimisation:
- Librairie SD de base remplacée par SDFat qui offre de meilleurs performances.
- Modification de la méthode pushColor() de la classe Adafruit_TFT afin de permettre l’usage d’un buffer de pixels supérieur à 256. On peut ainsi allouer toute la largeur d’une image plein écran de 320 pixels.
- Les fichiers bitmap 24 bits sont remplacés par de vrais fichiers bmp 16 Bits. On évite ainsi tout besoin de conversion pour l’écran 16 bits.
- Les fichiers bmp sont aussi préalablement retournés haut/bas du fait de l’origine inversée entre le format bmp et l’écran. Ainsi on peut se déplacer linéairement lors de la lecture (pas besoin de seek).
Au final les performances sont améliorées d’un facteur 3x pour de l’affichage bitmap. :)
Ecran TFT or not écran TFT?
https://www.amazon.fr/gp/product/B01C3RDFN6/ref=oh_aui_detailpage_o02_s00?ie=UTF8&psc=1
L’écran offre une résolution de 320x240 en 16bits (65535 couleurs). Au dos on trouve un lecteur de carte micro SD. Et pour le tactile c’est du résistif on ne peut plus commun. Alors autant le dire tout de suite, pour 14€ ce shield est une plagia pur et simple du produit proposé par Adafruit…
2.8" TFT TOUCH SHIELD FOR ARDUINO WITH RESISTIVE TOUCH SCREEN
D’ailleurs, Kuman fournit le code source du driver sur demande uniquement par mail. Et pour cause, c’est une version à peine modifiée du code proposé par Adafruit. Sacrés chinois!!!
Les plus:
- Shield plug & play.
- Pas cher.
- Lecteur de carte SD intégré.
- Qualité d’écran très correcte notamment en mode portrait.
Les moins:
- Performance d’affichage assez limitées.
- Utilise quasiment toutes les connections d’un Arduino Uno.
- Angle de vue optimisé pour un affichage portrait ce qui devient désagréable visuellement si on préfère un usage en mode paysage.
- L’usage en simultané des librairies pour l’affichage, le tactile et la carte SD consomme quasi entièrement les 32Ko de stockage. L’usage d’un Arduino Mega n’est donc pas du luxe.
Astuce: le remplacement de la librairie SD par la librairie SDFat permet un gain substantiel: l’usage de la mémoire Flash est plus réduit (environ 9% sur un Uno) ainsi que l’usage de la SRAM et les performances sont sensiblement améliorées.
Dans l’immédiat, je ne pense pas utiliser cet écran TFT pour la raquette de commande mais il pourrait être pratique pour concevoir une console de débogage déportée avec une connexion Bluetooth.
Et hop un GPS pour le projet
Le module est piloté via la librairie TinyGPS ou TinyGPS++. Et vous savez quoi? Ca le fait carrément! Latitude/Longitude/Altitude et bien sûr horloge interne synchronisée par satellite. Voilà qui va remplacer avantageusement l’horloge avec pile bouton de mon kit de base. :)
Niveau connectique, c’est on ne peut plus basique: deux pins d’alimentations (VCC et GND) et deux pins de communications (Tx/Rx) pour la communication série des infos de la puce GPS vers le Arduino.
Seul petit bémol, le module ne maintient pas l’horloge interne en cas de coupure prolongée.
Voici la modélisation 3D sous OpenSCAD…
Module Bluetooth HC-05 et HM-10
J’ai tout d’abord opté pour un HC-06 de chez Neuftech à 10€. La puce est automatiquement reconnue par le PC au niveau des périphériques Bluetooth et se comporte ensuite comme une simple liaison série. Cela fonctionne vraiment bien. Le hic c’est qu’il n’en va pas de même pour un iBidule comme mon iPhone ou l’iPad qui ne le détectent pas.
Après quelques recherches sur le Net, il s’avère que c’est un problème connu avec les HC. La solution est le HM-10. Etant un peu échaudé par les soucis de « fake chinois » avec le souci rencontré sur les Arduino Mega, j’ai opté pour une carte SunFounder Bluetooth 4.0 HM-10. Cela reste du chinois mais cette marque semble relativement plus fiable.
Le module fonctionne parfaitement que ce soit avec le PC ou la tablette. Le seul défaut du HM-10 est de ne pas être « Plug & Play » comme le HC-06. Il faut donc en passer par les frameworks système dédiés à la gestion du Bluetooth comme par exemple IOBluetooth sur Mac.
DFRobot MicroSD
https://www.amazon.fr/gp/product/B01C8EWDDW/
Couplé à une carte 4GB, cela fera parfaitement l’affaire pour stocker la base d’objets célestes.
Voici la modélisation 3D sous OpenSCAD…
Modélisation 3D de la télécommande infra rouge
Dans mon esprit, l’idée serait de l’intégrer à une plus grosse raquette de commande câblée au télescope et contenant le Arduino et un afficheur LCD. On pourrait ainsi l’utiliser dans son compartiment ou bien la détacher pour piloter manuellement le télescope à distance...
Chaque pièce est mesurée précisément à l’aide d’un pied à coulisse pour coller au plus prêt de la réalité. Voici l’afficheur LCD modélisé…
Et son intégration de la raquette. On peut même paramètrer le texte affiché! :)
Prototypage de la raquette de commande avec OpenSCAD
Pas assez parlant? Ok. Une connaissance de mon Fab lab ayant eu la bonne idée de m’initier à OpenSCAD, voici donc un début d’ébauche que je vais peaufiner avec le temps (le squelette en carton est ici représenté en bleu)…
A terme le but est de modéliser l’ensemble des pièces électroniques pour contrôler leur intégration et au final réaliser la raquette de commande avec une imprimante 3D.
Modification des moteurs pas à pas de l'EM-10 USD

Je pourrais maintenant interchanger d'électronique à loisir le temps du prototype...

J'en ai profité pour mesurer les fils des bobines. Les résultats sont cohérents avec les specs à l'erreur de mesure près de mon ohmmètre. Il faut se faire un raison. Avec 2 ohms de résistance et 1 volt de tension, on est loin des standards habituels.
Arduino Mega
Autre chose intéressante, alors qu’un Arduino Uno dispose d’un seul timer 16 bits matériel (Timer1) le Mega en a 4 (Timer1, Timer3, Timer4, Timer5). Après quelques essais, il s’avère que les timers matériels sont beaucoup plus précis pour la gestion des pulsations de moteurs pas à pas. Avec un Arduino Mega, on peut donc piloter les deux axes avec des timers matériels ce qui est idéal.
Note: attention aux Arduinos chinois. Le premier modèle à bas prix que j’avais commandé sur Ebay s’est avéré avoir des Timers au fonctionnement hasardeux. Ils fonctionnaient au premier chargement du programme et ensuite plus rien après un reset. Heureusement, pas de mauvaise surprise avec ce modèle SunFounder un peu plus cher (18€) commandé sur amazon.
Détails de l'écran LCD 16x2
De haut en bas, l’affichage des coordonnées en ascension droite et déclinaison avec pour le fun à gauche un icône de mire de pointage et en fonction de la vitesse de suivie: des étoiles (vitesse sidérale), un croissant de Lune (vitesse Lunaire), un soleil (vitesse solaire).
J’ai prévu dans la foulée d’agrémenter l’électronique d’un capteur de température interne pour le miroir, d’un capteur de température externe et d’un capteur d’humidité. Les capteurs de température seront tout particulièrement utiles pour le contrôle de la mise en température du télescope.
Début du prototype
Voici un aperçu du prototype destiné à valider les premiers composants du système de commande. Ok, c’est un peut « roots » mais l’essentiel est là...
En complément du kit, un lecteur de carte SD (situé à proximité de la télécommande sur la photo) a été ajouté pour le stockage de la base de donnée d’objets célestes.
Observations:
- Je pensais que l’afficheur LCD 16 caractères sur 2 lignes serait un peu juste mais c’est pas si mal.
- Le capteur d’humidité du kit est un DHT-11. Il fait le job mais sa précision de +-2°c n’est pas idéale. Prévoir de le remplacer par un DHT-22.
- Le lecteur de carte SD est un peu gros. Je vais le remplacer par un lecteur micro SD plus compact.
- L’Arduino Uno du prototype est déjà au taquet niveau entrées/sorties et la librairie du lecteur SD est assez gourmande en mémoire. Il va falloir passer à un Arduino Mega pour tenir la route.
Un kit Arduino comme base de travail
http://eud.dx.com/product/uno-learning-kit-for-arduino-with-ir-1602lcd-relay-temperature-humidity-clock-module-resistor-card-844424271
Attention: prévoir un délai d’un bon mois pour réception.
Listing du kit (in English sur le site):
1 x UNO main board
1 x 1602 screen
1 x Stepper motor driver board
1 x Temperature humidity module
1 x Clock module
1 x 1 relay module
1 x 400 holes breadboard
1 x Small breadboard
1 x Fixed board
1 x Battery box (6 x AA, 15cm-cable)
4 x Button switches
3 x Photoresistors
1 x Flame sensor
2 x Buzzers
1 x Temperature sensor
2 x Tilt switches
1 x IR receiver
1 x LED light
1 x Adjustable resistor
1 x 74HC595
1 x Remote controller
1 x 1-digit seven-segment display
1 x 4-digit seven-segment display
1 x 8x8 dot matrix
1 x 9g servo (25cm-cable)
1 x Stepper motor (23cm-cable)
10 x Jumper wires (10cm)
20 x Jumper wires (20cm)
10 x DuPont wires (20cm)
1 x USB cable (139cm)
8 x 220R resistors
5 x 1K resistors
5 x 10K resistors
5 x Red led
5 x Yellow led
5 x Blue led
1 x Resistor card
1 x 16 pin header
1 x Box
Les éléments qui me semblent les plus intéressants:
- Un contrôleur Arduino Uno pour commencer le prototype.
- Un écran LCD deux lignes pour l’affichage.
- Un capteur IR avec une télécommande plutôt bien adaptée pour nos besoins.
- Un buzzer pour les effets sonores (ex: signalement fin de pointage).
- Led pour la mise en veille.
- Horloge avec pile.
- Capteur d’humidité/température pour les mesures ambiantes.
- Capteur de température simple pour le miroir.
- Un moteur pas à pas et son circuit de puissance pour se faire les dents (utilisable pour se faire une mise au point électrique à terme?).
- Capteur d’inversion pour la position du télescope (détection du pointage Ouest ou Est).
- De quoi voir venir pour câbler le prototype et vérifier la faisabilité du projet.
Moteurs pas à pas de l'EM-10 USD
Il s’agit de deux moteurs unipolaires 6 fils avec pour caractéristiques:
- 2 Ohms.
- 1 Volt.
- 24 pas.
- démultiplication de 1/500.
Dans l’immédiat, faute de mieux, j’ai mesuré le courant à l’ampèremètre côté batterie. Voici ce qui en ressort:
Conso au « repos » (vitesse sidérale en AD): 0,48A
Mouvement rapide en AD: 1,16A.
Mouvement rapide en Dec: 1,64A.
Mouvement rapide en AD et Dec: 2,32A.
Dans la foulée, j'ai remis la main sur la doc d'origine:
>>Motorisation:
>> - pas à pas quartz 50 pulsations/sec.
>> - rattrapage rapide Alpha 50x (la vitesse sidérale)
>> - rattrapage rapide delta 750" d'arc/sec.
>> - rattrapage fins alpha +/- 1.1 à 1.9x la vitesse sidérale.
>> - rattrapage fins delta +/- 1.5 à 13.5" d'arc/sec.
>>Consommation:
>> - 500mA en vitesse sidérale et rattrapage lents.
>> - 2.5A en vitesse rapide.
>>Alimentation:
>> - 12V continu.
J’ai évoqué ces caractéristiques avec un électronicien de métier de mon Fab lab local. Il en ressort que la partie puissance risque d’être plus complexe que je l’espérais. Affaire à suivre avec un passage à l’oscilloscope pour caractériser l’électronique actuelle. La première étape sera de mettre en place des connecteurs entre les moteurs et le circuit de puissance.
Présentation du projet
- Calibration plus précise de la vitesse sidérale.
- Rattrapage automatique du backslash sur la déclinaison.
- Correction d'erreur périodique par modulation de fréquence.
- Interface d'autoguidage modernisée (genre protocole LX200).
- Goto relatif.
- Etc.