Go语言在边缘计算设备中的应用尝试：在IoT设备中构建轻量级服务的实践之路

// 多协议采集器核心逻辑
package main

import (
    "context"
    "fmt"
    "time"
    "github.com/goburrow/modbus" // Modbus协议库
)

type SensorData struct {
    DeviceID  string
    Timestamp int64
    Values    map[string]float32
}

func main() {
    // 创建带超时的Modbus处理器
    handler := modbus.NewTCPClientHandler("192.168.1.100:502")
    handler.Timeout = 3 * time.Second
    
    // 启动数据采集协程池
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()
    
    dataChan := make(chan SensorData, 100)
    
    // 协程1：PLC温度传感器采集
    go func() {
        client := modbus.NewClient(handler)
        for {
            select {
            case <-ctx.Done():
                return
            default:
                results, _ := client.ReadHoldingRegisters(0, 10)
                dataChan <- processTemperature(results)
            }
            time.Sleep(500 * time.Millisecond)
        }
    }()
    
    // 协程2：数据聚合处理器
    go processAggregatedData(dataChan)
    
    // 主线程保持运行
    select {}
}

// 温度数据处理（带数据校验）
func processTemperature(raw []byte) SensorData {
    // 解析Modbus数据帧
    if len(raw) < 20 {
        return SensorData{Error: "invalid data length"}
    }
    return SensorData{
        DeviceID:  "PLC-001",
        Timestamp: time.Now().Unix(),
        Values: map[string]float32{
            "temp1": parseFloat32(raw[0:4]),
            "temp2": parseFloat32(raw[4:8]),
        },
    }
}

// 多协议设备管理API
package main

import (
    "github.com/gin-gonic/gin"
    "sync"
)

var deviceRegistry = struct {
    sync.RWMutex
    devices map[string]SmartDevice
}{devices: make(map[string]SmartDevice)}

type SmartDevice struct {
    ID       string `json:"id"`
    Protocol string `json:"protocol"` // Zigbee/Matter/Wi-Fi
    Status   string `json:"status"`
}

func main() {
    r := gin.Default()
    
    // 设备注册接口
    r.POST("/devices", func(c *gin.Context) {
        var newDevice SmartDevice
        if err := c.ShouldBindJSON(&newDevice); err != nil {
            c.JSON(400, gin.H{"error": err.Error()})
            return
        }
        
        deviceRegistry.Lock()
        defer deviceRegistry.Unlock()
        
        if _, exists := deviceRegistry.devices[newDevice.ID]; exists {
            c.JSON(409, gin.H{"error": "device already exists"})
            return
        }
        
        deviceRegistry.devices[newDevice.ID] = newDevice
        c.JSON(201, newDevice)
    })
    
    // 设备状态查询接口
    r.GET("/devices/:id", func(c *gin.Context) {
        deviceID := c.Param("id")
        
        deviceRegistry.RLock()
        defer deviceRegistry.RUnlock()
        
        device, exists := deviceRegistry.devices[deviceID]
        if !exists {
            c.JSON(404, gin.H{"error": "device not found"})
            return
        }
        
        c.JSON(200, device)
    })
    
    r.Run(":8080")
}