ROS2 QT 多线程功能包设计

最新推荐文章于 2025-08-10 23:56:24 发布
最新推荐文章于 2025-08-10 23:56:24 发布
阅读量186 收藏 4
点赞数 2
CC 4.0 BY-SA版权
分类专栏： ROS 文章标签： qt 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZPC8210/article/details/150153535

一个完整的 ROS2 QT 多线程功能包实现，包含可选 GUI 界面、发布者线程、接收者线程和参数服务器交互功能。

功能包结构

plaintext

ros2_qt_multi_thread/
├── CMakeLists.txt
├── package.xml
├── src/
│   ├── main.cpp
│   ├── main_window.cpp
│   ├── main_window.ui
│   ├── ros_node.cpp
│   ├── publisher_thread.cpp
│   ├── subscriber_thread.cpp
│   └── param_manager.cpp
└── include/
    └── ros2_qt_multi_thread/
        ├── main_window.hpp
        ├── ros_node.hpp
        ├── publisher_thread.hpp
        ├── subscriber_thread.hpp
        └── param_manager.hpp

核心文件实现

1. package.xml

xml

<?xml version="1.0"?>
<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
<package format="3">
  <name>ros2_qt_multi_thread</name>
  <version>0.0.0</version>
  <description>ROS2 QT Multi-threaded Package with GUI, Publisher, Subscriber and Param Server</description>
  <maintainer email="your@email.com">Your Name</maintainer>
  <license>Apache-2.0</license>
  
  <buildtool_depend>ament_cmake</buildtool_depend>
  <buildtool_depend>ament_cmake_qt</buildtool_depend>
  <depend>rclcpp</depend>
  <depend>std_msgs</depend>
  <depend>Qt5Widgets</depend>
  <depend>Qt5Core</depend>
  
  <build_depend>ament_cmake</build_depend>
  <exec_depend>rclcpp</exec_depend>
  <exec_depend>std_msgs</exec_depend>
  <exec_depend>Qt5Widgets</exec_depend>
  
  <build_type>ament_cmake</build_type>
  <export>
    <build_type>ament_cmake</build_type>
  </export>
</package>

2. CMakeLists.txt

cmake

cmake_minimum_required(VERSION 3.5)
project(ros2_qt_multi_thread)

if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
  add_compile_options(-Wall -Wextra -Wpedantic)
endif()

# Qt5 配置
find_package(Qt5 COMPONENTS Widgets Core REQUIRED)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_AUTOUIC ON)
set(Qt5_LIBRARIES Qt5::Widgets Qt5::Core)

# ROS2 配置
find_package(ament_cmake REQUIRED)
find_package(rclcpp REQUIRED)
find_package(std_msgs REQUIRED)

# 包含目录
include_directories(
  include
  ${Qt5Widgets_INCLUDE_DIRS}
)

# 源文件
set(SOURCES
  src/main.cpp
  src/main_window.cpp
  src/ros_node.cpp
  src/publisher_thread.cpp
  src/subscriber_thread.cpp
  src/param_manager.cpp
)

# UI文件
set(UIS
  src/main_window.ui
)

# 生成可执行文件
add_executable(${PROJECT_NAME}
  ${SOURCES}
  ${UIS}
)

# 链接库
target_link_libraries(${PROJECT_NAME}
  ${Qt5_LIBRARIES}
  rclcpp::rclcpp
  ${std_msgs_TARGETS}
)

# 安装
install(TARGETS
  ${PROJECT_NAME}
  DESTINATION lib/${PROJECT_NAME}
)

ament_package()

3. 头文件

include/ros2_qt_multi_thread/main_window.hpp

cpp

运行

#ifndef ROS2_QT_MULTI_THREAD_MAIN_WINDOW_HPP_
#define ROS2_QT_MULTI_THREAD_MAIN_WINDOW_HPP_

#include <QMainWindow>
#include <QThread>
#include <QTimer>
#include <memory>
#include "ui_main_window.h"
#include "ros_node.hpp"
#include "param_manager.hpp"

