manipulation d'un focuser

[norma]

Bonjour,

a) la tolérance de la mise au point est faible : 0,13 mm environs pour un instrument à f/D15.

b) sur un mak disposant d'un secondaire multipliant la focale du primaire par 5,4 cette tolérance tombe à 24 microns.

Par curiosité, sur un focuser disposant d'une démultiplication 1/10, j'ai mesuré la rotation nécessaire pour une variationde 10 microns soit 1,7°

Où veux-je en venir ?

- le raisonnement b) est-il correct ?

- dans l'affirmative, serait-il opportun de commander le focuser par un moteur pas à pas en lui envoyant des "paquets de pas" définis à l'avance ?

- si un passionné Arduino passe par là ...

[adamckiewicz]

il y a 41 minutes, norma a dit :

la focale du primaire par 5,4 cette tolérance tombe à 24 microns.

24microns de deplacement du primaire non? Du coup si tu utilises en crayford tu es bien à 0,13mm de tolerance (10°)

Modifié 20 octobre 2022 par adamckiewicz

[djalex1664]

si tu multiplie la focale, tu augmente la tolérance de mise au point.

Pour connaitre à combien ça correspond sur la demultiplication, il faut mesurer l'avancée pour 1 tour de la molette à 1/10. De là on en déduit l'angle critique de mise au point.

Tu peut tout à fait commander un focuser via un moteur pas à pas comme celui que j'ai fait. Je te déconseille fortement d'utiliser dans ce cas la démultiplication si c'est un réducteur à billes.

Ce genre de réducteur utilise des billes en contact par adhérence. Bien réglé il n'y a pas de jeu mais il y a du glissement interne. Donc tu va avoir des différences de positionnement.

Pour obtenir une focalisation motorisée, j'ai utilisé un petit moteur pas à pas avec réducteur, un driver genre A4988 ou DR8825 et une arduino avec un programme ascom (myfocuserpro2 par ex)

entrainement par courroie sur la molette et pis voilà

[norma]

Arf, je m'exprime mal : 24 microns, point. Ensuite comment fait-on, c'est une autre question. Cela peut effectivement se réaliser par déplacement du primaire mais également par action sur un crayford.

Si j'ai réussi à mesurer, c'est que je sais faire  et que je dispose de l'outillage. J'ai déjà réalisé des montages destinés à motoriser sur la base de moteur pas à pas 

mais pour des commandes entièrement automatiques comprenant entre autres la compensation de température. Ma prestation ne concernait que la partie mécanique.

Je précise alors ma question puisque la démarche semble opportune : quel serait le programme Arduino pour n'envoyer que des "paquets de pas" ?

[djalex1664]

Pour te donner un programme arduino il faut plusieurs données avant. déplacer de 24micron c'est un soucis mécanique ça on est d'accord. le truc c'est comment les envoyer.

Tu veux passer par une arduino, très bien ça marche nickel pour ça. Par contre, quand ces déplacement doivent être effectués? via des boutons? Tu veux commander à distance? Par PC? par communication série? RJ45?

Ensuite pour la compensation de température, le pilote que je t'ai indiqué le gère sans problèmes. Utilisation d'un DS18B20 pour le capteur. Le pilote envoie les commandes à l'arduino pour qu'il fasse le déplacement en rapport à la température.

 

Ou alors tu veux juste un système autonome qui te conserve ta mise au point manuelle que tu a faite, et ce même si la température change.

Dans ce cas, rien de bien compliqué. Il faut mesurer la modification de ta focalisation sur 10° C(10x plus precis que sur 1°C). Sur l'arduino, on prend une mesure de température à l'allumage, et quand ça varie de X degrés, tu envoie un nombre de pulsations correspondant au déplacement souhaité. Une fois le déplacement fait, on désactive le moteur pour conservé la mise au point manuelle possible.

[norma]

il y a 42 minutes, djalex1664 a dit :

tu envoie un nombre de pulsations correspondant au déplacement souhaité. Une fois le déplacement fait, on désactive le moteur pour conservé la mise au point manuelle possible.

Juste ça, avec des boutons et la possibilité de calibrer à la demande la taille du"paquet". Le coté température n'a pas d'intérêt pour ce que j'envisage. Du simple, du très simple et ce sera déjà très bien. Tu es maître du choix du moteur. Et merci d'avance pour l'intérêt que tu portes au problème. Perso, je me penche sur l'aspect mécanique ...

[djalex1664]

As tu déjà programmé une arduino?

 

pour le programme de l'arduino je verrais les choses comme cela:

