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

{booster_robotics_sdk_python-1.3.5 → booster_robotics_sdk_python-1.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: booster_robotics_sdk_python
-Version: 1.3.5
+Version: 1.3.7
 Summary: Booster Robotics SDK Python bindings and examples.
 Author-Email: Booster Robotics <liupeize@boosterobotics.com>
 Requires-Python: >=3.10

{booster_robotics_sdk_python-1.3.5/sdk_release → booster_robotics_sdk_python-1.3.7}/include/booster/robot/b1/b1_loco_api.hpp

@@ -59,6 +59,7 @@ enum class LocoApiId {
     kLionDanceStart = 2040,
     kLionDanceMove = 2041,
     kSwitchGait = 2042,
+    kRotateHeadWithTime = 2043,
 };
 
 enum class GaitType {
@@ -93,6 +94,38 @@ public:
     float yaw_;
 };
 
+class RotateHeadWithTimeParameter {
+public:
+    RotateHeadWithTimeParameter() = default;
+
+    RotateHeadWithTimeParameter(float pitch, float yaw, int time_millis) :
+        pitch_(pitch),
+        yaw_(yaw),
+        time_millis_(time_millis) {
+    }
+
+public:
+    void FromJson(nlohmann::json &json) {
+        pitch_ = json["pitch"];
+        yaw_ = json["yaw"];
+        time_millis_ = json["time_millis"];
+    }
+
+    nlohmann::json ToJson() const {
+        nlohmann::json json;
+
+        json["pitch"] = pitch_;
+        json["yaw"] = yaw_;
+        json["time_millis"] = time_millis_;
+        return json;
+    }
+
+public:
+    float pitch_;
+    float yaw_;
+    int time_millis_;
+};
+
 class ChangeModeParameter {
 public:
     ChangeModeParameter() = default;

{booster_robotics_sdk_python-1.3.5 → booster_robotics_sdk_python-1.3.7}/include/booster/robot/b1/b1_loco_client.hpp

@@ -166,6 +166,22 @@ public:
         return SendApiRequest(LocoApiId::kRotateHead, param);
     }
 
+    /**
+     * @brief Robot rotates its head to target position within specific time
+     *
+     * @param pitch target pitch angle, unit: rad
+     * @param yaw target yaw angle, unit: rad
+     * @param time_millis duration to reach the target, unit: ms
+     *
+     * @return 0 if success, otherwise return error code
+     */
+
+    int32_t RotateHeadWithTime(float pitch, float yaw, int time_millis) {
+        RotateHeadWithTimeParameter head_ctrl(pitch, yaw, time_millis);
+        std::string param = head_ctrl.ToJson().dump();
+        return SendApiRequest(LocoApiId::kRotateHeadWithTime, param);
+    }
+
     /**
      * @brief Robot waves its hand
      *

{booster_robotics_sdk_python-1.3.5 → booster_robotics_sdk_python-1.3.7}/include/booster/robot/common/robot_shared.hpp

@@ -24,10 +24,11 @@ enum class BodyControl {
     kGetUp = 7,                 // Get up body control, in get up body control, the robot can get up from lying down
     kWholeBodyDance = 8,        // Whole body dance body control, in whole body dance, the robot can do some whole body dance actions
     kShoot = 9,                 // Shoot body control, in shoot body control, the robot can scored with a powerful shot
-    kInsideFoot = 10,           // Inside foot kick body control, in inside foot kick body control, the robot can do precise inside foot kick actions
+    kInsideFoot = 10,           // History caused name, actually is visual kick body control V2
     kGoalie = 11,               // Goalie body control, in goalie body control, the robot can perform goalie actions
     kWBCGait = 12,              // Whole body control gait body control, in WBC gait, the robot walking by whole body control
     kLionDancePreparePose = 13, // Lion dance prepare pose, in this body control, the robot will do lion dance prepare pose
+    kVisualKickV1 = 14,         // Visual kick body control V1, in visual kick body control, the robot can do visual kick actions
 };
 
 enum class Action {

{booster_robotics_sdk_python-1.3.5 → booster_robotics_sdk_python-1.3.7}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "booster_robotics_sdk_python"
-version = "1.3.5"
+version = "1.3.7"
 description = "Booster Robotics SDK Python bindings and examples."
 requires-python = ">=3.10"
 authors = [

{booster_robotics_sdk_python-1.3.5 → booster_robotics_sdk_python-1.3.7}/python_example/sdk_pybind_b1_exmaple.py

@@ -34,6 +34,8 @@ def print_help():
   hr                      Look right
   hl                      Look left
   ho                      Reset head orientation
+  rhd                     Rotate head with direction: pitch +1, yaw 0
+  rht <pitch> <yaw> <ms>  Rotate head to target pose within given time
 
 # Hand end-effector
   mhel                    Execute a two-stage motion sequence to move both end-effectors to the target pose via the MoveHandEndEffectorV2 interface
@@ -366,6 +368,17 @@ def main():
                 # Example for RotateHeadWithDirection: pitch +1, yaw 0
                 client.RotateHeadWithDirection(1, 0)
 
+            elif cmd == "rht":
+                if len(args) != 3:
+                    print("Usage: rht <pitch> <yaw> <time_millis>")
+                    continue
+                head_pitch = float(args[0])
+                head_yaw = float(args[1])
+                time_millis = int(args[2])
+                client.RotateHeadWithTime(head_pitch, head_yaw, time_millis)
+                need_print = True
+                print(f"Head duration: {time_millis} ms")
+
             # ===== Wave / Handshake =====
             elif cmd == "wave":
                 # Use HandAction to open or close the hand

{booster_robotics_sdk_python-1.3.5 → booster_robotics_sdk_python-1.3.7}/sdk_release/CMakeLists.txt

@@ -17,7 +17,6 @@ link_libraries(booster_robotics_sdk.a fastrtps fastcdr libfoonathan_memory-0.7.3
 
 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_move_controller example/high_level/b1_move_controller_interactive_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)
@@ -25,6 +24,8 @@ add_executable(low_level_hand_data_subscriber example/low_level/low_level_hand_d
 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)
+
 
 
 include_directories(BEFORE $(PROJECT_SOURCE_DIR)/include)

booster_robotics_sdk_python-1.3.7/sdk_release/README.md

@@ -0,0 +1,81 @@
+# Booster Robotics SDK
+Booster Robotics SDK aims to provide a simple and easy-to-use interface for developers to control the Booster Robotics products.
+Booster Robotics SDK provides APIs for both C++ and Python.
+
+## 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
+### Option 1: Install via pip (Recommended)
+The easiest way to use the SDK with Python is to install the pre-built package.
+
+```bash
+pip install booster_robotics_sdk_python --user
+```
+
+### Option 2: Build from Source
+If you need to build the Python binding locally for development or debugging purposes, follow these steps:
+#### Install build dependencies
+```bash
+pip3 install pybind11
+pip3 install pybind11-stubgen
+```
+if pybind11-stubgen cannot be found even after pip install, export PATH
+```bash
+export PATH=/home/[user name]/.local/bin:$PATH
+```
+#### Build and install
+```bash
+mkdir build
+cd build
+cmake .. -DBUILD_PYTHON_BINDING=on
+make
+sudo make install
+```
+
+### Python example
+```bash
+python3 python_example/sdk_pybind_b1_exmaple.py 127.0.0.1
+```
+Note: If you installed via pip, you can find the examples at ~/.local/lib/python3.10/site-packages/python_example.
+
+## 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)
+- pybind11 (BSD 3-Clause License)
+- pybind11-stubgen (MIT License)

{booster_robotics_sdk_python-1.3.5 → booster_robotics_sdk_python-1.3.7}/sdk_release/example/high_level/b1_loco_example_client.cpp

@@ -292,8 +292,6 @@ int main(int argc, char const *argv[]) {
                 z = 0.0;
                 need_print = true;
                 res = client.Move(x, y, z);
-            } else if (input == "ddd") {
-                client.WholeBodyDance(booster::robot::b1::WholeBodyDanceId::kMichaelDance1And2);
             } else if (input == "l") {
                 x = 0.0;
                 y = 0.0;
@@ -367,10 +365,6 @@ int main(int argc, char const *argv[]) {
                 res = client.WaveHand(booster::robot::b1::HandAction::kHandClose);
             } else if (input == "ld") {
                 res = client.LieDown();
-            } else if (input == "vsk") {
-                res = client.VisualKick(true, booster::robot::b1::VisualKickVersion::kV1);
-            } else if (input == "vsk2") {
-                res = client.VisualKick(false, booster::robot::b1::VisualKickVersion::kV1);
             } else if (input == "gu") {
                 res = client.GetUp();
             } else if (input == "mhel") {

booster_robotics_sdk_python-1.3.7/sdk_release/example/low_level/battery_state_subscriber.cpp

@@ -0,0 +1,37 @@
+#include <booster/robot/channel/channel_subscriber.hpp>
+#include <booster/idl/b1/BatteryState.h>
+
+#include <thread>
+#include <chrono>
+#include <iostream>
+
+#define TOPIC "rt/battery_state"
+
+using namespace booster::robot;
+using namespace booster::common;
+using namespace booster_interface::msg;
+
+void Handler(const void *msg)
+{
+    const BatteryState* bat = static_cast<const BatteryState*>(msg);
+
+    std::cout << "------- Battery State -------" << std::endl;
+    std::cout << "  Voltage        : " << bat->voltage() << " V" << std::endl;
+    std::cout << "  Current        : " << bat->current() << " A" << std::endl;
+    std::cout << "  SOC            : " << bat->soc() << " %" << std::endl;
+    std::cout << "  Avg Voltage    : " << bat->average_voltage() << " V" << std::endl;
+    std::cout << "------------------------------" << std::endl;
+}
+
+int main()
+{
+    ChannelFactory::Instance()->Init(0);
+
+    ChannelSubscriber<BatteryState> sub(TOPIC, Handler);
+    sub.InitChannel();
+
+    while (true)
+    {
+        std::this_thread::sleep_for(std::chrono::seconds(1));
+    }
+}

booster_robotics_sdk_python-1.3.7/sdk_release/include/booster/common/dds/dds_callback.hpp

@@ -0,0 +1,53 @@
+#ifndef __BOOSTER_ROBOTICS_SDK_DDS_CALLBACK_HPP__
+#define __BOOSTER_ROBOTICS_SDK_DDS_CALLBACK_HPP__
+
+#include <chrono>
+#include <memory>
+#include <functional>
+
+using DdsMessageHandler = std::function<void(const void *)>;
+
+namespace booster {
+namespace common {
+
+struct DdsMessageContext {
+    std::chrono::steady_clock::time_point listener_enter_steady_time{};
+    std::chrono::system_clock::time_point listener_enter_system_time{};
+    std::chrono::steady_clock::time_point dds_rx_steady_time{};
+    std::chrono::system_clock::time_point dds_rx_system_time{};
+    std::chrono::steady_clock::time_point callback_start_steady_time{};
+    std::chrono::system_clock::time_point callback_start_system_time{};
+    std::chrono::steady_clock::duration listener_enter_to_dds_rx_delay{};
+    std::chrono::steady_clock::duration dds_rx_to_callback_delay{};
+    size_t queue_size_before_callback{0};
+    size_t queue_size_after_pop{0};
+    bool has_source_timestamp{false};
+    std::chrono::system_clock::time_point source_timestamp_system_time{};
+    bool has_reception_timestamp{false};
+    std::chrono::system_clock::time_point reception_timestamp_system_time{};
+};
+
+const DdsMessageContext *GetCurrentDdsMessageContext();
+
+class DdsReaderCallback {
+public:
+    DdsReaderCallback() = default;
+    explicit DdsReaderCallback(const DdsMessageHandler &handler) :
+        handler_(handler){};
+    DdsReaderCallback(const DdsReaderCallback &other) = default;
+    DdsReaderCallback &operator=(const DdsReaderCallback &other) = default;
+    ~DdsReaderCallback() = default;
+
+    bool HasMessageHandler() const;
+    void OnDataAvailable(const void *data);
+    void OnDataAvailable(const void *data, const DdsMessageContext &context);
+
+private:
+    DdsMessageHandler handler_;
+};
+
+
+}
+} // namespace booster::common
+
+#endif // __BOOSTER_ROBOTICS_SDK_DDS_CALLBACK_HPP__

{booster_robotics_sdk_python-1.3.5 → booster_robotics_sdk_python-1.3.7}/sdk_release/include/booster/common/dds/dds_entity.hpp

@@ -9,27 +9,39 @@
 #include <functional>
 #include <memory>
 #include <mutex>
+#include <iostream>
 #include <thread>
 #include <vector>
 
+#include <pthread.h>
+#include <sched.h>
+
 #include <fastdds/dds/domain/DomainParticipant.hpp>
 #include <fastdds/dds/domain/DomainParticipantFactory.hpp>
-#include <fastdds/dds/topic/Topic.hpp>
+#include <fastdds/dds/domain/qos/DomainParticipantQos.hpp>
+#include <fastdds/dds/core/policy/QosPolicies.hpp>
+#include <fastdds/dds/core/status/PublicationMatchedStatus.hpp>
+#include <fastdds/dds/core/status/SubscriptionMatchedStatus.hpp>
 #include <fastdds/dds/publisher/Publisher.hpp>
 #include <fastdds/dds/publisher/DataWriter.hpp>
+#include <fastdds/dds/publisher/qos/DataWriterQos.hpp>
+#include <fastdds/dds/publisher/qos/PublisherQos.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 <fastdds/dds/subscriber/qos/SubscriberQos.hpp>
+#include <fastdds/dds/topic/Topic.hpp>
+#include <fastdds/dds/topic/TopicDataType.hpp>
+#include <fastdds/dds/topic/TypeSupport.hpp>
+#include <fastdds/dds/topic/qos/TopicQos.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;
@@ -42,17 +54,32 @@ using namespace eprosima::fastdds::dds;
 
 // };
 
-using DdsParticipantPtr = std::shared_ptr<eprosima::fastdds::dds::DomainParticipant>;
+using DdsParticipant = eprosima::fastdds::dds::DomainParticipant;
+using DdsParticipantPtr = std::shared_ptr<DdsParticipant>;
 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 DdsPublisher = eprosima::fastdds::dds::Publisher;
+using DdsPublisherPtr = std::shared_ptr<DdsPublisher>;
+using DdsSubscriber = eprosima::fastdds::dds::Subscriber;
+using DdsSubscriberPtr = std::shared_ptr<DdsSubscriber>;
 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 DdsTypeSupport = eprosima::fastdds::dds::TypeSupport;
+using DdsDataReaderListener = eprosima::fastdds::dds::DataReaderListener;
+using DdsSampleInfo = eprosima::fastdds::dds::SampleInfo;
+using DdsDataWriterQos = eprosima::fastdds::dds::DataWriterQos;
+using DdsDataReaderQos = eprosima::fastdds::dds::DataReaderQos;
+using DdsDomainParticipantQos = eprosima::fastdds::dds::DomainParticipantQos;
+using DdsTopicQos = eprosima::fastdds::dds::TopicQos;
+using DdsPublisherQos = eprosima::fastdds::dds::PublisherQos;
+using DdsSubscriberQos = eprosima::fastdds::dds::SubscriberQos;
+using DdsPublicationMatchedStatus = eprosima::fastdds::dds::PublicationMatchedStatus;
+using DdsSubscriptionMatchedStatus = eprosima::fastdds::dds::SubscriptionMatchedStatus;
 using DdsReaderCallbackPtr = std::shared_ptr<DdsReaderCallback>;
+using ReturnCode_t = eprosima::fastrtps::types::ReturnCode_t;
 
 enum class DdsExecutorOverflowPolicy {
     kDropNewest,
@@ -71,6 +98,12 @@ struct DdsReaderExecutorOptions {
     DdsExecutorOverflowPolicy overflow_policy{DdsExecutorOverflowPolicy::kDropOldest};
     bool enable_metrics{false};
     DdsExecutorDispatchMode dispatch_mode{DdsExecutorDispatchMode::kShared};
+    bool enable_realtime_listener{false};
+    int realtime_listener_priority{80};
+    uint64_t realtime_listener_cpu_affinity_mask{0};
+    bool enable_realtime_dedicated_executor{false};
+    int realtime_dedicated_executor_priority{70};
+    uint64_t realtime_dedicated_executor_cpu_affinity_mask{0};
 };
 
 struct DdsReaderExecutorMetrics {
@@ -156,7 +189,8 @@ private:
 
 class DdsDedicatedCallbackExecutor {
 public:
-    DdsDedicatedCallbackExecutor() :
+    explicit DdsDedicatedCallbackExecutor(const DdsReaderExecutorOptions &options) :
+        options_(options),
         executor_([this]() { Run(); }) {
     }
 
@@ -179,8 +213,56 @@ public:
         cv_.notify_one();
     }
 
-private:
+    static void TryConfigureThread(
+        const char *name,
+        int priority,
+        uint64_t cpu_affinity_mask) {
+#if defined(__linux__)
+        if (cpu_affinity_mask != 0) {
+            cpu_set_t cpuset;
+            CPU_ZERO(&cpuset);
+            for (size_t cpu_index = 0; cpu_index < sizeof(cpu_affinity_mask) * 8; ++cpu_index) {
+                if ((cpu_affinity_mask & (uint64_t(1) << cpu_index)) != 0) {
+                    CPU_SET(static_cast<int>(cpu_index), &cpuset);
+                }
+            }
+            const int affinity_rc = pthread_setaffinity_np(
+                pthread_self(),
+                sizeof(cpuset),
+                &cpuset);
+            if (affinity_rc != 0) {
+                std::cerr << name << ": pthread_setaffinity_np(mask=0x"
+                          << std::hex << cpu_affinity_mask << std::dec
+                          << ") failed, rc=" << affinity_rc << std::endl;
+            }
+        }
+
+        if (priority > 0) {
+            sched_param params{};
+            params.sched_priority = priority;
+            const int priority_rc = pthread_setschedparam(
+                pthread_self(),
+                SCHED_FIFO,
+                &params);
+            if (priority_rc != 0) {
+                std::cerr << name << ": pthread_setschedparam(SCHED_FIFO, "
+                          << priority << ") failed, rc=" << priority_rc << std::endl;
+            }
+        }
+#else
+        (void)name;
+        (void)priority;
+        (void)cpu_affinity_mask;
+#endif
+    }
+
     void Run() {
+        if (options_.enable_realtime_dedicated_executor) {
+            TryConfigureThread(
+                "DdsDedicatedCallbackExecutor",
+                options_.realtime_dedicated_executor_priority,
+                options_.realtime_dedicated_executor_cpu_affinity_mask);
+        }
         while (true) {
             std::function<void()> task;
             {
@@ -205,6 +287,7 @@ private:
     }
 
 private:
+    DdsReaderExecutorOptions options_;
     std::mutex mutex_;
     std::condition_variable cv_;
     std::deque<std::function<void()>> tasks_;
@@ -213,7 +296,7 @@ private:
 };
 
 template <typename MSG>
-class DdsReaderListener : public DataReaderListener, public std::enable_shared_from_this<DdsReaderListener<MSG>> {
+class DdsReaderListener : public DdsDataReaderListener, public std::enable_shared_from_this<DdsReaderListener<MSG>> {
 public:
     DdsReaderListener() = default;
     ~DdsReaderListener() override {
@@ -237,7 +320,8 @@ public:
         executor_options_ = options;
         if (executor_options_.dispatch_mode == DdsExecutorDispatchMode::kDedicated) {
             if (dedicated_executor_ == nullptr) {
-                dedicated_executor_ = std::make_unique<DdsDedicatedCallbackExecutor>();
+                dedicated_executor_ = std::make_unique<DdsDedicatedCallbackExecutor>(
+                    executor_options_);
             }
         } else {
             dedicated_executor_.reset();
@@ -251,13 +335,17 @@ public:
         return metrics;
     }
 
-    void on_data_available(DataReader *reader) override {
+    void on_data_available(DdsReader *reader) override {
         if (reader == nullptr || cb_ == nullptr) {
             return;
         }
 
+        ApplyRealtimeListenerThreadConfigOnce();
+
         std::deque<PendingMessage> ready_messages;
-        SampleInfo info;
+        DdsSampleInfo info;
+        const auto listener_enter_steady = std::chrono::steady_clock::now();
+        const auto listener_enter_system = std::chrono::system_clock::now();
         while (true) {
             MSG st;
             if (reader->take_next_sample(&st, &info) != ReturnCode_t::RETCODE_OK) {
@@ -266,7 +354,11 @@ public:
             if (info.valid_data) {
                 ready_messages.push_back(PendingMessage{
                     std::move(st),
+                    info,
+                    listener_enter_steady,
+                    listener_enter_system,
                     std::chrono::steady_clock::now(),
+                    std::chrono::system_clock::now(),
                 });
             }
         }
@@ -298,9 +390,35 @@ public:
 private:
     struct PendingMessage {
         MSG message;
+        DdsSampleInfo sample_info;
+        std::chrono::steady_clock::time_point listener_enter_steady_time;
+        std::chrono::system_clock::time_point listener_enter_system_time;
         std::chrono::steady_clock::time_point enqueued_at;
+        std::chrono::system_clock::time_point enqueued_system_time;
+    };
+
+    static bool IsValidRtpsSystemTime(const eprosima::fastrtps::rtps::Time_t &time) {
+        return time.seconds() >= 0;
+    }
+
+    static std::chrono::system_clock::time_point RtpsTimeToSystemClock(
+        const eprosima::fastrtps::rtps::Time_t &time) {
+        return std::chrono::system_clock::time_point(
+            std::chrono::nanoseconds(time.to_ns()));
     };
 
+    void ApplyRealtimeListenerThreadConfigOnce() {
+        std::lock_guard<std::mutex> lock(mutex_);
+        if (listener_thread_configured_ || !executor_options_.enable_realtime_listener) {
+            return;
+        }
+        DdsDedicatedCallbackExecutor::TryConfigureThread(
+            "DdsReaderListener",
+            executor_options_.realtime_listener_priority,
+            executor_options_.realtime_listener_cpu_affinity_mask);
+        listener_thread_configured_ = true;
+    }
+
     void EnqueuePendingMessageLocked(PendingMessage &&message) {
         if (executor_options_.enable_metrics) {
             ++metrics_.samples_received;
@@ -375,7 +493,8 @@ private:
             PendingMessage pending_message;
             DdsReaderCallbackPtr cb;
             bool metrics_enabled = false;
-            size_t pending_queue_size = 0;
+            size_t pending_queue_size_before_callback = 0;
+            size_t pending_queue_size_after_pop = 0;
             {
                 std::unique_lock<std::mutex> lock(mutex_);
                 if (stop_requested_) {
@@ -387,28 +506,56 @@ private:
                     return;
                 }
 
+                pending_queue_size_before_callback = pending_messages_.size();
                 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();
+                pending_queue_size_after_pop = pending_messages_.size();
             }
 
-            const auto callback_start = std::chrono::steady_clock::now();
+            const auto callback_start_steady = std::chrono::steady_clock::now();
+            const auto callback_start_system = std::chrono::system_clock::now();
             if (cb != nullptr) {
-                cb->OnDataAvailable(&pending_message.message);
+                DdsMessageContext context;
+                context.listener_enter_steady_time =
+                    pending_message.listener_enter_steady_time;
+                context.listener_enter_system_time =
+                    pending_message.listener_enter_system_time;
+                context.dds_rx_steady_time = pending_message.enqueued_at;
+                context.dds_rx_system_time = pending_message.enqueued_system_time;
+                context.callback_start_steady_time = callback_start_steady;
+                context.callback_start_system_time = callback_start_system;
+                context.listener_enter_to_dds_rx_delay =
+                    pending_message.enqueued_at - pending_message.listener_enter_steady_time;
+                context.dds_rx_to_callback_delay = callback_start_steady - pending_message.enqueued_at;
+                context.queue_size_before_callback = pending_queue_size_before_callback;
+                context.queue_size_after_pop = pending_queue_size_after_pop;
+                context.has_source_timestamp = IsValidRtpsSystemTime(
+                    pending_message.sample_info.source_timestamp);
+                if (context.has_source_timestamp) {
+                    context.source_timestamp_system_time = RtpsTimeToSystemClock(
+                        pending_message.sample_info.source_timestamp);
+                }
+                context.has_reception_timestamp = IsValidRtpsSystemTime(
+                    pending_message.sample_info.reception_timestamp);
+                if (context.has_reception_timestamp) {
+                    context.reception_timestamp_system_time = RtpsTimeToSystemClock(
+                        pending_message.sample_info.reception_timestamp);
+                }
+                cb->OnDataAvailable(&pending_message.message, context);
             }
 
             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();
+                    callback_start_steady - pending_message.enqueued_at).count();
                 const auto callback_duration_us = std::chrono::duration_cast<std::chrono::microseconds>(
-                    callback_end - callback_start).count();
+                    callback_end - callback_start_steady).count();
 
                 std::lock_guard<std::mutex> lock(mutex_);
                 ++metrics_.callbacks_executed;
-                metrics_.current_queue_size = pending_queue_size;
+                metrics_.current_queue_size = pending_queue_size_after_pop;
                 metrics_.max_queue_latency_us = std::max<uint64_t>(
                     metrics_.max_queue_latency_us,
                     static_cast<uint64_t>(queue_latency_us));
@@ -424,6 +571,7 @@ private:
     std::deque<PendingMessage> pending_messages_;
     bool stop_requested_{false};
     bool callback_scheduled_{false};
+    bool listener_thread_configured_{false};
     DdsReaderExecutorOptions executor_options_;
     DdsReaderExecutorMetrics metrics_;
     DdsReaderCallbackPtr cb_;