LinuxCNC : Installation

linux CNC nécessite une version avec Noyau temps réel pour fonctionner sur un raspberry PI.

en consequence , il n’est pas possible d’installer une version classique de DEBIAN ou de RASPIAN et d’ensuite y installer LinuxCNC via un APP get /install.

il va falloir récupérer une Image déjà bâtie, avec un noyau temps réel et linuxCNC compris dans le package.

je vous propose donc de telecharger l’image systeme suivante stockée sur google drive (fichier trop important pour etre mis a dispo directement ici sur le site).

https://drive.google.com/file/d/1ek_3taDOUOHC2HvTFmRjt7TApK163Qxe/view?usp=sharing

une fois le fichier téléchargé (quelques minutes car il fait un peu plus de 1Go) , il ne vous restera plus qu’a l’installer sur une carte SD via l’imager standard du Raspberry .

https://www.raspberrypi.com/software/

une fois installé l’imageur sur votre PC , le lancer , il se présente comme ci dessous:

premiere opération , case de gauche, choisir le type de raspberry PI , ici un RPI 4B

ensuite il faut choisir la localisation de l’image systeme dans la deuxième case du loader:

il va falloir ici spécifier l’utilisation d’une image personnalisée , derniere option en bas du menu de selection

puis aller dans le répertoire de téléchargement y chercher l’image recupérée sur google drive:

derniere opération, spécifier dans la case de droite du loader , la destination d’installation de l’image selectionnée, dans le cas present , la carte SD logée dans le lecteur de carte SD du PC:

ne reste ensuite plus qu’a lancer l’opération suivante:

dans le menu suivant choisir NON:

puis OUI dans l’ecran suivant:

l’installation de l’image systeme debute alors et durera plusieurs minutes, une operation de verification de l’image se deroulera ensuite et prendra a nouveau quleques minutes.

une fois tout fini , sortir la carte micro SD puis la mettre dans le logement du raspberry PI 4B et le démarrer .

Linux CNC Configuration: principes généraux

ici débute la partie un peu “hard” de la préparation de linuxCNC.

avant de rentrer dans les explications et pour ceux qui comprennent l’anglais, ci dessous le lien vers la documentation Linux CNC:

http://linuxcnc.org/docs/stable/html/

contrairement aux installations plus classiques sur des PC utilisant une interface parallèle , non seulement nous sommes sur un raspberryPI 4B avec 8go de Ram, mais en plus nous allons piloter une CNC directement via les ports GPIO du raspberry et ceci de la meme façon qu’avec un ARDUINO UNO avec GRBL (voir rubrique ARDUINO CNC du site).

LinuxCNC tel que fourni avec l’image systeme est prévu pour fonctionner avec un certain nombre de modules de sortie standards : port Parallèle , carte MESA , carte Mechatronic . quand on le lance il propose donc en standard de le configurer via des utilitaires déja installés avec le soft.

dans le cas du Raspberry PI et de son interface GPIO , il va falloir passer outre toutes ces procedures d’installations “faciles” et mettre un peu plus les mains dans le cambouis.

heureusement pour nous, les développeurs de LinuxCNC , on prévu un driver GPIO pour le Raspberry PI et moyennant la mise en place de quelques fichiers de configuration dans le repertoire adéqua , nous allons pouvoir mettre en place une version qui tourne sur RPI et qui utilise des broches GPIO pour piloter des moteurs Pas a Pas en mode DIR/STEP comme un arduino avec des drivers d’axes utilisant ce principe

nous allons donc voir voir comment configurer une version 3 axes X Y Z de ce type:

et sur le meme principe , une extension a 4 axes avec un 4° axe rotatif A . pour cela , il suffira de modifier les fichiers de la version 3 axes pour rajouter le 4° axe.

avant de passer a la configuration des fichiers , il est possible de lancer LinuxCNC en mode simulation permettant de voir a quoi ressemble l’ecran standard et de tester quelques fonctions du soft .

une fois votre RPI démarré, il va vous demander un identifiant et un mot de passe pour l’ouverture de cession. taper :

cnc pour l’identifiant

puis a nouveau cnc pour le mot de passe

apres l’ouverture de la cession DEBIAN , pour lancer Linux CNC, cliquer en haut a gauche sur la case “applications”, puis descendre sur la rubrique CNC puis cliquer dans le menu de droite sur LinuxCNC.

