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) .

SLIDER PHOTO pour TIMELAPSE 3 AXES

presentation d’un SLIDER 3 axes (PAN/TILT/Translation) DIY pour du timelapse photo .

le projet présenté ci dessous a pour objectif primaire de faire du timelapse photo mais en “dynamique” sur 3 axes , un axe de translation longitudinale et 2 axes de pivot PAN et TILT . il peut être utilisé de jour mais aussi de nuit pour du timelapse astro .

AVERTISSEMENT : ce projet est présenté a titre indicatif comme base d’inspiration a ceux qui voudraient faire un projet similaire . aucun fichier CAO , aucun fichier STL et aucun programme arduino ou autre ne sera fourni => pas la peine de déranger pour les demander

LES CONCEPTS DE BASE

l’idée originale du projet était de monter un appareil photo reflex, fixé sur un chariot muni de 2 axes PAN et TIL , le chariot se déplaçant lui meme sur une glissier a base de rail Alu Vslot l’ensemble commandé par un ARDUINO UNO , un CNC SHIELD avec des drivers POLOLU A4988 , des pas a pas 28BYJ-48 et programmé par un ecran clavier I2C

LE RAIL LONGITUDINAL

pour l’axe de translation longitudinal , le fil conducteur c’est de reprendre le principe de guidage et d’entrainement de bon nombre d’imprimantes 3D et de graveuses laser de type portique avec du rail alu Vslot sur lequel roule un chariot a galets (profil Vslot) entrainé par un moteur pas a pas 28BYJ-48 . l’écartement des 2 rails est réalisé par des cales faites sur imprimante 3D. le moteur pas a pas est logé dans une des 2 traverses du chariot , et comporte sur son axe une poulie GT2 qui engrène sur une courroie caoutchouc. la courroie est tendue dans la rainure du rail en profil Vslot entre les deux extrémités du rail et passe sous les deux galets Vslot mais par dessus la poulie Gt2 en bout de moteur . le comportement est identique a celui d’un pignon attaquant une crémaillère mais a un cout bien moindre .

la pièce rouge sur la vue CAO qui porte le moteur est imprimée 2 fois , ce sera l’autre coté du chariot mais sans moteur dessus .

LE SYSTEME PAN/TILT

ici , il s’agit de réaliser deux axes de pivot perpendiculaires , un axe vertical et un axe horizontal et de prendre a nouveau des pas a pas 28BYJ-48 pour mouvoir/tourner l’ensemble . la partie complexe de l’ensemble a été de concevoir une équerre support permettant de monter le pas a pas de l’axe horizontal et d’y loger également des roulements a billes pour la fluidité des mouvements :

compte tenu des contraintes d’impression 3D , le bras pivot a été fait en 2 parties goupillées et collées ensembles selon le concept de la vue CAO 3D ci dessus et donne comme résultat réel l’ensemble de la photo ci dessous .

LE CHARIOT SUPPORT

au final , le chariot support est simple a faire , 2 tube alu de section carré et quelques vis font la jonction des 2 traverses porte galet du chariot. un bloc support pas a pas imprimé 3D pour loger le moteur de l’axe de rotation vertical vient compléter l’ensemble ( piece en bleu sur la vue ci dessous).

une poutre support d’axe vertical avec un logement porte roulements vient compléter le mécanisme du chariot :

LE CHARIOT COMPLET

reste a assembler l’ équerre/bras support pan/tilt sur le chariot et y fixer une plaque alu pliée pour porter l’APN reflex:

test de mise en place de l’APN (ici un NIKON D3200) pour valider les implantations.

L’ ÉLECTRONIQUE DE COMMANDE

le coeur du systeme est un ARDUINO UNO surmonté d’un Shield CNC ( carte support pour 3 drivers POLOLU A4988) permettant de commander 3 moteurs pas a pas . ici aussi on ne réinvente pas l’eau chaude , c’est du materiel standard du commerce utilisé dans les CNC DIY a base d’ARDUINO et controle via GRBL (pour ceux éventuellement intéressés voir ici ) :

reste a mettre tout ça dans un boitier intégré sous le chariot :

le boitier se clippe tout simplement dans une plaque support histoire de pouvoir démonter facilement si panne et/ou besoin d’accès au dispositif.

la plaque est rivetée ( rivets pop) sous les traverse alu du chariot. Les 2 trous oblongs de part et d’autre de la plaque servent au passage de la vis de fixation du systeme pan tilt en partie supérieure.

