add debug_protocol::build_command()

include/librealsense2/h/rs_device.h

@@ -81,7 +81,7 @@ int rs2_supports_device_info(const rs2_device* device, rs2_camera_info info, rs2
 void rs2_hardware_reset(const rs2_device * device, rs2_error ** error);
 
 /**
-* Build debug_protocl raw data command from opcode, parameters and data.
+* Build debug_protocol raw data command from opcode, parameters and data.
 * The result can be used as raw_data_to_send parameter in send_and_receive_raw_data
 * \param[in]  device                    RealSense device to send data to
 * \param[in]  opcode                    Commad opcode
@@ -94,8 +94,8 @@ void rs2_hardware_reset(const rs2_device * device, rs2_error ** error);
 * \param[out] error                     If non-null, receives any error that occurs during this call, otherwise, errors are ignored
 * \return                               rs2_raw_data_buffer which includes raw command
 */
-const rs2_raw_data_buffer* rs2_build_debug_protocol_command(rs2_device* device, unsigned int opcode, unsigned int param1, unsigned int param2,
-    unsigned int param3, unsigned int param4, void* data, unsigned size_of_data, rs2_error** error);
+const rs2_raw_data_buffer* rs2_build_debug_protocol_command(rs2_device* device, unsigned opcode, unsigned param1, unsigned param2,
+    unsigned param3, unsigned param4, void* data, size_t size_of_data, rs2_error** error);
 
 /**
 * Send raw data to device

include/librealsense2/hpp/rs_device.hpp

@@ -830,12 +830,12 @@ namespace rs2
             error::handle(e);
         }
 
-        std::vector<uint8_t> build_command(const uint32_t opcode,
-            const uint32_t param1 = 0,
-            const uint32_t param2 = 0,
-            const uint32_t param3 = 0,
-            const uint32_t param4 = 0,
-            const std::vector<uint8_t>& data = std::vector<uint8_t>()) const
+        std::vector<uint8_t> build_command(uint32_t opcode,
+            uint32_t param1 = 0,
+            uint32_t param2 = 0,
+            uint32_t param3 = 0,
+            uint32_t param4 = 0,
+            std::vector<uint8_t> & const data = std::vector<uint8_t>()) const
         {
             std::vector<uint8_t> results;
 

src/core/debug.h

@@ -12,13 +12,13 @@ namespace librealsense
     {
     public:
         virtual std::vector<uint8_t> send_receive_raw_data(const std::vector<uint8_t>& input) = 0;
-        virtual std::vector<uint8_t> build_command(const uint32_t opcode,
-            const uint32_t param1 = 0,
-            const uint32_t param2 = 0,
-            const uint32_t param3 = 0,
-            const uint32_t param4 = 0,
-            const uint8_t* data = nullptr,
-            int dataLength = 0) = 0;
+        virtual std::vector<uint8_t> build_command(uint32_t opcode,
+            uint32_t param1 = 0,
+            uint32_t param2 = 0,
+            uint32_t param3 = 0,
+            uint32_t param4 = 0,
+            uint8_t * const data = nullptr,
+            size_t dataLength = 0) const = 0;
 
     };
 

src/ds5/ds5-device.cpp

@@ -123,13 +123,13 @@ namespace librealsense
         return _hw_monitor->send(input);
     }
 
-    std::vector<uint8_t> ds5_device::build_command(const uint32_t opcode,
-        const uint32_t param1,
-        const uint32_t param2,
-        const uint32_t param3,
-        const uint32_t param4,
-        const uint8_t* data,
-        int dataLength)
+    std::vector<uint8_t> ds5_device::build_command(uint32_t opcode,
+        uint32_t param1,
+        uint32_t param2,
+        uint32_t param3,
+        uint32_t param4,
+        uint8_t * const data,
+        size_t dataLength) const
     {
         return _hw_monitor->build_command(opcode, param1, param2, param3, param4, data, dataLength);
     }

src/ds5/ds5-device.h

@@ -55,13 +55,13 @@ namespace librealsense
 
         std::vector<uint8_t> send_receive_raw_data(const std::vector<uint8_t>& input) override;
 
-        std::vector<uint8_t> build_command(const uint32_t opcode,
-            const uint32_t param1 = 0,
-            const uint32_t param2 = 0,
-            const uint32_t param3 = 0,
-            const uint32_t param4 = 0,
-            const uint8_t* data = nullptr,
-            int dataLength = 0) override;
+        std::vector<uint8_t> build_command(uint32_t opcode,
+            uint32_t param1 = 0,
+            uint32_t param2 = 0,
+            uint32_t param3 = 0,
+            uint32_t param4 = 0,
+            uint8_t * const data = nullptr,
+            size_t dataLength = 0) const override;
 
         void hardware_reset() override;
 

src/hw-monitor.cpp

@@ -174,8 +174,13 @@ namespace librealsense
             newCommand.receivedCommandData + newCommand.receivedCommandDataLength);
     }
 
-    std::vector<uint8_t> hw_monitor::build_command(const uint32_t opcode, const uint32_t param1, const uint32_t param2,
-        const uint32_t param3, const uint32_t param4, const uint8_t* data, int dataLength) const
+    std::vector<uint8_t> hw_monitor::build_command(uint32_t opcode,
+        uint32_t param1,
+        uint32_t param2,
+        uint32_t param3,
+        uint32_t param4,
+        uint8_t * const data,
+        size_t dataLength) const
     {
         int length;
         std::vector<uint8_t> result;

src/hw-monitor.h

@@ -332,8 +332,13 @@ namespace librealsense
 
         std::vector< uint8_t > send( std::vector< uint8_t > const & data ) const;
         std::vector<uint8_t> send( command cmd, hwmon_response * = nullptr, bool locked_transfer = false ) const;
-        std::vector<uint8_t> build_command(const uint32_t opcode, const uint32_t param1 = 0, const uint32_t param2 = 0,
-            const uint32_t param3 = 0, const uint32_t param4 = 0, const uint8_t* data = nullptr, int dataLength = 0) const;
+        std::vector<uint8_t> build_command(uint32_t opcode,
+            uint32_t param1 = 0,
+            uint32_t param2 = 0,
+            uint32_t param3 = 0,
+            uint32_t param4 = 0,
+            uint8_t * const data = nullptr,
+            size_t dataLength = 0) const;
 
         void get_gvd(size_t sz, unsigned char* gvd, uint8_t gvd_cmd) const;
         static std::string get_firmware_version_string(const std::vector<uint8_t>& buff, size_t index, size_t length = 4);

src/ivcam/sr300.h

@@ -342,13 +342,13 @@ namespace librealsense
         }
 
 
-        std::vector<uint8_t> build_command(const uint32_t opcode,
-            const uint32_t param1 = 0,
-            const uint32_t param2 = 0,
-            const uint32_t param3 = 0,
-            const uint32_t param4 = 0,
-            const uint8_t* data = nullptr,
-            int dataLength = 0)
+        std::vector<uint8_t> build_command(uint32_t opcode,
+            uint32_t param1 = 0,
+            uint32_t param2 = 0,
+            uint32_t param3 = 0,
+            uint32_t param4 = 0,
+            uint8_t * const data = nullptr,
+            size_t dataLength = 0) const override
         {
             return _hw_monitor->build_command(opcode, param1, param2, param3, param4, data, dataLength);
         }

src/l500/l500-device.cpp

@@ -587,13 +587,13 @@ namespace librealsense
         return _hw_monitor->send(input);
     }
 
-    std::vector<uint8_t> l500_device::build_command(const uint32_t opcode,
-        const uint32_t param1,
-        const uint32_t param2,
-        const uint32_t param3,
-        const uint32_t param4,
-        const uint8_t* data,
-        int dataLength)
+    std::vector<uint8_t> l500_device::build_command(uint32_t opcode,
+        uint32_t param1,
+        uint32_t param2,
+        uint32_t param3,
+        uint32_t param4,
+        uint8_t * const data,
+        size_t dataLength) const
     {
         return _hw_monitor->build_command(opcode, param1, param2, param3, param4, data, dataLength);
     }

src/l500/l500-device.h

@@ -48,13 +48,13 @@ namespace librealsense
         }
 
         std::vector< uint8_t > send_receive_raw_data(const std::vector< uint8_t > & input) override;
-        std::vector<uint8_t> build_command(const uint32_t opcode,
-            const uint32_t param1 = 0,
-            const uint32_t param2 = 0,
-            const uint32_t param3 = 0,
-            const uint32_t param4 = 0,
-            const uint8_t* data = nullptr,
-            int dataLength = 0) override;
+        std::vector<uint8_t> build_command(uint32_t opcode,
+            uint32_t param1 = 0,
+            uint32_t param2 = 0,
+            uint32_t param3 = 0,
+            uint32_t param4 = 0,
+            uint8_t * const data = nullptr,
+            size_t dataLength = 0) const override;
 
         void hardware_reset() override
         {

src/rs.cpp

@@ -557,8 +557,8 @@ rs2_stream_profile* rs2_clone_video_stream_profile(const rs2_stream_profile* mod
 }
 HANDLE_EXCEPTIONS_AND_RETURN(nullptr, mode, stream, index, format, width, height, intr)
 
-const rs2_raw_data_buffer* rs2_build_debug_protocol_command(rs2_device* device, unsigned int opcode, unsigned int param1, unsigned int param2,
-    unsigned int param3, unsigned int param4, void* data, unsigned size_of_data, rs2_error** error) BEGIN_API_CALL
+const rs2_raw_data_buffer* rs2_build_debug_protocol_command(rs2_device* device, unsigned opcode, unsigned param1, unsigned param2,
+    unsigned param3, unsigned param4, void* data, size_t size_of_data, rs2_error** error) BEGIN_API_CALL
 {
     VALIDATE_NOT_NULL(device);
 

unit-tests/debug_protocol/test-build-raw-data-command.py → unit-tests/debug_protocol/test-build-command.py

@@ -22,7 +22,9 @@ def convert_bytes_to_decimal(command):
 
 def send_hardware_monitor_command(device, command):
     raw_result = rs.debug_protocol(device).send_and_receive_raw_data(command)
-    return raw_result[4:]
+    status = raw_result[:4]
+    result = raw_result[4:]
+    return status, result
 
 
 #############################################################################################
@@ -33,6 +35,7 @@ def send_hardware_monitor_command(device, command):
 try:
     ctx = rs.context()
     dev = ctx.query_devices()[0]
+    expected_status = convert_bytes_to_decimal("10 00 00 00")
 except:
     test.unexpected_exception()
 test.finish()
@@ -43,7 +46,8 @@ def send_hardware_monitor_command(device, command):
 try:
     gvd_command = "14 00 ab cd 10 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00"
     raw_command = convert_bytes_to_decimal(gvd_command)
-    old_scenario_result = send_hardware_monitor_command(dev, raw_command)
+    status, old_scenario_result = send_hardware_monitor_command(dev, raw_command)
+    test.check_equal_lists(status, expected_status)
 except:
     test.unexpected_exception()
 test.finish()
@@ -54,7 +58,8 @@ def send_hardware_monitor_command(device, command):
 try:
     gvd_opcode = 0x10
     raw_command = rs.debug_protocol(dev).build_command(gvd_opcode)
-    new_scenario_result = send_hardware_monitor_command(dev, raw_command)
+    status, new_scenario_result = send_hardware_monitor_command(dev, raw_command)
+    test.check_equal_lists(status, expected_status)
     test.check_equal_lists(new_scenario_result, old_scenario_result)
 except:
     test.unexpected_exception()

wrappers/csharp/Intel.RealSense/Devices/DebugDevice.cs

@@ -31,7 +31,7 @@ public static DebugDevice FromDevice(Device dev)
         }
 
 
-        public byte[] BuildRawData(UInt32 opcode, UInt32 param1 = 0, UInt32 param2 = 0, UInt32 param3 = 0,
+        public byte[] BuildCommand(UInt32 opcode, UInt32 param1 = 0, UInt32 param2 = 0, UInt32 param3 = 0,
             UInt32 param4 = 0, byte[] data = null)
         {
             IntPtr nativeBytes = IntPtr.Zero;