PAUSES LONGUES avec une PI cam HQ

la dernière née des PI camera , outre une meilleure définition (4056 x 3040) offre la possibilité de faire des pauses longues jusqu’à 200 secondes pour l’astrophotographie du ciel profond . nous allons voir comment exploiter ces capacités en Python.

tout d’abord petit rappel des caractéristiques des différentes PIcam dans le tableau comparatif ci dessous:

voyons un premier petit bout de programme python basique utilisant les propriétés pause longue de la bibliothèque Pi camera.

import picamera
from time import sleep
from fractions import Fraction

camera = picamera.PiCamera()

# camera en resolution max
camera.resolution=(4056, 3040)
# framerate a 6s
camera.framerate =Fraction(1,6)
# capteur en mode Pause longue (mode 3) 
camera.sensor_mode=3
# vitesse d'obturation a 6 secondes
camera.shutter_speed = 6000000
#sensibilite ISO a 800 pour un gain maximum en condition nocturnes
camera.iso = 800
# pause de 10 secondes pour balance des blanc auto
sleep(10)
# exposure mode off pour figer les parametres balance des blanc et gain
camera.exposure_mode = 'off'
#prise de vue et sauvegarde sous le nom 'pauselongue.jpg'
camera.capture('pauselongue.jpg')

la version txt a télécharger n’a pas les commentaire et se réduit donc a 12 lignes , ce qui permet de voir qu’avec quelques simples lignes de commandes python on peut déclencher une prise de vue pause longue de 6 secondes a 800 ISO et sauvegarder le fichier résultant.

outre le fait que l’on peut paramétrer tout un tas de valeurs de reglage ( gain, AWB, ISO, résolution, shuter speed, etc …) . il est important de noter que la vitesse d’obturation (shutter speed ) est en fait dépendante directement du framerate. il est donc indispensable de ne jamais dissocier les deux => donc on défini systématiquement le framerate avec la fonction Fraction , et ensuite le shutter speed a l’identique avec la même valeur x 1000000.

