Merge branch 'xlink_device_search_improvements' into develop

themarpe · themarpe · commit d0a7f1be4e79 · 2022-05-17T19:35:01.000+02:00
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
@@ -177,6 +177,7 @@ jobs:
       matrix:
         python-version: [3.6, 3.7, 3.8, 3.9, '3.10']
         python-architecture: [x64, x86]
+      fail-fast: false
     steps:
       - name: Cache .hunter folder
         uses: actions/cache@v2
@@ -230,6 +231,7 @@ jobs:
     strategy:
       matrix:
         python-version: [3.6, 3.7, 3.8, 3.9, '3.10']
+      fail-fast: false
     steps:
       - name: Cache .hunter folder
         uses: actions/cache@v2
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -9,6 +9,12 @@ if(NOT WIN32)
     set(HUNTER_CONFIGURATION_TYPES "Release" CACHE STRING "Hunter dependencies list of build configurations")
 endif()
 
+# Specify path separator
+set(SYS_PATH_SEPARATOR ";")
+if(UNIX)
+    set(SYS_PATH_SEPARATOR ":")
+endif()
+
 # Generate combined Hunter config
 file(READ depthai-core/cmake/Hunter/config.cmake depthai_core_hunter_config)
 file(READ cmake/Hunter/config.cmake hunter_config)
@@ -97,6 +103,23 @@ pybind11_add_module(${TARGET_NAME}
     src/log/LogBindings.cpp
 )
 
+if(WIN32)
+    # Copy dlls to target directory - Windows only
+    # TARGET_RUNTIME_DLLS generator expression available since CMake 3.21
+    if(CMAKE_VERSION VERSION_LESS "3.21")
+        file(GLOB depthai_dll_libraries "${HUNTER_INSTALL_PREFIX}/bin/*.dll")
+    else()
+        set(depthai_dll_libraries "$<TARGET_RUNTIME_DLLS:${TARGET_NAME}>")
+    endif()
+    add_custom_command(TARGET ${TARGET_NAME} POST_BUILD COMMAND
+        ${CMAKE_COMMAND} -E copy ${depthai_dll_libraries} $<TARGET_FILE_DIR:${TARGET_NAME}>
+        COMMAND_EXPAND_LISTS
+    )
+
+    # Disable "d" postfix, so python can import the library as is
+    set_target_properties(${TARGET_NAME} PROPERTIES DEBUG_POSTFIX "")
+endif()
+
 # Add stubs (pyi) generation step after building bindings
 execute_process(COMMAND "${PYTHON_EXECUTABLE}" "-c" "from mypy import api" RESULT_VARIABLE error OUTPUT_QUIET ERROR_QUIET)
 if(error)
@@ -108,7 +131,12 @@ else()
     endif()
     message(STATUS "Mypy available, creating and checking stubs. Running with generate_stubs.py ${TARGET_NAME} ${bindings_directory}")
     add_custom_command(TARGET ${TARGET_NAME} POST_BUILD COMMAND
-        ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_LIST_DIR}/generate_stubs.py" "${TARGET_NAME}" "${bindings_directory}"
+        ${CMAKE_COMMAND} -E env 
+        # PATH (dlls)
+        "PATH=${HUNTER_INSTALL_PREFIX}/bin${SYS_PATH_SEPARATOR}$ENV{PATH}"
+        # Python path (to find compiled module)
+        "PYTHONPATH=$<TARGET_FILE_DIR:${TARGET_NAME}>${SYS_PATH_SEPARATOR}$ENV{PYTHONPATH}"
+        ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_LIST_DIR}/generate_stubs.py" "${TARGET_NAME}" "$<TARGET_FILE_DIR:${TARGET_NAME}>"
         DEPENDS "${CMAKE_CURRENT_LIST_DIR}/generate_stubs.py"
         WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
     )