namespace ros2_qt_multi_thread
{

class MainWindow : public QMainWindow
{
  Q_OBJECT

public:
  MainWindow(bool use_gui = true, QWidget *parent = nullptr);
  ~MainWindow();

  void showStatusMessage(const QString &message);
  void updatePublisherRate(int rate);
  void updateSubscriberCount(int count);
  void addSubscriberMessage(const QString &message);

public slots:
  void onStartPublishClicked();
  void onStopPublishClicked();
  void onUpdateParamsClicked();
  void onRosSpinOnce();

private:
  Ui::MainWindow ui_;
  bool use_gui_;
  std::shared_ptr<RosNode> ros_node_;
  std::unique_ptr<ParamManager> param_manager_;
  QTimer *ros_timer_;
};

}  // namespace ros2_qt_multi_thread

#endif  // ROS2_QT_MULTI_THREAD_MAIN_WINDOW_HPP_
include/ros2_qt_multi_thread/ros_node.hpp

cpp

运行

#ifndef ROS2_QT_MULTI_THREAD_ROS_NODE_HPP_
#define ROS2_QT_MULTI_THREAD_ROS_NODE_HPP_

#include <rclcpp/rclcpp.hpp>
#include <std_msgs/msg/string.hpp>
#include <QObject>
#include <memory>
#include "publisher_thread.hpp"
#include "subscriber_thread.hpp"
#include "param_manager.hpp"

namespace ros2_qt_multi_thread
{

class RosNode : public rclcpp::Node
{
  Q_OBJECT

public:
  RosNode(const std::string &node_name = "qt_ros2_node");
  ~RosNode() override;

  void startPublishing(int rate);
  void stopPublishing();
  void startSubscribing();
  void setParameters(const std::map<std::string, std::string> &params);
  std::map<std::string, std::string> getParameters();

  std::shared_ptr<PublisherThread> getPublisherThread() { return publisher_thread_; }
  std::shared_ptr<SubscriberThread> getSubscriberThread() { return subscriber_thread_; }
  std::shared_ptr<ParamManager> getParamManager() { return param_manager_; }

signals:
  void statusUpdated(const QString &status);
  void messageReceived(const QString &message);
  void subscriberCountUpdated(int count);

private:
  std::shared_ptr<PublisherThread> publisher_thread_;
  std::shared_ptr<SubscriberThread> subscriber_thread_;
  std::shared_ptr<ParamManager> param_manager_;
};

}  // namespace ros2_qt_multi_thread

#endif  // ROS2_QT_MULTI_THREAD_ROS_NODE_HPP_
include/ros2_qt_multi_thread/publisher_thread.hpp

cpp

运行

#ifndef ROS2_QT_MULTI_THREAD_PUBLISHER_THREAD_HPP_
#define ROS2_QT_MULTI_THREAD_PUBLISHER_THREAD_HPP_

#include <rclcpp/rclcpp.hpp>
#include <std_msgs/msg/string.hpp>
#include <QThread>
#include <QMutex>
#include <atomic>

namespace ros2_qt_multi_thread
{

class PublisherThread : public QThread
{
  Q_OBJECT

public:
  PublisherThread(rclcpp::Node::SharedPtr node);
  ~PublisherThread() override;

  void setRate(int rate);
  void startPublishing();
  void stopPublishing();
  bool isPublishing() const { return is_publishing_; }

signals:
  void statusUpdated(const QString &status);
  void messagePublished(const QString &message);

protected:
  void run() override;

private:
  rclcpp::Node::SharedPtr node_;
  rclcpp::Publisher<std_msgs::msg::String>::SharedPtr publisher_;
  mutable QMutex mutex_;
  std::atomic<bool> is_publishing_;
  int publish_rate_;
  int message_count_;
};

}  // namespace ros2_qt_multi_thread

#endif  // ROS2_QT_MULTI_THREAD_PUBLISHER_THREAD_HPP_
include/ros2_qt_multi_thread/subscriber_thread.hpp

cpp

运行

