SD.
Gallery
About
Blog
Contact
Hire Me
2024-08-20IoT

MyDolly 傀儡引擎机器人：智能摄像小车的远程互动探索

9 min

MyDolly 傀儡引擎机器人

MyDolly 依托智能摄像小车的形式提供新的拍摄视角，支持异地遥控、兴趣点分享、探秘挑战等功能，颠覆日常生活视角，帮助用户实现远程互动、情感陪伴、空间探索的生活与社交需求。

项目概述

MyDolly provides a new shooting perspective in the form of intelligent camera car, supports remote control in different places, sharing interest points, exploring challenges and other functions, subverts the perspective of daily life, and helps users realize the life and social needs of remote interaction, emotional companionship and space exploration.

技术架构

核心技术栈

  • Go-Gin：高性能 Web 框架，处理实时控制指令
  • GORM：数据持久化与用户数据管理
  • MySQL：存储用户信息、兴趣点、探索记录
  • GPT-4/Claude 3：AI 智能推荐与场景识别
  • WebSocket：实时双向通信
  • 视频流传输：实时摄像头画面推送

核心功能实现

1. 远程控制系统

基于 Go-Gin 构建实时控制 API，支持异地用户远程操控摄像小车：

type ControlCommand struct {
    UserID    string  `json:"user_id"`
    Direction string  `json:"direction"` // forward, backward, left, right
    Speed     float64 `json:"speed"`
    Timestamp int64   `json:"timestamp"`
}

func HandleControl(c *gin.Context) {
    var cmd ControlCommand
    if err := c.ShouldBindJSON(&cmd); err != nil {
        c.JSON(400, gin.H{"error": "Invalid command"})
        return
    }
    
    // 验证用户权限
    if !validateUserPermission(cmd.UserID) {
        c.JSON(403, gin.H{"error": "Permission denied"})
        return
    }
    
    // 发送控制指令到硬件
    if err := sendToHardware(cmd); err != nil {
        c.JSON(500, gin.H{"error": "Control failed"})
        return
    }
    
    c.JSON(200, gin.H{"status": "success"})
}

2. 实时视频流传输

通过 WebSocket 实现低延迟的视频流传输，让用户获得第一视角体验：

import (
    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    CheckOrigin: func(r *http.Request) bool {
        return true
    },
}

func HandleVideoStream(c *gin.Context) {
    conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
    if err != nil {
        return
    }
    defer conn.Close()
    
    // 订阅视频流
    videoChannel := subscribeToVideoFeed()
    
    for frame := range videoChannel {
        if err := conn.WriteMessage(websocket.BinaryMessage, frame); err != nil {
            break
        }
    }
}

3. 兴趣点分享功能

使用 GORM 设计兴趣点数据模型，支持用户标记与分享探索发现：

type InterestPoint struct {
    ID          uint    `gorm:"primaryKey"`
    UserID      string  `gorm:"index"`
    Title       string  `gorm:"size:255"`
    Description string  `gorm:"type:text"`
    Latitude    float64
    Longitude   float64
    ImageURL    string  `gorm:"size:512"`
    Likes       int     `gorm:"default:0"`
    CreatedAt   time.Time
}

func CreateInterestPoint(c *gin.Context) {
    var point InterestPoint
    if err := c.ShouldBindJSON(&point); err != nil {
        c.JSON(400, gin.H{"error": err.Error()})
        return
    }
    
    // 保存到数据库
    if err := db.Create(&point).Error; err != nil {
        c.JSON(500, gin.H{"error": "Failed to save"})
        return
    }
    
    // 通知关注者
    notifyFollowers(point.UserID, point)
    
    c.JSON(200, point)
}

4. AI 智能推荐

集成 GPT-4/Claude 3 实现智能场景识别与探索建议：

func GetExplorationSuggestions(c *gin.Context) {
    userID := c.Query("user_id")
    
    // 获取用户历史探索记录
    history := getUserExplorationHistory(userID)
    
    // 调用 AI 生成推荐
    prompt := fmt.Sprintf(
        "Based on user's exploration history: %v, suggest 3 interesting places to explore",
        history,
    )
    
    suggestions, err := callAIModel(prompt)
    if err != nil {
        c.JSON(500, gin.H{"error": "AI service unavailable"})
        return
    }
    
    c.JSON(200, gin.H{"suggestions": suggestions})
}

func callAIModel(prompt string) ([]string, error) {
    client := &http.Client{Timeout: 30 * time.Second}
    
    payload := map[string]interface{}{
        "model":  "gpt-4",
        "prompt": prompt,
    }
    
    resp, err := client.Post(aiEndpoint, "application/json", payload)
    if err != nil {
        return nil, err
    }
    
    defer resp.Body.Close()
    return parseAIResponse(resp.Body)
}

5. 探秘挑战系统

设计挑战任务系统，增强用户互动与探索动力：

type Challenge struct {
    ID          uint   `gorm:"primaryKey"`
    Title       string `gorm:"size:255"`
    Description string `gorm:"type:text"`
    TargetArea  string `gorm:"size:100"`
    Difficulty  int    `gorm:"default:1"`
    Reward      int    `gorm:"default:0"`
    Status      string `gorm:"default:'active'"`
}