diff --git a/depthai-core b/depthai-core
@@ -1 +1 @@
-Subproject commit f31975b86bccf204d108da98fea21313370d45de
+Subproject commit 2aeb3413b457c3611f55c32f630d04eee51e05ef
diff --git a/docs/CMakeLists.txt b/docs/CMakeLists.txt
@@ -40,6 +40,8 @@ else()
     add_custom_target(sphinx ALL
         ${CMAKE_COMMAND} -E env
         # Environment variables
+        # PATH (dlls)
+        "PATH=${HUNTER_INSTALL_PREFIX}/bin${SYS_PATH_SEPARATOR}$ENV{PATH}"            
         # Python path (to find compiled module)
         "PYTHONPATH=$<TARGET_FILE_DIR:${TARGET_NAME}>${SYS_PATH_SEPARATOR}$ENV{PYTHONPATH}"
         # ASAN in case of sanitizers
diff --git a/docs/source/components/device.rst b/docs/source/components/device.rst
@@ -40,6 +40,20 @@ When you create the device in the code, firmware is uploaded together with the p
         cfg = depthai.ImageManipConfig()
         input_q.send(cfg)
 
+Connect to specified device
+###########################
+
+If you have multiple devices and only want to connect to a specific one, or if your OAK PoE camera is outside of your
+subnet, you can specify the device (either with MxID, IP, or USB port name) you want to connect to.
+
+.. code-block:: python
+
+  # Specify MXID, IP Address or USB path
+  device_info = depthai.DeviceInfo("14442C108144F1D000") # MXID
+  #device_info = depthai.DeviceInfo("192.168.1.44") # IP Address
+  #device_info = depthai.DeviceInfo("3.3.3") # USB port name
+  with depthai.Device(pipeline, device_info) as device:
+      # ...
 
 Multiple devices
 ################
diff --git a/docs/source/tutorials/standalone_mode.rst b/docs/source/tutorials/standalone_mode.rst
@@ -139,10 +139,9 @@ You can also **factory reset OAK POE at specific IP** if it's not reachable (not
     with tempfile.NamedTemporaryFile() as tmpBlFw:
         tmpBlFw.write(bytes(blBinary))
 
-        device_info = dai.DeviceInfo()
+        device_info = dai.DeviceInfo("192.168.34.110") # Set IP here
         device_info.state = dai.XLinkDeviceState.X_LINK_BOOTLOADER
-        device_info.desc.protocol = dai.XLinkProtocol.X_LINK_TCP_IP
-        device_info.desc.name = "192.168.34.110" # Set IP here
+        device_info.protocol = dai.XLinkProtocol.X_LINK_TCP_IP
 
         with dai.DeviceBootloader(device_info, allowFlashingBootloader=True) as bootloader:
             progress = lambda p : print(f'Factory reset progress: {p*100:.1f}%')
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
@@ -33,6 +33,8 @@ function(add_python_example example_name python_script_path)
     add_custom_target(${example_name}
         ${CMAKE_COMMAND} -E env
         # Environment variables
+        # PATH (dlls)
+        "PATH=${HUNTER_INSTALL_PREFIX}/bin${SYS_PATH_SEPARATOR}$ENV{PATH}"
         # Python path (to find compiled module)
         "PYTHONPATH=$<TARGET_FILE_DIR:${TARGET_NAME}>${SYS_PATH_SEPARATOR}$ENV{PYTHONPATH}"
         # ASAN in case of sanitizers
@@ -49,6 +51,8 @@ function(add_python_example example_name python_script_path)
         # Adds test with 5 seconds timeout and bumps all python warnings to errors
         add_test(NAME ${example_name} COMMAND
             ${CMAKE_COMMAND} -E env
+            # PATH (dlls)
+            "PATH=${HUNTER_INSTALL_PREFIX}/bin${SYS_PATH_SEPARATOR}$ENV{PATH}"
             # Python path (to find compiled module)
             "PYTHONPATH=$<TARGET_FILE_DIR:${TARGET_NAME}>${SYS_PATH_SEPARATOR}$ENV{PYTHONPATH}"
             # ASAN in case of sanitizers
@@ -70,6 +74,8 @@ if(DEPTHAI_PYTHON_TEST_EXAMPLES)
     # Adds install requirements test with 5 minute timeout
     add_test(NAME install_requirements COMMAND
         ${CMAKE_COMMAND} -E env
+        # PATH (dlls)
+        "PATH=${HUNTER_INSTALL_PREFIX}/bin${SYS_PATH_SEPARATOR}$ENV{PATH}"
         # Python path (to find compiled module)
         "PYTHONPATH=$<TARGET_FILE_DIR:${TARGET_NAME}>${SYS_PATH_SEPARATOR}$ENV{PYTHONPATH}"
         # ASAN in case of sanitizers
diff --git a/examples/bootloader/bootloader_config.py b/examples/bootloader/bootloader_config.py
@@ -31,7 +31,7 @@
 (res, info) = dai.DeviceBootloader.getFirstAvailableDevice()
 
 if res:
-    print(f'Found device with name: {info.desc.name}');
+    print(f'Found device with name: {info.name}');
     with dai.DeviceBootloader(info) as bl:
         if read:
             print('Current flashed configuration')
diff --git a/examples/bootloader/bootloader_version.py b/examples/bootloader/bootloader_version.py
@@ -5,7 +5,7 @@
 (res, info) = dai.DeviceBootloader.getFirstAvailableDevice()
 
 if res == True:
-    print(f'Found device with name: {info.desc.name}')
+    print(f'Found device with name: {info.name}')
     bl = dai.DeviceBootloader(info)
     print(f'Version: {bl.getVersion()}')
 else:
diff --git a/examples/bootloader/poe_set_ip.py b/examples/bootloader/poe_set_ip.py
@@ -12,7 +12,7 @@ def check_str(s: str):
     return s
 
 if found:
-    print(f'Found device with name: {info.desc.name}')
+    print(f'Found device with name: {info.name}')
     print('-------------------------------------')
     print('"1" to set a static IPv4 address')
     print('"2" to set a dynamic IPv4 address')
diff --git a/setup.py b/setup.py
@@ -10,6 +10,7 @@
 from setuptools import setup, Extension
 from setuptools.command.build_ext import build_ext
 from distutils.version import LooseVersion
+from pathlib import Path
 
 ### NAME
 MODULE_NAME = 'depthai'
@@ -95,9 +96,16 @@ def build_extension(self, ext):
         # initialize cmake_args and build_args
         cmake_args = []
         build_args = []
+        env = os.environ.copy()
 
         # Specify output directory and python executable
         cmake_args += ['-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=' + extdir, '-DPYTHON_EXECUTABLE=' + sys.executable]
+        # Specify dir of python executable (pybind11)
+        if platform.system() == "Windows":
+            # Windows - remove case insensitive variants
+            env = {key:env[key] for key in env if key.upper() != 'pythonLocation'.upper()}
+        env['pythonLocation'] = str(Path(sys.executable).parent.absolute())
+        
 
         # Pass a commit hash
         if buildCommitHash != None :
@@ -127,8 +135,6 @@ def build_extension(self, ext):
                 raise
             except:
                 freeMemory = 4000
-        # Memcheck (guard if it fails)
-
 
         # Configure and build
         # Windows
@@ -149,8 +155,8 @@ def build_extension(self, ext):
             # if macos add some additional env vars
             if sys.platform == 'darwin':
                 from distutils import util
-                os.environ['MACOSX_DEPLOYMENT_TARGET'] = '10.9'
-                os.environ['_PYTHON_HOST_PLATFORM'] = re.sub(r'macosx-[0-9]+\.[0-9]+-(.+)', r'macosx-10.9-\1', util.get_platform())
+                env['MACOSX_DEPLOYMENT_TARGET'] = '10.9'
+                env['_PYTHON_HOST_PLATFORM'] = re.sub(r'macosx-[0-9]+\.[0-9]+-(.+)', r'macosx-10.9-\1', util.get_platform())
 
             # Specify how many threads to use when building, depending on available memory
             max_threads = multiprocessing.cpu_count()
@@ -161,7 +167,6 @@ def build_extension(self, ext):
             build_args += ['--', '-j' + str(num_threads)]
             cmake_args += ['-DHUNTER_JOBS_NUMBER=' + str(num_threads)]
 
-        env = os.environ.copy()
         env['CXXFLAGS'] = '{} -DVERSION_INFO=\\"{}\\"'.format(env.get('CXXFLAGS', ''), self.distribution.get_version())
 
         # Add additional cmake args from environment
@@ -170,8 +175,10 @@ def build_extension(self, ext):
 
         if not os.path.exists(self.build_temp):
             os.makedirs(self.build_temp)
+
+        # Configure and build
         subprocess.check_call(['cmake', ext.sourcedir] + cmake_args, cwd=self.build_temp, env=env)
-        subprocess.check_call(['cmake', '--build', '.'] + build_args, cwd=self.build_temp)
+        subprocess.check_call(['cmake', '--build', '.'] + build_args, cwd=self.build_temp, env=env)
 
 setup(
     name=MODULE_NAME,
diff --git a/src/DeviceBindings.cpp b/src/DeviceBindings.cpp
@@ -24,46 +24,14 @@ PYBIND11_MAKE_OPAQUE(std::unordered_map<std::int8_t, dai::BoardConfig::UART>);
 template<typename DEVICE, class... Args>
 static auto deviceSearchHelper(Args&&... args){
 
-    auto startTime = std::chrono::steady_clock::now();
-    bool found = false;
-    bool invalidDeviceFound = false;
-    dai::DeviceInfo deviceInfo = {};
-    dai::DeviceInfo invalidDeviceInfo = {};
-    do {
-        {
-            // releases python GIL
-            py::gil_scoped_release release;
-            std::tie(found, deviceInfo) = DEVICE::getFirstAvailableDevice(false);
-
-            if(strcmp("<error>", deviceInfo.desc.name) == 0){
-                invalidDeviceFound = true;
-                invalidDeviceInfo = deviceInfo;
-                found = false;
-            }
-
-            // Check if found
-            if(found){
-                break;
-            } else {
-                // block for 100ms
-                std::this_thread::sleep_for(std::chrono::milliseconds(100));
-            }
-        }
-        // reacquires python GIL for PyErr_CheckSignals call
-        // check if interrupt triggered in between
+    bool found;
+    dai::DeviceInfo deviceInfo;
+    // releases python GIL
+    py::gil_scoped_release release;
+    std::tie(found, deviceInfo) = DEVICE::getAnyAvailableDevice(DEVICE::getDefaultSearchTime(), [](){
+        py::gil_scoped_acquire acquire;
         if (PyErr_CheckSignals() != 0) throw py::error_already_set();
-    } while(std::chrono::steady_clock::now() - startTime < DEVICE::getDefaultSearchTime());
-
-    // Check if its an invalid device
-    if(invalidDeviceFound){
-        // Warn
-        // spdlog::warn("skipping {} device having name \"{}\"", XLinkDeviceStateToStr(invalidDeviceInfo.state), invalidDeviceInfo.desc.name);
-        // TODO(themarpe) - move device search into C++ and expose a callback
-        DEVICE::getFirstAvailableDevice(true);
-    }
-
-    // If neither UNBOOTED nor BOOTLOADER were found (after 'DEFAULT_SEARCH_TIME'), try BOOTED
-    if(!found) std::tie(found, deviceInfo) = dai::XLinkConnection::getFirstDevice(X_LINK_BOOTED);
+    });
 
     // if no devices found, then throw
     if(!found) throw std::runtime_error("No available devices");
@@ -339,7 +307,7 @@ void DeviceBindings::bind(pybind11::module& m, void* pCallstack){
 
         //dai::Device methods
         //static
-        .def_static("getAnyAvailableDevice", [](std::chrono::microseconds us){ return Device::getAnyAvailableDevice(us); }, py::arg("timeout"), DOC(dai, DeviceBase, getAnyAvailableDevice))
+        .def_static("getAnyAvailableDevice", [](std::chrono::milliseconds ms){ return DeviceBase::getAnyAvailableDevice(ms); }, py::arg("timeout"), DOC(dai, DeviceBase, getAnyAvailableDevice))
         .def_static("getAnyAvailableDevice", [](){ return DeviceBase::getAnyAvailableDevice(); }, DOC(dai, DeviceBase, getAnyAvailableDevice, 2))
         .def_static("getFirstAvailableDevice", &DeviceBase::getFirstAvailableDevice, py::arg("skipInvalidDevices") = true, DOC(dai, DeviceBase, getFirstAvailableDevice))
         .def_static("getAllAvailableDevices", &DeviceBase::getAllAvailableDevices, DOC(dai, DeviceBase, getAllAvailableDevices))
diff --git a/src/XLinkBindings.cpp b/src/XLinkBindings.cpp
@@ -47,22 +47,45 @@ void XLinkBindings::bind(pybind11::module &m, void *pCallstack)
 
     // Bindings
     deviceInfo
-        .def(py::init<>())
-        .def_readwrite("desc", &DeviceInfo::desc)
-        .def_readwrite("state", &DeviceInfo::state)
+        .def(py::init<>(), DOC(dai, DeviceInfo, DeviceInfo))
+        .def(py::init<std::string, std::string, XLinkDeviceState_t, XLinkProtocol_t, XLinkPlatform_t, XLinkError_t>(), py::arg("name"), py::arg("mxid"), py::arg("state"), py::arg("protocol"), py::arg("platform"), py::arg("status"), DOC(dai, DeviceInfo, DeviceInfo, 2))
+        .def(py::init<std::string>(), py::arg("mxidOrName"), DOC(dai, DeviceInfo, DeviceInfo, 3))
+        .def(py::init<const deviceDesc_t&>(), DOC(dai, DeviceInfo, DeviceInfo, 4))
         .def("getMxId", &DeviceInfo::getMxId)
+        .def("getXLinkDeviceDesc", &DeviceInfo::getXLinkDeviceDesc)
+        .def_readwrite("name", &DeviceInfo::name)
+        .def_readwrite("mxid", &DeviceInfo::mxid)
+        .def_readwrite("state", &DeviceInfo::state)
+        .def_readwrite("protocol", &DeviceInfo::protocol)
+        .def_readwrite("platform", &DeviceInfo::platform)
+        .def_readwrite("status", &DeviceInfo::status)
+        .def("__repr__", &DeviceInfo::toString)
         ;
 
     deviceDesc
         .def(py::init<>())
         .def_readwrite("protocol", &deviceDesc_t::protocol)
         .def_readwrite("platform", &deviceDesc_t::platform)
+        .def_readwrite("state", &deviceDesc_t::state)
+        .def_readwrite("status", &deviceDesc_t::status)
         .def_property(
             "name",
             [](deviceDesc_t &o)
             { return std::string(o.name); },
             [](deviceDesc_t &o, std::string n)
-            { std::strncpy(o.name, n.c_str(), std::min(XLINK_MAX_NAME_SIZE, (int)n.size())); })
+            {
+                memset(o.name, 0, sizeof(o.name));
+                std::strncpy(o.name, n.c_str(), sizeof(o.name));
+            })
+        .def_property(
+            "mxid",
+            [](deviceDesc_t &o)
+            { return std::string(o.mxid); },
+            [](deviceDesc_t &o, std::string n)
+            {
+                memset(o.mxid, 0, sizeof(o.mxid));
+                std::strncpy(o.mxid, n.c_str(), sizeof(o.mxid));
+            })
         ;
 
     xLinkDeviceState
diff --git a/src/pybind11_common.hpp b/src/pybind11_common.hpp
@@ -45,7 +45,7 @@ namespace pybind11 { namespace detail {
                 bool isPath = false;
                 try{
                     isPath = isinstance(src, module::import("pathlib").attr("PurePath"));
-                } catch (const std::exception& ex) {
+                } catch (const std::exception&) {
                     //ignore
                 }
                 if(!isinstance<str>(src) && !isPath) {
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
@@ -21,6 +21,8 @@ pybind11_add_module(${TARGET_TEST_MODULE} THIN_LTO ${TARGET_TEST_MODULE}.cpp ${P
 add_custom_target(
     pytest COMMAND
         ${CMAKE_COMMAND} -E env
+        # PATH (dlls)
+        "PATH=${HUNTER_INSTALL_PREFIX}/bin${SYS_PATH_SEPARATOR}$ENV{PATH}"
         # Python path (to find compiled modules)
         "PYTHONPATH=$<TARGET_FILE_DIR:${TARGET_NAME}>${SYS_PATH_SEPARATOR}$<TARGET_FILE_DIR:${TARGET_TEST_MODULE}>${SYS_PATH_SEPARATOR}$ENV{PYTHONPATH}"
         # ASAN in case of sanitizers