#ifndef ROS2_QT_MULTI_THREAD_SUBSCRIBER_THREAD_HPP_
#define ROS2_QT_MULTI_THREAD_SUBSCRIBER_THREAD_HPP_

#include <rclcpp/rclcpp.hpp>
#include <std_msgs/msg/string.hpp>
#include <QThread>
#include <QMutex>
#include <atomic>

namespace ros2_qt_multi_thread
{

class SubscriberThread : public QThread
{
  Q_OBJECT

public:
  SubscriberThread(rclcpp::Node::SharedPtr node);
  ~SubscriberThread() override;

  void startSubscribing();
  void stopSubscribing();
  int getMessageCount() const { return message_count_; }

signals:
  void messageReceived(const QString &message);
  void countUpdated(int count);

private:
  void topicCallback(const std_msgs::msg::String::SharedPtr msg);

  rclcpp::Node::SharedPtr node_;
  rclcpp::Subscription<std_msgs::msg::String>::SharedPtr subscriber_;
  mutable QMutex mutex_;
  std::atomic<bool> is_subscribing_;
  std::atomic<int> message_count_;
};

}  // namespace ros2_qt_multi_thread

#endif  // ROS2_QT_MULTI_THREAD_SUBSCRIBER_THREAD_HPP_
include/ros2_qt_multi_thread/param_manager.hpp

cpp

运行

#ifndef ROS2_QT_MULTI_THREAD_PARAM_MANAGER_HPP_
#define ROS2_QT_MULTI_THREAD_PARAM_MANAGER_HPP_

#include <rclcpp/rclcpp.hpp>
#include <QObject>
#include <map>
#include <string>

namespace ros2_qt_multi_thread
{

class ParamManager : public QObject
{
  Q_OBJECT

public:
  ParamManager(rclcpp::Node::SharedPtr node);
  ~ParamManager() override = default;

  void setParameters(const std::map<std::string, std::string> &params);
  std::map<std::string, std::string> getParameters() const;
  void declareDefaultParameters();

signals:
  void parametersUpdated(const std::map<std::string, std::string> &params);
  void statusUpdated(const QString &status);

private:
  rclcpp::Node::SharedPtr node_;
  mutable std::recursive_mutex param_mutex_;
  std::map<std::string, std::string> current_params_;
};

}  // namespace ros2_qt_multi_thread

#endif  // ROS2_QT_MULTI_THREAD_PARAM_MANAGER_HPP_

4. 源文件实现

src/main.cpp

cpp

运行

#include <QApplication>
#include <rclcpp/rclcpp.hpp>
#include <iostream>
#include "ros2_qt_multi_thread/main_window.hpp"

int main(int argc, char *argv[])
{
  // 初始化ROS2
  rclcpp::init(argc, argv);
  
  // 检查是否需要启动GUI
  bool use_gui = true;
  for (int i = 0; i < argc; ++i) {
    if (std::string(argv[i]) == "--no-gui") {
      use_gui = false;
      break;
    }
  }

  // 初始化QT应用
  QApplication app(argc, argv);
  
  // 创建主窗口
  ros2_qt_multi_thread::MainWindow main_window(use_gui);
  
  // 如果使用GUI，则显示窗口
  if (use_gui) {
    main_window.show();
  } else {
    main_window.showStatusMessage("Running in headless mode");
  }

  // 运行QT事件循环
  int result = app.exec();
  
  // 关闭ROS2
  rclcpp::shutdown();
  return result;
}
src/main_window.cpp

cpp

运行

#include "ros2_qt_multi_thread/main_window.hpp"
#include <QMessageBox>
#include <QTimer>

