External trigger not working on OAK-D-SR-POE

Hi Jaka,
Thanks for the help. Will try the suggestions on the FPS and queue size.
I still can't get triggering the TOF sensor directly to work. Can you share the code you used to test yourself? Or please check the code below; I tried to make it the most minimal combination of the tof_depth example and the external trigger example. This code for me just gives me continuous output with a warning "[warning] Device configured to generate sync, but no camera with sync output capability was started"
The triggering works if I change TOF to a MonoCamera.

#include <iostream>
#include <chrono>
#include <opencv2/opencv.hpp>
#include <depthai/depthai.hpp>
#include <windows.h>
#include <vector>
#include <string>
#include "depthai-shared/datatype/RawToFConfig.hpp"
#include "depthai/pipeline/datatype/ToFConfig.hpp"
#include <mutex>
#include <filesystem>
#include <stdexcept>

// Define the shared pointers and other variables
std::shared_ptr<dai::DataOutputQueue> qDepth;

dai::Pipeline pipeline;
std::shared_ptr<dai::node::ToF> tof;
dai::RawToFConfig tofConfig;
std::shared_ptr<dai::Device> device;


std::shared_ptr<dai::ToFConfig> createConfig(dai::RawToFConfig configRaw) {
    auto config = std::make_shared<dai::ToFConfig>();
    config->set(std::move(configRaw));
    return config;
}

cv::Mat getDepth() {
    auto imgFrame = qDepth->get<dai::ImgFrame>(); // blocking call, will wait until new data has arrived

    cv::Mat depthFrame = imgFrame->getFrame(true);

    return depthFrame;
}

cv::Mat convertToByte(const cv::Mat& frameDepth) {
    cv::Mat invalidMask = (frameDepth == 0);
    cv::Mat depthFrameScaled;
    try {
        double minDepth = 100.0;
        double maxDepth = minDepth + 255;

        cv::Mat rawDepth;
        frameDepth.convertTo(rawDepth, CV_32F);
        cv::medianBlur(rawDepth, rawDepth, 5);
        rawDepth = (rawDepth - minDepth) / (maxDepth - minDepth) * 255;
        rawDepth.convertTo(depthFrameScaled, CV_8UC1);
        depthFrameScaled.setTo(cv::Scalar(0, 0, 0), invalidMask);
    }
    catch (const std::exception& e) {
        depthFrameScaled = cv::Mat::zeros(frameDepth.size(), CV_8UC1);
    }
    return depthFrameScaled;
}



bool Init() {
    printf("Initializing DepthAI\n");

    tof = pipeline.create<dai::node::ToF>();

    // Configure the ToF node
    tofConfig = tof->initialConfig.get();
    tofConfig.enableFPPNCorrection = true;
    tofConfig.enableOpticalCorrection = true;
    tofConfig.enableWiggleCorrection = false;
    tofConfig.enablePhaseShuffleTemporalFilter = false;
    tofConfig.enablePhaseUnwrapping = true;
    tofConfig.phaseUnwrappingLevel = 1;
    tofConfig.phaseUnwrapErrorThreshold = 300;
    tofConfig.enableTemperatureCorrection = true;
    

    printf("Configuring the ToF node\n");

    auto xinTofConfig = pipeline.create<dai::node::XLinkIn>();
    xinTofConfig->setStreamName("tofConfig");
    xinTofConfig->out.link(tof->inputConfig);

    tof->initialConfig.set(tofConfig);

    auto camTof = pipeline.create<dai::node::Camera>();
    camTof->setFps(60);
    camTof->setBoardSocket(dai::CameraBoardSocket::CAM_A);
    camTof->initialControl.setFrameSyncMode(dai::CameraControl::FrameSyncMode::INPUT);
    camTof->initialControl.setExternalTrigger(1, 0);

    camTof->raw.link(tof->input);

    auto xoutDepth = pipeline.create<dai::node::XLinkOut>();
    xoutDepth->setStreamName("depth");
    tof->depth.link(xoutDepth->input);
    xoutDepth->input.setBlocking(false);
    xoutDepth->input.queueSize = 1;

    tofConfig = tof->initialConfig.get();

    device = std::make_shared<dai::Device>(pipeline);

    std::cout << "Connected cameras: " << device->getConnectedCameraFeatures().size() << std::endl;
    qDepth = device->getOutputQueue("depth", 1, false);
    
    return true;
}

int main(int argc, char* argv[]) {

    if (!Init())
        return -1;
    printf("Completed init\n");

    int counter = 0;
    while (true) {
        auto start = std::chrono::high_resolution_clock::now();

        if (qDepth->has()) {
            
            cv::Mat depthFrameScaled = convertToByte(getDepth());
            cv::imshow("Depth", depthFrameScaled);
        }
        else {
            printf(".");
        }
        

        int key = cv::waitKey(1);
        
        if (key == 'q') {
            break;
        }

        counter++;
    }

    return 0;
}