Updated xlink and added test for Gate Write

Author: Filippo Mutta

cmake/depthaiDependencies.cmake

@@ -176,7 +176,7 @@ else()
     FetchContent_Declare(
         XLink
         GIT_REPOSITORY https://github.com/luxonis/XLink.git
-        GIT_TAG        fdc7ca6699431bab598e366057274c9e215967c0
+        GIT_TAG        e519b8698d81722b05b389551e1038006198ef77
     )
 
     FetchContent_MakeAvailable(

examples/cpp/Camera/camera_max_resolution.cpp

@@ -23,12 +23,14 @@ int main() {
         auto videoIn = videoQueue->get<dai::ImgFrame>();
         if(videoIn == nullptr) continue;
 
-        cv::imshow("video", videoIn->getCvFrame());
+	videoIn->getCvFrame();
+std::cout << "Got frame" << std::endl;
+        //cv::imshow("video", videoIn->getCvFrame());
 
-        if(cv::waitKey(1) == 'q') {
-            break;
-        }
+        //if(cv::waitKey(1) == 'q') {
+        //    break;
+        //}
     }
 
     return 0;
-}
+}

examples/cpp/Camera/camera_output.cpp

@@ -13,21 +13,22 @@ int main() {
 
     // Create nodes
     auto cam = pipeline.create<dai::node::Camera>()->build();
-    auto videoQueue = cam->requestOutput(std::make_pair(640, 400))->createOutputQueue();
+    auto videoQueue = cam->requestOutput(std::make_pair(4096, 2160))->createOutputQueue();
+    //auto videoQueue = cam->requestOutput(std::make_pair(2048, 1556))->createOutputQueue();
 
     // Start pipeline
     pipeline.start();
 
     while(true) {
         auto videoIn = videoQueue->get<dai::ImgFrame>();
         if(videoIn == nullptr) continue;
-
-        cv::imshow("video", videoIn->getCvFrame());
+	videoIn->getCvFrame();
+/*        cv::imshow("video", videoIn->getCvFrame());
 
         if(cv::waitKey(1) == 'q') {
             break;
-        }
+        }*/
     }
 
     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;

include/depthai/xlink/XLinkStream.hpp

@@ -92,12 +92,14 @@ class XLinkStream {
     void write(long fd);
     void write(long fd, span<const uint8_t> data);
     void write(const void* data, std::size_t size);
+    void writeGate(span<const uint8_t> data);
     std::vector<std::uint8_t> read();
     std::vector<std::uint8_t> read(XLinkTimespec& timestampReceived);
     void read(std::vector<std::uint8_t>& data);
     void read(std::vector<std::uint8_t>& data, long& fd);
     void read(std::vector<std::uint8_t>& data, XLinkTimespec& timestampReceived);
     void read(std::vector<std::uint8_t>& data, long& fd, XLinkTimespec& timestampReceived);
+    void readGate(std::vector<std::uint8_t>& data);
     // split write helper
     void writeSplit(const void* data, std::size_t size, std::size_t split);
     void writeSplit(const std::vector<uint8_t>& data, std::size_t split);

src/device/DeviceGate.cpp

@@ -44,7 +44,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 +56,27 @@ 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);
+        
+    gateConnection = std::make_shared<XLinkConnection>(deviceInfo, X_LINK_GATE);
+    gateStream = std::make_shared<XLinkStream>(gateConnection, "XLink Gate Stream", 32 * 1024 * 1024);
+    
 }
 
 bool DeviceGate::isOkay() {
     if(auto res = pimpl->cli->Get("/api/v1/status")) {
         return nlohmann::json::parse(res->body)["status"].get<bool>();
     }
+
+    struct request_t {
+	uint16_t RequestNum;
+    }__attribute__((packed));
+    request_t request;
+    request.RequestNum = 1;
+
+    span<const uint8_t> data;
+    memcpy((char*)data.data(), &request, sizeof(request));
+    gateStream->writeGate(data);
+
     return false;
 }
 

src/xlink/XLinkStream.cpp

@@ -113,6 +113,14 @@ void XLinkStream::write(long fd, span<const uint8_t> data) {
     }
 }
 
+void XLinkStream::writeGate(span<const uint8_t> data) {
+    auto status = XLinkGateWriteData(streamId, data.data(), static_cast<int>(data.size()));
+    if(status != X_LINK_SUCCESS) {
+        throw XLinkWriteError(status, streamName);
+    }
+}
+
+
 void XLinkStream::read(std::vector<std::uint8_t>& data) {
     XLinkTimespec timestampReceived;
     read(data, timestampReceived);
@@ -158,6 +166,15 @@ std::vector<std::uint8_t> XLinkStream::read(XLinkTimespec& timestampReceived) {
     return data;
 }
 
+void XLinkStream::readGate(std::vector<std::uint8_t>& data) {
+    StreamPacketDesc packet;
+    const auto status = XLinkReadMoveData(streamId, &packet);
+    if(status != X_LINK_SUCCESS) {
+        throw XLinkReadError(status, streamName);
+    }
+    data = std::vector<std::uint8_t>(packet.data, packet.data + packet.length);
+}
+
 StreamPacketDesc XLinkStream::readMove() {
     StreamPacketDesc packet;
     const auto status = XLinkReadMoveData(streamId, &packet);