Robot Operating System——std_msgs消息类型说明和使用

breaksoftware

于 2024-08-12 00:30:00 发布

阅读量1.4k

点赞数 20

分类专栏： Robot Operating System 文章标签： linux C++ 机器人

本文链接：https://blog.csdn.net/breaksoftware/article/details/140923621

版权

Robot Operating System 专栏收录该内容

96 篇文章 8 订阅

订阅专栏

大纲

特点
类型

在ROS2中，std_msgs 是一个标准消息包，包含了一组常用的消息类型。这些消息类型通常用于基本的数据传输和通信。比如在“主题订阅”的场景下，我们可以直接发布这些类型的消息。

auto msg_ = std::make_unique<std_msgs::msg::String>();
msg_->data = "Hello World: ";

rclcpp::QoS qos(rclcpp::KeepLast{7});
rclcpp::Publisher<std_msgs::msg::String>::SharedPtr pub_ = create_publisher<std_msgs::msg::String>("chatter", qos);

pub_->publish(std::move(msg_));

接收端的回调只要正确指明对应的类型即可

auto callback =
  [this](std_msgs::msg::String::ConstSharedPtr msg) -> void
  {
    RCLCPP_INFO(this->get_logger(), "I heard: [%s]", msg->data.c_str());
  };
  
rclcpp::Subscription<std_msgs::msg::String>::SharedPtr sub_ = create_subscription<std_msgs::msg::String>("chatter", 10, callback);

特点

标准化：std_msgs 提供了一组标准化的消息类型，便于不同节点之间的通信。
简单易用：这些消息类型设计简单，易于理解和使用。
通用性：适用于各种应用场景，提供了基本的数据类型，如整数、浮点数、字符串、布尔值等。
跨平台：std_msgs 消息类型在不同平台上具有一致的表现，确保跨平台兼容性。

类型

std_msgs::msg::Bool

用于表示布尔值。

结构定义