une fenêtre s’ouvre avec une liste déroulante dans laquelle il faut aller prendre dans la liste “sample configuration” puis “sim” puis “axis” , l’item “axis_mm” pour ouvrir une simulation LinuxCNC 3 axes X Y Z avec les unités en mm. après avoir sélectionné “axis_mm” puis cliqué sur OK en bas a droite , une fenêtre demande la confirmation de copie de certains fichiers dans un répertoire , confirmer en cliquant sur OUI

après confirmation, linuxCNC s’ouvre sur la fenêtre suivante

vous pouvez cliquer et naviguer dans les differents menus et options qui se presentent sans etat d’ame, s’agissant d’une simulation, il ne se passera rien de spécial a part des mouvements d’axes a l’écran.

Linux CNC Configuration: Brochage du GPIO

une des notions importantes de la config linuxCNC est la notion de masque pour la description des entrées/sorties du GPIO du RPI.

les 40 broches du GPIO du RPI sont composées de 2 broches de 5V , 2 broche de 3,3V , 8 broches de masse (ground) et 28 broches configurables en entrées/sorties. sur un raspberry PI 4B , la répartition des broches est comme ci dessous:

la première chose a faire avant de rentrer dans la configuration soft de LinuxCNC est de définir la façon dont vont être utilisées les broches GPIO du RPI pour s’interfacer avec la partie hard aval (drivers, moteurs pas a pas, switchs fin de course , broche d’usinage, etc …).

a partir du brochage retenu , va etre calculé un masque de definition pour le fichier HAL tel que defini dans la doc Linux CNC pour le driver ‘ hal_pi_gpio’ :

http://linuxcnc.org/docs/stable/html/drivers/hal_pi_gpio.html

Choix d’affectation du brochage GPIO et masque resultant:

pour faciliter le travail sur les 2 versions (CNC 3 axes et CNC 4 axes) , la config a ete choisie pour l’affectation des broches en version 4 axes (qui peut le plus peut le moins).

les broches d’envoi de signaux (Dir, Step, démarrage broche) sont des broches de sortie OUT , les broches de Switchs limite , probe et autres organes divers sont des broches d’entrées IN.

les broches 27 et 28 (GPIO 0 et GPIO 1) sont réservées pour certains protocoles de communication donc non disponible en entrée/sortie GPIO

les broches 3 et 5 (GPIO 2 et GPIO 3) etant a un niveau logique haut 3V pour le protocole de communication I2C , elles ne seront pas utilisées et configurees en entrées disponibles ainsi que la broche 7 (GPIO 4).

le masque résultant a utiliser dans le fichier HAL de configuration est donc :

loadrt hal_pi_gpio dir=27152376 exclude=0

pour ceux intéressés , ci dessous au format compressé RAR, le tableur format Libre office qui permet de faire le calcul en fonction des broches que l’on souhaite utiliser:

Linux CNC Configuration: fichiers INI et HAL

dans la rubrique précedente , nous avons vu qu’au démarrage en mode simulation, linuxCNC copiait des fichiers dans un répertoire. ce sont les fichier de configuration de base permettant le lancement du soft avec les paramètres de configuration.

le répertoire créé contient 2 fichiers majeurs , un fichier “xxxx.INI” et un fichier “xxxx.HAL”.

ce sont ces 2 fichiers qui permettent la configuration de linuxCNC dans le mode choisi.

si on regarde la structure des fichiers LinuxCNC avec l’explorateur de fichiers de l’OS DEBIAN installé par l’image utilisée , linux cnc installe les fichiers necessaires a son fonctionnement dans un repertoire ‘home/cnc/linuxcnc‘ qui comporte 2 sous répertoires : ‘config‘ et ‘nc_files

le répertoire ‘nc_files‘ servira a stocker les fichiers programme GCODE

le répertoire ‘config‘ permet de stocker les fichiers INI et HAL nécessaire a la configuration de linuxCNC au démarrage. dans ce répertoire ‘configs’ on peut créer autant de sous répertoires de configuration que de type de machine a utiliser/démarrer avec linuxCNC.

pour créer les profils des 2 machines 3 axes et 4 axes , il suffit de faire 2 repertoires avec les noms suivant ” 3axis-MILL” et “4axis-MILL” et d’y mettre dans chacun les extract des fichiers RAR respectifs suivants.

fichier INI et HAL CNC 3 axes

fichier INI et HAL CNC 4 axes

.le fichier INI comporte les lignes permettant de configurer les limites d’axes les vitesses , les accelarations, les step moteur et tout un tas de paramtres relatifs aux moteurs pas a pas et aux drivers utilisés. le fichier tel que fourni n’est donc pas utilisable en l’etat et devra etre modifié en fonction de votre configuration.

