# bridge

**Repository Path**: rippleos/bridge

## Basic Information

- **Project Name**: bridge
- **Description**: MOSS 外部系统桥接模块
- **Primary Language**: Unknown
- **License**: MIT
- **Default Branch**: main
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-05-10
- **Last Updated**: 2026-05-20

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# mbridge - 外部系统桥接模块

## 概述

mbridge 是 MOSS 中间件的外部系统桥接模块，提供与 ROS2、AUTOSAR AP 等外部系统的互操作能力，实现跨中间件通信。

## 架构设计

### 模块定位

```
┌─────────────────────────────────────────────────────────────┐
│                   External Systems                           │
│         ROS2 Nodes    AUTOSAR AP    Legacy Systems          │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                      mbridge (NEW)                           │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐       │
│  │ ROS2Bridge   │  │ AutosarBridge│  │ LegacyBridge │       │
│  └──────────────┘  └──────────────┘  └──────────────┘       │
│  ┌──────────────┐  ┌──────────────┐                         │
│  │ TopicMapper  │  │ TypeConverter│                         │
│  └──────────────┘  └──────────────┘                         │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                      mcom (MOSS)                             │
│         Topic Pub/Sub    Service RPC    Action               │
└─────────────────────────────────────────────────────────────┘
```

### 依赖关系

```yaml
mbridge:
  depends_on:
    - mcom      # MOSS 通信中间件
    - mruntime  # 运行时基础
    - mlog      # 日志
  optional:
    - rclcpp    # ROS2 Client Library (条件编译)
```

### 目录结构

```
moss/bridge/
├── CMakeLists.txt
├── README.md
├── include/bridge/
│   ├── mbridge.h              # 模块入口
│   ├── types.h                # 类型定义
│   ├── bridge_base.h          # 桥接基类
│   ├── topic_mapper.h         # Topic 映射
│   ├── type_converter.h       # 类型转换
│   ├── ros2/
│   │   ├── ros2_bridge.h      # ROS2 桥接
│   │   └── ros2_type_traits.h # ROS2 类型特性
│   └── autosar/
│       └── autosar_bridge.h   # AUTOSAR 桥接
├── src/
│   ├── mbridge.cpp
│   ├── bridge_base.cpp
│   ├── topic_mapper.cpp
│   ├── type_converter.cpp
│   ├── ros2/
│   │   └── ros2_bridge.cpp
│   └── autosar/
│       └── autosar_bridge.cpp
├── test/
│   ├── test_bridge_base.cpp
│   ├── test_topic_mapper.cpp
│   └── test_type_converter.cpp
└── cmake/
    └── mbridgeConfig.cmake.in
```

## 核心组件

### 1. BridgeBase - 桥接基类

定义桥接的通用接口。

```cpp
namespace moss {
namespace mbridge {

enum class BridgeDirection {
    TO_EXTERNAL,    // MOSS -> 外部系统
    FROM_EXTERNAL,  // 外部系统 -> MOSS
    BIDIRECTIONAL   // 双向
};

struct BridgeConfig {
    std::string name;
    BridgeDirection direction{BridgeDirection::BIDIRECTIONAL};
    bool auto_start{true};
    uint32_t queue_size{10};
    std::chrono::milliseconds timeout{1000};
};

class BridgeBase {
public:
    explicit BridgeBase(const BridgeConfig& config);
    virtual ~BridgeBase() = default;

    // 生命周期
    virtual bool start() = 0;
    virtual void stop() = 0;
    virtual bool is_running() const = 0;

    // Topic 映射
    virtual bool add_topic_mapping(const std::string& moss_topic,
                                   const std::string& external_topic,
                                   const std::string& type_name) = 0;
    virtual bool remove_topic_mapping(const std::string& moss_topic) = 0;

    // 状态
    const std::string& name() const { return config_.name; }
    const BridgeConfig& config() const { return config_; }

protected:
    BridgeConfig config_;
    std::atomic<bool> running_{false};
};

}  // namespace mbridge
}  // namespace moss
```

### 2. TopicMapper - Topic 映射器

管理 MOSS Topic 与外部系统 Topic 的映射关系。