type UserChallenge struct {
    ID          uint `gorm:"primaryKey"`
    UserID      string
    ChallengeID uint
    Progress    int       `gorm:"default:0"`
    CompletedAt time.Time
}

func GetActiveChallenges(c *gin.Context) {
    var challenges []Challenge
    db.Where("status = ?", "active").Find(&challenges)
    
    c.JSON(200, challenges)
}

func UpdateChallengeProgress(c *gin.Context) {
    var progress UserChallenge
    if err := c.ShouldBindJSON(&progress); err != nil {
        c.JSON(400, gin.H{"error": err.Error()})
        return
    }
    
    // 更新进度
    db.Save(&progress)
    
    // 检查是否完成
    if progress.Progress >= 100 {
        rewardUser(progress.UserID, progress.ChallengeID)
    }
    
    c.JSON(200, progress)
}

性能优化

1. 视频流优化

通过帧率控制与压缩算法，降低带宽占用：

func optimizeVideoFrame(frame []byte) []byte {
    // 动态调整压缩率
    quality := calculateOptimalQuality(networkSpeed)
    
    compressed := compressFrame(frame, quality)
    return compressed
}

func calculateOptimalQuality(speed float64) int {
    if speed > 10 { // 10 Mbps
        return 90
    } else if speed > 5 {
        return 70
    } else {
        return 50
    }
}

2. 控制指令优化

通过指令队列与去重，提升控制响应速度：

type CommandQueue struct {
    commands chan ControlCommand
    mu       sync.Mutex
}

func (q *CommandQueue) Add(cmd ControlCommand) {
    q.mu.Lock()
    defer q.mu.Unlock()
    
    // 去重：如果队列中已有相同方向的指令，替换为最新的
    select {
    case q.commands <- cmd:
    default:
        // 队列满时，丢弃最旧的指令
        <-q.commands
        q.commands <- cmd
    }
}

3. 数据库查询优化

通过索引与缓存，提升兴趣点查询性能：

// 添加索引
db.Model(&InterestPoint{}).AddIndex("idx_user_created", "user_id", "created_at")
db.Model(&InterestPoint{}).AddIndex("idx_location", "latitude", "longitude")

// 缓存热门兴趣点
func GetPopularPoints() []InterestPoint {
    cacheKey := "popular_points"
    
    // 尝试从 Redis 获取
    if cached := redis.Get(cacheKey); cached != nil {
        return parsePoints(cached)
    }
    
    // 从数据库查询
    var points []InterestPoint
    db.Order("likes DESC").Limit(20).Find(&points)
    
    // 缓存结果
    redis.Set(cacheKey, points, 5*time.Minute)
    
    return points
}

系统稳定性保障

1. 断线重连机制

实现 WebSocket 自动重连，确保控制连续性：

func maintainConnection(userID string) {
    for {
        conn, err := connectToServer(userID)
        if err != nil {
            log.Printf("Connection failed, retrying in 3s...")
            time.Sleep(3 * time.Second)
            continue
        }
        
        handleConnection(conn)
        
        // 连接断开，自动重连
        log.Printf("Connection lost, reconnecting...")
    }
}

2. 硬件状态监控

实时监控摄像小车状态，及时预警异常：

type HardwareStatus struct {
    BatteryLevel int
    Temperature  float64
    SignalStrength int
    IsMoving     bool
}

func MonitorHardware() {
    ticker := time.NewTicker(5 * time.Second)
    
    for range ticker.C {
        status := getHardwareStatus()
        
        // 电量预警
        if status.BatteryLevel < 20 {
            notifyUser("Low battery warning")
        }
        
        // 温度预警
        if status.Temperature > 60 {
            notifyUser("High temperature warning")
            emergencyStop()
        }
        
        // 信号预警
        if status.SignalStrength < 30 {
            notifyUser("Weak signal warning")
        }
    }
}

技术挑战与解决方案

挑战 1：实时性要求高

解决方案：WebSocket 双向通信 + 指令队列优化，控制延迟 < 100ms

挑战 2：视频流带宽占用大

解决方案：动态压缩 + 帧率自适应，根据网络状况调整画质

挑战 3：多用户并发控制

解决方案：权限管理 + 排队机制，确保控制权有序切换

挑战 4：硬件稳定性

解决方案：状态监控 + 自动保护，异常情况自动停止

项目成果

  • 实现异地远程控制，延迟 < 100ms，提供流畅的第一视角体验
  • 支持兴趣点分享与探秘挑战，构建用户社交生态
  • 集成 AI 智能推荐，提升探索趣味性与个性化体验
  • 系统稳定性高，支持多用户并发访问

技术启示

  1. 实时通信是核心：WebSocket 提供低延迟双向通信能力
  2. 视频流优化是关键：动态压缩与自适应策略平衡画质与带宽
  3. AI 增强用户体验：智能推荐与场景识别提升探索乐趣
  4. 稳定性需多层保障：断线重连、状态监控、异常保护缺一不可
Portfolio

专注于创造高品质、简洁且富有情感的数字产品体验。

链接

关于作品博客

社交

GitHubTwitterLinkedIn

© 2026 Portfolio. All rights reserved.

隐私政策服务条款