> ## 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.
# Sincronización de imágenes en varias cámaras
> Una guía sobre cómo sincronizar cámaras stellarHD.
***¡Esta documentación aún se está mejorando y está en construcción!***
Se requiere sincronización **eléctrica** y **por software**. Consulta las instrucciones detalladas a continuación.
# Guía de cableado eléctrico
## Descripción general
Este modo está diseñado para configuraciones **que no utilizan una señal de reloj externa**.
Utilizarás una cámara en modo `leader` (emitiendo una señal de sincronización) y todas las cámaras restantes en modo `follower`.
Haz clic aquí para consultar nuestra guía sobre cómo actualizar tu cámara entre los modos Leader y Follower.
***
## Cableado
### Ejemplo
## Descripción general
Este modo está diseñado para configuraciones **que utilizan una señal de reloj externa** para emitir la señal de sincronización a todas las cámaras.
En este modo, todas las cámaras deben estar configuradas en modo `follower`.
Haz clic aquí para consultar nuestra guía sobre cómo actualizar tu cámara entre los modos Leader y Follower.
***
## Cableado
Consulta la página de tu dispositivo específico para conocer las especificaciones de sincronización de imagen externa.
***
## Generación de la señal de reloj externa
### Integración con Arduino
La **Arduino Uno (ATmega328P)** es actualmente la única placa *confirmada* que funciona con esta configuración.
Descarga el código fuente de la biblioteca PWM aquí: [ArduinoPWM v1.0.0](https://github.com/DeepWaterExploration/ArduinoPWM/archive/refs/tags/v1.0.0.zip)
Importa la biblioteca `.ZIP` descargada en tu Arduino IDE.
Sube uno de los dos sketches siguientes a tu Arduino.
* **Control simple:** la forma más rápida de comenzar, pero requiere volver a flashear el firmware para ajustar tus FPS.
* **Control por serial:** te permite ajustar la frecuencia y el ciclo de trabajo en tiempo real sin volver a flashear (los ajustes se restablecerán si el dispositivo pierde alimentación).
```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).");
}
}
}
```
Este código te permite modificar la señal PWM sobre la marcha. Abre tu monitor serial a `9600` baudios y envía comandos con el formato `{FRECUENCIA},{CICLO_DE_TRABAJO}` (por ejemplo, `60,50` para 60 Hz con un ciclo de trabajo del 50%).
***
## Biblioteca de video sincronizado en Python (Linux)
Además de nuestro próximo SDK, actualmente proporcionamos un proceso sencillo en Python para obtener fotogramas sincronizados desde tus configuraciones de cámara. *(Nota: esto podría eliminarse en favor del SDK completo en el futuro.)*
Sigue nuestra guía en GitHub para instalar y usar nuestra biblioteca personalizada de Python para Linux.
***
## Video unido y sincronizado
Esto explicará cómo usar GStreamer para sincronizar y unir dos flujos de video.
Luego, crear un dispositivo virtual para usarlo en otros programas.
Instala las dependencias necesarias con el siguiente comando:
```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
```
Ejecuta el siguiente comando para encontrar tus cámaras conectadas:
```bash theme={null}
v4l2-ctl --list-devices
```
**Ejemplo de salida:**
```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
```
Identifica los IDs de dispositivo de las dos cámaras que quieres usar y selecciona un número de ID de dispositivo que **no** aparezca actualmente en la lista.
En este ejemplo, usaremos `9` (ya que no está en uso arriba) para crear un dispositivo virtual llamado `stellarHD_stitched`. Actualiza el `9` en el comando siguiente para que coincida con tu ID sin usar elegido:
```bash theme={null}
sudo modprobe v4l2loopback video_nr=9 \
card_label=stellarHD_stitched exclusive_caps=1
```
Inicia el pipeline para crear el video unido y enviar el flujo a tu nuevo dispositivo virtual:
```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
```
Debes mantener este comando en ejecución mientras utilices los videos unidos y sincronizados. Puedes modificar este comando para añadir más cámaras, cambiar resoluciones/frecuencias de imagen o modificar el diseño.
Sigue nuestro código de ejemplo para usar `/dev/video9` en OpenCV.
Para eliminar de forma segura el dispositivo loopback, puedes reiniciar tu computadora o ejecutar la siguiente secuencia de comandos:
**1. Identifica los programas que actualmente usan el dispositivo loopback:**
```bash theme={null}
sudo lsof /dev/video*
```
**2. Termina los procesos usando sus números PID (Process ID):**
```bash theme={null}
sudo kill
```
**3. Elimina el dispositivo loopback:**
```bash theme={null}
sudo modprobe -r v4l2loopback
```