```cpp
namespace moss {
namespace mbridge {

struct TopicMapping {
    std::string moss_topic;
    std::string external_topic;
    std::string type_name;
    BridgeDirection direction;
    bool active{true};

    // 统计
    uint64_t msg_count_in{0};
    uint64_t msg_count_out{0};
    uint64_t bytes_in{0};
    uint64_t bytes_out{0};
};

class TopicMapper {
public:
    TopicMapper() = default;

    // 映射管理
    bool add_mapping(const std::string& moss_topic,
                    const std::string& external_topic,
                    const std::string& type_name,
                    BridgeDirection direction = BridgeDirection::BIDIRECTIONAL);

    bool remove_mapping(const std::string& moss_topic);
    bool has_mapping(const std::string& moss_topic) const;

    // 查询
    std::optional<TopicMapping> get_mapping(const std::string& moss_topic) const;
    std::optional<TopicMapping> get_mapping_by_external(const std::string& external_topic) const;

    // 列表
    std::vector<TopicMapping> get_all_mappings() const;
    std::vector<std::string> get_moss_topics() const;
    std::vector<std::string> get_external_topics() const;

    // 统计更新
    void record_inbound(const std::string& moss_topic, size_t bytes);
    void record_outbound(const std::string& moss_topic, size_t bytes);

private:
    mutable std::mutex mutex_;
    std::map<std::string, TopicMapping> mappings_;  // moss_topic -> mapping
    std::map<std::string, std::string> external_to_moss_;  // external_topic -> moss_topic
};

}  // namespace mbridge
}  // namespace moss
```

### 3. TypeConverter - 类型转换器

处理 MOSS Protobuf 与外部系统消息类型的转换。

```cpp
namespace moss {
namespace mbridge {

class TypeConverter {
public:
    using ConvertFunc = std::function<std::vector<uint8_t>(const std::vector<uint8_t>&)>;

    TypeConverter() = default;

    // 注册转换函数
    void register_converter(const std::string& moss_type,
                           const std::string& external_type,
                           ConvertFunc to_external,
                           ConvertFunc to_moss);

    // 转换
    std::optional<std::vector<uint8_t>> convert_to_external(
        const std::string& moss_type,
        const std::vector<uint8_t>& moss_data);

    std::optional<std::vector<uint8_t>> convert_to_moss(
        const std::string& external_type,
        const std::vector<uint8_t>& external_data);

    // 查询
    bool has_converter(const std::string& moss_type) const;
    std::string get_external_type(const std::string& moss_type) const;

private:
    struct Converter {
        std::string external_type;
        ConvertFunc to_external;
        ConvertFunc to_moss;
    };

    std::mutex mutex_;
    std::map<std::string, Converter> converters_;  // moss_type -> converter
};

// 常用类型转换器
class BuiltinConverters {
public:
    static void register_all(TypeConverter& converter);

    // std_msgs/String <-> moss String
    static std::vector<uint8_t> ros_string_to_moss(const std::vector<uint8_t>& ros_data);
    static std::vector<uint8_t> moss_string_to_ros(const std::vector<uint8_t>& moss_data);

    // geometry_msgs/Twist <-> moss Twist
    static std::vector<uint8_t> ros_twist_to_moss(const std::vector<uint8_t>& ros_data);
    static std::vector<uint8_t> moss_twist_to_ros(const std::vector<uint8_t>& moss_data);

    // sensor_msgs/Image <-> moss Image
    static std::vector<uint8_t> ros_image_to_moss(const std::vector<uint8_t>& ros_data);
    static std::vector<uint8_t> moss_image_to_ros(const std::vector<uint8_t>& moss_data);
};

}  // namespace mbridge
}  // namespace moss
```

### 4. ROS2Bridge - ROS2 桥接

```cpp
namespace moss {
namespace mbridge {

struct ROS2Config : public BridgeConfig {
    std::string node_name{"moss_bridge"};
    std::string namespace_{""};
    bool use_intra_process{false};
};

#ifdef MBRIDGE_ENABLE_ROS2
class ROS2Bridge : public BridgeBase {
public:
    explicit ROS2Bridge(const ROS2Config& config);
    ~ROS2Bridge() override;

    bool start() override;
    void stop() override;
    bool is_running() const override;

    bool add_topic_mapping(const std::string& moss_topic,
                          const std::string& ros_topic,
                          const std::string& type_name) override;
    bool remove_topic_mapping(const std::string& moss_topic) override;

    // ROS2 特定
    void spin_once();
    void spin();
    void spin_some(size_t max_iterations = 100);

private:
    void on_moss_message(const std::string& topic,
                        const std::vector<uint8_t>& data);
    void on_ros_message(const std::string& topic,
                       const std::vector<uint8_t>& data);

    struct Impl;
    std::unique_ptr<Impl> impl_;
};
#endif  // MBRIDGE_ENABLE_ROS2

}  // namespace mbridge
}  // namespace moss
```

### 5. AutosarBridge - AUTOSAR AP 桥接

