# drone-message

**Repository Path**: kunker/drone-message

## Basic Information

- **Project Name**: drone-message
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: main
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-12-05
- **Last Updated**: 2025-12-05

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 无人机通信框架 (Drone Message Framework)

一个可扩展的无人机通信框架，支持多平台级联、无人机信息推送与远程控制。框架采用SPI机制设计，使用者通过实现接口来完成具体业务逻辑。

## 核心特性

- 🔌 **SPI扩展机制**：通过实现接口来扩展功能
- 🌐 **多协议支持**：HTTP、WebSocket、TCP、UDP
- 🔗 **多平台级联**：同时连接多个上级平台
- 📤 **灵活推送**：可配置推送周期和推送内容
- 🎮 **远程控制**：接收并执行上级平台的控制指令
- 📡 **事件驱动**：基于Spring Event的事件机制

## 快速开始

### 1. 添加依赖

```xml
<dependency>
    <groupId>com.drone</groupId>
    <artifactId>drone-message</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>
```

### 2. 实现核心接口

#### 2.1 实现无人机数据提供者

```java
@Component
public class MyDroneDataProvider implements DroneDataProvider {
    
    @Autowired
    private DroneRepository droneRepository;
    
    @Override
    public List<DroneInfo> getAllDrones() {
        return droneRepository.findAll().stream()
            .map(this::convertToInfo)
            .collect(Collectors.toList());
    }
    
    @Override
    public Optional<DroneInfo> getDrone(String droneId) {
        return droneRepository.findByDroneId(droneId)
            .map(this::convertToInfo);
    }
    
    // ... 其他方法
}
```

#### 2.2 实现控制指令执行器

```java
@Component
public class TakeOffExecutor implements CommandExecutor {
    
    @Autowired
    private DroneSDK droneSDK;
    
    @Override
    public CommandType supportedType() {
        return CommandType.TAKE_OFF;
    }
    
    @Override
    public CommandResult execute(CommandContext context) {
        // 调用你的无人机SDK执行起飞
        droneSDK.takeOff(context.getDroneId());
        return CommandResult.success("起飞成功");
    }
    
    @Override
    public boolean validate(CommandContext context) {
        // 校验无人机是否可以起飞
        return context.getDroneInfo().getStatus().getState() == State.IDLE;
    }
}
```

### 3. 使用框架API

```java
@Service
public class MyService {
    
    @Autowired
    private DroneMessageClient client;
    
    public void setup() {
        // 添加上级平台
        client.addPlatform(PlatformConfig.builder()
            .platformId("command-center")
            .name("指挥中心")
            .host("192.168.1.100")
            .port(8080)
            .protocol(ProtocolType.HTTP)
            .pushInterval(30)  // 30秒推送一次
            .build());
        
        // 绑定无人机（选择要推送哪些无人机）
        client.bindDrone("command-center", "DRONE-001");
        client.bindDrone("command-center", "DRONE-002");
        
        // 连接平台
        client.connect("command-center");
    }
}
```

## 核心接口说明

### SPI接口

| 接口 | 说明 | 必须实现 |
|------|------|---------|
| `DroneDataProvider` | 无人机数据提供者，框架通过此接口获取无人机信息 | ✅ 是 |
| `CommandExecutor` | 控制指令执行器，实现具体的控制逻辑 | ✅ 是 |
| `MessageHandler` | 消息处理器，处理从上级平台接收的消息 | 否 |
| `ConnectionListener` | 连接监听器，监听平台连接状态变化 | 否 |
| `PlatformAuthenticator` | 平台认证器，自定义认证逻辑 | 否 |
| `DataSerializer` | 数据序列化器，自定义序列化方式 | 否 |

### 支持的指令类型

```java
// 飞行控制
TAKE_OFF, LAND, RETURN_HOME, HOVER, EMERGENCY_STOP

// 航线任务
START_MISSION, PAUSE_MISSION, RESUME_MISSION, CANCEL_MISSION, UPLOAD_WAYPOINTS

// 相机控制
TAKE_PHOTO, START_RECORDING, STOP_RECORDING, GIMBAL_CONTROL, CAMERA_ZOOM

// 参数设置
SET_ALTITUDE, SET_SPEED, SET_HEADING, GO_TO_LOCATION

// 系统
GET_STATUS, GET_LOCATION, REBOOT, CALIBRATE
```

## 事件机制

框架基于Spring Event提供了丰富的事件，可以监听：

```java
@Component
public class MyEventListener {
    
    @EventListener
    public void onCommandReceived(CommandReceivedEvent event) {
        log.info("收到指令: {} -> {}", event.getCommandId(), event.getDroneId());
    }
    
    @EventListener
    public void onCommandExecuted(CommandExecutedEvent event) {
        log.info("指令执行完成: {}, 结果: {}", 
            event.getCommandContext().getCommandId(),
            event.isSuccess() ? "成功" : "失败");
    }
    
    @EventListener
    public void onPlatformConnected(PlatformConnectedEvent event) {
        log.info("平台连接成功: {}", event.getPlatformId());
    }
    
    @EventListener
    public void onPlatformDisconnected(PlatformDisconnectedEvent event) {
        log.warn("平台断开连接: {}", event.getPlatformId());
    }
}
```