le Fichier HAL , comporte lui principalement tout ce qui concerne le brochage des entrées sorties du GPIO du raspberry PI . la aussi , il faudra tout d’abord configurer le masque dir/exclude du driver Hal_pi-gpio via le modele de calcul de la rubrique précédente en ayant pris soin de bien lister les broches utilisées et les elements connectés dessus pour ensuite completer/modifier la ligne suivante en debut de fichier HAL:

loadrt hal_pi_gpio dir=27152376 exclude=0

puis ensuite , toujours a partir du tableau d’affectation des broches, bien assigner les reference des PIN GPIO aux lignes de configuration de chaque axe au milieu du fichier , a savoir toutes les lignes du type :

net spindle-on spindle.0.on => hal_pi_gpio.pin-26-out
net xenable => hal_pi_gpio.pin-29-out
net xstep stepgen.0.step => hal_pi_gpio.pin-32-out
net xdir  stepgen.0.dir  => hal_pi_gpio.pin-24-out
net limit-x-switch hal_pi_gpio.pin-13-in => debounce.0.0.in

dans tous les cas , les erreurs seront sanctionnées par un message d’erreur au lancement de Linux CNC. il faudra prendre soin de lire le contenu du message pour connaitre la typologie de l’erreur a corriger. on rencontre les grands types d’erreurs ci dessous :

  • erreur sur le masque dir/exclude en debut de fichier HAL
  • erreur d’affectation des broches sur fichier HAL (broche en OUT sur le masque et en IN sur lignes de config)
  • erreur d’appel du fichier HAL dans le fichier INI => syntaxe de la ligne “HALFILE = nomfichier.hal

une fois les configurations et déclarations faites correctement , au démarrage de linuCNC il faut choisir la config a démarrer :

ce qui par exemple donne dans le cas de la config 4 axes , l’écran suivant:

moyennant d’avoir fait un montage proto en cablant des micro-swiths (normalement ouverts) entre la broche concernée et le +3,3V , il est même possible de faire un homming global sur les 4 axes dans l’ordre axe Z / axe Y / axe X / axe A en actionnant chacun des switch dans l’ordre après démarrage du mouvement a l’écran.

reste ensuite a cabler les PIN step et drive de chaque axe vers le driver et le moteur pas a pas correspondant . attention, le GPIO RPI sort du 3,3V sur ses broches , il faut donc soit des drivers compatibles d’un signal d’entrée 3,3V (pololu A4988 ou équivalent) soit utiliser des convertisseur 3,3V / 5V pour ataquer des drivers de puissance .

LINUX CNC Configuration de l’affichage

linux CNC possede differents types d’interfaces d’affichage qui se paramètrent dans le fichier de config “xxxx.INI”.

les differents look en standard dans l’image iso sont:

AXIS: un ecran basique

GMOCCAPY: interface pour ecran tactile mais utilisable aussi avec ecran normal, clavier et souris.

TOUCHY: interface specifique minimaliste pour petits écrans tactiles

GSCREEN (version par defaut): c’est un ecran customisable dont voici la version basique:

TKlinux: une interface egalement basique avec 1 fenetre controles et 1 fenetre visualisation trajectoires

QTVCP QTDRAGON: une interface au look tres pros et tres pratique (ma préférée). elle a un look style MACH 3.elle peut etre redimensionnée pour des ecrans de 1280×768 a 1680×1200

QTVCP QTDRAGON_HD: la meme que précédemment mais pour de grands ecrans HD , la résolution est fixe a 1920×1056.

QTVCP QTPLASMA: une interface spécifique a la decoupe plasma

CHOIX DE L’AFFICHAGE dans le FICHIER INI

le type d’interface est choisie en spécifiant en debut de fichier INI dans la partie [DISPLAY]

[DISPLAY]

DISPLAY = typeaffichage

typeaffichage peut prendre les valeurs:

  • axis
  • gmoccapy
  • touchy
  • tklinuxcnc
  • gscreen
  • qtvcp qtdragon
  • qtvcp qtdragon_hd
  • qtvcp qtplasma

Linux CNC : circuit prototype

quelques explications sur le circuit prototype pour la validation du fonctionnement en 4 axes.

l’idée de base est d’utiliser un CNC shield ARDUINO et de l’utiliser en version 4 drivers d’axes avec des Pololu DRV 8825 .

un premier test de validation sur 1 seul axe a ete réalisé , voici une photo du premier montage de test “proof of concept” . il a permis de tester le Homming des 4 axes X-Y-Z-A via des micro switches puis de faire tourner un moteur pas a Pas NEMA 17 sur l’axe X . l’alimentation en puissance des drivers a ete faite via une batterie 12V Lithium-ion.