ci dessous petite photo qui permet de comprendre que c’est l’intégration du boitier support arduino et son shield CNC qui a déterminé l’écartement des 2 rails alu profil Vslot .

LE BOITIER DE SAISIE:

ici pour faire compact et léger , reprise d’un principe utilisé sur d’autre projets ARDUINO , à savoir un boitier Ecran/clavier I2C maison.

on complete avec un petit support en tôle alu et on fixe le clavier sur le chariot avec un velcro pour qu’il soit amovible mais reste bien en place pendant les mouvements de translation de l’ensemble une fois reposé sur le support.

DERNIERS PRÉPARATIFS et TEST :

reste a mettre les courroies GT2 , un câble d’alimentation et une batterie 12V lithium ion embarquée, un câble avec jack pour le déclenchement prise de vue photo ( branché sur une broche de l’arduino UNO) , un gros bout de programme ARDUINO ( plusieurs dizaines d’heures de “jus de cervelle” pour faire fonctionner tout ça) , 2 trépieds photo pour supporter l’ensemble et c’est parti pour un Test en live :

les paramètres de fonctionnement a saisir ( debut de la video) , sont le nombre de point d’arrêt sur la trajectoire, les angles pan et tilt et le temps d’arret entre chaque point . pour que le mouvement et les points d’arrêts soient soit visibles surla video , un nombre de point de trajectoire réduit a été utilisé dans la démo ci dessous .

prochaine étape , une version ou le clavier I2C est remplacé par un module bluetooth HC-05 sur l’arduino et un smartphone avec l’appli REMOTE XY (voir ici )

etape ulterieure , un raspberry PI pour de la video en mouvement continu et des évolutions sur les possibilités de programmation (way point, suivi automatique de cible avec PIcamera, , recuperation des photos et des videos, controle des parametres APN via USB avec la librairie GPHOTO etc…).

les systèmes a base d’ARDUINO montrent vite leurs limites en terme de capacité mémoire programme, et possibilité de calculs complexes ainsi que les limites en terme d’Interface Homme-Machine, il est en effet plus commode d’utiliser des mini PC ou des calculateurs type Raspberry PI associé a des mini écrans tactiles et des mini claviers avec trackpad de façon a conserver l’aspect nomade .

ESP32cam: systeme PAN TILT

voyons ici comment implémenter un systeme PAN TILT a base de servo et d’un petit kit support. l’ensemble commandé via une page internet ( PC ou smartphone).

ce qui donnera le montage suivant:

et le résultat attendu :

pour réaliser ce montage , il est nécessaire de commander le module suivant :

on peut le trouver chez Bangood , Aliexpress ou Amazone . la version utilisée a été commandée chez Amazone pour un peu moins de 17 euros (aout 2021) avec les 2 servos G90 inclus . ce support peut également être utilisé pour des PIcam .

PRINCIPE DE FONCTIONNEMENT

l’ ESP32cam va héberger non seulement le programme Arduino de commande de la partie servo mais aussi la page HTML qui permettra l’affichage et la commande de mouvement . l’ESP32cam agira donc en serveur . la visualisation via un navigateur pourra donc se faire aussi bien sur PC que sur smartphone ou sur raspberry PI.

BIBLIOTHEQUE ARDUINO

pour le fonctionnement du programme arduino , il faudra la bibliotheque ESP32servo. pour l’installer , ouvrir le menu Outils >Gestionnaire de bibliotheque> puis dans la fenetre de recherche , tapper ESP32Servo puis installer la bibliothèque .

LE PROGRAMME ARDUINO:

ci dessous le programme arduino au format txt a copier/coller dans l’IDE arduino . pour plus d’info sur la configuration voir la rubrique dédiée a l’ESP32cam ICI.

IDENTIFICATION RÉSEAU:

pour utiliser le réseau domestique de votre box , il faudra fournir au programme votre identifiant et mot de passe réseau . cela se fait dans les lignes ci dessous:

CABLAGE

ci dessous le cablage des servos sur l’ ESP32cam.

CONNEXION

pour la connexion, ne reste plus qu’a ouvrir un navigateur web et saisir l’adresse IP de l’ESP32cam sur votre réseau ( faire une recherche via votre profil administrateur box) et une page devrait s’ouvrir avec la vidéo live view en partie haute et en dessous les touches de contrôle de mouvements PAN/TILT .

une PIcam comme camera CCD