## 配置说明

```yaml
drone:
  framework:
    # 本平台ID
    platform-id: my-drone-platform
    # 本平台名称
    platform-name: 我的无人机平台
    # 默认推送间隔（秒）
    default-push-interval: 30
    # 默认心跳间隔（秒）
    default-heartbeat-interval: 60
    # 心跳超时时间（秒）
    heartbeat-timeout: 120
    # 是否启用自动连接
    auto-connect: true
    # 是否启用自动推送
    auto-push: true
    
    # UDP服务端配置
    udp:
      server:
        enabled: true        # 启用UDP服务端
        port: 9999           # 监听端口
        buffer-size: 1048576 # 缓冲区大小
```

## UDP协议使用

### 配置UDP上级平台

```java
// 添加使用UDP协议的上级平台
PlatformConfig udpPlatform = PlatformConfig.builder()
        .platformId("udp-command-center")
        .name("UDP指挥中心")
        .host("192.168.1.100")      // 上级平台IP
        .port(9999)                  // 上级平台端口
        .protocol(ProtocolType.UDP)  // 使用UDP协议
        .pushInterval(10)            // 10秒推送一次
        .build();

client.addPlatform(udpPlatform);
client.bindDrone("udp-command-center", "DRONE-001");
client.connect("udp-command-center");
```

### UDP消息格式

框架使用JSON格式封装UDP消息，消息结构：

```json
{
  "messageId": "uuid",
  "type": "DRONE_STATUS",
  "payload": [...],
  "timestamp": "2024-01-01T12:00:00"
}
```

### 上级平台发送控制指令

上级平台可以通过UDP向本平台的9999端口发送控制指令：

```json
{
  "messageId": "cmd-001",
  "type": "COMMAND",
  "payload": {
    "commandId": "take-off-001",
    "droneId": "DRONE-001",
    "commandType": "TAKE_OFF",
    "parameters": {}
  }
}
```

### UDP状态查询

```bash
curl http://localhost:8080/api/v1/udp/status
```

## 项目结构

```
src/main/java/com/drone/framework/
├── api/                    # 对外API
│   ├── DroneMessageClient.java   # 主要API入口
│   └── CommandApi.java           # REST API
├── core/                   # 核心组件
│   ├── CommandDispatcher.java    # 指令分发器
│   ├── MessageDispatcher.java    # 消息分发器
│   ├── PlatformManager.java      # 平台管理器
│   └── PushScheduler.java        # 推送调度器
├── model/                  # 数据模型
│   ├── DroneInfo.java
│   ├── CommandContext.java
│   ├── CommandResult.java
│   ├── Message.java
│   └── PlatformConfig.java
├── protocol/               # 通信协议实现
│   ├── PlatformConnection.java
│   ├── HttpPlatformConnection.java
│   ├── WebSocketPlatformConnection.java
│   ├── TcpPlatformConnection.java
│   └── UdpPlatformConnection.java
├── spi/                    # SPI接口定义
│   ├── CommandExecutor.java
│   ├── DroneDataProvider.java
│   ├── MessageHandler.java
│   ├── ConnectionListener.java
│   └── DataSerializer.java
├── event/                  # 事件定义
│   ├── CommandReceivedEvent.java
│   ├── CommandExecutedEvent.java
│   └── PlatformConnectedEvent.java
└── config/                 # 自动配置
    └── DroneFrameworkAutoConfiguration.java
```

## 扩展开发

### 添加新的通信协议

```java
public class MqttPlatformConnection extends AbstractPlatformConnection {
    
    @Override
    public boolean connect() {
        // MQTT连接实现
    }
    
    @Override
    public boolean send(Message message) {
        // MQTT发送实现
    }
}
```

### 自定义序列化方式

```java
@Component
public class ProtobufSerializer implements DataSerializer {
    
    @Override
    public byte[] serialize(Object obj) {
        // Protobuf序列化
    }
    
    @Override
    public <T> T deserialize(byte[] data, Class<T> clazz) {
        // Protobuf反序列化
    }
    
    @Override
    public String contentType() {
        return "application/x-protobuf";
    }
}
```

## 运行示例

```bash
mvn spring-boot:run
```

启动后，框架会自动注册示例中的指令执行器。你可以通过API测试：

```bash
# 发送起飞指令
curl -X POST http://localhost:8080/api/v1/commands \
  -H "Content-Type: application/json" \
  -d '{
    "droneId": "DRONE-001",
    "commandType": "TAKE_OFF"
  }'

# 查看支持的指令类型
curl http://localhost:8080/api/v1/commands/types
```

## 许可证

MIT License

## 参考

本项目参考了 [wvp-GB28181-pro](https://github.com/648540858/wvp-GB28181-pro) 的架构设计理念。