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

booster_robotics_sdk_python-1.3.9/.workflow/git-ee-pipe-build.yml

@@ -0,0 +1,123 @@
+version: '1.0'
+name: git-ee-pipe-1760475713
+displayName: git-ee-pipe-1760475713
+triggers:
+  trigger: auto
+  push:
+    branches:
+      prefix:
+        - 'ci-'
+
+# 太蠢了
+# Yaml的锚点语法不支持
+
+stages:
+
+
+  - name: wait-paralleled
+    displayName: wait-paralleled
+    steps:
+
+      - step: shell@agent
+        name: step-wait-u-24-unknown-linux-gnu
+        displayName: step-wait-u-24-unknown-linux-gnu
+        hostGroupID:
+          ID: u-24-unknown-linux-gnu
+          hostID:
+            - 7a200648-f7df-484f-89e6-85a616a66e7c
+            - a8b94e6c-c723-4e77-bf12-12c6ac67f349
+        script:
+          - export CUSTOM_ENV_JOB_STAGE_STEP_NAME="step-wait-u-24-unknown-linux-gnu"
+          - curl --silent --show-error --output s-70-closure-build-project.sh http://192.168.33.162:20103/file-build-storage/script/s-70-closure-build-project.sh
+          - curl --silent --show-error --output s-80-action-build-project.sh http://192.168.33.162:20103/file-build-storage/script/s-80-action-build-project.sh
+          - sh s-80-action-build-project.sh
+
+
+
+
+  - name: build-paralleled
+    displayName: build-paralleled
+    steps:
+
+      - step: shell@agent
+        name: step-build-u-22-aarch64-unknown-linux-gnu
+        displayName: step-build-u-22-aarch64-unknown-linux-gnu
+        hostGroupID:
+          ID: u-22-aarch64-unknown-linux-gnu
+          hostID:
+            - de76b749-9d62-440d-88d8-4373526769a6
+            - 33b6f200-5b8d-4e88-94ba-b21a9d847e98
+            - 926aebf7-42a1-4794-8166-f0ca28fadab8
+            - 2e9d29c7-31c2-4814-ae78-2108163acb5c
+            - e386b9c2-5a21-4e55-9fd2-6a8ef3e8c5f6
+            - c490100d-fc59-486e-bea0-4a5d246176dc
+            - 6cdb7da3-ae1d-4625-8949-9451c246099a
+            - 5cea8344-2e78-4824-8988-96ec6635c62d
+            - 010af21e-d19d-41be-a511-884ae558d307
+            - 521f5f1a-cc02-4d28-a03e-ec6cd1065715
+        script:
+          - export CUSTOM_ENV_JOB_STAGE_STEP_NAME="step-build-22-aarch64-unknown-linux-gnu"
+          - curl --silent --show-error --output s-70-closure-build-project.sh http://192.168.33.162:20103/file-build-storage/script/s-70-closure-build-project.sh
+          - curl --silent --show-error --output s-80-action-build-project.sh http://192.168.33.162:20103/file-build-storage/script/s-80-action-build-project.sh
+          - sh s-80-action-build-project.sh
+
+
+      - step: shell@agent
+        name: step-build-u-24-aarch64-unknown-linux-gnu
+        displayName: step-build-u-24-aarch64-unknown-linux-gnu
+        hostGroupID:
+          ID: u-24-aarch64-unknown-linux-gnu
+          hostID:
+            - ceb50007-5022-4528-82f8-cac56fff1997
+            - de35a264-5cdb-40f0-9f61-20959d44ec47
+            - e2b356f1-bc7c-4218-baf9-992ecc11b3c0
+            - b8c44a03-2fdc-449e-b582-5b92c740fcb6
+            - 15d27cd4-7fb2-484d-ad03-b8552fc20701
+            - afee24da-28c6-4476-8860-7ec42a82a27b
+        script:
+          - export CUSTOM_ENV_JOB_STAGE_STEP_NAME="step-build-24-aarch64-unknown-linux-gnu"
+          - curl --silent --show-error --output s-70-closure-build-project.sh http://192.168.33.162:20103/file-build-storage/script/s-70-closure-build-project.sh
+          - curl --silent --show-error --output s-80-action-build-project.sh http://192.168.33.162:20103/file-build-storage/script/s-80-action-build-project.sh
+          - sh s-80-action-build-project.sh
+
+
+      - step: shell@agent
+        name: step-build-u-22-x86_64-unknown-linux-gnu
+        displayName: step-build-u-22-x86_64-unknown-linux-gnu
+        hostGroupID:
+          ID: u-22-x86_64-unknown-linux-gnu
+          hostID:
+            - 13de56cc-be54-4140-a383-84610d6edacb
+            - 08cc933d-21e6-45c5-94d3-91b74e585fb7
+            - 3989f12a-5077-4a9f-bf14-db89c7b05343
+            - 23b30227-7027-4ddc-9552-21447f7f5d82
+            - 95629513-e57e-42de-ac18-d1bb89194547
+            - 68f8ef54-5453-45cf-8b35-acaeee1fb0e9
+            - 4f16f4f1-9875-410a-a9e6-f604ee8cd2eb
+            - c3c611fb-4fc1-4732-acf0-57a032965657
+        script:
+          - export CUSTOM_ENV_JOB_STAGE_STEP_NAME="step-build-22-x86_64-unknown-linux-gnu"
+          - curl --silent --show-error --output s-70-closure-build-project.sh http://192.168.33.162:20103/file-build-storage/script/s-70-closure-build-project.sh
+          - curl --silent --show-error --output s-80-action-build-project.sh http://192.168.33.162:20103/file-build-storage/script/s-80-action-build-project.sh
+          - sh s-80-action-build-project.sh
+
+
+      - step: shell@agent
+        name: step-build-u-24-x86_64-unknown-linux-gnu
+        displayName: step-build-u-24-x86_64-unknown-linux-gnu
+        hostGroupID:
+          ID: u-24-x86_64-unknown-linux-gnu
+          hostID:
+#           - fbd07b0d-41ea-420d-8d8c-27aa3d77fcc5
+            - ea4bde4e-6911-4730-9ed5-7dd1f3199c53
+            - f98df53b-60da-4946-b710-7d3e3b585bcc
+            - 94f48ac9-2a23-4868-a998-392155eb3849
+            - d782e716-897c-42ee-822c-3c1d50749b10
+            - 6b01cde0-f4d2-4080-8157-d3a721498248
+            - f4c4a860-d0ff-40fc-ae43-5fe65726d6f1
+            - 4a41bf06-87ef-4cbd-b92f-163096f2a542
+        script:
+          - export CUSTOM_ENV_JOB_STAGE_STEP_NAME="step-build-24-x86_64-unknown-linux-gnu"
+          - curl --silent --show-error --output s-70-closure-build-project.sh http://192.168.33.162:20103/file-build-storage/script/s-70-closure-build-project.sh
+          - curl --silent --show-error --output s-80-action-build-project.sh http://192.168.33.162:20103/file-build-storage/script/s-80-action-build-project.sh
+          - sh s-80-action-build-project.sh

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