Add M8 Fsync role switching

Signed-off-by: stas.bucik <[email protected]>

Author: sb-lxn

bindings/python/src/DeviceBindings.cpp

@@ -837,6 +837,23 @@ void DeviceBindings::bind(pybind11::module& m, void* pCallstack) {
             },
             py::arg("enable"),
             DOC(dai, DeviceBase, setTimesync, 2))
+        .def(
+            "setM8FsyncRole",
+            [](DeviceBase& d, M8FsyncRole role) {
+                py::gil_scoped_release release;
+                return d.setM8FsyncRole(role);
+            },
+            py::arg("role"),
+            DOC(dai, DeviceBase, setM8FsyncRole)
+        )
+        .def(
+            "getM8FsyncRole",
+            [](DeviceBase& d) {
+                py::gil_scoped_release release;
+                return d.getM8FsyncRole();
+            },
+            DOC(dai, DeviceBase, getM8FsyncRole)
+        )
         .def(
             "getDeviceName",
             [](DeviceBase& d) {

bindings/python/src/pipeline/CommonBindings.cpp

@@ -5,6 +5,7 @@
 
 // depthai/
 #include "depthai/common/CameraBoardSocket.hpp"
+#include "depthai/common/M8FsyncRoles.hpp"
 #include "depthai/common/CameraFeatures.hpp"
 #include "depthai/common/CameraImageOrientation.hpp"
 #include "depthai/common/CameraSensorType.hpp"
@@ -50,6 +51,7 @@ void CommonBindings::bind(pybind11::module& m, void* pCallstack) {
     py::class_<Quaterniond> quaterniond(m, "Quaterniond", DOC(dai, Quaterniond));
     py::class_<Size2f> size2f(m, "Size2f", DOC(dai, Size2f));
     py::enum_<CameraBoardSocket> cameraBoardSocket(m, "CameraBoardSocket", DOC(dai, CameraBoardSocket));
+    py::enum_<M8FsyncRole> m8FsyncRole(m, "M8FsyncRole", DOC(dai, M8FsyncRole));
     py::enum_<ConnectionInterface> connectionInterface(m, "connectionInterface", DOC(dai, ConnectionInterface));
     py::enum_<CameraSensorType> cameraSensorType(m, "CameraSensorType", DOC(dai, CameraSensorType));
     py::enum_<CameraImageOrientation> cameraImageOrientation(m, "CameraImageOrientation", DOC(dai, CameraImageOrientation));
@@ -221,6 +223,12 @@ void CommonBindings::bind(pybind11::module& m, void* pCallstack) {
         });
     HEDLEY_DIAGNOSTIC_POP
 
+    // M8FsyncRole enum bindings
+    m8FsyncRole.value("AUTO_DETECT", M8FsyncRole::AUTO_DETECT)
+        .value("MASTER_WITHOUT_OUTPUT", M8FsyncRole::MASTER_WITHOUT_OUTPUT)
+        .value("MASTER_WITH_OUTPUT", M8FsyncRole::MASTER_WITH_OUTPUT)
+        .value("SLAVE", M8FsyncRole::SLAVE);
+
     // CameraSensorType enum bindings
     cameraSensorType.value("COLOR", CameraSensorType::COLOR)
         .value("MONO", CameraSensorType::MONO)

include/depthai/common/M8FsyncRoles.hpp

@@ -0,0 +1,40 @@
+#pragma once
+#include <cstdint>
+#include <iostream>
+#include <string>
+
+namespace dai {
+/**
+ * Which Fsymc role the device will have.
+ *
+ * AUTO_DETECT denotes that the decision will be made by device.
+ * It will choose between MASTER_WITH_OUTPUT and SLAVE.
+ */
+enum class M8FsyncRole : int32_t {
+    AUTO_DETECT = -1,
+    MASTER_WITHOUT_OUTPUT,
+    MASTER_WITH_OUTPUT,
+    SLAVE,
+};
+
+inline std::string toString(M8FsyncRole role) {
+    switch(role) {
+        case M8FsyncRole::AUTO_DETECT:
+            return "AUTO DETECT";
+        case M8FsyncRole::MASTER_WITHOUT_OUTPUT:
+            return "MASTER, NO OUTPUT";
+        case M8FsyncRole::MASTER_WITH_OUTPUT:
+            return "MASTER, WITH OUTPUT";
+        case M8FsyncRole::SLAVE:
+            return "SLAVE";
+        default:
+            return "UNKNOWN";
+    }
+}
+
+}  // namespace dai
+
+// Global namespace
+inline std::ostream& operator<<(std::ostream& out, const dai::M8FsyncRole& socket) {
+    return out << dai::toString(socket);
+}

include/depthai/device/DeviceBase.hpp

@@ -17,6 +17,7 @@
 // project
 #include "depthai/common/CameraBoardSocket.hpp"
 #include "depthai/common/CameraFeatures.hpp"
+#include "depthai/common/M8FsyncRoles.hpp"
 #include "depthai/common/UsbSpeed.hpp"
 #include "depthai/device/CalibrationHandler.hpp"
 #include "depthai/device/DeviceGate.hpp"
@@ -797,6 +798,19 @@ class DeviceBase {
      */
     void setMaxReconnectionAttempts(int maxAttempts, std::function<void(ReconnectionStatus)> callBack = nullptr);
 
+    /**
+     * Sets M8 Fsync role for the device
+     * @param role M8 Fsync role to be set, AUTO_DETECT by default
+     * @returns Tuple of bool and string. Bool specifies if role was set without failures. String is the error message describing the failure reason.
+     */
+    std::tuple<bool, std::string> setM8FsyncRole(M8FsyncRole role = M8FsyncRole::AUTO_DETECT);
+
+    /**
+     * Gets M8 Fsync role for the device
+     * @returns Gets M8 Fsync role
+     */
+    M8FsyncRole getM8FsyncRole();
+
    protected:
     std::shared_ptr<XLinkConnection> connection;
 

src/device/DeviceBase.cpp

@@ -1190,6 +1190,14 @@ void DeviceBase::crashDevice() {
     }
 }
 
+std::tuple<bool, std::string>  DeviceBase::setM8FsyncRole(M8FsyncRole role) {
+    return pimpl->rpcClient->call("setM8FsyncRole", role);
+}
+
+M8FsyncRole DeviceBase::getM8FsyncRole() {
+    return pimpl->rpcClient->call("getM8FsyncRole");
+}
+
 dai::Version DeviceBase::getIMUFirmwareVersion() {
     isClosed();
     std::string versionStr = pimpl->rpcClient->call("getIMUFirmwareVersion").as<std::string>();