deuxime chose importante a prendre en compte , ne pas oublier d’inclure une pause ( sleep(10) avant la prise de vue pour laisser le temps a la camera d’ajuster la balance des blancs en automatique. l’autre solution étant de fixer manuellement la valeur de balance des blancs et ainsi pouvoir se passer du sleep().

la PI camera HQ est fournie en standard avec un cadre fileté au pas de monture photo Type C . pour l’utiliser sur un telescope ou une lunette , il faut lui adjoindre un adaptateur d’oculaire au pas de la monture type C ( 11€ sur Amazone tarif mai 2021):

sur la base du premier programme , il est facile de programmer une sequence de prise de vues pause longue en automatique en ajoutant une boucle while avec increment et de numeroter automatiquement le nom du fichier a l’enregistrement :

import picamera
from time import sleep
from fractions import Fraction

camera = picamera.PiCamera()

camera.resolution=(4056, 3040)
camera.framerate =Fraction(1,6)
camera.sensor_mode=3
camera.shutter_speed = 6000000
camera.iso = 800
sleep(10)
camera.exposure_mode = 'off'

i=1
while i=< 5
	camera.capture('pauselongue' + str(i) +'.jpg')
	sleep(10)
	i=i+1

ce deuxieme programme fait donc une série de 5 photos en pause de 6 secondes chacune avec un temps d’attente de 10 secondes entre chaque photo.

sur ces bases et en utilisant Tkinter ( voir rubrique ICI et ICI ) il est possible de faire des menu et d’intégrer des boutons et sliders pour paramétrer le nombre de photos, le temps de pause , le temps interpose , la sensibilité ISO et tous les autres paramètres potentiels utilisables.

exemple d’une appli perso qui transforme la PI cam HQ en capteur multimode combinant Video / timelapse Photo / timelaps pauses longues, l’ensemble très pratique en mode nomade avec un ecran TFT HDMI touschscreen qui permet d’activer les sliders et boutons sans clavier ni souris …

a vos clavier pour developper vos appli perso ….

pour aller plus loin , voici le lien vers la documentation picamera:

https://picamera.readthedocs.io/en/release-1.13/index.html

PIcam et Webcam en même temps

afficher l’image simultanée d’une PIcam et d’une webcam USB avec un bout de Python c’est possible , le programme est extrêmement simple:

copier le petit morceau de python ci dessous dans votre éditeur python et lancez le (votre PICAM doit etre raccordée a son slot et une webcam raccordée au RPI en USB), vous devriez voir 2 fenêtres s’ouvrir dans votre écran avec chacune la vidéo de la camera concernée a l’intérieur.

ce programme nécessite d’avoir installé au préalable la librairie python “OpenCV”.

import cv2

cap0=cv2.VideoCapture(0) #sortie 0 Picam
cap1=cv2.VideoCapture(1) #sortie 1 Webcam USB

while True:
    ret, frame0 = cap0.read()
    ret, frame1 = cap1.read()
    cv2.imshow("PIcam", frame0)
    cv2.imshow("USBcam", frame1)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

NOTA1: les numéros de sorties a utiliser (ici sortie 0 et sortie 1 ) sont fonctionnels dans la majorité des cas. mais si vous rencontrez des problèmes , utiliser la commande shell “lsusb” pour déterminer quelles sorties du RPI sont utilisées.

NOTA2:il est possible d’ajouter d’autres webcam , pour cela il suffit d’implémenter autant de lignes dédié ( capx , ret, et cv2.imshow) que de flux video souhaité.

ce type d’utilisation en astro , permet par exemple d’utiliser une Webcam USB en autoguidage et la PIcam HQ en prise de vue pause longue ou en vidéo planetaire . une autre utilisation potentielle avec plusieurs Wab cam serait pour la video surveillance exterieure et interieure d’un observatoire en combinaison avec de la detection de mouvement et un envoi automatique de photo par mail …

AMELIORATION: voyons comment redimensionner et positionner les 2 fenêtres d’affichage

import cv2

cap0=cv2.VideoCapture(0) #sortie 0 Picam
Picamwin="PIcam"    # nom de la fenetre PIcam
cv2.namedWindow(PIcamwin, cv2.WINDOW_NORMAL)
cv2.resizeWindow(PIcamwin, 600, 450)
cv2.moveWindow(PIcamwin, 420, 110)

cap1=cv2.VideoCapture(1) #sortie 1 Webcam USB
USBcamwin="USBcam"  # nom de la fenetre Webcam
cv2.namedWindow(USBcamwin,cv2.WINDOW_NORMAL)
cv2.resizeWindow(USBcamwin, 400, 300)
cv2.moveWindow(USBcamwin, 10, 260)

while True:
    ret, frame0 = cap0.read()
    ret, frame1 = cap1.read()
    cv2.imshow(PIcamwin", frame0)
    cv2.imshow(USBcamwin, frame1)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

voici un exemple du resultat du pgme ci dessus avec une PIcam sur son slot et une Webcam USB sur port USB, l’ensemble affiché sur un petit ecran HDMI touschscreen 7″ 1024×600 pixels .chacune des video est affichée en taille de fenetre differente et positionnées en bas et dans la largeur de l’ecran , permettant l’acces au menu du bureau du RPI . l’affichage avec des fenetres Opencv permet en outre d’avoir la vue video via VNC en acces distant . ce qui n’est pas possible avec les fenetres live view de la librairie Picam.

POLEMASTER en Python

tout le monde connait le prix d’un pole master, voyons ici comment faire le sien avec une webcam et un bout de python pour exploiter ça sur un raspberry PI.

Un polemaster est tout simplement une camera CCD commandée par un software qui affiche une mire d’alignement polaire comme par exemple la mire Skywatcher.

le principe est donc simple, il faut superposer une mire “graphique” sur la video d’une camera.

vous trouverez ci dessous un petit bout de programme Python qui affichera en temps réel la mire d’entête par dessus la vidéo d’une webcam.

pour la mise au point finale, il faudra faire des essai en fonction de la camera choisie , et de la focale de l’objectif monté dessus et ajuster les diametres et coordonnées des figures graphiques en fonction de vos besoins. l’idéal étant de se calibrer avec un viseur polaire optique type skywatcher . le principe fonctionne egalement avec une PIcam sur son slot , il suffit de changer le numéro de sortie ( en général 0 pour la PIcam) .

il faudra en préliminaire installer la librairie python computer Vision “OpenCV“. bien entendu , libre a vous de concevoir votre propre mire en utilisant les option d’openCV draw .

import cv2

cv2.namedWindow("POLARALIGN")
vc = cv2.VideoCapture(1)

if vc.isOpened(): # try to get the first frame
    rval, frame = vc.read()
else:
    rval = False
    
while rval:
    cv2.imshow("POLARALIGN", frame)
    rval, frame = vc.read()
    key = cv2.waitKey(20)
    if key == 27: # exit on ESC
        break
    else:
        cv2.circle(img=frame, center=(320, 210), radius=110, color=(0, 0, 255), thickness=3, lineType=8, shift=0)
        cv2.circle(img=frame, center=(320, 210), radius=120, color=(0, 0, 255), thickness=3, lineType=8, shift=0)
        cv2.line(img=frame, pt1=(320, 60), pt2=(320, 360), color=(255, 0, 0), thickness=2, lineType=8, shift=0)
        cv2.line(img=frame, pt1=(180, 210), pt2=(460, 210), color=(255, 0, 0), thickness=2, lineType=8, shift=0)
        cv2.line(img=frame, pt1=(220, 100), pt2=(420, 320), color=(0, 255, 255), thickness=2, lineType=8, shift=0)
        cv2.line(img=frame, pt1=(220, 320), pt2=(420, 100), color=(0, 255, 255), thickness=2, lineType=8, shift=0)        

vc.release()
cv2.destroyWindow("POLARALIGN")

Commande d’un APN reflex avec GPHOTO2

il est possible de commander et configurer un APN reflex moderne en remote via USB avec un Raspberry PI en utilisant la librairie GPHOTO2.cette option est très intéressante pour l’astro-photo, en particulier pour des time-laps en pauses longues. nous allons voir ici comment procéder.

le site internet dédié a Gphoto2 est accessible via ce lien: http://www.gphoto.org/

avant de poursuivre plus loin, il est important de verifier que votre APN reflexe est compatible avec la librairie, pour cela voir la liste ici:

liste des APN compatibles: http://www.gphoto.org/proj/libgphoto2/support.php

INSTRUCTION D’INSTALLATION

avant de pouvoir utiliser Gphoto2 il va falloir faire l’installation des prérequis et de la librairie elle même . ci dessous les instructions qui sont disponible dans le fichier joint en PDF pour pour pouvoir faire des copier coller des lignes de commandes.

PREREQUIS: installation des dependances:

sudo apt-get install git make autoconf libltdl-dev libusb-dev libexif-dev libpopt-dev libxml2-dev libjpeg-dev libgd-dev gettext autopoint

INSTALLATION DE libghoto2:

télécharger le code pour libgphoto2 ici: https://github.com/gphoto/libgphoto2.git

executer les commandes ci dessous pour installer libgphoto2

cd ~/libgphoto2
autoreconf --install --symlink
./configure
make
sudo make install

INSTALLATION DE ghoto2

télécharger le code pour gphoto2 ici: https://github.com/gphoto/gphoto2.git

executer les commandes ci dessous pour installer gphoto2

cd ~/gphoto2
autoreconf --install --symlink
./configure
make
sudo make install

MISE A JOUR DE LA CONFIGURATION RPI

ajouter la lignes ci dessous dans le fichierde configuration : /etc/ld.so.conf.d/libc.conf

/usr/local/lib

rafraichir le cache avant de continuer:

sudo ldconfig

créer les regles udev pour l’APN

/usr/local/lib/libgphoto2/print-camera-list udev-rules version 201 group plugdev mode 0660 | sudo tee /etc/udev/rules.d/90-libgphoto2.rules

créer la base de données pour udev

/usr/local/lib/libgphoto2/print-camera-list hwdb | sudo tee /etc/udev/hwdb.d/20-gphoto.hwdb

UTILISATION DE GPHOTO2

connecter votre APN reflex a votre RPI via son cordon USB et executer la commande shell ci dessous pour verifier que votre Gphoto2 detecte bien votre APN:

gphoto2 –auto-detect

si le nom de votre Appareil photo apparait après l’exécution de la commande c’est que tout est OK et vous pouvez aller plus loin et exécuter le premier test en prenant une photo. pour cela exécuter la commande shell ci dessous:

gphoto2 –capture-image

UTILISATION DE GPHOTO2 AVEC PYTHON

nous allons voir ici comment utiliser Gphoto2 via un programme python. pour cela , il faut d’abord installer le module python permettant d’encapsuler Gphoto2 . executer la commande:

sudo pip install -v gphoto2

nous allons maintenant écrire un petit programme Python qui permet de prendre une photo:

import logging
import os
import subprocess
import sys

import gphoto2 as gp

logging.basicConfig(
        format='%(levelname)s: %(name)s: %(message)s', level=logging.WARNING)
callback_obj = gp.check_result(gp.use_python_logging())

def get_camera():
    camera = gp.Camera()
    camera.init()
    return camera

def capture_image_from_dslr():
    camera = get_camera()
    capture_image(camera)
    camera.exit()
    return 0

def capture_image(camera):
    print('Capturing image')
    file_path = camera.capture(gp.GP_CAPTURE_IMAGE)
    print('Camera file path: {0}/{1}'.format(file_path.folder, file_path.name))
    target = os.path.join('/tmp', file_path.name)
    print('Copying image to', target)
    camera_file = camera.file_get(
        file_path.folder, file_path.name, gp.GP_FILE_TYPE_NORMAL)
    camera_file.save(target)
    return 0
  
  if __name__ == "__main__":
    sys.exit(capture_image_from_dslr())