deux boutons pour + et -

un potentiometre pour indiquer le déplacement voulu

 

donc trois entrées dont 1 analogique

parametres réglables du programme:

-pulses/µ

-valeur mini et maxi de deplacement

 

tu tourne en boucle tant que nu n'as pas de boutons appuyé.

quand tu appuye sur le bouton +, tu lit la valeur du potentiometre en la bornant au mini et maxi, activation de l'entrée enable du driver, tu demande d'aller à la position actuelle + la valeur du potentiometre et après tu désactive le driver.

 

la librairie stepper est toute indiquée pour ça.

 

Commence par creer et bidouiller un programme. Si tu cherche une solution déjà faite, ça va être dur à trouver. l'intérêt du fait maison c'est d'apprendre et de faire quelque chose qui correspond exactement et ce dont tu as besoin. Si quelqu'un te fait le programme, tu ne pourras pas le modifier ou l'ajuster suivant tes besoins de manière facile.

 

Au vu de la simplicité de ce que tu veux faire, il est vraiment valable que tu te penche sur la programmation. Ca ne te prendra pas beaucoup de temps, même si tu part absolument de zéro.

[norma]

J'ai déjà programmé un Arduino. Compte tenu du temps que j'y passe et du manque d'intérêt pour le sujet (l'informatique passe bien après la mécanique), je m'orienterai vers une solution toute faite enfin de consacrer le temps nécessaire à l'intégration mécanique. Tes trois entrées répondent parfaitement à mon problème. Bon, l'hiver approche soit de longs mois à ne rien faire  Je pourrai mettre à profit ce "blanc" mais voilà, j'ai un livre à terminer (et ce ne sera pas encore pour cette année) 

Je vais sous-traiter. Encore merci mais si le sujet retient ton attention, nous pourrions faire cela ensemble.

 

[djalex1664]

voici un bout de code vite fait devant la TV

pas testé

 

/*
  début de programme pour le controle du focuser de norma

*/

#include <AccelStepper.h>

//liste des paramètres modifiables
const int step_mm = 200;    //  a changer pour correspondre au focuser, nombre de pulses par mm
const int inc_min = 10;     //  quel sera le nombre de micron à faire en position mini du potentiometre
const int inc_max = 1000;   //  quel sera le nombre de micron à faire en position maxi du potentiometre
const int vitesse = 200;    //  nombre de pulsations par secondes

 

//liste des pins
#define step_pin    2   //pin step sur le driver
#define dir_pin     3   //pin dir sur le driver
#define enable_pin  4   //pin enable sur le driver
#define moins_pin   5
#define plus_pin    6
#define potard_pin  A0

 

//liste des variables
bool appui_moins = false;
bool appui_plus = false;
bool sens_moteur = false;
int step_a_faire = 0;

 

// initialisation de la librairie
AccelStepper Stepper(step_mm, step_pin, dir_pin);

 

void setup()
{
  //déclaration des ES
  pinMode(step_pin, OUTPUT);
  pinMode(dir_pin, OUTPUT);
  pinMode(enable_pin, OUTPUT);
  pinMode(moins_pin, INPUT);
  pinMode(plus_pin, INPUT);
  pinMode(potard_pin, INPUT);

  //définition de vitesse du moteur
  Stepper.setMaxSpeed(vitesse);
}

 

void loop()
{
  //on lit si valeurs des boutons, si il y a un changement on passe au sous programme
  if (digitalRead(plus_pin) && appui_plus == false&& appui_moins == false)
  {
    appui_plus = true;
    deplacement_moteur();
  }
  if (digitalRead(moins_pin) && appui_moins == false&& appui_plus == false)
  {
    appui_moins = true;
    deplacement_moteur();
  }

 

  //on réinitialise les memoire des boutons quand ils sont relachés
  if (!digitalRead(plus_pin)) appui_plus = false;
  if (!digitalRead(moins_pin)) appui_moins = false;
}

 

void deplacement_moteur()
{
  //on lit la valeur du potentiometre

  step_a_faire = analogRead(potard_pin);

 

  //on conditionne la valeur de deplacement suivant les parametres mini maxi
  step_a_faire = map(step_a_faire, 0, 1023, inc_min, inc_max);

 

  //on défini le sens inverse
  if (appui_moins == true)
  {
    step_a_faire = -step_a_faire;
  }

 

  //on lance un deplacement en boucle jusqu'à ce que l'on soit arrivé à la position voulue
  Stepper.setCurrentPosition(0);

  while (Stepper.currentPosition() != step_a_faire)
  {
    Stepper.setSpeed(vitesse);
    Stepper.runSpeed();
  }

 

  //on fait une pause de 0.5sec
  delay(500);
}