le concept etant fonctionnel , l’etape suivante consiste a faire une version complete avec 4 moteurs NEMA 17 et 4 Pololu DRV 8825 sur un shiel CNC . voici le materiel de base:

  • un cable en nappe avec son adaptateur GPIO
  • un shield CNC pour ARDUINO UNO et 4 pololu DRV 8825
  • un PCB d’embase Arduino UNO pour faire des shield UNO personnalisés

a partir de l’adaptateur GPIO et de la platine SHIELD proto UNO , il faut maintenant réaliser une interface permetant de relier les PIN GPIO aux PIN du CNC SHIELD

premiere etape : soudure de connecteurs pour les differentes broches coté adaptateur GPIO

puis soudure de connecteurs pour le coté Shield CNC UNO.

etape suivante , cablages de jonction suivant le schema ci dessous , avec au milieu les PIN de l’adaptateur GPIO et de chaque coté les broches (inversées) du Shield CNC retourné.

le shield CNC n’ayant pas asses de broche pour les switchs fin de course , les câbles seront sortis sur un connecteur independant du shield.

LES CONNECTEURS

cette page a pour objectif de recenser et documenter les spécifications des connecteurs courants en électronique.

le but n’est pas de faire un récapitulatif exhaustif mais de recenser les plus utilisés sur des PCB ou câbles pour de l’électronique DIY a base de microcontrôleurs .

Les connecteurs JST

ils sont principalement utilisés pour de la connectique de capteurs , de batteries rechargeables, de moteurs Pas a Pas type NEMA, de cartes d’imprimante 3D, et en modélisme radiocommandé sur les servomoteurs.

on les désigne sous le nom JST qui est le standard originel du fabriquant J.S.T. Mfg. Co. (Japan Solderless Terminal).

la caractéristique principale de ces connecteurs est le pas d’écartement des broches. et les connecteurs femelle a souder sur les circuits existent en broche droites (le plus courant) , en broche perpendiculaires et en connecteur pour montage en surface (CMS).

voici 2 tableaux récapitulatifs des désignations et écartements correspondants:

ARDUINO: Capteurs Ultrason

nous allons voir ici comment faire une mesure de distance avec un capteur Ultrason.

nous examinerons 2 types de capteur , le capteur classique disponible dans tous les kit arduino, a savoir le HC-SR04 mais aussi un capteur un peu plus evolué , le capteur A02YY , qui est un capteur étanche a commande UART.

Capteur ULTRASON le principe

les capteur a ultrason sont des circuits électroniques comportant un Émetteur et un récepteur a Ultrasons.

l’émetteur envoie une impulsion sonore qui est réfléchie par les obstacles situés en face. le récepteur capte l’écho reçu en retour. on mesure le temps mis entre le départ du son et le retour, et connaissant la vitesse de propagation du son dans le milieu ou s’effectue la mesure on peut en déduire la distance.

Distance = (temps x vitesse du son) / 2

Le capteur HC-SR04

principe de commande:

le circuit du capteur est alimenté en 5V via ses broches Gnd et Vcc , il comporte une broche Trig (Trigger) permettant de commander l’envoi du signal , et une broche Echo permettant de détecter le signal du retour d’echo.

il suffit donc d’alimenter le capteur via le Gnd et le 5V de l’arduino et de brancher les broches Trig et Echo sur des sorties de l’arduino.

histoire de changer de l’éternel affichage dans le moniteur série , nous allons ici directement utiliser un petit écran Oled I2C 128×64 pixels pour afficher le résultat. le principe du Bus I2C est expliqué ici : Bus I2C

pour la gestion en I2C , nous utiliserons la librairie “Wire.h” et pour le petit écran Oled I2C nous utiliserons les librairies “Adafruit_SSD1306.h” et “Adafruit_GFX.h” . ces librairies seront a installer en préalable sur votre IDE arduino.

pour le pilotage globale , nous utiliserons un Arduino Nano ce qui permettra un ensemble très compact .

Cablage Arduino:

  • la broche Trig du HC-SR04 est raccordée a la broche D7 de l’arduino nano
  • la broche Echo du HC-SR04 est raccordée a la broche D6 de l’arduino nano
  • la broche SCL de l’ecran OLED est raccordée a la broche A5 de l’arduino nano
  • la broche SDA de l’ecran OLED est raccordée a la broche A4 de l’arduino nano
  • les broches GND et Vcc des 2 composants sont a raccorder aux broches GND et 5V du Nano
  • l’arduino Nano sera alimenté par le cable USB de telechargement du programme . pour un montage autonome , voir derniere photo en bas de page sur le cas du deuxieme capteur .

