Skip to main content

Étape 2 : Hardware x Software

0La deuxième étape dans la fabrication du système consiste à mettre en place le système de capture. Dans cette section, nous allons créer un environnement virtuel, installer les bibliothèques nécessaires pour le travail, et ajouter des notes supplémentaires sur chaque composant.

Pour se cultiver

pip est utilisé pour télécharger et installer des paquets directement depuis PyPI (Python Package Index), hébergé par la Python Software Foundation. Il s'agit d'un gestionnaire de paquets spécialisé exclusivement pour les paquets Python.

apt-get, en revanche, est utilisé pour télécharger et installer des paquets depuis les dépôts Ubuntu hébergés par Canonical.

Voici quelques différences clés entre l'installation des paquets Python avec apt-get et pip :

1. Disponibilité des Paquets: Canonical fournit des paquets pour un ensemble sélectionné de modules Python. En revanche, PyPI héberge une gamme beaucoup plus large de modules Python. Par conséquent, de nombreux modules Python ne peuvent pas être installés via apt-get mais sont disponibles sur PyPI.

2. Contrôle des Versions : Canonical héberge généralement une seule version de chaque paquet (généralement la plus récente ou celle sortie récemment). Avec apt-get, vous ne pouvez pas choisir quelle version d'un paquet Python installer. En revanche, pip vous permet d'installer n'importe quelle version d'un paquet précédemment téléchargé sur PyPI. Cette flexibilité est essentielle pour gérer les conflits de dépendances.

3. Portée de l'Installation : apt-get installe les modules Python de manière globale sur le système, ce qui signifie qu'ils sont disponibles globalement. Cela peut entraîner des conflits si différents projets nécessitent différentes versions du même paquet. pip résout ce problème en installant les paquets dans l'environnement virtuel du projet (virtualenv). Cette isolation garantit que les dépendances sont gérées indépendamment pour chaque projet.

4. Conventions de Nom de Paquet : Canonical nomme généralement les paquets Python 2 comme `python-<nom_du_paquet>` et les paquets Python 3 comme `python3-<nom_du_paquet>`. En revanche, pip simplifie l'installation des paquets en utilisant `<nom_du_paquet>` pour les paquets Python 2 et Python 3.

Choix entre apt-get et pip:

apt-get et pip sont tous deux des gestionnaires de paquets matures qui gèrent la résolution des dépendances lors de l'installation. Vous pouvez utiliser l'un ou l'autre en fonction de vos préférences. Cependant, envisagez d'utiliser **pip** dans les scénarios suivants :
- Lorsque vous avez besoin d'installer une version spécifique d'un paquet Python.
- Lorsque vous souhaitez installer des paquets dans l'environnement virtuel d'un projet.
- Lorsque le paquet dont vous avez besoin n'est disponible que sur PyPI.

Si vous êtes à l'aise avec l'installation de paquets globalement et qu'il n'y a pas de conflits de versions, apt-get ou pip conviendront pour l'installation générale de paquets Python.

C'est quoi un Environment Virtuelle  :https://www.geeksforgeeks.org/python-virtual-environment/

Installation d'un Environment Virtuelle

On utilisera pip depuis un environnement virtuel pour installer les bibliothèques.

Une fois connecté à votre Raspberry Pi via SSH:

Étape 1 : Naviguer vers votre répertoire de projet

Accédez au répertoire où vous souhaitez créer votre environnement virtuel, ex :

/home/pi/Desktop/scripts


Étape 2 : Créer l'environnement virtuel

Utilisez la commande `python3 -m venv venv` pour créer un environnement virtuel. Remplacez `venv` par le nom que vous souhaitez donner à votre environnement virtuel.

python3 -m venv venv

Étape 3 : Activer l'environnement virtuel

source venv/bin/activate


Étape 4 : Déactiver l'environnement virtuel

Vous ne pourriez pas lancer le code si environnement virtuelle est déactiver

deactivate
Étape 5 : Installer les modules requis

