booster-robotics-sdk-python 1.3.7__tar.gz → 1.3.9__tar.gz

booster_robotics_sdk_python-1.3.9/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.2
+Name: booster_robotics_sdk_python
+Version: 1.3.9
+Summary: Booster Robotics SDK Python bindings and examples.
+Author-Email: Booster Robotics <liupeize@boosterobotics.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# Booster Robotics SDK
+Booster Robotics SDK aims to provide a simple and easy-to-use interface for developers to control the Booster Robotics products. 
+
+## Prebuild environment
+* OS  (Ubuntu 22.04 LTS)  
+* CPU  (aarch64 and x86_64)   
+* Compiler  (gcc version 11.4.0) 
+
+## Installation
+```bash
+pip3 install pybind11
+# pip3 install pybind11-stubgen
+```
+
+## Build examples
+```bash
+mkdir build
+cd build
+cmake ..
+make
+```
+
+## Build python binding api and install
+```bash
+mkdir build
+cd build
+cmake .. -DBUILD_PYTHON_BINDING=on
+make
+sudo make install
+
+if pybind11-stubgen cannot be found even after pip install, export PATH
+```bash
+export PATH=/home/[user name]/.local/bin:$PATH
+```

booster_robotics_sdk_python-1.3.9/include/booster/common/dds/dds_entity.hpp

@@ -0,0 +1,438 @@
+#ifndef __BOOSTER_DDS_ENTITY_HPP__
+#define __BOOSTER_DDS_ENTITY_HPP__
+
+#include <algorithm>
+#include <chrono>
+#include <condition_variable>
+#include <cstdint>
+#include <deque>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <thread>
+#include <vector>
+
+#include <fastdds/dds/domain/DomainParticipant.hpp>
+#include <fastdds/dds/domain/DomainParticipantFactory.hpp>
+#include <fastdds/dds/topic/Topic.hpp>
+#include <fastdds/dds/publisher/Publisher.hpp>
+#include <fastdds/dds/publisher/DataWriter.hpp>
+#include <fastdds/dds/subscriber/Subscriber.hpp>
+#include <fastdds/dds/subscriber/DataReader.hpp>
+#include <fastdds/dds/subscriber/DataReaderListener.hpp>
+#include <fastdds/dds/subscriber/SampleInfo.hpp>
+#include <fastdds/dds/subscriber/qos/DataReaderQos.hpp>
+
+#include <booster/common/dds/dds_callback.hpp>
+
+namespace booster {
+namespace common {
+
+using namespace eprosima::fastdds::dds;
+
+// class DdsParticipant {
+// public:
+//     using NATIVE_TYPE = dds::domain::DomainParticipant;
+
+// }
+
+// class DdsReaderListener {
+// public:
+//     explicit
+
+// };
+
+using DdsParticipantPtr = std::shared_ptr<eprosima::fastdds::dds::DomainParticipant>;
+using DdsWriterPtr = std::shared_ptr<eprosima::fastdds::dds::DataWriter>;
+using DdsWriter = eprosima::fastdds::dds::DataWriter;
+using DdsReaderPtr = std::shared_ptr<eprosima::fastdds::dds::DataReader>;
+using DdsReader = eprosima::fastdds::dds::DataReader;
+using DdsPublisherPtr = std::shared_ptr<eprosima::fastdds::dds::Publisher>;
+using DdsSubscriberPtr = std::shared_ptr<eprosima::fastdds::dds::Subscriber>;
+using DdsTopicPtr = std::shared_ptr<eprosima::fastdds::dds::Topic>;
+using DdsTopic = eprosima::fastdds::dds::Topic;
+using DdsTopicDataTypePtr = std::shared_ptr<eprosima::fastdds::dds::TopicDataType>;
+using DdsReaderCallbackPtr = std::shared_ptr<DdsReaderCallback>;
+
+enum class DdsExecutorOverflowPolicy {
+    kDropNewest,
+    kDropOldest,
+    kLatestOnly,
+};
+
+enum class DdsExecutorDispatchMode {
+    kShared,
+    kDedicated,
+};
+
+struct DdsReaderExecutorOptions {
+    // 0 means unbounded. Generic subscribers use a bounded queue by default.
+    size_t queue_capacity{64};
+    DdsExecutorOverflowPolicy overflow_policy{DdsExecutorOverflowPolicy::kDropOldest};
+    bool enable_metrics{false};
+    DdsExecutorDispatchMode dispatch_mode{DdsExecutorDispatchMode::kShared};
+};
+
+struct DdsReaderExecutorMetrics {
+    uint64_t samples_received{0};
+    uint64_t samples_dropped{0};
+    uint64_t callbacks_executed{0};
+    size_t current_queue_size{0};
+    size_t queue_high_watermark{0};
+    uint64_t max_queue_latency_us{0};
+    uint64_t max_callback_duration_us{0};
+};
+
+class DdsCallbackExecutor {
+public:
+    static DdsCallbackExecutor &Instance() {
+        static DdsCallbackExecutor instance;
+        return instance;
+    }
+
+    void Submit(std::function<void()> task) {
+        {
+            std::lock_guard<std::mutex> lock(mutex_);
+            tasks_.emplace_back(std::move(task));
+        }
+        cv_.notify_one();
+    }
+
+private:
+    DdsCallbackExecutor() {
+        const auto thread_count = std::min<size_t>(
+            4,
+            std::max<size_t>(1, std::thread::hardware_concurrency()));
+        executors_.reserve(thread_count);
+        for (size_t i = 0; i < thread_count; ++i) {
+            executors_.emplace_back([this]() { Run(); });
+        }
+    }
+
+    ~DdsCallbackExecutor() {
+        {
+            std::lock_guard<std::mutex> lock(mutex_);
+            stop_requested_ = true;
+        }
+        cv_.notify_all();
+        for (auto &executor : executors_) {
+            if (executor.joinable()) {
+                executor.join();
+            }
+        }
+    }
+
+    void Run() {
+        while (true) {
+            std::function<void()> task;
+            {
+                std::unique_lock<std::mutex> lock(mutex_);
+                cv_.wait(lock, [this] {
+                    return stop_requested_ || !tasks_.empty();
+                });
+
+                if (tasks_.empty()) {
+                    if (stop_requested_) {
+                        return;
+                    }
+                    continue;
+                }
+
+                task = std::move(tasks_.front());
+                tasks_.pop_front();
+            }
+
+            task();
+        }
+    }
+
+private:
+    std::mutex mutex_;
+    std::condition_variable cv_;
+    std::deque<std::function<void()>> tasks_;
+    std::vector<std::thread> executors_;
+    bool stop_requested_{false};
+};
+
+class DdsDedicatedCallbackExecutor {
+public:
+    DdsDedicatedCallbackExecutor() {
+        executor_ = std::thread([this]() { Run(); });
+    }
+
+    ~DdsDedicatedCallbackExecutor() {
+        {
+            std::lock_guard<std::mutex> lock(mutex_);
+            stop_requested_ = true;
+        }
+        cv_.notify_all();
+        if (executor_.joinable()) {
+            executor_.join();
+        }
+    }
+
+    void Submit(std::function<void()> task) {
+        {
+            std::lock_guard<std::mutex> lock(mutex_);
+            tasks_.emplace_back(std::move(task));
+        }
+        cv_.notify_one();
+    }
+
+private:
+    void Run() {
+        while (true) {
+            std::function<void()> task;
+            {
+                std::unique_lock<std::mutex> lock(mutex_);
+                cv_.wait(lock, [this] {
+                    return stop_requested_ || !tasks_.empty();
+                });
+
+                if (tasks_.empty()) {
+                    if (stop_requested_) {
+                        return;
+                    }
+                    continue;
+                }
+
+                task = std::move(tasks_.front());
+                tasks_.pop_front();
+            }
+
+            task();
+        }
+    }
+
+private:
+    std::mutex mutex_;
+    std::condition_variable cv_;
+    std::deque<std::function<void()>> tasks_;
+    bool stop_requested_{false};
+    std::thread executor_;
+};
+
+template <typename MSG>
+class DdsReaderListener : public DataReaderListener, public std::enable_shared_from_this<DdsReaderListener<MSG>> {
+public:
+    DdsReaderListener() = default;
+    ~DdsReaderListener() override {
+        std::lock_guard<std::mutex> lock(mutex_);
+        stop_requested_ = true;
+        pending_messages_.clear();
+        callback_scheduled_ = false;
+    }
+
+    void SetCallback(const DdsReaderCallback &cb) {
+        if (!cb.HasMessageHandler()) {
+            std::cerr << "Listener Set Callback: invalid hanlder" << std::endl;
+            return;
+        }
+        std::lock_guard<std::mutex> lock(mutex_);
+        cb_ = std::make_shared<DdsReaderCallback>(cb);
+    }
+
+    void SetExecutorOptions(const DdsReaderExecutorOptions &options) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        executor_options_ = options;
+        if (executor_options_.dispatch_mode == DdsExecutorDispatchMode::kDedicated) {
+            if (dedicated_executor_ == nullptr) {
+                dedicated_executor_ = std::make_unique<DdsDedicatedCallbackExecutor>();
+            }
+        } else {
+            dedicated_executor_.reset();
+        }
+    }
+
+    DdsReaderExecutorMetrics GetExecutorMetrics() const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        auto metrics = metrics_;
+        metrics.current_queue_size = pending_messages_.size();
+        return metrics;
+    }
+
+    void on_data_available(DataReader *reader) override {
+        if (reader == nullptr || cb_ == nullptr) {
+            return;
+        }
+
+        std::deque<PendingMessage> ready_messages;
+        SampleInfo info;
+        while (true) {
+            MSG st;
+            if (reader->take_next_sample(&st, &info) != ReturnCode_t::RETCODE_OK) {
+                break;
+            }
+            if (info.valid_data) {
+                ready_messages.push_back(PendingMessage{
+                    std::move(st),
+                    std::chrono::steady_clock::now(),
+                });
+            }
+        }
+
+        if (ready_messages.empty()) {
+            return;
+        }
+
+        bool should_schedule = false;
+        {
+            std::lock_guard<std::mutex> lock(mutex_);
+            if (stop_requested_) {
+                return;
+            }
+            for (auto &message : ready_messages) {
+                EnqueuePendingMessageLocked(std::move(message));
+            }
+            if (!callback_scheduled_ && !pending_messages_.empty()) {
+                callback_scheduled_ = true;
+                should_schedule = true;
+            }
+        }
+
+        if (should_schedule) {
+            ScheduleExecution();
+        }
+    }
+
+private:
+    struct PendingMessage {
+        MSG message;
+        std::chrono::steady_clock::time_point enqueued_at;
+    };
+
+    void EnqueuePendingMessageLocked(PendingMessage &&message) {
+        if (executor_options_.enable_metrics) {
+            ++metrics_.samples_received;
+        }
+
+        const auto capacity = executor_options_.queue_capacity;
+        switch (executor_options_.overflow_policy) {
+        case DdsExecutorOverflowPolicy::kDropNewest:
+            if (capacity > 0 && pending_messages_.size() >= capacity) {
+                RecordDropLocked(1);
+                return;
+            }
+            pending_messages_.push_back(std::move(message));
+            break;
+        case DdsExecutorOverflowPolicy::kDropOldest:
+            if (capacity > 0 && pending_messages_.size() >= capacity) {
+                pending_messages_.pop_front();
+                RecordDropLocked(1);
+            }
+            pending_messages_.push_back(std::move(message));
+            break;
+        case DdsExecutorOverflowPolicy::kLatestOnly:
+            if (!pending_messages_.empty()) {
+                RecordDropLocked(pending_messages_.size());
+                pending_messages_.clear();
+            }
+            pending_messages_.push_back(std::move(message));
+            break;
+        }
+
+        if (executor_options_.enable_metrics) {
+            metrics_.queue_high_watermark = std::max(
+                metrics_.queue_high_watermark,
+                pending_messages_.size());
+        }
+    }
+
+    void RecordDropLocked(size_t drop_count) {
+        if (executor_options_.enable_metrics) {
+            metrics_.samples_dropped += drop_count;
+        }
+    }
+
+    void ScheduleExecution() {
+        auto weak_self = this->weak_from_this();
+        std::function<void()> task = [weak_self]() {
+            auto self = weak_self.lock();
+            if (self == nullptr) {
+                return;
+            }
+            self->ExecutePendingCallbacks();
+        };
+
+        DdsExecutorDispatchMode dispatch_mode = DdsExecutorDispatchMode::kShared;
+        DdsDedicatedCallbackExecutor *dedicated_executor = nullptr;
+        {
+            std::lock_guard<std::mutex> lock(mutex_);
+            dispatch_mode = executor_options_.dispatch_mode;
+            dedicated_executor = dedicated_executor_.get();
+        }
+
+        if (dispatch_mode == DdsExecutorDispatchMode::kDedicated && dedicated_executor != nullptr) {
+            dedicated_executor->Submit(std::move(task));
+            return;
+        }
+
+        DdsCallbackExecutor::Instance().Submit(std::move(task));
+    }
+
+    void ExecutePendingCallbacks() {
+        while (true) {
+            PendingMessage pending_message;
+            DdsReaderCallbackPtr cb;
+            bool metrics_enabled = false;
+            size_t pending_queue_size = 0;
+            {
+                std::unique_lock<std::mutex> lock(mutex_);
+                if (stop_requested_) {
+                    callback_scheduled_ = false;
+                    return;
+                }
+                if (pending_messages_.empty()) {
+                    callback_scheduled_ = false;
+                    return;
+                }
+
+                pending_message = std::move(pending_messages_.front());
+                pending_messages_.pop_front();
+                cb = cb_;
+                metrics_enabled = executor_options_.enable_metrics;
+                pending_queue_size = pending_messages_.size();
+            }
+
+            const auto callback_start = std::chrono::steady_clock::now();
+            if (cb != nullptr) {
+                cb->OnDataAvailable(&pending_message.message);
+            }
+
+            if (metrics_enabled) {
+                const auto callback_end = std::chrono::steady_clock::now();
+                const auto queue_latency_us = std::chrono::duration_cast<std::chrono::microseconds>(
+                    callback_start - pending_message.enqueued_at).count();
+                const auto callback_duration_us = std::chrono::duration_cast<std::chrono::microseconds>(
+                    callback_end - callback_start).count();
+
+                std::lock_guard<std::mutex> lock(mutex_);
+                ++metrics_.callbacks_executed;
+                metrics_.current_queue_size = pending_queue_size;
+                metrics_.max_queue_latency_us = std::max<uint64_t>(
+                    metrics_.max_queue_latency_us,
+                    static_cast<uint64_t>(queue_latency_us));
+                metrics_.max_callback_duration_us = std::max<uint64_t>(
+                    metrics_.max_callback_duration_us,
+                    static_cast<uint64_t>(callback_duration_us));
+            }
+        }
+    }
+
+private:
+    std::mutex mutex_;
+    std::deque<PendingMessage> pending_messages_;
+    bool stop_requested_{false};
+    bool callback_scheduled_{false};
+    DdsReaderExecutorOptions executor_options_;
+    DdsReaderExecutorMetrics metrics_;
+    DdsReaderCallbackPtr cb_;
+    std::unique_ptr<DdsDedicatedCallbackExecutor> dedicated_executor_;
+};
+
+template <typename MSG>
+using DdsReaderListenerPtr = std::shared_ptr<DdsReaderListener<MSG>>;
+}
+} // namespace booster::common
+
+#endif

booster_robotics_sdk_python-1.3.9/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = [
+  "scikit-build-core>=0.11",
+  "pybind11>=2.11",
+]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "booster_robotics_sdk_python"
+version = "1.3.9"
+description = "Booster Robotics SDK Python bindings and examples."
+requires-python = ">=3.10"
+authors = [
+  { name = "Booster Robotics", email = "liupeize@boosterobotics.com" },
+]
+readme = "README.md"
+
+[project.scripts]
+b1-ai-cli    = "python_example.sdk_pybind_ai_example:main"
+b1-cli       = "python_example.sdk_pybind_b1_exmaple:main"
+b1-low-level = "python_example.sdk_pybind_low_level:main"
+
+[tool.scikit-build]
+cmake.define.BUILD_PYTHON_BINDING = "ON"
+cmake.define.BUILD_TEST = "OFF"
+
+
+[tool.scikit-build.wheel.packages]
+"python_example" = "python_example"
+"booster_robotics_sdk_python"     = "src/python/controller/booster_robotics_sdk_python"

booster_robotics_sdk_python-1.3.9/sdk_release/CMakeLists.txt

@@ -0,0 +1,52 @@
+cmake_minimum_required(VERSION 3.15...3.27)
+cmake_policy(SET CMP0048 NEW)
+
+if(NOT DEFINED SKBUILD_PROJECT_NAME)
+    set(SKBUILD_PROJECT_NAME booster_robotics_sdk_release)
+endif()
+
+if(NOT DEFINED SKBUILD_PROJECT_VERSION)
+    set(SKBUILD_PROJECT_VERSION 0.1.0)
+endif()
+
+project(
+  ${SKBUILD_PROJECT_NAME}
+  VERSION ${SKBUILD_PROJECT_VERSION}
+  LANGUAGES CXX)
+
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+set(CMAKE_CXX_STANDARD 17)
+
+find_package(Threads REQUIRED)
+
+set(BOOSTER_SDK_ARCH "${CMAKE_SYSTEM_PROCESSOR}")
+if(NOT BOOSTER_SDK_ARCH)
+    execute_process(
+        COMMAND uname -m
+        OUTPUT_VARIABLE BOOSTER_SDK_ARCH
+        OUTPUT_STRIP_TRAILING_WHITESPACE)
+endif()
+
+if(BOOSTER_SDK_ARCH MATCHES "^(AMD64|amd64)$")
+    set(BOOSTER_SDK_ARCH x86_64)
+endif()
+
+set(BOOSTER_SDK_LIBRARY "${PROJECT_SOURCE_DIR}/lib/${BOOSTER_SDK_ARCH}/libbooster_robotics_sdk.a")
+if(NOT EXISTS "${BOOSTER_SDK_LIBRARY}")
+    message(FATAL_ERROR "Booster Robotics SDK library not found: ${BOOSTER_SDK_LIBRARY}")
+endif()
+
+include_directories(BEFORE ${PROJECT_SOURCE_DIR}/include)
+link_libraries("${BOOSTER_SDK_LIBRARY}" Threads::Threads ${CMAKE_DL_LIBS} rt)
+
+add_executable(b1_loco_example_client example/high_level/b1_loco_example_client.cpp)
+add_executable(b1_arm_sdk_example_client example/high_level/b1_arm_sdk_example.cpp)
+add_executable(b1_7dof_arm_sdk_example_client example/high_level/b1_7dof_arm_sdk_example.cpp)
+add_executable(b1_low_level_publisher example/low_level/low_level_publisher.cpp)
+add_executable(b1_low_level_subscriber example/low_level/low_level_subscriber.cpp)
+add_executable(low_level_hand_data_subscriber example/low_level/low_level_hand_data_subscriber.cpp)
+add_executable(b1_low_sdk_example example/low_level/b1_low_sdk_example.cpp)
+add_executable(b1_7dof_arm_low_sdk_example example/low_level/b1_7dof_arm_low_sdk_example.cpp)
+add_executable(odometer_example example/low_level/odometer_example.cpp)
+add_executable(battery_state_subscriber example/low_level/battery_state_subscriber.cpp)

booster_robotics_sdk_python-1.3.9/sdk_release/LICENSE

@@ -0,0 +1,21 @@
+Copyright [2024] [Booster Robotics Technology Co., Ltd ("Booster Robotics")]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+------------------
+
+This code builds upon following open-source code-bases. Please visit the URLs to see the respective LICENSES:
+
+1) https://github.com/eProsima/Fast-DDS
+
+------------------

booster_robotics_sdk_python-1.3.9/sdk_release/README.md

@@ -0,0 +1,52 @@
+# Booster Robotics SDK
+Booster Robotics SDK aims to provide a simple and easy-to-use interface for developers to control the Booster Robotics products.
+This release package provides the C++ SDK. Python SDK delivery is handled by the pip package.
+
+## Prebuild environment
+* OS  (Ubuntu 22.04 LTS)  
+* CPU  (aarch64 and x86_64)   
+* Compiler  (gcc version 11.4.0) 
+
+## Installation of deps
+```bash
+sudo ./install.sh
+```
+## C++ SDK Usage
+### Build C++ examples
+```bash
+mkdir build
+cd build
+cmake ..
+make
+```
+
+### Run examples
+#### 1. run b1_loco_example_client locally
+```
+cd build
+./b1_loco_example_client 127.0.0.1
+```
+#### 2. run b1_low_level_subscriber locally
+```
+cd build
+./b1_low_level_subscriber
+```
+#### 3. run other example xxx locally
+```
+cd build
+./xxx 127.0.0.1
+```
+
+## Python SDK Usage
+The Python SDK is delivered separately through pip.
+
+```bash
+pip install booster_robotics_sdk_python --user
+```
+
+## License
+
+This project is licensed under the Apache License, Version 2.0. See the LICENSE file for details.
+
+This project uses the following third-party libraries:
+- fastDDS (Apache License 2.0)