Programme:

#include <Wire.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_GFX.h>
#define OLED_ADDR   0x3C    // OLED display TWI address
Adafruit_SSD1306 display(-1);
#define ECHpin 6
#define TRIGpin 7
unsigned long duree ;
const float SOUND_SPEED = 343.00 / 1000;
float distance = 0.00;

void setup() {
 pinMode(ECHpin, INPUT);
 pinMode(TRIGpin, OUTPUT);
 digitalWrite(TRIGpin, LOW);
 Wire.begin( );                // démarre la communication I2C
 display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR); // initialize l'ecran OLED
 display.clearDisplay();     //efface l'affichage OLED
 display.display(); 
}

void loop() {
 digitalWrite(TRIGpin, HIGH);
 delayMicroseconds(10);
 digitalWrite(TRIGpin, LOW);
 // mesure du temps aller retour de l'impulsion US
 duree = pulseIn(ECHpin, HIGH);
 distance = duree  * SOUND_SPEED / 2.0 ;
 display.clearDisplay();
 display.display();  
 display.setTextColor(WHITE);
 display.setTextSize(1);
 display.setCursor(35,1);    
 display.print("DISTANCE" );
 display.display(); // actually display all of the above 
 display.setTextSize(2);
 display.setCursor(10,17);    
 display.print(distance);
 display.setCursor(85,17);    
 display.print(" mm");
 display.display();
 delay(5000);
}

Résultat:

dans la photo ci dessous , le montage posé horizontalement sur une table, et qui mesure la hauteur au plafond en mm .

Nota: il faudra étalonner le montage en mesurant la cote réelle et modifier la vitesse du son en conséquence . il faut savoir que la vitesse du son dans l’air est fonction de la température et de la densité de l’air a l’endroit de la mesure. pour faire un appareil de mesure précis , il faudrait aussi mesurer la température et ajouter une table de correction …

.

Le capteur A02YY :

les differents Modeles :

dans la famille des capteurs A02YY , il existe 5 types dont voici un tableau récapitulatif des caractéristiques principales:

dans ce tutos , nous allons voir le modèle A02YYTW qui a l’avantage d’être commandable de la même façon que le capteur HC-SR04 et donc plus économe en énergie que par exemple le modèle UW qui lui est en émission réception constante et ou il faut récupérer les données a la volée.

brochage du câble du capteur

Principe de fonctionnement

ici la petite particularité par rapport au capteur HC-SR04, c’est que la carte electronique du A0221AT calcule directement la distance et l’envoie sous forme de chaine de 4 caractères sur le bus série avec un protocole de type Tx/Rx . dans le programme Arduino, il va donc falloir implémenter un protocole serie avec la bibliotheque “SoftwareSerial.h” et un protocole Myserial pour le bus serie du capteur , afin de lire les bits reçus du capteur et calculer la distance correspondante .

ci dessous un extrait de la data sheet du capteur qui explique cela pour les modules UART contrôlés.

Câblage Arduino:

il est similaire a celui du HC-RS04 plus haut avec :

  • la broche Rx (cable jaune) du capteur (equivalent au Trig du HC-SR04) est raccordée a la broche D7 de l’arduino nano
  • la broche Tx (cable blanc) du capteur (equivalent au Echo du HC-SR04) est raccordée a la broche D7 de l’arduino nano
  • la broche SCL de l’écran OLED est raccordée a la broche A5 de l’arduino nano
  • la broche SDA de l’écran OLED est raccordée a la broche A4 de l’arduino nano
  • les broches GND et Vcc des 2 composants sont a raccorder aux broches GND et 5V du Nano

Programme:

#include <SoftwareSerial.h>
#include <Wire.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_GFX.h>
#define OLED_ADDR   0x3C    // OLED display TWI address
Adafruit_SSD1306 display(-1);
#define RXpin 6
#define TXpin 7
SoftwareSerial mySerial(RXpin,TXpin); // RX, TX connected to US sensor
unsigned char data[4]={};
float distance = 0.00;

void setup() {
 pinMode(RXpin, INPUT);
 pinMode(TXpin, OUTPUT);
 Wire.begin( );                // démarre la communication I2C
 Serial.begin(9600);
 mySerial.begin(9600); 
 display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR); // initialize
 display.clearDisplay();     //and clear display
 display.display(); 
}