Si pip n'est pas déjà installé sur votre système, vous pouvez l'installer en utilisant la commande adaptée à votre distribution Linux. Par exemple

sudo apt-get install python3-pip

puis 

pip install adafruit-circuitpython-rgb-display
pip install adafruit-blinka busio digitalio
pip install opencv-python
pip install pillow

verifier les bibliothèques installées 

(venv) pi@raspberrypi:~/Desktop/scripts $ pip list
Package                                  Version
---------------------------------------- ---------
Adafruit-Blinka                          8.45.0
adafruit-circuitpython-busdevice         5.2.9
adafruit-circuitpython-connectionmanager 3.1.1
adafruit-circuitpython-requests          4.1.1
adafruit-circuitpython-rgb-display       3.12.4
adafruit-circuitpython-typing            1.10.3
Adafruit-PlatformDetect                  3.71.0
Adafruit-PureIO                          1.1.11
binho-host-adapter                       0.1.6
numpy                                    2.0.0
opencv-python                            4.10.0.84
pillow                                   10.3.0
pip                                      23.0.1
pyftdi                                   0.55.4
pyserial                                 3.5
pyusb                                    1.2.1
RPi.GPIO                                 0.7.1
rpi-ws281x                               5.0.0
setuptools                               66.1.1
sysv-ipc                                 1.1.0
typing_extensions                        4.12.2

Le code réel

vous pouvez installed le code depuis le Git ou bien depuis la(_--__) , sauvegarder tous les fichiers dans un repertoitre ex : scripts 

puis rendez les fichiers exécutable avec par exemple :

chmod -R +x os5
Bref, explications des fichiers.
(venv) pi@raspberrypi:~/Desktop/scripts $ ls
camera_feed_test.py  camera_properties.txt  os1  os2  os3  os4  os5  venv

camera_feed_test.py est utilisé pour tester les différentes capacités de votre caméra. Nous allons apprendre ensuite comment les trouver et les stocker dans un fichier, par exemple : camera_properties.txt. Les fichiers os1...5 sont les différentes itérations du système. Nous allons nous concentrer uniquement sur os5.Pour plus d'informations à propos des autres systèmes d'exploitation, veuillez consulter le rapport complet.

(venv) pi@raspberrypi:~/Desktop/scripts/os5 $ ls
button.py  camera.py  draw.py  main.py  menu.py  __pycache__  rotary_encoder.py  screen.py

Vous pouvez trouver une documentation de chaque classe dans les fichiers à la fin.

button.py :

Ce fichier contient la classe responsable du contrôle du bouton. Dans cette version, on peut détecter des clics simples et des clics longs de 6 secondes.secondes, Accéaccédez au fichier pour modifier cela.cette durée. Plus d'infos dans le rapport

Veuillez n'utiliser que le pin GPIO3 pour le bouton, car il servira à allumer et éteindre le système avec le même bouton.

rotary_encoder.py

Ce fichier contient la classe responsable du contrôle de l'encodeur rotatif. Pour plus d'imnfoinformations sur les preoblemesproblèmes rencontreesrencontrés, veuillez visiterconsulter le rapportrapport. .Pas de préférence sur les GPIO pins.

screen.py :

Ce fichier contient la classe responsable d'initialiser l'écran. On utilise l'interface SPI0 pour communiquer avec l'écran, c'est pourquoi nous avons besoin de l'activer au préalable. Pour changer les GPIO utilisés, vous devez accéder directement à la classe et les modifier. Cette classe ne prend pas les pins comme argument, contrairement aux classes `button` et `rotary_encoder`.

Comment activer l'interface SPI

Depuis un terminal tapez cette commande 

sudo raspi-config

rc_cmd_main_interfacing.png

Naviguez vers 'Interfacing Options' puis sélectionnez 'SPI' , activez le , puis rebootez le système

rc_cmd_interfacing_spi.png 

camera.py :

Ce fichier contient la classe CameraCamera, responsabelresponsable de la capture videovidéo et de l'enregistrementson d'euxenregistrement.

comments trouvez les caractéristiques de votre caméra 