namespace ros2_qt_multi_thread
{

MainWindow::MainWindow(bool use_gui, QWidget *parent)
  : QMainWindow(parent), use_gui_(use_gui)
{
  // 设置UI
  if (use_gui_) {
    ui_.setupUi(this);
    setWindowTitle("ROS2 QT Multi-Thread");

    // 连接信号槽
    connect(ui_.start_publish_btn, &QPushButton::clicked, 
            this, &MainWindow::onStartPublishClicked);
    connect(ui_.stop_publish_btn, &QPushButton::clicked, 
            this, &MainWindow::onStopPublishClicked);
    connect(ui_.update_params_btn, &QPushButton::clicked, 
            this, &MainWindow::onUpdateParamsClicked);
  }

  // 创建ROS节点
  ros_node_ = std::make_shared<RosNode>();
  
  // 设置参数管理器
  param_manager_ = std::make_unique<ParamManager>(ros_node_);
  param_manager_->declareDefaultParameters();

  // 启动订阅者
  ros_node_->startSubscribing();

  // 连接ROS信号
  connect(ros_node_->getSubscriberThread().get(), &SubscriberThread::messageReceived,
          this, &MainWindow::addSubscriberMessage);
  connect(ros_node_->getSubscriberThread().get(), &SubscriberThread::countUpdated,
          this, &MainWindow::updateSubscriberCount);
  connect(ros_node_.get(), &RosNode::statusUpdated,
          this, &MainWindow::showStatusMessage);

  // 创建ROS定时器，定期处理事件
  ros_timer_ = new QTimer(this);
  connect(ros_timer_, &QTimer::timeout, this, &MainWindow::onRosSpinOnce);
  ros_timer_->start(10);  // 每10ms处理一次
}

MainWindow::~MainWindow()
{
  ros_node_->stopPublishing();
  delete ros_timer_;
}

void MainWindow::showStatusMessage(const QString &message)
{
  if (use_gui_) {
    ui_.status_bar->showMessage(message, 3000);
    ui_.log_textEdit->append(message);
  } else {
    std::cout << "[STATUS] " << message.toStdString() << std::endl;
  }
}

void MainWindow::updatePublisherRate(int rate)
{
  if (use_gui_) {
    ui_.publish_rate_label->setText(QString("Publish Rate: %1 Hz").arg(rate));
  }
}

void MainWindow::updateSubscriberCount(int count)
{
  if (use_gui_) {
    ui_.sub_count_label->setText(QString("Received Messages: %1").arg(count));
  } else {
    std::cout << "Total received messages: " << count << std::endl;
  }
}

void MainWindow::addSubscriberMessage(const QString &message)
{
  if (use_gui_) {
    ui_.sub_messages_textEdit->append(message);
    // 限制显示行数
    while (ui_.sub_messages_textEdit->document()->blockCount() > 100) {
      QTextCursor cursor(ui_.sub_messages_textEdit->document()->firstBlock());
      cursor.select(QTextCursor::BlockUnderCursor);
      cursor.removeSelectedText();
      cursor.deleteChar();
    }
  } else {
    std::cout << "[RECEIVED] " << message.toStdString() << std::endl;
  }
}

void MainWindow::onStartPublishClicked()
{
  if (use_gui_) {
    int rate = ui_.publish_rate_spinBox->value();
    ros_node_->startPublishing(rate);
    showStatusMessage(QString("Starting publishing at %1 Hz").arg(rate));
  }
}

void MainWindow::onStopPublishClicked()
{
  ros_node_->stopPublishing();
  showStatusMessage("Stopped publishing");
}

void MainWindow::onUpdateParamsClicked()
{
  if (use_gui_) {
    std::map<std::string, std::string> params;
    params["publish_topic"] = ui_.pub_topic_lineEdit->text().toStdString();
    params["subscribe_topic"] = ui_.sub_topic_lineEdit->text().toStdString();
    params["message_prefix"] = ui_.msg_prefix_lineEdit->text().toStdString();
    
    ros_node_->setParameters(params);
    showStatusMessage("Parameters updated");
  }
}

void MainWindow::onRosSpinOnce()
{
  // 处理ROS事件
  rclcpp::spin_some(ros_node_);
}

}  // namespace ros2_qt_multi_thread
src/ros_node.cpp

cpp

运行

#include "ros2_qt_multi_thread/ros_node.hpp"

