Merge 'origin/gen2_uvc' into develop -- #820

Author: alex-luxonis

CMakeLists.txt

@@ -127,6 +127,7 @@ pybind11_add_module(${TARGET_NAME}
     src/pipeline/node/AprilTagBindings.cpp
     src/pipeline/node/DetectionParserBindings.cpp
     src/pipeline/node/WarpBindings.cpp
+    src/pipeline/node/UVCBindings.cpp
     src/pipeline/node/ToFBindings.cpp
 
     src/pipeline/datatype/ADatatypeBindings.cpp

depthai-core

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+
+import time
+import argparse
+
+parser = argparse.ArgumentParser()
+parser.add_argument('-fb', '--flash-bootloader', default=False, action="store_true")
+parser.add_argument('-f',  '--flash-app',        default=False, action="store_true")
+parser.add_argument('-l',  '--load-and-exit',    default=False, action="store_true")
+args = parser.parse_args()
+
+if args.load_and_exit:
+    import os
+    # Disabling device watchdog, so it doesn't need the host to ping periodically.
+    # Note: this is done before importing `depthai`
+    os.environ["DEPTHAI_WATCHDOG"] = "0"
+
+import depthai as dai
+
+def getPipeline():
+    enable_4k = True  # Will downscale 4K -> 1080p
+
+    pipeline = dai.Pipeline()
+
+    # Define a source - color camera
+    cam_rgb = pipeline.createColorCamera()
+    cam_rgb.setBoardSocket(dai.CameraBoardSocket.CAM_A)
+    cam_rgb.setInterleaved(False)
+    #cam_rgb.initialControl.setManualFocus(130)
+
+    if enable_4k:
+        cam_rgb.setResolution(dai.ColorCameraProperties.SensorResolution.THE_4_K)
+        cam_rgb.setIspScale(1, 2)
+    else:
+        cam_rgb.setResolution(dai.ColorCameraProperties.SensorResolution.THE_1080_P)
+
+    # Create an UVC (USB Video Class) output node
+    uvc = pipeline.createUVC()
+    cam_rgb.video.link(uvc.input)
+
+    # Note: if the pipeline is sent later to device (using startPipeline()),
+    # it is important to pass the device config separately when creating the device
+    config = dai.Device.Config()
+    # config.board.uvc = dai.BoardConfig.UVC()  # enable default 1920x1080 NV12
+    config.board.uvc = dai.BoardConfig.UVC(1920, 1080)
+    config.board.uvc.frameType = dai.ImgFrame.Type.NV12
+    # config.board.uvc.cameraName = "My Custom Cam"
+    pipeline.setBoardConfig(config.board)
+
+    return pipeline
+
+# Will flash the bootloader if no pipeline is provided as argument
+def flash(pipeline=None):
+    (f, bl) = dai.DeviceBootloader.getFirstAvailableDevice()
+    bootloader = dai.DeviceBootloader(bl, True)
+
+    # Create a progress callback lambda
+    progress = lambda p : print(f'Flashing progress: {p*100:.1f}%')
+
+    startTime = time.monotonic()
+    if pipeline is None:
+        print("Flashing bootloader...")
+        bootloader.flashBootloader(progress)
+    else:
+        print("Flashing application pipeline...")
+        bootloader.flash(progress, pipeline)
+
+    elapsedTime = round(time.monotonic() - startTime, 2)
+    print("Done in", elapsedTime, "seconds")
+
+if args.flash_bootloader or args.flash_app:
+    if args.flash_bootloader: flash()
+    if args.flash_app: flash(getPipeline())
+    print("Flashing successful. Please power-cycle the device")
+    quit()
+
+if args.load_and_exit:
+    device = dai.Device(getPipeline())
+    print("\nDevice started. Attempting to force-terminate this process...")
+    print("Open an UVC viewer to check the camera stream.")
+    print("To reconnect with depthai, a device power-cycle may be required in some cases")
+    # We do not want the device to be closed, so terminate the process uncleanly.
+    # (TODO add depthai API to be able to cleanly exit without closing device)
+    import signal
+    os.kill(os.getpid(), signal.SIGTERM)
+
+# Standard UVC load with depthai
+with dai.Device(getPipeline()) as device:
+    print("\nDevice started, please keep this process running")
+    print("and open an UVC viewer to check the camera stream.")
+    print("\nTo close: Ctrl+C")
+
+    # Doing nothing here, just keeping the host feeding the watchdog
+    while True:
+        try:
+            time.sleep(0.1)
+        except KeyboardInterrupt:
+            break

examples/ColorCamera/rgb_uvc.py

@@ -343,6 +343,7 @@ void DeviceBindings::bind(pybind11::module& m, void* pCallstack){
     py::enum_<BoardConfig::GPIO::Pull> boardConfigGpioPull(boardConfigGpio, "Pull", DOC(dai, BoardConfig, GPIO, Pull));
     py::enum_<BoardConfig::GPIO::Drive> boardConfigGpioDrive(boardConfigGpio, "Drive", DOC(dai, BoardConfig, GPIO, Drive));
     py::class_<BoardConfig::UART> boardConfigUart(boardConfig, "UART", DOC(dai, BoardConfig, UART));
+    py::class_<BoardConfig::UVC> boardConfigUvc(boardConfig, "UVC", DOC(dai, BoardConfig, UVC));
     struct PyClock{};
     py::class_<PyClock> clock(m, "Clock");
 
@@ -379,6 +380,8 @@ void DeviceBindings::bind(pybind11::module& m, void* pCallstack){
         .def_readwrite("flashBootedVid", &BoardConfig::USB::flashBootedVid)
         .def_readwrite("flashBootedPid", &BoardConfig::USB::flashBootedPid)
         .def_readwrite("maxSpeed", &BoardConfig::USB::maxSpeed)
+        .def_readwrite("productName", &BoardConfig::USB::productName)
+        .def_readwrite("manufacturer", &BoardConfig::USB::manufacturer)
     ;
 
     // Bind BoardConfig::Network
@@ -456,6 +459,17 @@ void DeviceBindings::bind(pybind11::module& m, void* pCallstack){
         .def_readwrite("tmp", &BoardConfig::UART::tmp)
     ;
 
+    // Bind BoardConfig::UVC
+    boardConfigUvc
+        .def(py::init<>())
+        .def(py::init<uint16_t, uint16_t>())
+        .def_readwrite("cameraName", &BoardConfig::UVC::cameraName)
+        .def_readwrite("width", &BoardConfig::UVC::width)
+        .def_readwrite("height", &BoardConfig::UVC::height)
+        .def_readwrite("frameType", &BoardConfig::UVC::frameType)
+        .def_readwrite("enable", &BoardConfig::UVC::enable)
+    ;
+
     // Bind BoardConfig
     boardConfig
         .def(py::init<>())
@@ -474,6 +488,7 @@ void DeviceBindings::bind(pybind11::module& m, void* pCallstack){
         .def_readwrite("logSizeMax", &BoardConfig::logSizeMax, DOC(dai, BoardConfig, logSizeMax))
         .def_readwrite("logVerbosity", &BoardConfig::logVerbosity, DOC(dai, BoardConfig, logVerbosity))
         .def_readwrite("logDevicePrints", &BoardConfig::logDevicePrints, DOC(dai, BoardConfig, logDevicePrints))
+        .def_readwrite("uvc", &BoardConfig::uvc, DOC(dai, BoardConfig, uvc))
     ;
 
     // Bind Device::Config

src/DeviceBindings.cpp

@@ -28,6 +28,7 @@
 #include "depthai/pipeline/node/FeatureTracker.hpp"
 #include "depthai/pipeline/node/AprilTag.hpp"
 #include "depthai/pipeline/node/DetectionParser.hpp"
+#include "depthai/pipeline/node/UVC.hpp"
 
 // depthai-shared
 #include "depthai-shared/properties/GlobalProperties.hpp"
@@ -142,6 +143,7 @@ void PipelineBindings::bind(pybind11::module& m, void* pCallstack){
         .def("createFeatureTracker", &Pipeline::create<node::FeatureTracker>)
         .def("createAprilTag", &Pipeline::create<node::AprilTag>)
         .def("createDetectionParser", &Pipeline::create<node::DetectionParser>)
+        .def("createUVC", &Pipeline::create<node::UVC>)
         ;
 
 

src/pipeline/PipelineBindings.cpp

@@ -114,6 +114,7 @@ void bind_edgedetector(pybind11::module& m, void* pCallstack);
 void bind_featuretracker(pybind11::module& m, void* pCallstack);
 void bind_apriltag(pybind11::module& m, void* pCallstack);
 void bind_detectionparser(pybind11::module& m, void* pCallstack);
+void bind_uvc(pybind11::module& m, void* pCallstack);
 void bind_tof(pybind11::module& m, void* pCallstack);
 
 void NodeBindings::addToCallstack(std::deque<StackFunction>& callstack) {
@@ -144,6 +145,7 @@ void NodeBindings::addToCallstack(std::deque<StackFunction>& callstack) {
     callstack.push_front(bind_featuretracker);
     callstack.push_front(bind_apriltag);
     callstack.push_front(bind_detectionparser);
+    callstack.push_front(bind_uvc);
     callstack.push_front(bind_tof);
 }
 

src/pipeline/node/NodeBindings.cpp

@@ -0,0 +1,50 @@
+
+#include "NodeBindings.hpp"
+#include "Common.hpp"
+
+#include "depthai/pipeline/Pipeline.hpp"
+#include "depthai/pipeline/Node.hpp"
+#include "depthai/pipeline/node/UVC.hpp"
+
+void bind_uvc(pybind11::module& m, void* pCallstack){
+
+    using namespace dai;
+    using namespace dai::node;
+
+    // Node and Properties declare upfront
+    py::class_<UVCProperties> uvcProperties(m, "UVCProperties", DOC(dai, UVCProperties));
+    auto uvc = ADD_NODE(UVC);
+
+    ///////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////
+    // Call the rest of the type defines, then perform the actual bindings
+    Callstack* callstack = (Callstack*) pCallstack;
+    auto cb = callstack->top();
+    callstack->pop();
+    cb(m, pCallstack);
+    // Actual bindings
+    ///////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////
+
+    // Properties
+    uvcProperties
+        .def_readwrite("gpioInit", &UVCProperties::gpioInit)
+        .def_readwrite("gpioStreamOn", &UVCProperties::gpioStreamOn)
+        .def_readwrite("gpioStreamOff", &UVCProperties::gpioStreamOff)
+        ;
+
+    // UVC node
+    uvc
+        .def_readonly("input", &UVC::input, DOC(dai, node, UVC, input))
+        .def("setGpiosOnInit", &UVC::setGpiosOnInit, py::arg("list"), DOC(dai, node, UVC, setGpiosOnInit))
+        .def("setGpiosOnStreamOn", &UVC::setGpiosOnStreamOn, py::arg("list"), DOC(dai, node, UVC, setGpiosOnStreamOn))
+        .def("setGpiosOnStreamOff", &UVC::setGpiosOnStreamOff, py::arg("list"), DOC(dai, node, UVC, setGpiosOnStreamOff))
+        ;
+
+    // ALIAS
+    daiNodeModule.attr("UVC").attr("Properties") = uvcProperties;
+
+}
+