(Consultez le rapport pour plus d'informations à propos de la caméra.)

https://www.mankier.com/1/v4l2-ctl


Listez tous les périphériques vidéo :

'v4l2-ctl --list-devices'

(venv) pi@raspberrypi:~/Desktop/scripts/os5 $ v4l2-ctl --list-devices
bcm2835-codec-decode (platform:bcm2835-codec):
        /dev/video10
        /dev/video11
        /dev/video12
        /dev/video18
        /dev/video31
        /dev/media2

bcm2835-isp (platform:bcm2835-isp):
        /dev/video13
        /dev/video14
        /dev/video15
        /dev/video16
        /dev/video20
        /dev/video21
        /dev/video22
        /dev/video23
        /dev/media0
        /dev/media1

HD Webcam C525 (usb-3f980000.usb-1.2):
        /dev/video0
        /dev/video1
        /dev/media3

Détectez votre appareil, puis :

Lister les formats vidéo supportés et les résolutions d'un périphérique vidéo spécifique :

'v4l2-ctl --list-formats-ext --device path/to/video_device'

(venv) pi@raspberrypi:~/Desktop/scripts/os5 $ v4l2-ctl --list-formats-ext --device /dev/video0
ioctl: VIDIOC_ENUM_FMT
        Type: Video Capture

        [0]: 'YUYV' (YUYV 4:2:2)
                Size: Discrete 640x480
                        Interval: Discrete 0.033s (30.000 fps)
                        Interval: Discrete 0.042s (24.000 fps)
                        Interval: Discrete 0.050s (20.000 fps)
                        Interval: Discrete 0.067s (15.000 fps)
                        Interval: Discrete 0.100s (10.000 fps)

Maintenant copier toutes ces informations dans un fichier .txt  et tester les avec camera_feed_test.py

def main():
    # Initialize the camera (0 is the default camera)
    cap = cv2.VideoCapture(0)
    #set the video dimensions(resolution)
    cap.set(cv2.CAP_PROP_FRAME_WIDTH, 800)
    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 448)

    # Set the frame rate
    #cap.set(cv2.CAP_PROP_FPS, 24)
    
    if not cap.isOpened():
        print("Error: Could not open video capture.")
        return

    w=cap.get(3)
    h=cap.get(4)
    print('width=',w)
    print('height=',h)
    print('capturing fps = ',cap.get(5))

Quoi choisir et comment :  Testez tous les formats, commencez par changer cv2.CAP_PROP_FRAME_WIDTH et cv2.CAP_PROP_FRAME_HEIGHT dans camera_feed_test.py. Ensuite, vérifiez à combien de FPS vous enregistrez. Notez tout cela dans une feuille quelque part, puis choisissez parmi toutes les options testées les plus pertinentes pour vous. Par exemple, nous avons choisi 5 options de:

:

pour plus d'info a propos de ces choix visiter le rapport complet.