void loop() {
 mySerial.flush();
 delay(30);
 digitalWrite(TXpin,HIGH);
 delay(30);
 digitalWrite(TXpin,LOW);
 delay(30);
  digitalWrite(TXpin,HIGH);
 delay(60);
     for(int i=0;i<4;i++)  {
       data[i]=mySerial.read();
     }
 distance = (data[1]*256)+data[2];
 display.clearDisplay();
 display.display();  
 display.setTextColor(WHITE);
 display.setTextSize(1);
 display.setCursor(35,1);    
 display.print("DISTANCE" );
 display.display(); // actually display all of the above 
 display.setTextSize(2);
 display.setCursor(10,17);    
 display.print(distance);
 display.setCursor(85,17);    
 display.print(" mm");
 display.display();
 delay(5000);
}

voici ci dessous, une photo d’une adaptation du montage et du programme ci dessus pour calculer le volume d’eau residuel dans une cuve rectangulaire de camping car.

a partir de la distance entre le dessus de cuve et la surface de l’eau, on calcule le volume d’air supérieur de la cuve que l’on retranche au volume global de la cuve .

pour l’alimentation electrique , sont utilisées 2 pile Li-ion 18650 de 3,7 V en série connectées a la broche GND et Vin du Nano. ce qui rends le dispositif autonome.

il est parfaitement imaginable de faire de même dans un puits de section cylindrique .

NOTA: le capteur fonctionne sur une plage de distance de 3cm a 4,5 mètres .

PIcam PAN / TILT

présentation d’un montage basique PAN TILT d’une PI camera pilotée par un Raspberry PI.

le principe du montage est d’afficher l’image de la camera sur écran et d’utiliser une souris ou un trackpad pour pointer dans l’image le nouveau point de focus central . après clic sur le bouton gauche , la camera change d’orientation (mouvement Pan/Tilt) pour pointer sur le nouveau point désigné dans l’image.

vue CAO du montage:

Vue du Montage réel:

il est fait a partir de pièces imprimées 3D , les moteurs pas a pas sont des 28BYJ-48 bien connus dans les montages proto a base d’arduino. ici ils seront commandés par un Raspberry PI (schéma plus bas).

Principe de commande et câblage:

pour la partie commande et affichage , nous allons utiliser un Raspberry PI 4B 8Go et utiliser le port GPIO pour piloter les 2 moteurs pas a pas 28BYJ-48 du montage Pan/Tilt via deux drivers Pololu A4988. la camera est une simple PIcam V1 a quelques euros ( def. photo maxi: 2592×1944 , def video max: 1920 x 1080 30fps)

le principe de ce type de commande avec Pololu A4988 est expliqué ici :

https://www.e-techno-tutos.com/2021/03/14/moteur-pas-a-pas-type-nema-17/

avec pour particularité de remplacer un NEMA17 par un 28BYJ-48 dont la modification de branchement est décrite ici (pilotage par un Arduino Uno):

https://www.e-techno-tutos.com/2022/03/18/arduino-pap-28byj-48-a4988/

ci dessous une vue schématique des branchements sur le port GPIO. les sorties GPIO2 et GPIO3 vont sur les entrée STEP/DIR du driver 1 et les sorties GPIO5 et GPIO6 vont sur les entrée STEP/DIR du driver 2. les 2 drivers sont alimenté en puissance par une alim 5V externe (ici pile 9V et régulateur 5V) car le 5V du RPI 4B est insuffisant pour l’ensemble ce qui pourrait provoquer une chute de puissance et des dysfonctionnements globaux.

pour mémo rappel des brochages du GPIO

pour la partie driver Pololu , sont utilisés ici des petites platines proto spécifique que l’on trouve sur Amazone ou aliexpress et qui supportent les pololu A4988.

pour piloter un 28BYJ-48 , vu les faibles puissances en jeu , pas besoin de radiateur sur les drivers Pololu.

petite vue globale du montage proto une fois tout branché :

petite vue de l’ensemble une fois le PI démarré et le programme ci dessous lancé .

LE PROGRAMME PYTHON

