> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dwe.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Synchronisation des images entre plusieurs caméras
> Un guide expliquant comment synchroniser les caméras stellarHD.
***Cette documentation est encore en cours d'amélioration et de construction !***
Les synchronisations **électrique** et **logicielle** sont toutes deux nécessaires. Voir ci-dessous pour des instructions détaillées.
# Guide de câblage électrique
## Présentation
Ce mode est conçu pour les configurations **n'utilisant pas de signal d'horloge externe**.
Vous utiliserez une caméra en mode `leader` (émettant un signal de synchronisation) et toutes les autres caméras en mode `follower`.
Cliquez ici pour consulter notre guide sur la mise à jour de votre caméra entre les modes Leader et Follower.
***
## Câblage
### Exemple
## Présentation
Ce mode est conçu pour les configurations **utilisant un signal d'horloge externe** afin de fournir le signal de synchronisation à toutes les caméras.
Dans ce mode, toutes les caméras doivent être réglées en mode `follower`.
Cliquez ici pour consulter notre guide sur la mise à jour de votre caméra entre les modes Leader et Follower.
***
## Câblage
Consultez la page produit de votre appareil pour connaître les spécifications de synchronisation externe.
***
## Génération du signal d'horloge externe
### Intégration Arduino
L'**Arduino Uno (ATmega328P)** est actuellement la seule carte *confirmée* fonctionnant pour cette configuration.
Téléchargez le code source de la bibliothèque PWM ici : [ArduinoPWM v1.0.0](https://github.com/DeepWaterExploration/ArduinoPWM/archive/refs/tags/v1.0.0.zip)
Importez la bibliothèque `.ZIP` téléchargée dans votre IDE Arduino.
Téléversez l'un des deux sketches ci-dessous sur votre Arduino.
* **Contrôle simple :** le moyen le plus rapide pour démarrer, mais nécessite de reprogrammer le firmware pour ajuster vos FPS.
* **Contrôle série :** vous permet d'ajuster la fréquence et le rapport cyclique en temps réel sans reprogrammer (les paramètres seront réinitialisés si l'appareil perd l'alimentation).
```cpp theme={null}
#include
// Pin configuration
int pin = 9; // Pin
int value = 127; // Initial value for the PWM duty cycle
// SET FREQUENCY HERE
float frequency = 60; // Initial frequency in Hz
void setup()
{
// Initialize all timers except for timer0 to save timekeeping tasks
InitTimersSafe();
// Set the initial PWM frequency and duty cycle
if (SetPinFrequencySafe(pin, frequency))
{
pwmWrite(pin, value);
Serial.println("PWM frequency and initial duty cycle set.");
}
else
{
Serial.println("Failed to set frequency.");
}
}
```
```cpp theme={null}
#include
// Pin configuration
int pin = 9; // Pin
int value = 127; // Initial value for the PWM duty cycle
float frequency = 60; // Initial frequency in Hz
void setup()
{
Serial.begin(9600);
// Initialize all timers except for timer0 to save timekeeping tasks
InitTimersSafe();
// Set the initial PWM frequency and duty cycle
if (SetPinFrequencySafe(pin, frequency))
{
pwmWrite(pin, value);
Serial.println("PWM frequency and initial duty cycle set.");
}
else
{
Serial.println("Failed to set frequency.");
}
}
void loop()
{
if (Serial.available())
{
// Read frequency and duty cycle values over Serial
String inputString = Serial.readStringUntil('\n');
inputString.trim();
int freqDutySplitIndex = inputString.indexOf(',');
if (freqDutySplitIndex != -1)
{
String freqStr = inputString.substring(0, freqDutySplitIndex);
String dutyStr = inputString.substring(freqDutySplitIndex + 1);
// Parse floats
float newFrequency = freqStr.toFloat();
int newDutyCycle = dutyStr.toInt();
// Validate frequency range
if (newFrequency >= 1 && newFrequency <= 2000000)
{
// Set the PWM frequency and apply duty cycle
if (SetPinFrequencySafe(pin, newFrequency))
{
value = map(constrain(newDutyCycle, 0, 100), 0, 100, 0, 255);
pwmWrite(pin, value);
Serial.print("Set frequency to: ");
Serial.print(newFrequency);
Serial.print(" Hz, duty cycle to: ");
Serial.print(newDutyCycle);
Serial.println("%");
}
else
{
Serial.println("Failed to set new frequency.");
}
}
else
{
Serial.println("Invalid frequency value.");
}
}
else
{
Serial.println("Invalid input format. Use frequency,dutycycle (e.g., 60,50).");
}
}
}
```
Ce code vous permet de modifier le signal PWM à la volée. Ouvrez votre moniteur série à `9600` bauds et envoyez des commandes au format `{FREQUENCE},{RAPPORT_CYCLIQUE}` (par exemple, `60,50` pour 60 Hz avec un rapport cyclique de 50%).
***
## Bibliothèque Python de vidéo synchronisée (Linux)
En complément de notre SDK à venir, nous proposons actuellement un simple processus Python pour récupérer des images synchronisées depuis vos configurations de caméras. *(Remarque : cela pourrait être progressivement abandonné au profit du SDK complet à l'avenir.)*
Suivez notre guide GitHub pour installer et utiliser notre bibliothèque Python personnalisée pour Linux.
***
## Vidéo synchronisée et assemblée (stitched)
Cette section présente l'utilisation de GStreamer pour synchroniser et assembler deux flux vidéo.
Ensuite, la création d'un périphérique virtuel à utiliser dans d'autres programmes.
Installez les dépendances nécessaires avec la commande suivante :
```bash theme={null}
sudo apt install -y libx264-dev libjpeg-dev \
libglib2.0-dev libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev \
gstreamer1.0-tools gstreamer1.0-x gstreamer1.0-plugins-base gstreamer1.0-plugins-good \
gstreamer1.0-plugins-bad gstreamer1.0-libav libgstreamer-plugins-bad1.0-dev \
gstreamer1.0-plugins-ugly gstreamer1.0-gl \
v4l-utils
```
Exécutez la commande suivante pour trouver vos caméras connectées :
```bash theme={null}
v4l2-ctl --list-devices
```
**Exemple de sortie :**
```text theme={null}
stellarHD Leader: stellarHD Lea (usb-0000:00:14.0-8.3):
/dev/video0
/dev/video1
/dev/media0
stellarHD Follower: stellarHD F (usb-0000:00:14.0-8.4):
/dev/video2
/dev/video3
/dev/media1
```
Identifiez les ID de périphérique des deux caméras que vous souhaitez utiliser, puis sélectionnez un numéro d'ID qui n'est **pas** déjà listé.
Dans cet exemple, nous utiliserons `9` (puisqu'il n'est pas utilisé ci-dessus) pour créer un périphérique virtuel nommé `stellarHD_stitched`. Mettez à jour le `9` dans la commande ci-dessous pour correspondre à votre ID non utilisé :
```bash theme={null}
sudo modprobe v4l2loopback video_nr=9 \
card_label=stellarHD_stitched exclusive_caps=1
```
Lancez le pipeline pour créer la vidéo assemblée et envoyer le flux vers votre nouveau périphérique virtuel :
```bash theme={null}
gst-launch-1.0 -v \
compositor name=mix \
sink_0::xpos=0 sink_0::ypos=0 sink_0::alpha=1 \
sink_1::xpos=1600 sink_1::ypos=0 sink_1::alpha=1 \
! jpegenc ! jpegdec ! videoconvert ! v4l2sink device=/dev/video9 \
v4l2src device=/dev/video0 ! image/jpeg,width=1600,framerate=60/1 ! jpegdec ! videorate ! mix.sink_0 \
v4l2src device=/dev/video2 ! image/jpeg,width=1600,framerate=60/1 ! jpegdec ! videorate ! mix.sink_1
```
Vous devez garder cette commande en cours d'exécution pendant l'utilisation des vidéos synchronisées et assemblées. Vous pouvez modifier cette commande pour ajouter d'autres caméras, changer les résolutions/fréquences d'images ou modifier la disposition.
Suivez notre exemple de code pour utiliser `/dev/video9` dans OpenCV.
Pour supprimer en toute sécurité le périphérique loopback, vous pouvez soit redémarrer votre ordinateur, soit exécuter la séquence de commandes suivante :
**1. Identifiez les programmes utilisant actuellement le périphérique loopback :**
```bash theme={null}
sudo lsof /dev/video*
```
**2. Tuez les processus à l'aide de leur numéro de PID (Process ID) :**
```bash theme={null}
sudo kill
```
**3. Supprimez le périphérique loopback :**
```bash theme={null}
sudo modprobe -r v4l2loopback
```