enfinEnfin, ouvrez votre fichier `camera.pypy` et modifiermodifiez le tragetchemin de sauvegarde de vos videosvidéos dans la methodeméthode 'set_rec_settings'`set_rec_settings`. ,Par par exmpleexemple, nous avons choisi : '`/home/pi/Desktop/videos' videos`.

def set_rec_settings(self,wfps,dimensions):
        self.video.set(cv.CAP_PROP_FRAME_WIDTH,dimensions[0])
        self.video.set(cv.CAP_PROP_FRAME_HEIGHT, dimensions[1])
        self.result = cv.VideoWriter(
                        os.path.join('/home/pi/Desktop/videos', f'{self.file}__{dimensions[0]}x{dimensions[1]}.avi'), 
                        cv.VideoWriter_fourcc(*'XVID'),wfps, dimensions)

Pour plus d'info a propos des choix de fichier et de sauvegarde , je vous invite a regarder le rapport finale.finaleet d'info a propos de ces choix visiter le rapport complet.(Consultez le rapport pour plus d'informations à propos de la caméra.)

Draw.py

ce fichier contient la classe Draw qui est responsable de 'creer les graphique pour le menu ' Chaque instance ne peux creer qu'une seul image , alors pour creer plusieur images et les afficher ( a la place de creer la meme image a chauqe fois) on a besoin de creer des instances de cette Classe autant de fois qu'on veux d'image.Plus d'info a la fin 

menu.py 

La classe Menu est respnsable pour integrer tous les parties du systemes ensemble . Vous pouvez trouvez plus d'info sur elle dans le rapport complet 

main.py 

 Ce fichier contient la loop principale de ce systeme , ce fichier sera runed pour marcher le system

def main():
    # Initialize the screen, draw, molette, and button
    screen = Screen()
    draw0=Draw(user_id="user 123",height=screen.height,width=screen.width)
    draw1=Draw(user_id="user 123",height=screen.height,width=screen.width)
    draw2=Draw(user_id="user 123",height=screen.height,width=screen.width)
    draw3=Draw(user_id="user 123",height=screen.height,width=screen.width)

    camera=Camera()
    button=Button(pin=3)
    molette=RotaryEncoder(clk_pin=board.D27, dt_pin=board.D22)
    
    # Initialize the menu
    menu = Menu(screen, draw0,draw1,draw2,draw3, molette, button,camera)
    
    # Add menu items
    menu.add_item("1 min",wfps=10,dimensions=(800,448),char='@ W I D E  V G A ',mode= 'S L O W  M O T I O N')
    menu.add_item("5 min",wfps=22,dimensions=(800,600),char='@ S U P E R   V G A ',mode='N O R M A L')
    menu.add_item("30 min",wfps=28,dimensions=(800,448),char='@ W I D E  V G A ',mode='E C O  -  N O R M A L')

    menu.add_item("1 h",wfps=100,dimensions=(1920,1080),char='@ F U L L  H D' ,mode=' T I M E - L A P S E ')

    menu.add_item("3 h",wfps=600,dimensions=(1280,720),char='@ H D',mode='E C O  -  T I M E - L A P S E ')
    
    #menu.add_item("C A M  V I E W ")
    
    menu.menu_0()
    #menu.menu_1()
    menu.menu_3()

maintenant etape finale pour le code c'est d'apporter les changement finale a ce fichier:

1-changer les options de votre menu  comme indiquer , les dimensions dependentent des caracteristique de votre camera que vous avez choisi precedement ,

2-wfps:ATTENTION w-fps n'est pas la frequence de capture de votre camera mais la frequence d'ecriture de votre caemra 

en resumer pour les mode Time Lapse vous voulez une frequence d'ecriture >> que la frequence de capture , ex pour nous : 720x1280 , frequence de capture =10 , frequence d'ecriture = 600

pour les modes normale , vous devez chercher une frequence d'ecriture ~= frequence de capture 

pour les slow-motion vous chercher une frequence d'ecriture < frequene de capture ex , chex nous 30 FPs de capture et 10 Fps d'ecriture 

Pour plus d'info a propos des frequence de capture visiter le rapport finale section 

3-Enfin changer les pins de votre encodeur rotatif selon vos preference 

Assembler le Systeme

  • Rotary Encoder + Button:

    • VCC = 5V
    • Ground = Ground
    • SW = GPIO3
    • CLK = GPIO27(votre choix)
    • DT = GPIO22(votre choix)
  • Screen:

    • VCC = 3.3V
    • Ground = Ground
    • SCL = GPIO11 (SCLK)
    • SDA = GPIO10 (MOSI)
    • DC = GPIO23(votre choix)
    • RES = GPIO24(votre choix)
    • CS = GPIO8 (CE0)

connections.png

Testez

Maintenant que tous es pret , tester votre system , les fichier , screen.py , rotary_encoder.py et button.py contiennent tous des codes pour vous aidez a verifier que vos composants marche bien , vous pouvez les lancez et testez , pour testez le system complet lancez main.py

(Votre environement virtuelle doit etre active)

python3 rotary_encoder.py
python3 button.py
python3 screen.py

Les classes