namespace ros2_qt_multi_thread
{

RosNode::RosNode(const std::string &node_name)
  : Node(node_name)
{
  // 创建发布者线程
  publisher_thread_ = std::make_shared<PublisherThread>(shared_from_this());
  
  // 创建订阅者线程
  subscriber_thread_ = std::make_shared<SubscriberThread>(shared_from_this());
  
  // 创建参数管理器
  param_manager_ = std::make_shared<ParamManager>(shared_from_this());
  
  // 连接信号
  connect(publisher_thread_.get(), &PublisherThread::statusUpdated,
          this, &RosNode::statusUpdated);
  connect(subscriber_thread_.get(), &SubscriberThread::messageReceived,
          this, &RosNode::messageReceived);
  connect(subscriber_thread_.get(), &SubscriberThread::countUpdated,
          this, &RosNode::subscriberCountUpdated);
}

RosNode::~RosNode()
{
  stopPublishing();
}

void RosNode::startPublishing(int rate)
{
  publisher_thread_->setRate(rate);
  publisher_thread_->startPublishing();
}

void RosNode::stopPublishing()
{
  if (publisher_thread_ && publisher_thread_->isPublishing()) {
    publisher_thread_->stopPublishing();
  }
}

void RosNode::startSubscribing()
{
  subscriber_thread_->startSubscribing();
}

void RosNode::setParameters(const std::map<std::string, std::string> &params)
{
  param_manager_->setParameters(params);
}

std::map<std::string, std::string> RosNode::getParameters()
{
  return param_manager_->getParameters();
}

}  // namespace ros2_qt_multi_thread
src/publisher_thread.cpp

cpp

运行

#include "ros2_qt_multi_thread/publisher_thread.hpp"
#include <chrono>
#include <thread>