[Discret68]

Il me semble ne pas avoir vraiment compris le fond de la question.

Tu veux pouvoir manœuvrer un focuser via une raquette (boite à boutons) ou via un ordinateur (driver Ascom ou logiciel spécifique) ? le premier cas, c'est préférentiellement pour faire la MAP en visuel. le 2ème cas, c'est pour de l'astrophoto !

 

Si c'est pour faire une commande manuelle, il y a plus simple que d'utiliser un Arduino. J'ai fait une motorisation pour un focuser à l'aide d'un NE555 (générateur d'impulsion - 8 pattes au lieu de 30 !)  qui alimente un driver de moteur pas à pas DRV8825 ou mieux, un TMC2208 qui amène un fonctionnement beaucoup plus silencieux du moteur) et  .... un moteur pas à pas Nema14 (un plus gros moteur est possible. Il y a 2 boutons pour le sens de manœuvre et 1 inter qui permet de changer de vitesse. 2 ajustables permettent d'ajuster 2 vitesses au choix (rapide/lente). Il est bien sûr possible de remplacer une des ajustable par un potentiomètre pour pouvoir faire varier la vitesse à l'aide d'un bouton. pattes au lieu de 30 !)

 

le schéma est beaucoup plus simple et de taille plus réduite qu'en partant avec un Arduino :

 

[djalex1664]

d'apres ce que j'ai compris il veut que ça fasse un déplacement d'une valeur donnée à chaque appui sur un bouton. Cette valeur de déplacement peut être modifiée grâce à un potard. En gros chaque fois qu'on appui sur le bouton ça bouge toujours de la même distance.

Modifié 20 octobre 2022 par djalex1664

[Discret68]

Il y a 7 heures, djalex1664 a dit :

d'apres ce que j'ai compris il veut que ça fasse un déplacement d'une valeur donnée à chaque appui sur un bouton. Cette valeur de déplacement peut être modifiée grâce à un potard. En gros chaque fois qu'on appui sur le bouton ça bouge toujours de la même distance.

 

Mais est-ce le vrai besoin ou une solution parmi d'autres potentielles à un problème rencontré ? Seul @norma peut nous répondre 😉

 

Fréquemment, dans l'énoncé d'un problème qu'on rencontre, on cherche comment mettre en œuvre une solution qu'on a imaginé, au lieu d'exprimer le vrai problème de fond. De fait, cette approche bride d'autres solutions qui pourraient s'avérer plus efficaces.

[norma]

Merci djalex. Je vais mettre beaucoup plus de temps pour l'intégration mécanique 

Pour Discret : je doute être capable de tourner un bouton de 1° avec précision . Il me semble que si j'envoie un "paquet de pas" connu, la rotation du moteur sera quasi parfaitement contrôlée. Là était le problème. Pour faire une comparaison mécanique, je mets parfois plusieurs heures pour caler le chariot transversal de mon tour lorsque je souhaite réaliser un cône morse ...

[Discret68]

il y a 52 minutes, norma a dit :

je doute être capable de tourner un bouton de 1° avec précision

 

Je ne comprends pas pourquoi « tourner un bouton de 1° »  alors qu’il faut appuyer sur un bouton pendant un laps de temps.

Avec mon système, sache qu’il est possible de descendre à une vitesse de rotation telle que tu ne verrais même pas le moteur qui tourne. L’intérêt du système est que tu peux avoir aussi bien 300 impulsions par seconde (donc 300 pas moteur par seconde)  comme avoir 1 impulsion toutes les 10 secondes (donc 1 pas toutes les 10 secondes).

 

Et comme il y a 2 vitesses réglables, il est possible de remplacer une des 2 ajustables par un potentiomètre pour avoir une vitesse fixe et une vitesse variable. Il est aussi possible de remplacer l’interrupteur par un commutateur à plusieurs positions, il est ainsi possible de programmer tout une gamme de vitesses.

[djalex1664]

norma maintenant tu as 2 solutions differentes pour ton usage, j'espère que tu pourras faire ce que tu souhaites 😉

[norma]

Je continue sur ta solution. L'autre, qui ne manque pas d'intérêt, existe déjà fusse sous d'autres formes. Merci à vous deux. Je vous tiendrai au courant si cela débouche : la partie mécanique n'est pas simple. 

[Hans Gruber]

Bonjour

 

Sur un mak (et sur n'importe quel instrument dans une moindre mesure) il est souhaitable d'intégrer le backlash directement dans le code, c'est à dire que quand le moteur tourne dans un sens on se contente d'appliquer les pas, si on change de direction on retourne en arrière, puis on applique le nombre de pas pour arriver à la valeur souhaitée. On peut aussi prendre en compte le backlash en le mesurant.

Plutôt que d'utiliser un potentiomètre et des boutons on peut prendre un encodeur rotatif qui est plus intuitif (c'est comme si on tournait la molette). Dans la procédure on peut appliquer un nombre de pas différent à chaque impulsion en fonction de la durée entre 2 impulsions (si on tourne le bouton plus vite une impulsions correspond à plusieurs pas).

[Discret68]

il y a 46 minutes, Hans Gruber a dit :

il est souhaitable d'intégrer le backlash directement dans le code,

Si pour de l’astrophoto, je trouve cette démarche pertinente, je suis très nuancé pour du visuel.

 

J’imagine que ça doit faire bizarre d’avoir l’image à l’oeil qui se défocalise à chaque fois qu’on fait la MAP. Ça doit faire un peu comme l’autofocus d’un APN, sauf que sur un focuser, c’est à chaque fois qu’on appuie sur un des 2 boutons de MAP et ce à une vitesse bien moindre qu’un autofocus.

 

L’avantage avec un Arduino, c’est qu’on peut changer facilement le code en fonction de ce qu’on veut.

 

A réfléchir !

[solfra]

Un petit switch pour activer/désactiver la gestion du backlash et le tour est joué 😉

[Hans Gruber]

Ça se voit à peine, parce que c'est rapide, mais sinon comme je l'ai dis plus haut on peut aussi simplement appliquer un certain nombre de pas en plus chaque fois qu'on change de direction, parce qu'il est très frustrant de tourner l'encodeur et que rien ne se passe.

[Moot]

Il y a 23 heures, Discret68 a dit :

Si c'est pour faire une commande manuelle, il y a plus simple que d'utiliser un Arduino.

 

Il y a quelque temps, j'en ai réalisé une avec un PIC. C'est conceptuellement plus complexe (ça reste un composant à programmer), mais électriquement, c'est ultra-rudimentaire : un régulateur pour faire du 5V (avec deux petits condensateurs de valeurs peu critiques), le PIC (qui a besoin du 5V) et un driver (j'avais pris un ULN 2803 parce que j'avais ça en stock et que mon moteur était unipolaire et peu puissant). Le PIC à huit papattes (12F...) suffit, deux pour les boutons, deux pour les sorties (phases). Les modèles actuels incluent l'oscillateur, donc le circuit intégré "tout nu" suffit à gérer le bazar.

 

Je suis assez partisan de la version avec un encodeur, surtout que ça existe avec des crans. Si on veut une version sophistiquée où tout est géré par un microcontrôleur, on peut ajouter un bouton pour un mode "rapide" (par exemple, 10 pas à chaque cran au lieu d'un seul), une prise en compte du jeu mécanique (réglable tant qu'à faire et non codé "en dur"), et un affichage de la position.

[Hans Gruber]

On peut en effet utiliser un PIC, mais le langage est un peu plus complexe, sinon il y a les attiny qui se programment comme des Arduino, c'est d'ailleurs avec ça que j'ai fais mon focuser (attiny 85), sinon on peut aussi utiliser un picaxe, que l'on programme en pseudo basic, et pour le coup ça devient archi simple à programmer.

[Discret68]

il y a 25 minutes, Hans Gruber a dit :

sinon il y a les attiny qui se programment comme des Arduino,

 

Je viens justement d’en commander ( https://www.gotronic.fr/art-module-trinket-5v-ada1501-21898.htm ) pour équiper un rotateur que je suis en train de fabriquer. L’Arduino Nano étant « trop volumineux » et disposant d’E/S surabondantes pour le besoin, je vais tester ce genre de circuit.

 

J’en ai profité pour prendre des cartes beetle avec quelques E/S supplémentaires pour  faire des tests : https://www.gotronic.fr/art-carte-beetle-rp2040-dfr0959-35875.htm

 

Pour piloter un moteur pas à pas, ça devrait être suffisant.

[Hans Gruber]

Je ne connaissais pas cette carte Beetle, intéressant.

Sinon j'utilise beaucoup la TTGO t-display, que j’apprécie car sur une carte unique on a 2 boutons intégrés, un écran tft, le bluetooth, wifi et une mémoire flash importante, et tout ça pour 10 à 12 euros port compris sur ali.