namespace std_msgs
{
namespace msg
{

struct Bool
{
  bool data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

data：一个布尔类型的字段，用于存储布尔值（true 或 false）。

示例用法

#include "std_msgs/msg/bool.hpp"
#include <iostream>

int main() {
    std_msgs::msg::Bool bool_msg;
    bool_msg.data = true;

    std::cout << "Bool message data: " << (bool_msg.data ? "true" : "false") << std::endl;

    return 0;
}

std_msgs::msg::Byte

用于表示单个字节的数据。

结构定义

namespace std_msgs
{
namespace msg
{

struct Byte
{
  uint8_t data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

data：一个无符号8位整数类型的字段，用于存储单个字节的数据。

示例用法

#include "std_msgs/msg/byte.hpp"
#include <iostream>

int main() {
    std_msgs::msg::Byte byte_msg;
    byte_msg.data = 65;  // ASCII code for 'A'

    std::cout << "Byte message data: " << static_cast<int>(byte_msg.data) << std::endl;

    return 0;
}

std_msgs::msg::ByteMultiArray

用于表示多维字节数组。

结构定义

namespace std_msgs
{
namespace msg
{

struct ByteMultiArray
{
  std_msgs::msg::MultiArrayLayout layout;
  std::vector<uint8_t> data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

layout：一个 std_msgs::msg::MultiArrayLayout 类型的字段，用于描述数组的布局信息。
data：一个 std::vector<uint8_t> 类型的字段，用于存储字节数组的数据。

示例用法

#include "std_msgs/msg/byte_multi_array.hpp"
#include "std_msgs/msg/multi_array_layout.hpp"
#include "std_msgs/msg/multi_array_dimension.hpp"
#include <iostream>

int main() {
    std_msgs::msg::ByteMultiArray byte_multi_array_msg;

    // 设置布局信息
    std_msgs::msg::MultiArrayDimension dim;
    dim.label = "dimension1";
    dim.size = 3;
    dim.stride = 3;
    byte_multi_array_msg.layout.dim.push_back(dim);
    byte_multi_array_msg.layout.data_offset = 0;

    // 设置数据
    byte_multi_array_msg.data = {65, 66, 67};  // ASCII codes for 'A', 'B', 'C'

    // 输出布局信息和数据
    std::cout << "Layout:" << std::endl;
    for (const auto& d : byte_multi_array_msg.layout.dim) {
        std::cout << "  Label: " << d.label << std::endl;
        std::cout << "  Size: " << d.size << std::endl;
        std::cout << "  Stride: " << d.stride << std::endl;
    }
    std::cout << "Data Offset: " << byte_multi_array_msg.layout.data_offset << std::endl;

    std::cout << "Data:" << std::endl;
    for (const auto& byte : byte_multi_array_msg.data) {
        std::cout << "  " << static_cast<int>(byte) << std::endl;
    }

    return 0;
}

std_msgs::msg::Char

用于表示单个字符的数据。

结构定义

namespace std_msgs
{
namespace msg
{

struct Char
{
  uint8_t data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

data：一个无符号8位整数类型的字段，用于存储单个字符的数据。

示例用法

#include "std_msgs/msg/char.hpp"
#include <iostream>

int main() {
    std_msgs::msg::Char char_msg;
    char_msg.data = 'A';  // ASCII code for 'A'

    std::cout << "Char message data: " << static_cast<char>(char_msg.data) << std::endl;

    return 0;
}

std_msgs::msg::ColorRGBA

用于表示颜色信息，包括红色、绿色、蓝色和透明度（alpha）通道。

结构定义

namespace std_msgs
{
namespace msg
{

struct ColorRGBA
{
  float r;
  float g;
  float b;
  float a;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

r：一个浮点数，表示红色通道的值。
g：一个浮点数，表示绿色通道的值。
b：一个浮点数，表示蓝色通道的值。
a：一个浮点数，表示透明度（alpha）通道的值。

示例用法

#include "std_msgs/msg/color_rgba.hpp"
#include <iostream>

int main() {
    std_msgs::msg::ColorRGBA color_msg;
    color_msg.r = 1.0f;  // 红色通道
    color_msg.g = 0.0f;  // 绿色通道
    color_msg.b = 0.0f;  // 蓝色通道
    color_msg.a = 1.0f;  // 透明度通道

    std::cout << "ColorRGBA message:" << std::endl;
    std::cout << "  R: " << color_msg.r << std::endl;
    std::cout << "  G: " << color_msg.g << std::endl;
    std::cout << "  B: " << color_msg.b << std::endl;
    std::cout << "  A: " << color_msg.a << std::endl;

    return 0;
}

std_msgs::msg::Empty

这个消息类型没有任何字段，通常用于触发某些事件或动作，而不需要传递任何数据。

结构定义

namespace std_msgs
{
namespace msg
{

struct Empty
{
  // This message has no data members
};

}  // namespace msg
}  // namespace std_msgs

示例用法

#include "std_msgs/msg/empty.hpp"
#include <iostream>

int main() {
    std_msgs::msg::Empty empty_msg;

    // Since the message has no data, there's nothing to set or print
    std::cout << "Empty message created." << std::endl;

    return 0;
}

std_msgs::msg::Float32

用于表示单精度浮点数的数据。

结构定义

namespace std_msgs
{
namespace msg
{

struct Float32
{
  float data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

data：一个浮点数类型的字段，用于存储单精度浮点数的数据。

示例用法

#include "std_msgs/msg/float32.hpp"
#include <iostream>

int main() {
    std_msgs::msg::Float32 float_msg;
    float_msg.data = 3.14f;  // 设置浮点数值

    std::cout << "Float32 message data: " << float_msg.data << std::endl;

    return 0;
}

std_msgs::msg::Float32MultiArray

用于表示多维单精度浮点数数组。

结构定义

namespace std_msgs
{
namespace msg
{

struct Float32MultiArray
{
  std_msgs::msg::MultiArrayLayout layout;
  std::vector<float> data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

layout：一个 std_msgs::msg::MultiArrayLayout 类型的字段，用于描述数组的布局信息。
data：一个 std::vector 类型的字段，用于存储单精度浮点数数组的数据。

示例用法

#include "std_msgs/msg/float32_multi_array.hpp"
#include "std_msgs/msg/multi_array_layout.hpp"
#include "std_msgs/msg/multi_array_dimension.hpp"
#include <iostream>

int main() {
    std_msgs::msg::Float32MultiArray float_multi_array_msg;

    // 设置布局信息
    std_msgs::msg::MultiArrayDimension dim;
    dim.label = "dimension1";
    dim.size = 3;
    dim.stride = 3;
    float_multi_array_msg.layout.dim.push_back(dim);
    float_multi_array_msg.layout.data_offset = 0;

    // 设置数据
    float_multi_array_msg.data = {1.1f, 2.2f, 3.3f};

    // 输出布局信息和数据
    std::cout << "Layout:" << std::endl;
    for (const auto& d : float_multi_array_msg.layout.dim) {
        std::cout << "  Label: " << d.label << std::endl;
        std::cout << "  Size: " << d.size << std::endl;
        std::cout << "  Stride: " << d.stride << std::endl;
    }
    std::cout << "Data Offset: " << float_multi_array_msg.layout.data_offset << std::endl;

    std::cout << "Data:" << std::endl;
    for (const auto& value : float_multi_array_msg.data) {
        std::cout << "  " << value << std::endl;
    }

    return 0;
}

std_msgs::msg::Float64

用于表示双精度浮点数的数据。

结构定义

namespace std_msgs
{
namespace msg
{

struct Float64
{
  double data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

data：一个双精度浮点数类型的字段，用于存储双精度浮点数的数据。

示例用法

#include "std_msgs/msg/float64.hpp"
#include <iostream>

int main() {
    std_msgs::msg::Float64 float_msg;
    float_msg.data = 3.141592653589793;  // 设置双精度浮点数值

    std::cout << "Float64 message data: " << float_msg.data << std::endl;

    return 0;
}

std_msgs::msg::Float64MultiArray

用于表示多维双精度浮点数数组。

结构定义

namespace std_msgs
{
namespace msg
{

struct Float64MultiArray
{
  std_msgs::msg::MultiArrayLayout layout;
  std::vector<double> data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

layout：一个 std_msgs::msg::MultiArrayLayout 类型的字段，用于描述数组的布局信息。
data：一个 std::vector 类型的字段，用于存储双精度浮点数数组的数据。

示例用法

#include "std_msgs/msg/float64_multi_array.hpp"
#include "std_msgs/msg/multi_array_layout.hpp"
#include "std_msgs/msg/multi_array_dimension.hpp"
#include <iostream>

int main() {
    std_msgs::msg::Float64MultiArray float_multi_array_msg;

    // 设置布局信息
    std_msgs::msg::MultiArrayDimension dim;
    dim.label = "dimension1";
    dim.size = 3;
    dim.stride = 3;
    float_multi_array_msg.layout.dim.push_back(dim);
    float_multi_array_msg.layout.data_offset = 0;

    // 设置数据
    float_multi_array_msg.data = {1.1, 2.2, 3.3};

    // 输出布局信息和数据
    std::cout << "Layout:" << std::endl;
    for (const auto& d : float_multi_array_msg.layout.dim) {
        std::cout << "  Label: " << d.label << std::endl;
        std::cout << "  Size: " << d.size << std::endl;
        std::cout << "  Stride: " << d.stride << std::endl;
    }
    std::cout << "Data Offset: " << float_multi_array_msg.layout.data_offset << std::endl;

    std::cout << "Data:" << std::endl;
    for (const auto& value : float_multi_array_msg.data) {
        std::cout << "  " << value << std::endl;
    }

    return 0;
}

std_msgs::msg::Header

这个消息类型用于在消息中包含时间戳和帧 ID 信息。

结构定义

namespace std_msgs
{
namespace msg
{

struct Header
{
  builtin_interfaces::msg::Time stamp;
  std::string frame_id;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

stamp：一个 builtin_interfaces::msg::Time 类型的字段，表示消息的时间戳。
frame_id：一个字符串，表示消息所属的坐标系的 ID。

示例用法

#include "std_msgs/msg/header.hpp"
#include "builtin_interfaces/msg/time.hpp"
#include <iostream>

int main() {
    std_msgs::msg::Header header;
    header.stamp.sec = 1625079042;  // 设置秒数
    header.stamp.nanosec = 123456789;  // 设置纳秒数
    header.frame_id = "base_link";

    std::cout << "Header:" << std::endl;
    std::cout << "  Stamp: " << header.stamp.sec << " seconds, " << header.stamp.nanosec << " nanoseconds" << std::endl;
    std::cout << "  Frame ID: " << header.frame_id << std::endl;

    return 0;
}

std_msgs::msg::Int8

用于表示8位有符号整数的数据。

结构定义

namespace std_msgs
{
namespace msg
{

struct Int8
{
  int8_t data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

data：一个8位有符号整数类型的字段，用于存储8位有符号整数的数据。

示例用法

#include "std_msgs/msg/int8.hpp"
#include <iostream>

int main() {
    std_msgs::msg::Int8 int8_msg;
    int8_msg.data = -42;  // 设置8位有符号整数值

    std::cout << "Int8 message data: " << static_cast<int>(int8_msg.data) << std::endl;

    return 0;
}

std_msgs::msg::Int8MultiArray

用于表示多维8位有符号整数数组。

结构定义

namespace std_msgs
{
namespace msg
{

struct Int8MultiArray
{
  std_msgs::msg::MultiArrayLayout layout;
  std::vector<int8_t> data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

layout：一个 std_msgs::msg::MultiArrayLayout 类型的字段，用于描述数组的布局信息。
data：一个 std::vector<int8_t> 类型的字段，用于存储8位有符号整数数组的数据。

示例用法

#include "std_msgs/msg/int8_multi_array.hpp"
#include "std_msgs/msg/multi_array_layout.hpp"
#include "std_msgs/msg/multi_array_dimension.hpp"
#include <iostream>

int main() {
    std_msgs::msg::Int8MultiArray int8_multi_array_msg;

    // 设置布局信息
    std_msgs::msg::MultiArrayDimension dim;
    dim.label = "dimension1";
    dim.size = 3;
    dim.stride = 3;
    int8_multi_array_msg.layout.dim.push_back(dim);
    int8_multi_array_msg.layout.data_offset = 0;

    // 设置数据
    int8_multi_array_msg.data = {1, -2, 3};

    // 输出布局信息和数据
    std::cout << "Layout:" << std::endl;
    for (const auto& d : int8_multi_array_msg.layout.dim) {
        std::cout << "  Label: " << d.label << std::endl;
        std::cout << "  Size: " << d.size << std::endl;
        std::cout << "  Stride: " << d.stride << std::endl;
    }
    std::cout << "Data Offset: " << int8_multi_array_msg.layout.data_offset << std::endl;

    std::cout << "Data:" << std::endl;
    for (const auto& value : int8_multi_array_msg.data) {
        std::cout << "  " << static_cast<int>(value) << std::endl;
    }

    return 0;
}

std_msgs::msg::Int16

用于表示16位有符号整数的数据。

结构定义

namespace std_msgs
{
namespace msg
{

struct Int16
{
  int16_t data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

data：一个16位有符号整数类型的字段，用于存储16位有符号整数的数据。

示例用法

#include "std_msgs/msg/int16.hpp"
#include <iostream>

int main() {
    std_msgs::msg::Int16 int16_msg;
    int16_msg.data = -12345;  // 设置16位有符号整数值

    std::cout << "Int16 message data: " << int16_msg.data << std::endl;

    return 0;
}

std_msgs::msg::Int16MultiArray

用于表示多维16位有符号整数数组。

结构定义

namespace std_msgs
{
namespace msg
{

struct Int16MultiArray
{
  std_msgs::msg::MultiArrayLayout layout;
  std::vector<int16_t> data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

layout：一个 std_msgs::msg::MultiArrayLayout 类型的字段，用于描述数组的布局信息。
data：一个 std::vector<int16_t> 类型的字段，用于存储16位有符号整数数组的数据。

示例用法

#include "std_msgs/msg/int16_multi_array.hpp"
#include "std_msgs/msg/multi_array_layout.hpp"
#include "std_msgs/msg/multi_array_dimension.hpp"
#include <iostream>

int main() {
    std_msgs::msg::Int16MultiArray int16_multi_array_msg;

    // 设置布局信息
    std_msgs::msg::MultiArrayDimension dim;
    dim.label = "dimension1";
    dim.size = 3;
    dim.stride = 3;
    int16_multi_array_msg.layout.dim.push_back(dim);
    int16_multi_array_msg.layout.data_offset = 0;

    // 设置数据
    int16_multi_array_msg.data = {100, -200, 300};

    // 输出布局信息和数据
    std::cout << "Layout:" << std::endl;
    for (const auto& d : int16_multi_array_msg.layout.dim) {
        std::cout << "  Label: " << d.label << std::endl;
        std::cout << "  Size: " << d.size << std::endl;
        std::cout << "  Stride: " << d.stride << std::endl;
    }
    std::cout << "Data Offset: " << int16_multi_array_msg.layout.data_offset << std::endl;

    std::cout << "Data:" << std::endl;
    for (const auto& value : int16_multi_array_msg.data) {
        std::cout << "  " << value << std::endl;
    }

    return 0;
}

std_msgs::msg::Int32

用于表示32位有符号整数的数据。

结构定义

namespace std_msgs
{
namespace msg
{

struct Int32
{
  int32_t data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

data：一个32位有符号整数类型的字段，用于存储32位有符号整数的数据。

示例用法

#include "std_msgs/msg/int32.hpp"
#include <iostream>

int main() {
    std_msgs::msg::Int32 int32_msg;
    int32_msg.data = 123456789;  // 设置32位有符号整数值

    std::cout << "Int32 message data: " << int32_msg.data << std::endl;

    return 0;
}

std_msgs::msg::Int32MultiArray

用于表示多维32位有符号整数数组。

结构定义

namespace std_msgs
{
namespace msg
{

struct Int32MultiArray
{
  std_msgs::msg::MultiArrayLayout layout;
  std::vector<int32_t> data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

layout：一个 std_msgs::msg::MultiArrayLayout 类型的字段，用于描述数组的布局信息。
data：一个 std::vector<int32_t> 类型的字段，用于存储32位有符号整数数组的数据。

示例用法

#include "std_msgs/msg/int32_multi_array.hpp"
#include "std_msgs/msg/multi_array_layout.hpp"
#include "std_msgs/msg/multi_array_dimension.hpp"
#include <iostream>

int main() {
    std_msgs::msg::Int32MultiArray int32_multi_array_msg;

    // 设置布局信息
    std_msgs::msg::MultiArrayDimension dim;
    dim.label = "dimension1";
    dim.size = 3;
    dim.stride = 3;
    int32_multi_array_msg.layout.dim.push_back(dim);
    int32_multi_array_msg.layout.data_offset = 0;

    // 设置数据
    int32_multi_array_msg.data = {100, -200, 300};

    // 输出布局信息和数据
    std::cout << "Layout:" << std::endl;
    for (const auto& d : int32_multi_array_msg.layout.dim) {
        std::cout << "  Label: " << d.label << std::endl;
        std::cout << "  Size: " << d.size << std::endl;
        std::cout << "  Stride: " << d.stride << std::endl;
    }
    std::cout << "Data Offset: " << int32_multi_array_msg.layout.data_offset << std::endl;

    std::cout << "Data:" << std::endl;
    for (const auto& value : int32_multi_array_msg.data) {
        std::cout << "  " << value << std::endl;
    }

    return 0;
}

std_msgs::msg::Int64

用于表示64位有符号整数的数据。

结构定义

namespace std_msgs
{
namespace msg
{

struct Int64
{
  int64_t data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

data：一个64位有符号整数类型的字段，用于存储64位有符号整数的数据。

示例用法

#include "std_msgs/msg/int64.hpp"
#include <iostream>

int main() {
    std_msgs::msg::Int64 int64_msg;
    int64_msg.data = 1234567890123456789;  // 设置64位有符号整数值

    std::cout << "Int64 message data: " << int64_msg.data << std::endl;

    return 0;
}

std_msgs::msg::Int64MultiArray

用于表示多维64位有符号整数数组。

结构定义

namespace std_msgs
{
namespace msg
{

struct Int64MultiArray
{
  std_msgs::msg::MultiArrayLayout layout;
  std::vector<int64_t> data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

layout：一个 std_msgs::msg::MultiArrayLayout 类型的字段，用于描述数组的布局信息。
data：一个 std::vector<int64_t> 类型的字段，用于存储64位有符号整数数组的数据。

示例用法

#include "std_msgs/msg/int64_multi_array.hpp"
#include "std_msgs/msg/multi_array_layout.hpp"
#include "std_msgs/msg/multi_array_dimension.hpp"
#include <iostream>

int main() {
    std_msgs::msg::Int64MultiArray int64_multi_array_msg;

    // 设置布局信息
    std_msgs::msg::MultiArrayDimension dim;
    dim.label = "dimension1";
    dim.size = 3;
    dim.stride = 3;
    int64_multi_array_msg.layout.dim.push_back(dim);
    int64_multi_array_msg.layout.data_offset = 0;

    // 设置数据
    int64_multi_array_msg.data = {10000000000, -20000000000, 30000000000};

    // 输出布局信息和数据
    std::cout << "Layout:" << std::endl;
    for (const auto& d : int64_multi_array_msg.layout.dim) {
        std::cout << "  Label: " << d.label << std::endl;
        std::cout << "  Size: " << d.size << std::endl;
        std::cout << "  Stride: " << d.stride << std::endl;
    }
    std::cout << "Data Offset: " << int64_multi_array_msg.layout.data_offset << std::endl;

    std::cout << "Data:" << std::endl;
    for (const auto& value : int64_multi_array_msg.data) {
        std::cout << "  " << value << std::endl;
    }

    return 0;
}

std_msgs::msg::MultiArrayDimension

这个消息类型通常用于描述多维数组的维度信息。

结构定义

namespace std_msgs
{
namespace msg
{

struct MultiArrayDimension
{
  std::string label;
  uint32_t size;
  uint32_t stride;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

label：一个字符串，用于描述该维度的标签。
size：一个无符号32位整数，表示该维度的大小。
stride：一个无符号32位整数，表示该维度的步长。

示例用法

#include "std_msgs/msg/multi_array_dimension.hpp"
#include <iostream>

int main() {
    std_msgs::msg::MultiArrayDimension dim;
    dim.label = "height";
    dim.size = 10;
    dim.stride = 1;

    std::cout << "Label: " << dim.label << std::endl;
    std::cout << "Size: " << dim.size << std::endl;
    std::cout << "Stride: " << dim.stride << std::endl;

    return 0;
}

std_msgs::msg::MultiArrayLayout

这个消息类型通常用于描述多维数组的布局信息。

结构定义

namespace std_msgs
{
namespace msg
{

struct MultiArrayLayout
{
  std::vector<MultiArrayDimension> dim;
  uint32_t data_offset;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

dim：一个 std::vector，包含多个 MultiArrayDimension 对象，用于描述每个维度的信息。
data_offset：一个无符号32位整数，表示数据的偏移量。

示例用法

#include "std_msgs/msg/multi_array_layout.hpp"
#include "std_msgs/msg/multi_array_dimension.hpp"
#include <iostream>

int main() {
    std_msgs::msg::MultiArrayLayout layout;
    std_msgs::msg::MultiArrayDimension dim1;
    dim1.label = "height";
    dim1.size = 10;
    dim1.stride = 1;

    std_msgs::msg::MultiArrayDimension dim2;
    dim2.label = "width";
    dim2.size = 20;
    dim2.stride = 10;

    layout.dim.push_back(dim1);
    layout.dim.push_back(dim2);
    layout.data_offset = 0;

    std::cout << "Layout:" << std::endl;
    for (const auto& dim : layout.dim) {
        std::cout << "  Label: " << dim.label << std::endl;
        std::cout << "  Size: " << dim.size << std::endl;
        std::cout << "  Stride: " << dim.stride << std::endl;
    }
    std::cout << "Data Offset: " << layout.data_offset << std::endl;

    return 0;
}

std_msgs::msg::UInt8

用于表示8位无符号整数的数据。

结构定义

namespace std_msgs
{
namespace msg
{

struct UInt8
{
  uint8_t data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

data：一个8位无符号整数类型的字段，用于存储8位无符号整数的数据。

示例用法

#include "std_msgs/msg/uint8.hpp"
#include <iostream>

int main() {
    std_msgs::msg::UInt8 uint8_msg;
    uint8_msg.data = 255;  // 设置8位无符号整数值

    std::cout << "UInt8 message data: " << static_cast<unsigned int>(uint8_msg.data) << std::endl;

    return 0;
}

std_msgs::msg::UInt8MultiArray

用于表示多维8位无符号整数数组。

结构定义

namespace std_msgs
{
namespace msg
{

struct UInt8MultiArray
{
  std_msgs::msg::MultiArrayLayout layout;
  std::vector<uint8_t> data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

layout：一个 std_msgs::msg::MultiArrayLayout 类型的字段，用于描述数组的布局信息。
data：一个 std::vector<uint8_t> 类型的字段，用于存储8位无符号整数数组的数据。

示例用法

#include "std_msgs/msg/uint8_multi_array.hpp"
#include "std_msgs/msg/multi_array_layout.hpp"
#include "std_msgs/msg/multi_array_dimension.hpp"
#include <iostream>

int main() {
    std_msgs::msg::UInt8MultiArray uint8_multi_array_msg;

    // 设置布局信息
    std_msgs::msg::MultiArrayDimension dim;
    dim.label = "dimension1";
    dim.size = 3;
    dim.stride = 3;
    uint8_multi_array_msg.layout.dim.push_back(dim);
    uint8_multi_array_msg.layout.data_offset = 0;

    // 设置数据
    uint8_multi_array_msg.data = {10, 20, 30};

    // 输出布局信息和数据
    std::cout << "Layout:" << std::endl;
    for (const auto& d : uint8_multi_array_msg.layout.dim) {
        std::cout << "  Label: " << d.label << std::endl;
        std::cout << "  Size: " << d.size << std::endl;
        std::cout << "  Stride: " << d.stride << std::endl;
    }
    std::cout << "Data Offset: " << uint8_multi_array_msg.layout.data_offset << std::endl;

    std::cout << "Data:" << std::endl;
    for (const auto& value : uint8_multi_array_msg.data) {
        std::cout << "  " << static_cast<unsigned int>(value) << std::endl;
    }

    return 0;
}

std_msgs::msg::UInt16

用于表示16位无符号整数的数据。

结构定义

namespace std_msgs
{
namespace msg
{

struct UInt16
{
  uint16_t data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

data：一个16位无符号整数类型的字段，用于存储16位无符号整数的数据。

示例用法

#include "std_msgs/msg/uint16.hpp"
#include <iostream>

int main() {
    std_msgs::msg::UInt16 uint16_msg;
    uint16_msg.data = 65535;  // 设置16位无符号整数值

    std::cout << "UInt16 message data: " << uint16_msg.data << std::endl;

    return 0;
}

std_msgs::msg::UInt16MultiArray

用于表示多维16位无符号整数数组。

结构定义

namespace std_msgs
{
namespace msg
{

struct UInt16MultiArray
{
  std_msgs::msg::MultiArrayLayout layout;
  std::vector<uint16_t> data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

layout：一个 std_msgs::msg::MultiArrayLayout 类型的字段，用于描述数组的布局信息。
data：一个 std::vector<uint16_t> 类型的字段，用于存储16位无符号整数数组的数据。

示例用法

#include "std_msgs/msg/uint16_multi_array.hpp"
#include "std_msgs/msg/multi_array_layout.hpp"
#include "std_msgs/msg/multi_array_dimension.hpp"
#include <iostream>

int main() {
    std_msgs::msg::UInt16MultiArray uint16_multi_array_msg;

    // 设置布局信息
    std_msgs::msg::MultiArrayDimension dim;
    dim.label = "dimension1";
    dim.size = 3;
    dim.stride = 3;
    uint16_multi_array_msg.layout.dim.push_back(dim);
    uint16_multi_array_msg.layout.data_offset = 0;

    // 设置数据
    uint16_multi_array_msg.data = {1000, 2000, 3000};

    // 输出布局信息和数据
    std::cout << "Layout:" << std::endl;
    for (const auto& d : uint16_multi_array_msg.layout.dim) {
        std::cout << "  Label: " << d.label << std::endl;
        std::cout << "  Size: " << d.size << std::endl;
        std::cout << "  Stride: " << d.stride << std::endl;
    }
    std::cout << "Data Offset: " << uint16_multi_array_msg.layout.data_offset << std::endl;

    std::cout << "Data:" << std::endl;
    for (const auto& value : uint16_multi_array_msg.data) {
        std::cout << "  " << value << std::endl;
    }

    return 0;
}

std_msgs::msg::UInt32

用于表示32位无符号整数的数据。

结构定义

namespace std_msgs
{
namespace msg
{

struct UInt32
{
  uint32_t data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

data：一个32位无符号整数类型的字段，用于存储32位无符号整数的数据。

示例用法

#include "std_msgs/msg/uint32.hpp"
#include <iostream>

int main() {
    std_msgs::msg::UInt32 uint32_msg;
    uint32_msg.data = 4294967295;  // 设置32位无符号整数值

    std::cout << "UInt32 message data: " << uint32_msg.data << std::endl;

    return 0;
}

std_msgs::msg::UInt32MultiArray

用于表示多维32位无符号整数数组。

结构定义

namespace std_msgs
{
namespace msg
{

struct UInt32MultiArray
{
  std_msgs::msg::MultiArrayLayout layout;
  std::vector<uint32_t> data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

layout：一个 std_msgs::msg::MultiArrayLayout 类型的字段，用于描述数组的布局信息。
data：一个 std::vector<uint32_t> 类型的字段，用于存储32位无符号整数数组的数据

示例用法

#include "std_msgs/msg/uint32_multi_array.hpp"
#include "std_msgs/msg/multi_array_layout.hpp"
#include "std_msgs/msg/multi_array_dimension.hpp"
#include <iostream>

int main() {
    std_msgs::msg::UInt32MultiArray uint32_multi_array_msg;

    // 设置布局信息
    std_msgs::msg::MultiArrayDimension dim;
    dim.label = "dimension1";
    dim.size = 3;
    dim.stride = 3;
    uint32_multi_array_msg.layout.dim.push_back(dim);
    uint32_multi_array_msg.layout.data_offset = 0;

    // 设置数据
    uint32_multi_array_msg.data = {100000, 200000, 300000};

    // 输出布局信息和数据
    std::cout << "Layout:" << std::endl;
    for (const auto& d : uint32_multi_array_msg.layout.dim) {
        std::cout << "  Label: " << d.label << std::endl;
        std::cout << "  Size: " << d.size << std::endl;
        std::cout << "  Stride: " << d.stride << std::endl;
    }
    std::cout << "Data Offset: " << uint32_multi_array_msg.layout.data_offset << std::endl;

    std::cout << "Data:" << std::endl;
    for (const auto& value : uint32_multi_array_msg.data) {
        std::cout << "  " << value << std::endl;
    }

    return 0;
}

std_msgs::msg::UInt64

用于表示64位无符号整数的数据。

结构定义

namespace std_msgs
{
namespace msg
{

struct UInt64
{
  uint64_t data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

data：一个64位无符号整数类型的字段，用于存储64位无符号整数的数据。

示例用法

#include "std_msgs/msg/uint64.hpp"
#include <iostream>

int main() {
    std_msgs::msg::UInt64 uint64_msg;
    uint64_msg.data = 18446744073709551615ULL;  // 设置64位无符号整数值

    std::cout << "UInt64 message data: " << uint64_msg.data << std::endl;

    return 0;
}

std_msgs::msg::UInt64MultiArray

用于表示多维64位无符号整数数组。

结构定义

namespace std_msgs
{
namespace msg
{

struct UInt64MultiArray
{
  std_msgs::msg::MultiArrayLayout layout;
  std::vector<uint64_t> data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

layout：一个 std_msgs::msg::MultiArrayLayout 类型的字段，用于描述数组的布局信息。
data：一个 std::vector<uint64_t> 类型的字段，用于存储64位无符号整数数组的数据

示例用法

#include "std_msgs/msg/uint64_multi_array.hpp"
#include "std_msgs/msg/multi_array_layout.hpp"
#include "std_msgs/msg/multi_array_dimension.hpp"
#include <iostream>

int main() {
    std_msgs::msg::UInt64MultiArray uint64_multi_array_msg;

    // 设置布局信息
    std_msgs::msg::MultiArrayDimension dim;
    dim.label = "dimension1";
    dim.size = 3;
    dim.stride = 3;
    uint64_multi_array_msg.layout.dim.push_back(dim);
    uint64_multi_array_msg.layout.data_offset = 0;

    // 设置数据
    uint64_multi_array_msg.data = {1000000000000, 2000000000000, 3000000000000};

    // 输出布局信息和数据
    std::cout << "Layout:" << std::endl;
    for (const auto& d : uint64_multi_array_msg.layout.dim) {
        std::cout << "  Label: " << d.label << std::endl;
        std::cout << "  Size: " << d.size << std::endl;
        std::cout << "  Stride: " << d.stride << std::endl;
    }
    std::cout << "Data Offset: " << uint64_multi_array_msg.layout.data_offset << std::endl;

    std::cout << "Data:" << std::endl;
    for (const auto& value : uint64_multi_array_msg.data) {
        std::cout << "  " << value << std::endl;
    }

    return 0;
}

std_msgs::msg::String

用于表示字符串数据。

结构定义

namespace std_msgs
{
namespace msg
{

struct String
{
  std::string data;
};

}  // namespace msg
}  // namespace std_msgs

字段说明

data：一个 std::string 类型的字段，用于存储字符串数据。

示例用法

#include "std_msgs/msg/string.hpp"
#include <iostream>

int main() {
    std_msgs::msg::String string_msg;
    string_msg.data = "Hello, ROS 2!";  // 设置字符串值

    std::cout << "String message data: " << string_msg.data << std::endl;

    return 0;
}