Release v5.0.0 of Boston Dynamics Spot SDK (#14)

Co-authored-by: Boston Dynamics SDK Publisher <[email protected]>

Author: khughes-bdai

README.md

@@ -21,7 +21,7 @@ The official Spot SDK documentation also contains information relevant to the C+
 - [Payload developer documentation](https://dev.bostondynamics.com/docs/payload/readme). Payloads add additional sensing, communication, and control capabilities beyond what the base platform provides. The Payload ICD covers the mechanical, electrical, and software interfaces that Spot supports.
 - [Spot API protocol definition](https://dev.bostondynamics.com/docs/protos/readme). This reference guide covers the details of the protocol applications used to communicate to Spot. Application developers who wish to use a language other than Python can implement clients that speak the protocol.
 
-This is version 4.1.1 of the C++ SDK. Please review the [Release Notes](docs/cpp_release_notes.md) to see what has changed.
+This is version 5.0.0 of the C++ SDK. Please review the [Release Notes](docs/cpp_release_notes.md) to see what has changed.
 
 ## Contents
 

cpp/CMakeLists.txt

@@ -7,7 +7,7 @@
 # This file is autogenerated.
 
 cmake_minimum_required (VERSION 3.10.2)
-project (bosdyn VERSION 4.1.1)
+project (bosdyn VERSION 5.0.0)
 
 # Dependencies:
 find_package(Protobuf REQUIRED)
@@ -250,6 +250,7 @@ target_include_directories(inverse_kinematics_reachability PUBLIC
 )
 target_link_libraries(inverse_kinematics_reachability PUBLIC bosdyn_client_static)
 install(TARGETS inverse_kinematics_reachability DESTINATION ${CMAKE_INSTALL_BINDIR})
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/examples/joint_control)
 add_executable(spot_cam ${CMAKE_CURRENT_SOURCE_DIR}/examples/spot_cam/ptz_example.cpp)
 target_compile_features(spot_cam PUBLIC cxx_std_17)
 target_include_directories(spot_cam PUBLIC

cpp/bosdyn/client/gripper_camera_param/gripper_camera_param_client.cpp

@@ -80,6 +80,43 @@ GripperCameraParamClient::GetGripperCameraParamsAsync(const RPCParameters& param
     return future;
 }
 
+SetGripperCameraCalibResponseType GripperCameraParamClient::SetGripperCameraCalib(
+    ::bosdyn::api::SetGripperCameraCalibrationRequest& request, const RPCParameters& parameters) {
+    return SetGripperCameraCalibAsync(request, parameters).get();
+}
+
+std::shared_future<SetGripperCameraCalibResponseType>
+GripperCameraParamClient::SetGripperCameraCalibAsync(
+    ::bosdyn::api::SetGripperCameraCalibrationRequest& request, const RPCParameters& parameters) {
+    std::promise<SetGripperCameraCalibResponseType> response;
+    std::shared_future<SetGripperCameraCalibResponseType> future = response.get_future();
+    BOSDYN_ASSERT_PRECONDITION(m_stub != nullptr, "Stub for service is unset!");
+
+    MessagePumpCallBase* one_time =
+        InitiateAsyncCall<::bosdyn::api::SetGripperCameraCalibrationRequest,
+                          ::bosdyn::api::SetGripperCameraCalibrationResponse,
+                          ::bosdyn::api::SetGripperCameraCalibrationResponse>(
+            request,
+            std::bind(&::bosdyn::api::GripperCameraParamService::StubInterface::AsyncSetCamCalib,
+                      m_stub.get(), _1, _2, _3),
+            std::bind(&GripperCameraParamClient::OnSetGripperCameraCalibComplete, this, _1, _2, _3,
+                      _4, _5),
+            std::move(response), parameters);
+
+    return future;
+}
+
+void GripperCameraParamClient::OnSetGripperCameraCalibComplete(
+    MessagePumpCallBase* call, const ::bosdyn::api::SetGripperCameraCalibrationRequest& request,
+    ::bosdyn::api::SetGripperCameraCalibrationResponse&& response, const grpc::Status& status,
+    std::promise<SetGripperCameraCalibResponseType> promise) {
+    ::bosdyn::common::Status ret_status =
+        ProcessResponseAndGetFinalStatus<::bosdyn::api::SetGripperCameraCalibrationResponse>(
+            status, response, SDKErrorCode::Success);
+
+    promise.set_value({ret_status, std::move(response)});
+}
+
 void GripperCameraParamClient::OnGetGripperCameraParamsComplete(
     MessagePumpCallBase* call, const ::bosdyn::api::GripperCameraGetParamRequest& request,
     ::bosdyn::api::GripperCameraGetParamResponse&& response, const grpc::Status& status,
@@ -91,6 +128,44 @@ void GripperCameraParamClient::OnGetGripperCameraParamsComplete(
     promise.set_value({ret_status, std::move(response)});
 }
 
+GetGripperCameraCalibrationResponseType GripperCameraParamClient::GetGripperCameraCalib(
+    const RPCParameters& parameters) {
+    return GetGripperCameraCalibAsync(parameters).get();
+}
+
+std::shared_future<GetGripperCameraCalibrationResponseType>
+GripperCameraParamClient::GetGripperCameraCalibAsync(const RPCParameters& parameters) {
+    std::promise<GetGripperCameraCalibrationResponseType> response;
+    std::shared_future<GetGripperCameraCalibrationResponseType> future = response.get_future();
+    BOSDYN_ASSERT_PRECONDITION(m_stub != nullptr, "Stub for service is unset!");
+
+    ::bosdyn::api::GetGripperCameraCalibrationRequest request;
+
+    MessagePumpCallBase* one_time =
+        InitiateAsyncCall<::bosdyn::api::GetGripperCameraCalibrationRequest,
+                          ::bosdyn::api::GetGripperCameraCalibrationResponse,
+                          ::bosdyn::api::GetGripperCameraCalibrationResponse>(
+            request,
+            std::bind(&::bosdyn::api::GripperCameraParamService::StubInterface::AsyncGetCamCalib,
+                      m_stub.get(), _1, _2, _3),
+            std::bind(&GripperCameraParamClient::OnGetGripperCameraCalibComplete, this, _1, _2, _3,
+                      _4, _5),
+            std::move(response), parameters);
+
+    return future;
+}
+
+void GripperCameraParamClient::OnGetGripperCameraCalibComplete(
+    MessagePumpCallBase* call, const ::bosdyn::api::GetGripperCameraCalibrationRequest& request,
+    ::bosdyn::api::GetGripperCameraCalibrationResponse&& response, const grpc::Status& status,
+    std::promise<GetGripperCameraCalibrationResponseType> promise) {
+    ::bosdyn::common::Status ret_status =
+        ProcessResponseAndGetFinalStatus<::bosdyn::api::GetGripperCameraCalibrationResponse>(
+            status, response, SDKErrorCode::Success);
+
+    promise.set_value({ret_status, std::move(response)});
+}
+
 // Start of ServiceClient overrides.
 ServiceClient::QualityOfService GripperCameraParamClient::GetQualityOfService() const {
     return QualityOfService::NORMAL;

cpp/bosdyn/client/gripper_camera_param/gripper_camera_param_client.h

@@ -22,6 +22,10 @@ namespace client {
 
 typedef Result<::bosdyn::api::GripperCameraParamResponse> GripperCameraSetParamResponseType;
 typedef Result<::bosdyn::api::GripperCameraGetParamResponse> GripperCameraGetParamResponseType;
+typedef Result<::bosdyn::api::SetGripperCameraCalibrationResponse>
+    SetGripperCameraCalibResponseType;
+typedef Result<::bosdyn::api::GetGripperCameraCalibrationResponse>
+    GetGripperCameraCalibrationResponseType;
 
 // GripperCameraParamClient is the GRPC client for the gripper camera parameter service defined in
 // gripper_camera_param_service.proto.
@@ -49,6 +53,24 @@ class GripperCameraParamClient : public ServiceClient {
     std::shared_future<GripperCameraGetParamResponseType> GetGripperCameraParamsAsync(
         const RPCParameters& parameters = RPCParameters());
 
+    // Synchronous method to request to set gripper camera calibration.
+    SetGripperCameraCalibResponseType SetGripperCameraCalib(
+        ::bosdyn::api::SetGripperCameraCalibrationRequest& request,
+        const RPCParameters& parameters = RPCParameters());
+
+    // Asynchronous method to request to set gripper camera calibration.
+    std::shared_future<SetGripperCameraCalibResponseType> SetGripperCameraCalibAsync(
+        ::bosdyn::api::SetGripperCameraCalibrationRequest& request,
+        const RPCParameters& parameters = RPCParameters());
+
+    // Synchronous method to request to get gripper camera calibration.
+    GetGripperCameraCalibrationResponseType GetGripperCameraCalib(
+        const RPCParameters& parameters = RPCParameters());
+
+    // Asynchronous method to request to get gripper camera calibration.
+    std::shared_future<GetGripperCameraCalibrationResponseType> GetGripperCameraCalibAsync(
+        const RPCParameters& parameters = RPCParameters());
+
     // Start of ServiceClient overrides.
     QualityOfService GetQualityOfService() const override;
     void SetComms(const std::shared_ptr<grpc::ChannelInterface>& channel) override;
@@ -86,6 +108,20 @@ class GripperCameraParamClient : public ServiceClient {
         ::bosdyn::api::GripperCameraGetParamResponse&& response, const grpc::Status& status,
         std::promise<GripperCameraGetParamResponseType> promise);
 
+    // Callback that will return SetGripperCameraCalibrationResponse message after
+    // SetGripperCameraCalib rpc returns to the client.
+    void OnSetGripperCameraCalibComplete(
+        MessagePumpCallBase* call, const ::bosdyn::api::SetGripperCameraCalibrationRequest& request,
+        ::bosdyn::api::SetGripperCameraCalibrationResponse&& response, const grpc::Status& status,
+        std::promise<SetGripperCameraCalibResponseType> promise);
+
+    // Callback that will return GetGripperCameraCalibrationResponse message after
+    // GetGripperCameraCalib rpc returns to the client.
+    void OnGetGripperCameraCalibComplete(
+        MessagePumpCallBase* call, const ::bosdyn::api::GetGripperCameraCalibrationRequest& request,
+        ::bosdyn::api::GetGripperCameraCalibrationResponse&& response, const grpc::Status& status,
+        std::promise<GetGripperCameraCalibrationResponseType> promise);
+
     std::unique_ptr<::bosdyn::api::GripperCameraParamService::StubInterface> m_stub;
 
     // Lease wallet for commands.

cpp/bosdyn/client/network_compute_bridge/network_compute_bridge_client.cpp

@@ -0,0 +1,102 @@
+/**
+ * Copyright (c) 2023 Boston Dynamics, Inc.  All rights reserved.
+ *
+ * Downloading, reproducing, distributing or otherwise using the SDK Software
+ * is subject to the terms and conditions of the Boston Dynamics Software
+ * Development Kit License (20191101-BDSDK-SL).
+ */
+
+
+#include "network_compute_bridge_client.h"
+
+using namespace std::placeholders;
+
+namespace bosdyn {
+
+namespace client {
+
+const char* NetworkComputeBridgeClient::s_default_service_name = "network-compute-bridge";
+
+const char* NetworkComputeBridgeClient::s_service_type = "bosdyn.api.NetworkComputeBridge";
+
+std::shared_future<NetworkComputeResultType> NetworkComputeBridgeClient::NetworkComputeAsync(
+    ::bosdyn::api::NetworkComputeRequest& request, const RPCParameters& parameters) {
+    std::promise<NetworkComputeResultType> response;
+    std::shared_future<NetworkComputeResultType> future = response.get_future();
+    BOSDYN_ASSERT_PRECONDITION(m_stub != nullptr, "Stub for service is unset!");
+
+    MessagePumpCallBase* one_time = InitiateAsyncCall<::bosdyn::api::NetworkComputeRequest,
+                                                      ::bosdyn::api::NetworkComputeResponse,
+                                                      ::bosdyn::api::NetworkComputeResponse>(
+        request,
+        std::bind(&::bosdyn::api::NetworkComputeBridge::StubInterface::AsyncNetworkCompute,
+                  m_stub.get(), _1, _2, _3),
+        std::bind(&NetworkComputeBridgeClient::OnNetworkComputeComplete, this, _1, _2, _3, _4, _5),
+        std::move(response), parameters);
+    return future;
+}
+
+void NetworkComputeBridgeClient::OnNetworkComputeComplete(
+    MessagePumpCallBase* call, const ::bosdyn::api::NetworkComputeRequest& request,
+    ::bosdyn::api::NetworkComputeResponse&& response, const grpc::Status& status,
+    std::promise<NetworkComputeResultType> promise) {
+    std::cout << "On network compute complete\n";
+    ::bosdyn::common::Status ret_status =
+        ProcessResponseAndGetFinalStatus<::bosdyn::api::NetworkComputeResponse>(status, response,
+                                                                                response.status());
+    std::cout << "Ret status: " << ret_status.DebugString() << std::endl;
+    promise.set_value({ret_status, std::move(response)});
+}
+
+NetworkComputeResultType NetworkComputeBridgeClient::NetworkCompute(
+    ::bosdyn::api::NetworkComputeRequest& request, const RPCParameters& parameters) {
+    return NetworkComputeAsync(request, parameters).get();
+}
+
+std::shared_future<ListAvailableModelsResultType>
+NetworkComputeBridgeClient::ListAvailableModelsAsync(
+    ::bosdyn::api::ListAvailableModelsRequest& request, const RPCParameters& parameters) {
+    std::promise<ListAvailableModelsResultType> response;
+    std::shared_future<ListAvailableModelsResultType> future = response.get_future();
+    BOSDYN_ASSERT_PRECONDITION(m_stub != nullptr, "Stub for service is unset!");
+
+    MessagePumpCallBase* one_time = InitiateAsyncCall<::bosdyn::api::ListAvailableModelsRequest,
+                                                      ::bosdyn::api::ListAvailableModelsResponse,
+                                                      ::bosdyn::api::ListAvailableModelsResponse>(
+        request,
+        std::bind(&::bosdyn::api::NetworkComputeBridge::StubInterface::AsyncListAvailableModels,
+                  m_stub.get(), _1, _2, _3),
+        std::bind(&NetworkComputeBridgeClient::OnListAvailableModelsComplete, this, _1, _2, _3, _4,
+                  _5),
+        std::move(response), parameters);
+    return future;
+};
+
+void NetworkComputeBridgeClient::OnListAvailableModelsComplete(
+    MessagePumpCallBase* call, const ::bosdyn::api::ListAvailableModelsRequest& request,
+    ::bosdyn::api::ListAvailableModelsResponse&& response, const grpc::Status& status,
+    std::promise<ListAvailableModelsResultType> promise) {
+    std::cout << "On list available models complete\n";
+    ::bosdyn::common::Status ret_status =
+        ProcessResponseAndGetFinalStatus<::bosdyn::api::ListAvailableModelsResponse>(
+            status, response, response.status());
+    std::cout << "Ret status: " << ret_status.DebugString() << std::endl;
+    promise.set_value({ret_status, std::move(response)});
+}
+
+ListAvailableModelsResultType NetworkComputeBridgeClient::ListAvailableModels(
+    ::bosdyn::api::ListAvailableModelsRequest& request, const RPCParameters& parameters) {
+    return ListAvailableModelsAsync(request, parameters).get();
+}
+
+ServiceClient::QualityOfService NetworkComputeBridgeClient::GetQualityOfService() const {
+    return QualityOfService::NORMAL;
+}
+
+void NetworkComputeBridgeClient::SetComms(const std::shared_ptr<grpc::ChannelInterface>& channel) {
+    m_stub.reset(new ::bosdyn::api::NetworkComputeBridge::Stub(channel));
+}
+
+}  // namespace client
+
+}  // namespace bosdyn

cpp/bosdyn/client/network_compute_bridge/network_compute_bridge_client.h

@@ -0,0 +1,99 @@
+/**
+ * Copyright (c) 2023 Boston Dynamics, Inc.  All rights reserved.
+ *
+ * Downloading, reproducing, distributing or otherwise using the SDK Software
+ * is subject to the terms and conditions of the Boston Dynamics Software
+ * Development Kit License (20191101-BDSDK-SL).
+ */
+
+
+#pragma once
+
+#include <bosdyn/api/network_compute_bridge.pb.h>
+#include <bosdyn/api/network_compute_bridge_service.grpc.pb.h>
+
+#include <future>
+
+#include "network_compute_bridge_error_codes.h"
+#include "bosdyn/client/service_client/service_client.h"
+
+namespace bosdyn {
+
+namespace client {
+
+// Defining result types for each RPC featuring the RPC call's status and the response message
+// the RPC was returning from the robot
+typedef Result<::bosdyn::api::NetworkComputeResponse> NetworkComputeResultType;
+typedef Result<::bosdyn::api::ListAvailableModelsResponse> ListAvailableModelsResultType;
+
+// Client which communicates with the NetworkComputeBridgeWorker service
+class NetworkComputeBridgeClient : public ServiceClient {
+ public:
+    NetworkComputeBridgeClient() = default;
+    ~NetworkComputeBridgeClient() = default;
+
+    // Asynchronous method to request a response to a (now deprecated) NetworkComputeRequest
+    std::shared_future<NetworkComputeResultType> NetworkComputeAsync(
+        ::bosdyn::api::NetworkComputeRequest& request,
+        const RPCParameters& parameters = RPCParameters());
+
+    // Synchronous method to request a response to a NetworkComputeRequest
+    NetworkComputeResultType NetworkCompute(::bosdyn::api::NetworkComputeRequest& request,
+                                            const RPCParameters& parameters = RPCParameters());
+
+    // Asynchronous method to request a list of available NCB models on the robot
+    std::shared_future<ListAvailableModelsResultType> ListAvailableModelsAsync(
+        ::bosdyn::api::ListAvailableModelsRequest& request,
+        const RPCParameters& parameters = RPCParameters());
+
+    // Synchronous method to request a list of available NCB models on the robot
+    ListAvailableModelsResultType ListAvailableModels(
+        ::bosdyn::api::ListAvailableModelsRequest& request,
+        const RPCParameters& parameters = RPCParameters());
+
+    // Start of ServiceClient overrides.
+    // Sets the QualityOfService enum for the network compute bridge worker client to be used for
+    // network selection optimization.
+    QualityOfService GetQualityOfService() const override;
+
+    // Set the communication details of the network compute bridge worker service, including the
+    // stub and request/response processors
+    void SetComms(const std::shared_ptr<grpc::ChannelInterface>& channel) override;
+
+    // End of ServiceClient overrides.
+
+    // Get the default service name the network compute bridge worker service will be registered in
+    // the directory with.
+    static std::string GetDefaultServiceName() { return s_default_service_name; }
+
+    // Get the default service type for the network compute bridge worker service that will be
+    // registered in the directory.
+    static std::string GetServiceType() { return s_service_type; }
+
+ private:
+    // Callback function for asynchronous NetworkCompute RPC calls to return a result
+    void OnNetworkComputeComplete(MessagePumpCallBase* call,
+                                  const ::bosdyn::api::NetworkComputeRequest& request,
+                                  ::bosdyn::api::NetworkComputeResponse&& response,
+                                  const grpc::Status& status,
+                                  std::promise<NetworkComputeResultType> promise);
+
+    // Callback function for asynchronous ListAvailableModels RPC calls to return a result
+    void OnListAvailableModelsComplete(MessagePumpCallBase* call,
+                                       const ::bosdyn::api::ListAvailableModelsRequest& request,
+                                       ::bosdyn::api::ListAvailableModelsResponse&& response,
+                                       const grpc::Status& status,
+                                       std::promise<ListAvailableModelsResultType> promise);
+
+    std::unique_ptr<::bosdyn::api::NetworkComputeBridge::StubInterface> m_stub;
+
+    // Default service name for the network compute bridge worker service.
+    static const char* s_default_service_name;
+
+    // Default service type for the network compute bridge worker service.
+    static const char* s_service_type;
+};
+
+}  // namespace client
+
+}  // namespace bosdyn

cpp/bosdyn/client/network_compute_bridge/network_compute_bridge_error_codes.cpp

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) 2023 Boston Dynamics, Inc.  All rights reserved.
+ *
+ * Downloading, reproducing, distributing or otherwise using the SDK Software
+ * is subject to the terms and conditions of the Boston Dynamics Software
+ * Development Kit License (20191101-BDSDK-SL).
+ */
+
+
+#include "bosdyn/client/network_compute_bridge//network_compute_bridge_error_codes.h"
+#include "bosdyn/client/error_codes/proto_enum_to_stderror_macro_source.h"
+
+DEFINE_PROTO_ENUM_ERRORCODE_IMPL_API(NetworkComputeStatus, valcode == 1)
+DEFINE_PROTO_ENUM_ERRORCODE_IMPL_API(ListAvailableModelsStatus, valcode == 1)