voici le lien vers le programme python au format txt (changer l’extension “.txt” en “.py” pour une utilisation sur RPI:

le détail du pgme:

#import des librairies
import cv2
from time import sleep 
import RPi.GPIO as GPIO
#config port GPIO
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
st1=6
dir1=5
st2=3
dir2=2
GPIO.setup(st1, GPIO.OUT)
GPIO.setup(dir1, GPIO.OUT)
GPIO.setup(st2, GPIO.OUT)
GPIO.setup(dir2, GPIO.OUT)
# fonction "motion" = action suite appui bouton et  position curseur souris        
def motion(event,x,y, flags, paramq):
    if event==cv2.EVENT_LBUTTONDOWN:
        Xpos=(x - 640)
        Ypos=(360 - y)
        S1=abs(round(Xpos/10))
        A= abs(round(Ypos/Xpos, 1))         
        if Xpos<=0:
            d1=0            
        else:
            d1=1
        if Ypos<=0:
            d2=1
        else:
            d2=0
        GPIO.output(dir1,d1)
        GPIO.output(dir2,d2)
        # mouvement combiné Pan/tilt par pas de 10 pixels en x
        for n in range(S1):            
            for x in range(10):
                GPIO.output(st1,1)
                sleep(0.001)
                GPIO.output(st1,0)
                sleep(0.001)
            for y in range(int(10*A)):
                GPIO.output(st2,1)
                sleep(0.001)
                GPIO.output(st2,0)
                sleep(0.001)
#programme principal
# ouverture camera, fenetre camera et definition affichage
Vcam="CAMERA"
cv2.namedWindow(Vcam, cv2.WINDOW_AUTOSIZE)
cv2.moveWindow(Vcam, 630, 220) 
cap0=cv2.VideoCapture(0) 
# defintion largeur/hauteur de la camera (ici mode HD)
cap0.set(cv2.CAP_PROP_FRAME_WIDTH, 1280)
cap0.set(cv2.CAP_PROP_FRAME_HEIGHT, 720)
if cap0.isOpened(): 
    rval, frame0 = cap0.read()
else:
    rval = False 
# boucle affichage et tracage centre image   
while rval:   
    cv2.imshow(Vcam, frame0)
    rval, frame0 = cap0.read()
    cv2.line(img=frame0, pt1=(640, 0), pt2=(640, 720), color=(0, 255, 255), thickness=2, lineType=8, shift=0)
    cv2.line(img=frame0, pt1=(0, 360), pt2=(1280, 360), color=(0, 255, 255), thickness=2, lineType=8, shift=0)
    # gestion appui clavier touche q = arret camera
    key=cv2.waitKey(1) & 0xFF
    if  key == ord('q'):            
        break
    # si pas arret camera , appel fonction "motion"
    else:    
        cv2.setMouseCallback("CAMERA",motion)
# arret camera et fermeture fenetres si appui touche q
cap0.release()
cv2.destroyAllWindows()

commentaires / explications:

  • le programme utilise 3 librairies : OpenCV ( import cv2 ) pour la partie camera et gestion des évènements clavier/souris , Time (from time import sleep) pour les pause pgmes, et GPIO ( import RPi.GPIO as GPIO ) pour la gestion des entrées sorties de l’interface GPIO.
  • les 10 lignes suivantes font définition des variables et la configuration des sorties du port GPIO pour l’envoi des impulsions STEP/DIR sur les entrées des drivers.
  • def motion() est une fonction qui définis les action sur appui gauche du bouton souris => on prend la valeur de position (x,y) en pixels de la souris dans l’image , on recalcule la position par rapport au milieu de l’image , on fixe la valeur des sortie dir des 2 moteurs pas a pas et on lance une boucle de mouvement combiné sur les 2 axes en fonction des décalages pixels entre centre de l’image et position de la souris sur l’image.
  • le programme central ouvre une fenêtre de visualisation, lance l’affichage camera et teste l’appui clavier puis appelle la fonction motion si clic gauche souris.

résultat sur écran raspberry:

a gauche, le programme ouvert avec l’IDE Thonny Python et a droite la fenêtre d’affichage de la camera . en jaune les lignes horizontales et verticales matérialisant le centre de visée de la caméra.

petite vidéo du résultat:

points a améliorer:

  • l’affichage caméra est figé pendant le mouvement Pan/Tilt ,ceci est du a l’intégration de l’affichage dans le module de programme . l’affichage n’est re-genéré qu’après le mouvement => utiliser le threading ou le multiprocessing pour séparer les deux processus et ainsi avoir un processus d’affichage independant permettant de rafraichir l’affichage en temps réel pendant le mouvement.
  • la position après mouvement est très approximative , integration pifométrique pixels camera / position finale => affiner la méthode de calcul en coordonnées polaires de la nouvelle position en fonction des pixels souris , de la focale de la camera , de la définition d’affichage et du microstepping des pas a pas.
  • la “dichotomie” du déplacement combiné x/y est sommaire (ratio entre la position x/y et arrondis sommaire sur le pas des boucles) => intégrer un calcul de décalage par rapport a la pente théorique et faire une correction (x,y) dans la boucle a chaque itération pour rattraper la position par rapport a la trajectoire théorique (principe de l’algorithme de Bresenham) .

SOFTWARE ASTRO

le traitement et le contrôle numérique est devenu courant en astronomie, de nombreux software ont été développés , explorons la liste des logiciels libres les plus utilisés que ce soit en astrophoto ou en contrôle/guidage.

PLANETARIUMS

STELLARIUM

le planétarium le plus connus , il est en version LIBRE pour les systèmes windows, linux et mac OS. outre les fonction de visualisation de la voute céleste, il possède des fonctions de guidage de montures et est compatible de différents standards (ASCOM, INDI, etc ..). il existe une version pour smartphone avec une version basique gratuite et une version payante complète.

lien d’information et de telechargement PC: https://stellarium.org/fr/

CARTE DU CIEL

la deuxième star des planétariums est le logiciel “Carte du Ciel”. concurrent direct de stellarium , ses capacités sont les mêmes (planétarium et conduite de monture)

lien d’information et de téléchargement PC: https://www.ap-i.net/skychart//fr/start

STACKING PHOTO

SIRIL

actuellement , le software gratuit le plus en vogue , la panoplie des options de SIRIL vont du prétraitement des images à l’empilement (stacking) en passant par la calibration et l’amélioration. il est gratuit et compatible tout OS (window, mac, linux)

lien d ‘information et de téléchargement : https://siril.org/fr/

REGISTAX

également gratuit , registax est l’équivalent de siril mais spécialisé pour le planétaire. il est un peu plus simple a mettre en oeuvre que SIRIL . il possede un mode de traitement automatique (copie, traitement alignement selection et empilage) . mais les parametres peuvent etre egalement réglés a la main pour un meilleur résultat.

lien d’information et de téléchargement: https://www.astronomie.be/registax/

DEEPSKYSTACKER

DEEPSKYSTACKER est le pendant de REGISTAX mais pour le ciel profond. lui aussi a un mode basique automatique avec des paramètres standards.

lien d ‘information et de téléchargement: http://deepskystacker.free.fr/french/index.html

PRISE DE VUE APN

CANON EOS UTILITY

disponible gratuite sur le site CANON, il permet de piloter les boitier EOS de la gamme CANON . une fois installé sur votre PC et branché a votre APN via son port USB, vous prenez le contrôle complet de l’appareil : prises de vues, sélection des réglages (mode, ISO , temps de pose , etc..). il est particulièrement utile en mode BULB (pause longue) via son module minuteur permettant du timelaps pauses longues (réglage du nombre de vues , temps de pause, temps interposes). le chargement des photos sur le PC peut être automatisé pendant la séquence de prise de vue avec visualisation temps réel . c’est le super couteau suisse pour APN CANON EOS …

doc et telechargement : https://www.canon.fr//software/eos-utility

PRISE DE VUE APN et CAMERA CCD

SHARPCAP

sans doute un des soft les plus connus, il existe en version gratuite et version payante. la version gratuite possède déjà des options étonnantes, auxquelles, moyennant paiement on accède a un certains nombre d’outils évolués : stacking, alignement polaire, sequences de vues plannifiées, etc..

doc et téléchargement : https://www.sharpcap.co.uk/

SPECIFIQUES LINUX

KSTAR – EKOS

cet ensemble est constitué de deux gros modules , le planétarium KSTAR et le logiciel de contrôle d’observatoire EKOS. KSTAR est le pendant LINUX de Stellarium , complété d’une suite d’outils EKOS nanti de son protocole de communication INDI. l’ensemble constituant un package tout en un de contrôle d’observatoire qui va du contrôle de la monture , a la prise de vue , au contrôle de coupole et au contrôle d’une station météo et de camera automatique extérieures . le protocole INDI est quasi sans limite sur la capacité a contrôler des éléments extérieurs via microcontrôleurs et reseau. s’agissant d’un ensemble open source , il est meme possible de développer ses propres interfaces. le package peut même être installé sur un Raspberry PI 4. on le trouve d’ailleurs sous cette forme dans le pack STELLARMATE qui n’est rien d’autre qu’un raspberry PI avec KSTAR EKOS , l’ensemble installé dans un joli boitier rendant le produit plus “commercial”. le célébré boitier ZWO ASIAIR n’est lui aussi rien d’autre qu’un RPI déguisé avec dedans KSTAR EKOS .

lien documentation et téléchargement KSTAR: https://apps.kde.org/fr/kstars/

lien documentation et téléchargement INDI/EKOS: https://www.indilib.org/