namespace ros2_qt_multi_thread
{

PublisherThread::PublisherThread(rclcpp::Node::SharedPtr node)
  : node_(node), is_publishing_(false), publish_rate_(10), message_count_(0)
{
  // 创建发布者
  std::string topic_name = "qt_publisher_topic";
  if (node_->has_parameter("publish_topic")) {
    node_->get_parameter("publish_topic", topic_name);
  } else {
    node_->declare_parameter("publish_topic", topic_name);
  }
  
  publisher_ = node_->create_publisher<std_msgs::msg::String>(topic_name, 10);
}

PublisherThread::~PublisherThread()
{
  stopPublishing();
  wait();
}

void PublisherThread::setRate(int rate)
{
  QMutexLocker locker(&mutex_);
  publish_rate_ = rate;
}

void PublisherThread::startPublishing()
{
  QMutexLocker locker(&mutex_);
  if (!is_publishing_) {
    is_publishing_ = true;
    if (!isRunning()) {
      start();
    }
  }
}

void PublisherThread::stopPublishing()
{
  QMutexLocker locker(&mutex_);
  is_publishing_ = false;
}

void PublisherThread::run()
{
  while (is_publishing_) {
    // 获取当前参数
    std::string topic_name = "qt_publisher_topic";
    std::string message_prefix = "Message from QT: ";
    
    node_->get_parameter("publish_topic", topic_name);
    node_->get_parameter("message_prefix", message_prefix);
    
    // 如果话题名称已更改，重新创建发布者
    if (publisher_->get_topic_name() != topic_name) {
      publisher_ = node_->create_publisher<std_msgs::msg::String>(topic_name, 10);
      emit statusUpdated(QString("Publisher topic changed to: %1").arg(QString::fromStdString(topic_name)));
    }
    
    // 创建并发布消息
    auto msg = std_msgs::msg::String();
    msg.data = message_prefix + std::to_string(message_count_++);
    publisher_->publish(msg);
    
    emit messagePublished(QString::fromStdString(msg.data));
    emit statusUpdated(QString("Published: %1").arg(QString::fromStdString(msg.data)));
    
    // 控制发布频率
    int rate;
    {
      QMutexLocker locker(&mutex_);
      rate = publish_rate_;
    }
    
    if (rate > 0) {
      std::this_thread::sleep_for(std::chrono::milliseconds(1000 / rate));
    } else {
      std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
  }
}

}  // namespace ros2_qt_multi_thread
src/subscriber_thread.cpp

cpp

运行

#include "ros2_qt_multi_thread/subscriber_thread.hpp"

namespace ros2_qt_multi_thread
{

SubscriberThread::SubscriberThread(rclcpp::Node::SharedPtr node)
  : node_(node), is_subscribing_(false), message_count_(0)
{
  // 初始化订阅者
  std::string topic_name = "qt_subscriber_topic";
  if (node_->has_parameter("subscribe_topic")) {
    node_->get_parameter("subscribe_topic", topic_name);
  } else {
    node_->declare_parameter("subscribe_topic", topic_name);
  }
  
  createSubscriber(topic_name);
}

SubscriberThread::~SubscriberThread()
{
  stopSubscribing();
  wait();
}

void SubscriberThread::startSubscribing()
{
  QMutexLocker locker(&mutex_);
  if (!is_subscribing_) {
    is_subscribing_ = true;
    if (!isRunning()) {
      start();
    }
  }
}

void SubscriberThread::stopSubscribing()
{
  QMutexLocker locker(&mutex_);
  is_subscribing_ = false;
}

void SubscriberThread::createSubscriber(const std::string &topic_name)
{
  subscriber_ = node_->create_subscription<std_msgs::msg::String>(
    topic_name,
    10,
    std::bind(&SubscriberThread::topicCallback, this, std::placeholders::_1)
  );
}

void SubscriberThread::topicCallback(const std_msgs::msg::String::SharedPtr msg)
{
  message_count_++;
  emit messageReceived(QString::fromStdString(msg->data));
  emit countUpdated(message_count_);
}

void SubscriberThread::run()
{
  std::string current_topic;
  
  while (is_subscribing_ && rclcpp::ok()) {
    // 检查话题是否更改
    std::string topic_name;
    node_->get_parameter("subscribe_topic", topic_name);
    
    if (topic_name != current_topic) {
      current_topic = topic_name;
      createSubscriber(topic_name);
    }
    
    // 处理回调
    rclcpp::spin_some(node_);
    
    // 短暂休眠，降低CPU占用
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
  }
}

}  // namespace ros2_qt_multi_thread
src/param_manager.cpp

cpp

运行

#include "ros2_qt_multi_thread/param_manager.hpp"

namespace ros2_qt_multi_thread
{

ParamManager::ParamManager(rclcpp::Node::SharedPtr node)
  : node_(node)
{
  declareDefaultParameters();
}

void ParamManager::declareDefaultParameters()
{
  std::lock_guard<std::recursive_mutex> lock(param_mutex_);
  
  // 声明默认参数
  node_->declare_parameter("publish_topic", "qt_publisher_topic");
  node_->declare_parameter("subscribe_topic", "qt_subscriber_topic");
  node_->declare_parameter("message_prefix", "Message from QT: ");
  node_->declare_parameter("log_level", "info");
  
  // 初始化当前参数映射
  current_params_["publish_topic"] = "qt_publisher_topic";
  current_params_["subscribe_topic"] = "qt_subscriber_topic";
  current_params_["message_prefix"] = "Message from QT: ";
  current_params_["log_level"] = "info";
}

void ParamManager::setParameters(const std::map<std::string, std::string> &params)
{
  std::lock_guard<std::recursive_mutex> lock(param_mutex_);
  
  for (const auto &[key, value] : params) {
    // 设置ROS参数
    node_->set_parameter(rclcpp::Parameter(key, value));
    current_params_[key] = value;
    
    emit statusUpdated(QString("Set parameter: %1 = %2").arg(QString::fromStdString(key), QString::fromStdString(value)));
  }
  
  emit parametersUpdated(current_params_);
}

std::map<std::string, std::string> ParamManager::getParameters() const
{
  std::lock_guard<std::recursive_mutex> lock(param_mutex_);
  return current_params_;
}

}  // namespace ros2_qt_multi_thread

使用说明

1. 编译功能包

bash

colcon build --packages-select ros2_qt_multi_thread
source install/setup.bash

2. 运行程序

带 GUI 模式

bash

ros2 run ros2_qt_multi_thread ros2_qt_multi_thread
无头模式（无 GUI）

bash

ros2 run ros2_qt_multi_thread ros2_qt_multi_thread --no-gui

3. 功能说明

