Depthai USB Support

cmake/depthaiDependencies.cmake

@@ -176,7 +176,7 @@ else()
     FetchContent_Declare(
         XLink
         GIT_REPOSITORY https://github.com/luxonis/XLink.git
-        GIT_TAG        87785828fabdb1718760bb0a044405d5bbfbb3a2
+        GIT_TAG        674b295ce8a260c8817ee3396a1403d8697ce226
     )
 
     FetchContent_MakeAvailable(

examples/cpp/Camera/camera_max_resolution.cpp

@@ -31,4 +31,4 @@ int main() {
     }
 
     return 0;
-}
+}

examples/cpp/Camera/camera_output.cpp

@@ -30,4 +30,4 @@ int main() {
     }
 
     return 0;
-}
+}

include/depthai/device/DeviceGate.hpp

@@ -14,6 +14,7 @@
 #include "depthai/device/Version.hpp"
 #include "depthai/utility/Pimpl.hpp"
 #include "depthai/xlink/XLinkConnection.hpp"
+#include "depthai/xlink/XLinkStream.hpp"
 namespace dai {
 
 /**
@@ -65,6 +66,8 @@ class DeviceGate {
     std::atomic_bool sessionCreated{false};
 
     XLinkPlatform_t platform;
+    std::shared_ptr<XLinkConnection> gateConnection;
+    std::shared_ptr<XLinkStream> gateStream;
     std::string version;
     // pimpl
     class Impl;

src/device/DeviceGate.cpp

@@ -1,6 +1,7 @@
 #include "device/DeviceGate.hpp"
 
 #include <XLink/XLinkPublicDefines.h>
+#include <XLink/XLink.h>
 
 // std
 #include <fstream>
@@ -27,6 +28,27 @@ const std::string API_ROOT{"/api/v1"};
 const auto sessionsEndpoint = API_ROOT + "/sessions";
 const int DEFAULT_PORT{11492};
 
+enum USBRequestID_t {
+	RESPONSE_OK,
+	RESPONSE_ERROR,
+	CREATE_SESSION,
+	START_SESSION,
+	UPLOAD_FWP,
+	STOP_SESSION,
+	DESTROY_SESSION,
+	DELETE_SESSION,
+	IS_OKAY,
+	GET_VERSION,
+	GET_STATE,
+	GET_FILE,
+};
+
+struct USBRequest_t {
+    uint32_t RequestNum;
+    uint32_t RequestSize;
+};
+
+
 class DeviceGate::Impl {
    public:
     Impl() = default;
@@ -44,7 +66,7 @@ DeviceGate::DeviceGate(const DeviceInfo& deviceInfo) : deviceInfo(deviceInfo) {
     if(deviceInfo.platform != X_LINK_RVC3 && deviceInfo.platform != X_LINK_RVC4) {
         throw std::invalid_argument("Gate only supports RVC3 and RVC4 platforms");
     }
-    this->platform = deviceInfo.platform;
+    this->platform =deviceInfo.platform;
     if(deviceInfo.platform == X_LINK_RVC3) {
         version = DEPTHAI_DEVICE_RVC3_VERSION;
     } else if(deviceInfo.platform == X_LINK_RVC4) {
@@ -56,12 +78,33 @@ DeviceGate::DeviceGate(const DeviceInfo& deviceInfo) : deviceInfo(deviceInfo) {
     pimpl->cli = std::make_unique<httplib::Client>(deviceInfo.name, DEFAULT_PORT);
     pimpl->cli->set_read_timeout(60);  // 60 seconds timeout to allow for compressing the crash dumps without async
     // pimpl->cli->set_connection_timeout(2);
+
 }
 
 bool DeviceGate::isOkay() {
     if(auto res = pimpl->cli->Get("/api/v1/status")) {
         return nlohmann::json::parse(res->body)["status"].get<bool>();
+    } else {
+	USBRequest_t request;
+	request.RequestNum = IS_OKAY;
+	request.RequestSize = 0;
+	XLinkGateWrite(&request, sizeof(USBRequest_t));
+
+	XLinkGateRead(&request, sizeof(request));
+	if(request.RequestNum == RESPONSE_ERROR) {
+		return false;
+	}
+
+	char *respBuffer = new char[request.RequestSize + 1];
+	XLinkGateRead(respBuffer, request.RequestSize);
+	respBuffer[request.RequestSize]= '\0';
+
+	bool result = nlohmann::json::parse(respBuffer)["status"].get<bool>();
+	delete[] respBuffer;
+
+	return result;
     }
+
     return false;
 }
 
@@ -70,6 +113,26 @@ Version DeviceGate::getVersion() {
     if(res && res->status == 200) {
         auto versionStr = nlohmann::json::parse(res->body)["version_gate"].get<std::string>();
         return Version{versionStr};
+    } else {
+	USBRequest_t request;
+	request.RequestNum = GET_VERSION;
+	request.RequestSize = 0;
+	XLinkGateWrite(&request, sizeof(USBRequest_t));
+
+	XLinkGateRead(&request, sizeof(request));
+	if(request.RequestNum == RESPONSE_ERROR) {
+		return Version{0, 0, 0};
+	}
+
+	char *respBuffer = new char[request.RequestSize + 1];
+	XLinkGateRead(respBuffer, request.RequestSize);
+	respBuffer[request.RequestSize]= '\0';
+
+	auto result = nlohmann::json::parse(respBuffer)["version_gate"].get<std::string>();
+	delete[] respBuffer;
+
+	return Version{result};
+
     }
     return Version{0, 0, 0};
 }
@@ -83,6 +146,28 @@ DeviceGate::VersionInfo DeviceGate::getAllVersion() {
         info.gate = result.value("version_gate", "");
         info.os = result.value("version_os", "");
         return info;
+    } else {
+	USBRequest_t request;
+	request.RequestNum = GET_VERSION;
+	request.RequestSize = 0;
+	XLinkGateWrite(&request, sizeof(USBRequest_t));
+
+	XLinkGateRead(&request, sizeof(request));
+	if(request.RequestNum == RESPONSE_ERROR) {
+		return {};
+	}
+
+	char *respBuffer = new char[request.RequestSize + 1];
+	XLinkGateRead(respBuffer, request.RequestSize);
+	respBuffer[request.RequestSize]= '\0';
+	auto result = nlohmann::json::parse(respBuffer);
+	delete[] respBuffer;
+
+	VersionInfo info;
+	info.gate = result.value("version_gate", "");
+	info.os = result.value("version_os", "");
+	return info;
+
     }
     return {};
 }
@@ -144,7 +229,54 @@ bool DeviceGate::createSession(bool exclusive) {
         sessionCreated = true;
         return true;
     } else {
-        spdlog::warn("DeviceGate createSession not successful - got no response");
+	USBRequest_t request;
+	request.RequestNum = CREATE_SESSION;
+	request.RequestSize = createSessionBody.dump().size();
+	XLinkGateWrite(&request, sizeof(USBRequest_t));
+	XLinkGateWrite((void*)createSessionBody.dump().c_str(), createSessionBody.dump().size());
+
+	XLinkGateRead(&request, sizeof(request));
+	if(request.RequestNum == RESPONSE_ERROR) {
+            spdlog::warn("DeviceGate createSession not successful - got no response");
+	    return false;
+	}
+	char *respBuffer = new char[request.RequestSize + 1];
+	XLinkGateRead(respBuffer, request.RequestSize);
+	respBuffer[request.RequestSize]= '\0';
+	auto resp = nlohmann::json::parse(respBuffer);
+	delete[] respBuffer;
+        spdlog::debug("DeviceGate createSession response: {}", resp.dump());
+
+        // Retrieve sessionId
+        sessionId = resp["id"];
+        bool fwpExists = resp["fwp_exists"].get<bool>();
+
+        if(!fwpExists) {
+            std::vector<uint8_t> package;
+            std::string path;
+            if(!path.empty()) {
+                std::ifstream fwStream(path, std::ios::binary);
+                if(!fwStream.is_open()) throw std::runtime_error(fmt::format("Cannot flash bootloader, binary at path: {} doesn't exist", path));
+                package = std::vector<std::uint8_t>(std::istreambuf_iterator<char>(fwStream), {});
+            } else {
+                package = platform == X_LINK_RVC3 ? Resources::getInstance().getDeviceRVC3Fwp() : Resources::getInstance().getDeviceRVC4Fwp();
+            }
+
+	    nlohmann::json uploadFwpBody = {{"sessionId", sessionId},
+                                        {"file", package}};
+            request.RequestNum = UPLOAD_FWP;
+	    request.RequestSize = uploadFwpBody.dump().size();
+	    XLinkGateWrite(&request, sizeof(USBRequest_t));
+	    XLinkGateWrite((void*)uploadFwpBody.dump().c_str(), uploadFwpBody.dump().size());
+
+	    XLinkGateRead(&request, sizeof(request));
+	    if(request.RequestNum == RESPONSE_ERROR) {
+                spdlog::warn("DeviceGate upload fwp not successful - got no response");
+		return false;
+	    }
+        }
+        sessionCreated = true;
+        return true;
     }
     return false;
 }
@@ -159,7 +291,19 @@ bool DeviceGate::startSession() {
         spdlog::debug("DeviceGate start fwp successful");
         return true;
     } else {
-        spdlog::debug("DeviceGate start fwp not successful - got no response");
+	USBRequest_t request;
+	request.RequestNum = START_SESSION;
+	request.RequestSize = sessionId.size();
+	XLinkGateWrite(&request, sizeof(USBRequest_t));
+	XLinkGateWrite((void*)sessionId.c_str(), sessionId.size());
+
+	XLinkGateRead(&request, sizeof(request));
+	if(request.RequestNum == RESPONSE_ERROR) {
+            spdlog::debug("DeviceGate start fwp not successful - got no response");
+	    return false;
+	}
+        spdlog::debug("DeviceGate start fwp successful");
+	return true;
     }
 
     return false;
@@ -188,7 +332,19 @@ bool DeviceGate::stopSession() {
         spdlog::debug("DeviceGate stopSession successful");
         return true;
     } else {
-        spdlog::error("DeviceGate stopSession not successful - got no response");
+	USBRequest_t request;
+	request.RequestNum = STOP_SESSION;
+	request.RequestSize = sessionId.size();
+	XLinkGateWrite(&request, sizeof(USBRequest_t));
+	XLinkGateWrite((void*)sessionId.c_str(), sessionId.size());
+
+	XLinkGateRead(&request, sizeof(request));
+	if(request.RequestNum == RESPONSE_ERROR) {
+            spdlog::error("DeviceGate stopSession not successful - got no response");
+	    return false;
+	}
+        spdlog::debug("DeviceGate stopSession successful");
+	return true;
     }
 
     return false;
@@ -214,7 +370,19 @@ bool DeviceGate::destroySession() {
         spdlog::debug("DeviceGate destroySession successful");
         return true;
     } else {
-        spdlog::error("DeviceGate destroySession not successful - got no response");
+	USBRequest_t request;
+	request.RequestNum = DESTROY_SESSION;
+	request.RequestSize = sessionId.size();
+	XLinkGateWrite(&request, sizeof(USBRequest_t));
+	XLinkGateWrite((void*)sessionId.c_str(), sessionId.size());
+
+	XLinkGateRead(&request, sizeof(request));
+	if(request.RequestNum == RESPONSE_ERROR) {
+            spdlog::error("DeviceGate destroySession not successful - got no response");
+	    return false;
+	}
+        spdlog::debug("DeviceGate destroySession successful");
+	return true;
     }
     return false;
 }
@@ -234,7 +402,19 @@ bool DeviceGate::deleteSession() {
         spdlog::debug("DeviceGate deleteSession successful");
         return true;
     } else {
-        spdlog::error("DeviceGate deleteSession not successful - got no response");
+	USBRequest_t request;
+	request.RequestNum = DELETE_SESSION;
+	request.RequestSize = sessionId.size();
+	XLinkGateWrite(&request, sizeof(USBRequest_t));
+	XLinkGateWrite((void*)sessionId.c_str(), sessionId.size());
+
+	XLinkGateRead(&request, sizeof(request));
+	if(request.RequestNum == RESPONSE_ERROR) {
+            spdlog::error("DeviceGate deleteSession not successful - got no response");
+	    return false;
+	}
+        spdlog::debug("DeviceGate deleteSession successful");
+	return true;
     }
     return false;
 }
@@ -273,7 +453,43 @@ DeviceGate::SessionState DeviceGate::getState() {
         }
         return sessionState;
     } else {
-        spdlog::warn("DeviceGate getState not successful - got no response");
+	USBRequest_t request;
+	request.RequestNum = GET_STATE;
+	request.RequestSize = sessionId.size();
+	XLinkGateWrite(&request, sizeof(USBRequest_t));
+	XLinkGateWrite((void*)sessionId.c_str(), sessionId.size());
+
+	XLinkGateRead(&request, sizeof(request));
+	if(request.RequestNum == RESPONSE_ERROR) {
+            spdlog::warn("DeviceGate getState not successful - got no response");
+    	    return SessionState::ERROR_STATE;
+	}
+
+	char *respBuffer = new char[request.RequestSize + 1];
+	XLinkGateRead(respBuffer, request.RequestSize);
+	respBuffer[request.RequestSize]= '\0';
+        auto resp = nlohmann::json::parse(respBuffer);
+	delete[] respBuffer;
+        spdlog::trace("DeviceGate getState response: {}", resp.dump());
+
+        std::string sessionStateStr = resp["state"];
+        if(sessionStateStr == "CREATED") {
+            sessionState = SessionState::CREATED;
+        } else if(sessionStateStr == "RUNNING") {
+            sessionState = SessionState::RUNNING;
+        } else if(sessionStateStr == "STOPPED") {
+            sessionState = SessionState::STOPPED;
+        } else if(sessionStateStr == "STOPPING") {
+            sessionState = SessionState::STOPPING;
+        } else if(sessionStateStr == "CRASHED") {
+            sessionState = SessionState::CRASHED;
+        } else if(sessionStateStr == "DESTROYED") {
+            sessionState = SessionState::DESTROYED;
+        } else {
+            spdlog::warn("DeviceGate getState not successful - unknown session state: {}", sessionStateStr);
+            sessionState = SessionState::ERROR_STATE;
+        }
+        return sessionState;
     }
     return SessionState::ERROR_STATE;
 }
@@ -293,8 +509,29 @@ std::optional<std::vector<uint8_t>> DeviceGate::getFile(const std::string& fileU
             return std::nullopt;
         }
     } else {
-        spdlog::warn("File download not successful - got no response");
-        return std::nullopt;
+	USBRequest_t request;
+	request.RequestNum = GET_FILE;
+	request.RequestSize = fileUrl.size();
+	XLinkGateWrite(&request, sizeof(USBRequest_t));
+	XLinkGateWrite((void*)fileUrl.c_str(), fileUrl.size());
+
+	XLinkGateRead(&request, sizeof(request));
+	if(request.RequestNum == RESPONSE_ERROR) {
+	    spdlog::warn("File download not successful - got no response");
+	    return std::nullopt;
+	}
+
+	char *respBuffer = new char[request.RequestSize + 1];
+	XLinkGateRead(respBuffer, request.RequestSize);
+	respBuffer[request.RequestSize]= '\0';
+        auto resp = nlohmann::json::parse(respBuffer);
+	delete[] respBuffer;
+
+	filename = resp["filename"].get<std::string>();
+        std::vector<uint8_t> fileData(resp["data"].get<std::vector<uint8_t>>());
+
+        spdlog::debug("File download successful. Filename: {}", filename);
+        return fileData;
     }
 }