```cpp
namespace moss {
namespace mbridge {

struct AutosarConfig : public BridgeConfig {
    std::string instance_id;
    std::string ara_com_config;
};

class AutosarBridge : public BridgeBase {
public:
    explicit AutosarBridge(const AutosarConfig& config);
    ~AutosarBridge() override;

    bool start() override;
    void stop() override;
    bool is_running() const override;

    bool add_topic_mapping(const std::string& moss_topic,
                          const std::string& autosar_topic,
                          const std::string& type_name) override;
    bool remove_topic_mapping(const std::string& moss_topic) override;

    // AUTOSAR 特定
    void set_service_instance(const std::string& service_id,
                             const std::string& instance_id);

private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
};

}  // namespace mbridge
}  // namespace moss
```

## 消息类型映射

### ROS2 <-> MOSS

| ROS2 类型 | MOSS 类型 | 说明 |
|-----------|-----------|------|
| std_msgs/String | moss.String | 字符串 |
| std_msgs/Bool | moss.Bool | 布尔 |
| std_msgs/Int32 | moss.Int32 | 整数 |
| std_msgs/Float64 | moss.Float64 | 浮点 |
| geometry_msgs/Twist | moss.Twist | 速度指令 |
| geometry_msgs/Pose | moss.Pose | 位姿 |
| sensor_msgs/Image | moss.Image | 图像 |
| sensor_msgs/PointCloud2 | moss.PointCloud | 点云 |
| nav_msgs/Odometry | moss.Odometry | 里程计 |

### AUTOSAR <-> MOSS

| AUTOSAR 类型 | MOSS 类型 | 说明 |
|--------------|-----------|------|
| ara::com::SamplePtr | moss.Topic | 采样数据 |
| ara::com::Service | moss.Service | 服务接口 |
| ara::com::Event | moss.Topic | 事件 |

## 使用示例

### ROS2 桥接

```cpp
#include "bridge/ros2/ros2_bridge.h"
#include "bridge/type_converter.h"

// 创建 ROS2 桥接
mbridge::ROS2Config config;
config.node_name = "moss_ros_bridge";
config.name = "ros2_bridge";

mbridge::ROS2Bridge bridge(config);

// 添加 Topic 映射
bridge.add_topic_mapping("/moss/velocity", "/cmd_vel", "geometry_msgs/Twist");
bridge.add_topic_mapping("/moss/odom", "/odom", "nav_msgs/Odometry");

// 启动
bridge.start();
bridge.spin();
```

### 类型转换

```cpp
#include "bridge/type_converter.h"

// 注册内置转换器
mbridge::TypeConverter converter;
mbridge::BuiltinConverters::register_all(converter);

// 转换消息
std::vector<uint8_t> ros_data = /* ... */;
auto moss_data = converter.convert_to_moss("geometry_msgs/Twist", ros_data);
```

## CMake 配置

```cmake
cmake_minimum_required(VERSION 3.14)
project(mbridge VERSION 0.1.0 LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

option(MBRIDGE_ENABLE_ROS2 "Enable ROS2 bridge" OFF)

find_package(Threads REQUIRED)
find_package(mcom REQUIRED)
find_package(mruntime REQUIRED)
find_package(mlog REQUIRED)

if(MBRIDGE_ENABLE_ROS2)
    find_package(rclcpp REQUIRED)
    find_package(std_msgs REQUIRED)
    find_package(geometry_msgs REQUIRED)
endif()

add_library(mbridge SHARED
    src/mbridge.cpp
    src/bridge_base.cpp
    src/topic_mapper.cpp
    src/type_converter.cpp
)

if(MBRIDGE_ENABLE_ROS2)
    target_sources(mbridge PRIVATE
        src/ros2/ros2_bridge.cpp
    )
    target_link_libraries(mbridge PUBLIC
        rclcpp::rclcpp
    )
    target_compile_definitions(mbridge PUBLIC MBRIDGE_ENABLE_ROS2)
endif()

target_link_libraries(mbridge PUBLIC
    mcom::mcom
    mruntime::mruntime
    mlog::mlog
    Threads::Threads
)

# 安装...
```

## 测试计划

| 测试文件 | 覆盖范围 |
|----------|----------|
| test_bridge_base.cpp | 桥接基类生命周期 |
| test_topic_mapper.cpp | Topic 映射管理 |
| test_type_converter.cpp | 类型转换 |
| test_ros2_bridge.cpp | ROS2 桥接 (条件编译) |

## 里程碑

| 里程碑 | 内容 | 预计工时 |
|--------|------|----------|
| mbridge-ms1 | 核心框架 (BridgeBase + TopicMapper + TypeConverter) | 2天 |
| mbridge-ms2 | ROS2 桥接实现 | 2天 |
| mbridge-ms3 | AUTOSAR 桥接设计 | 1天 |
| mbridge-ms4 | 测试 + 文档 | 1天 |

**总计: 6个工作日**