  • 发布者线程：可配置发布频率和消息前缀，通过 ROS 参数动态更改发布话题
  • 接收者线程：订阅指定话题，统计接收消息数量，支持动态更改订阅话题
  • 参数服务器：管理所有可配置参数，包括话题名称、消息前缀等
  • GUI 界面：提供直观的控制界面，显示发布 / 订阅状态和消息内容

4. 关键特性

  • 多线程分离：发布者和订阅者在独立线程中运行，避免相互阻塞
  • 参数动态更新：支持运行时更改参数，无需重启程序
  • 可选 GUI：根据需求选择是否启动图形界面
  • 信号槽机制：QT 信号槽与 ROS 回调无缝集成，确保线程安全

这个功能包可以作为 ROS2 与 QT 集成的基础框架，你可以根据实际需求扩展消息类型和功能。

【ROS】ROS1人机界面开发：第一个最简ROS+QtGui程序（按钮启动发布者）
郭老二
07-19 2448
学习将QtGui界面文件添加到ROS工程中，通过界面按钮启动ROS，在Qt线程中发布ROS消息
ROS2与QT的联合使用
qq_53044655的博客
04-22 1159
首先需要确保QT中已安装ros2的插件可参考[https://blog.csdn.net/Functioe/article/details/131659829]注意选择编译系统为此处建议先点击右下角构建一下选中src，右击选择添加新文件，创建package如果按钮仍然是灰色，可以点击后关闭界面，然后就能发现按钮可用了创建完毕右键,选择添加新文件一直下一步，完成创建右键添加新文件，文件名为,内容如下 2 修改Cmakelist.txt文件 此时如果编译大概率是不能通过的，需要修改Cmakelist.txt文件
在 Qt Creator 上创建 ROS 项目并新建/导入 ROS 包
YMGogre的博客
05-09 9429
本文将着手探讨如何在 Qt Creator 上编辑 ROS 项目（工作空间）
ROS和ROS2使用
boss-dog
06-03 974
在上面的代码中，我们使用了std::thread来启动和停止节点，这样可以避免阻塞主线程。在main函数中，我们初始化ROS2节点，创建NodeManager对象，并向其添加两个节点。以下是一个C++代码示例，可以对多个ROS2节点分别进行启动和关闭，通过调用相关函数可启动或关闭某个指定节点，不会阻塞主线程，且不需要用户操作来退出某个节点。：可以对多个ROS2节点分别进行进行启动和关闭，通过调用相关函数可启动或关闭某个指定节点，不会阻塞主线程，且不需要用户操作来退出某个节点。文件中编写节点代码。
ROS2话题通信订阅方实现
孤ROS的博客
07-05 279
功能包cpp01_topic的src目录下，新建C++文件demo02_listener_str.cpp，并编辑文件。
【Qt提高】Qt+ROS界面软件开发（一）
Christina_Clbert的博客
03-13 2103
本博客是博主在学习古月学院的ros＋qt课程中的课程笔记，欢迎共同学习 目录 １．qt多线程 ２．在Qｔ中创建publisher和subscriber 3. 键盘实现控制 ４．速度仪表盘实现 １．qt多线程 在ros节点中，需要循环调用spinOnce()函数，在while(ros::ok())里面 如果把这个死循环放入主进程，界面会直接卡死，因此需要使用多线程机制 开辟一个新的线程来执行一些比较费时的操作，就类似js里面的异步 ＱNode继承于ＱThread，通过重写run()...
ROS2 Humble 学习【openEuler】
天道酬勤
08-05 1610
ROS2 Humble 学习【openEuler】
ROS2小乌龟案例动作通信
孤ROS的博客
07-18 1254
编写动作接口文件；编写动作服务端实现；编写动作客户端实现；编写launch文件；编辑配置文件；编译；执行。
ros2-3.4话题通信最佳实践
bohu83的博客
01-07 764
ros2自定义通信接口，python采集系统信息并发布，C++订阅消息并展示。
使用Qt+librviz+ros设计点云显示界面.zip
05-22
由于ROS和Qt可能需要同时处理数据接收、处理和UI更新，项目可能涉及到多线程和并发编程，以保证界面的流畅性和响应性。 7. **Qt与ROS的集成**： 在项目中，开发者需要理解如何将ROS节点与Qt应用程序相结合，通过...
ros下编写QT界面功能包读取和驱动TX90及OptoForce力传感器
weixin_42355349的博客
05-26 1147
1.编写qt功能包 catkin_create_qt_pkg zlc_robot
深入探讨ROS与QT集成：实现订阅者SUB功能
这可能涉及到使用Qt的线程机制来处理ROS的回调函数，因为ROS要求订阅者回调函数必须在非主线程执行。 - **跨平台开发和部署**：Qt支持跨平台开发，这意味着使用Qt和ROS开发的程序可以轻松部署到不同的操作系统上。...
qt ros线程间通信
02-09
以上代码片段展示了如何在一个简单的GUI程序中嵌入ROS客户端库的功能模块，并通过事件驱动的方式来同步多线程间的协作过程。需要注意的是实际应用场景下可能还需要考虑更多细节问题比如错误恢复策略、资源管理等。
QT Creator 5.14.2安装
m0_70655689的博客
08-09 391
本文介绍了Qt 5.14.2的两种获取方式：通过百度网盘（含下载链接及提取码）或官网下载（国内IP受限）。安装步骤包括管理员身份运行、设置安装路径（建议D盘）、选择组件、同意协议等流程，最后等待安装完成。作者声明部分内容来自网络，如有侵权请联系。
RK3568笔记九十八：使用Qt实现RTMP拉流显示
08-07 85
本项目是一个基于Qt框架和FFmpeg音视频解码库实现的RTMP流媒体播放器。通过该播放器，用户可以实时拉取RTMP视频流并在界面上进行播放和显示。功能特点实时拉流：支持从RTMP服务器实时拉取视频流。视频解码：利用FFmpeg库对拉取的视频流进行解码。界面显示：通过Qt框架将解码后的视频流显示在用户界面上。依赖库Qt：用于构建用户界面和处理图形显示。FFmpeg：用于音视频流的解码和处理。
知识随记-----Qt 实用技巧：自定义倒计时按钮防止用户频繁点击
筏的博客
08-08 912
用户点击后按钮进入倒计时状态，倒计时结束后才能再次点击
gRPC for C++ 实战全流程 —— 从零搭建到同步/异步服务
人心有反复，好在山水有重逢。
08-09 256
定义了两个 RPC 接口：注册和登录。状态中创建新对象以处理后续请求。实现，有两种封装方式。
QT----不同线程中信号发送了槽函数没反应QObject::connect: Cannot queue arguments of typeXXX
混吃等死，研究生在读，毕业无望，偶尔搞点好玩的
08-06 222
QMap<QString, QString> 作为信号参数时，必须是已注册的元类型，否则 Qt 无法在不同线程之间传递该信号。也就是说qt不认识这个参数,注册一下就行.代码上绑定没有问题,但是debug时子线程中信号能够发送,但是主线程中的槽函数没有执行,同时日志里也有个不算报错的东西,正好是我信号传递的参数.里添加上这样一行代码就行。
QT常用控件三
最新发布
m0_74316391的博客
08-10 509
之前我们想要让元素出现到想要的位置，出现想要的大小，要么是手动在UI界面调整，要么在代码里面使用绝对定位，这样子既不方便，还可能不满意出错，还需要设置resizeEvent(QResizeEvent *event)来让控件大小随界面变化而变化，布局管理器就是用来解决这个问题的，当我们预设好后，布局管理器会自动计算这些帮我们调整位置大小。我们上面讲的是垂直和水平方向的布局管理器，现在我们要讲的是网格状的布局管理器，类似于上面两个布局管理器的结合，它的效果简单使用如下。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值