> ## 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.
# Sincronizando quadros de várias câmeras
> Um guia sobre como sincronizar câmeras stellarHD.
***Esta documentação ainda está sendo aprimorada e em construção!***
Tanto a sincronização **elétrica** quanto a **por software** são necessárias. Veja abaixo instruções detalhadas.
# Guia de fiação elétrica
## Visão geral
Este modo foi projetado para configurações **que não utilizam um sinal de clock externo**.
Você utilizará uma câmera no modo `leader` (emitindo um sinal de sincronização) e todas as demais câmeras no modo `follower`.
Clique aqui para ver nosso guia sobre como alternar sua câmera entre os modos Leader e Follower.
***
## Fiação
### Exemplo
## Visão geral
Este modo foi projetado para configurações **usando um sinal de clock externo** para gerar o sinal de sincronização para todas as câmeras.
Neste modo, todas as câmeras devem estar configuradas no modo `follower`.
Clique aqui para ver nosso guia sobre como alternar sua câmera entre os modos Leader e Follower.
***
## Fiação
Consulte a página do produto específico do seu dispositivo para conhecer as especificações de sincronização de quadros externa.
***
## Geração do sinal de clock externo
### Integração com Arduino
O **Arduino Uno (ATmega328P)** é atualmente a única placa *confirmada* como funcional para esta configuração.
Baixe o código-fonte da biblioteca PWM aqui: [ArduinoPWM v1.0.0](https://github.com/DeepWaterExploration/ArduinoPWM/archive/refs/tags/v1.0.0.zip)
Importe a biblioteca `.ZIP` baixada no seu Arduino IDE.
Faça o upload de um dos dois sketches abaixo para o seu Arduino.
* **Controle simples:** A maneira mais rápida de começar, mas requer reprogramar o firmware para ajustar o FPS.
* **Controle via serial:** Permite ajustar frequência e ciclo de trabalho em tempo real sem reprogramar (as configurações serão reiniciadas se o dispositivo perder energia).
```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 permite modificar o sinal PWM em tempo real. Abra o monitor serial em `9600` baud e envie comandos usando o formato `{FREQUENCY},{DUTY_CYCLE}` (por exemplo, `60,50` para 60Hz com ciclo de trabalho de 50%).
***
## Biblioteca Python de vídeo sincronizado (Linux)
Além do nosso SDK que está por vir, atualmente fornecemos um processo simples em Python para capturar quadros sincronizados de suas configurações de câmera. *(Observação: Isso pode ser descontinuado em favor do SDK completo no futuro.)*
Siga nosso guia no GitHub para instalar e usar nossa biblioteca Python personalizada para Linux.
***
## Vídeo sincronizado e mesclado
Isto explica como usar o GStreamer para sincronizar e mesclar dois feeds de vídeo.
Depois, criar um dispositivo virtual para usar em outros programas.
Instale as dependências necessárias usando o seguinte 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
```
Execute o seguinte comando para encontrar as câmeras conectadas:
```bash theme={null}
v4l2-ctl --list-devices
```
**Exemplo de saída:**
```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
```
Identifique os IDs de dispositivo das duas câmeras que deseja usar, depois selecione um número de ID de dispositivo que **não** esteja listado atualmente.
Neste exemplo, usaremos `9` (já que não está sendo usado acima) para criar um dispositivo virtual chamado `stellarHD_stitched`. Atualize o `9` no comando abaixo para corresponder ao ID não usado que você escolher:
```bash theme={null}
sudo modprobe v4l2loopback video_nr=9 \
card_label=stellarHD_stitched exclusive_caps=1
```
Inicie o pipeline para criar o vídeo mesclado e enviar o stream para o seu novo 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
```
Você deve manter este comando em execução enquanto usa os vídeos sincronizados e mesclados. Você pode modificar este comando para adicionar mais câmeras, alterar resoluções/taxas de quadros ou modificar o layout.
Siga nosso código de exemplo para usar `/dev/video9` no OpenCV.
Para remover com segurança o dispositivo de loopback, você pode reiniciar o computador ou executar a seguinte sequência de comandos:
**1. Identifique os programas que estão usando o dispositivo de loopback:**
```bash theme={null}
sudo lsof /dev/video*
```
**2. Encerre os processos usando seus números de PID (Process ID):**
```bash theme={null}
sudo kill
```
**3. Remova o dispositivo de loopback:**
```bash theme={null}
sudo modprobe -r v4l2loopback
```