nous allons ici illustrer une utilisations potentielles de la PI cam qui peut avantageusement être utilisée comme camera astro , soit pour de la prise de vue (photo ou video) , soit comme viseur polaire , soit comme chercheur.

pour l’utilisation en chercheur ou en prise de vue a la place d’un APN ou d’une camera CCD , il faut un adaptateur d’oculaire . il peut etre réalisé avec une imprimante 3D comme l’exemple en photo ci dessous . il est compatible des versions PIcamV1 ou V2 avec support d’objectif ( il faudra penser a enlever l’objectif de la PIcam en le dévissant):

cet adaptateur , permet de mettre la PI cam dans un porte oculaire de télescope ou dans le tube d’un chercheur , comme par exemple ci dessous dans le porte oculaire d’un CELESTRON C90.

autre exemple d’utilisation, en combinaison avec un adaptateur d’objectif photo (ici une version pour objectif NIKON ) pour realiser un instrument compact capable de faire des prise de vues lunaires ou pour les grandes nébuleuses .

a toutes fins utiles , ci dessous deux petits tableaux recapitulatifs , l’un avec les data de base relatives au 3 type de PI cam disponibles et l’autre avec des angles de champs calculés suivant la focale de l’instrument avec une PIcam V1 et une PIcam HQ ainsi que le rappel de l’angle de champ de quelques objets remarquables.

pour memo en rubrique microcontroleurs/ RASPBERRY PI vous trouverez des tutoriels de base sur l’utilisation d’une PIcam avec Python.

Motoriser une monture type EQ2

beaucoup ont commencé l’astronomie avec une monture équatoriale manuelle tres basique type EQ2 qu’ils ont ensuite rangé au grenier pour s’équiper de materiel plus performant.

je propose ici un bricolage maison pour motoriser de façon simple ce type de monture a partir d’une piece imprimée 3D , d’un arduino nano et d’un moteur pas a pas 28BYJ-48 avec son driver ULN 2003 . equipement de motorisation a completer de 2 poulies dentées pour courroie GT2 et d’une courroie GT2. ici le couple de poulies est une 20 dents coté moteur et une 60 dents coté roue et vis sans fin.

ce type de modification permettra déjà de dégager les mains et ainsi faciliter l’observation visuelle ( mouvement automatique) mais également de débuter en astrophotographie avec des moyens simples type camera CCD, webcam ou PIcam . pour la PIcam voir la rubrique ASTROBERRY PI .

LE SUPPORT MOTEUR 28BYJ-48

fichier STL pour impression 3D

LES BRANCHEMENTS

la partie électronique se compose d’un Pas a pas 28BYJ-48 et de son driver

l’ensemble connecté a un arduino nano et alimenté par une batterie Li-po 12V sur régulateur 5V. ci dessous un schéma de principe repris de la rubrique Arduino. il suffit de remplacer la pile 9V par une Li-po 12V et d’utiliser le regulateur adapté.

LE PROGRAMME

ci dessous le programme arduino au format txt , il devra être copié dans l’IDE ARDUINO et adapté .

les valeurs de broche A – A_bar – B – B_bar devront être choisies en conformité avec les broches de l’arduino nano choisies. la valeur de X dans les lignes “delay(x);” devront etre adaptée en fonction des step du 28BYJ et du rapport de réduction des poulies GT2 .ici la valeur de 101 est calculée pour une réduction 20/60.

#define A        10                    
#define A_bar    12                    
#define B        11                   
#define B_bar    13                    
#define x        101

void setup() {
  pinMode(A, OUTPUT);
  pinMode(A_bar, OUTPUT);
  pinMode(B, OUTPUT);
  pinMode(B_bar, OUTPUT);
}

void loop() {    
    digitalWrite(A, LOW);
    digitalWrite(A_bar, HIGH);
    digitalWrite(B, HIGH);
    digitalWrite(B_bar, LOW);
    delay (x);
    digitalWrite(A, LOW);
    digitalWrite(A_bar, HIGH);
    digitalWrite(B, LOW);
    digitalWrite(B_bar, LOW);
    delay (x);
    digitalWrite(A, HIGH);
    digitalWrite(A_bar, LOW);
    digitalWrite(B, LOW);
    digitalWrite(B_bar, HIGH);
    delay (x);
    digitalWrite(A, HIGH);
    digitalWrite(A_bar, LOW);
    digitalWrite(B, HIGH);
    digitalWrite(B_bar, LOW);
    delay (x);
}

pour finir , je vous propose ci dessous une petite vidéo YouTube plus complete de la réalisation et des tests .