使用Golang实现IoT智能家居控制的插件库smart-home

smart-home库简介

smart-home是一个用Go语言编写的智能家居控制插件库，它提供了统一的接口来控制各种智能家居设备，支持多种通信协议和厂商设备。下面我将介绍如何使用这个库来实现IoT自动化智能家居控制。

基本安装

首先安装smart-home库：

go get github.com/smarthome-go/smarthome

核心功能示例

1. 初始化连接

package main

import (
	"fmt"
	"github.com/smarthome-go/smarthome"
	"log"
)

func main() {
	// 初始化配置
	config := smarthome.Config{
		MQTTBroker:   "tcp://localhost:1883",
		Username:     "admin",
		Password:     "password",
		HomeID:       "my_home_123",
		CacheTimeout: 30, // 秒
	}

	// 创建智能家居客户端
	client, err := smarthome.NewClient(config)
	if err != nil {
		log.Fatalf("Failed to create client: %v", err)
	}
	defer client.Close()

	// 连接到MQTT代理
	if err := client.Connect(); err != nil {
		log.Fatalf("Failed to connect: %v", err)
	}
	
	fmt.Println("Connected to smart home system!")
}

2. 设备控制

// 控制灯光
func controlLight(client *smarthome.Client, deviceID string, on bool) error {
	action := smarthome.DeviceAction{
		DeviceID: deviceID,
		Action:   "set_power",
		Payload: map[string]interface{}{
			"power": on,
		},
	}

	response, err := client.ControlDevice(action)
	if err != nil {
		return err
	}

	if !response.Success {
		return fmt.Errorf("device control failed: %s", response.Message)
	}

	fmt.Printf("Light %s turned %v\n", deviceID, on)
	return nil
}

// 控制恒温器
func setThermostat(client *smarthome.Client, deviceID string, temp float64) error {
	action := smarthome.DeviceAction{
		DeviceID: deviceID,
		Action:   "set_temperature",
		Payload: map[string]interface{}{
			"temperature": temp,
		},
	}

	response, err := client.ControlDevice(action)
	if err != nil {
		return err
	}

	if !response.Success {
		return fmt.Errorf("failed to set temperature: %s", response.Message)
	}

	fmt.Printf("Thermostat %s set to %.1f°C\n", deviceID, temp)
	return nil
}

3. 自动化规则

// 创建自动化规则
func createAutomationRule(client *smarthome.Client) error {
	rule := smarthome.AutomationRule{
		Name:        "Night Mode",
		Description: "Turn off lights and lower temperature at night",
		Conditions: []smarthome.Condition{
			{
				Type:  "time",
				Value: "after 22:00",
			},
		},
		Actions: []smarthome.DeviceAction{
			{
				DeviceID: "living_room_light",
				Action:   "set_power",
				Payload:  map[string]interface{}{"power": false},
			},
			{
				DeviceID: "bedroom_thermostat",
				Action:   "set_temperature",
				Payload:  map[string]interface{}{"temperature": 20.0},
			},
		},
	}

	err := client.AddRule(rule)
	if err != nil {
		return fmt.Errorf("failed to add rule: %v", err)
	}

	fmt.Println("Automation rule created successfully")
	return nil
}

4. 设备状态监控

// 订阅设备状态变化
func subscribeToDevice(client *smarthome.Client, deviceID string) {
	ch := make(chan smarthome.DeviceState)
	err := client.SubscribeToDevice(deviceID, ch)
	if err != nil {
		log.Printf("Failed to subscribe to device %s: %v", deviceID, err)
		return
	}

	go func() {
		for state := range ch {
			fmt.Printf("Device %s state updated: %+v\n", deviceID, state)
		}
	}()
}

// 获取所有设备状态
func getAllDevicesStatus(client *smarthome.Client) {
	devices, err := client.GetAllDevices()
	if err != nil {
		log.Printf("Failed to get devices: %v", err)
		return
	}

	for _, device := range devices {
		fmt.Printf("Device ID: %s, Name: %s, Type: %s, State: %v\n",
			device.ID, device.Name, device.Type, device.State)
	}
}

高级功能

1. 场景模式

func activateScene(client *smarthome.Client, sceneName string) error {
	scenes := map[string][]smarthome.DeviceAction{
		"movie_mode": {
			{DeviceID: "living_room_light", Action: "set_power", Payload: map[string]interface{}{"power": false}},
			{DeviceID: "tv", Action: "set_power", Payload: map[string]interface{}{"power": true}},
			{DeviceID: "sound_system", Action: "set_volume", Payload: map[string]interface{}{"volume": 60}},
		},
		"morning_mode": {
			{DeviceID: "bedroom_light", Action: "set_power", Payload: map[string]interface{}{"power": true, "brightness": 50}},
			{DeviceID: "coffee_machine", Action: "start_brewing", Payload: map[string]interface{}{}},
		},
	}

	actions, ok := scenes[sceneName]
	if !ok {
		return fmt.Errorf("scene %s not found", sceneName)
	}

	for _, action := range actions {
		if _, err := client.ControlDevice(action); err != nil {
			return fmt.Errorf("failed to execute scene action: %v", err)
		}
	}

	fmt.Printf("Scene %s activated successfully\n", sceneName)
	return nil
}

2. 语音控制集成

func setupVoiceControl(client *smarthome.Client) {
	voiceCommands := map[string]func(){
		"turn on the lights": func() {
			controlLight(client, "living_room_light", true)
		},
		"turn off the lights": func() {
			controlLight(client, "living_room_light", false)
		},
		"set temperature to 22 degrees": func() {
			setThermostat(client, "living_room_thermostat", 22.0)
		},
	}

	// 这里可以集成实际的语音识别SDK
	// 示例伪代码:
	// voiceRecognition.OnCommand(func(cmd string) {
	//     if action, ok := voiceCommands[cmd]; ok {
	//         action()
	//     }
	// })
}

错误处理与日志

func setupLogging(client *smarthome.Client) {
	// 设置日志回调
	client.SetLogCallback(func(level smarthome.LogLevel, msg string) {
		switch level {
		case smarthome.LogLevelError:
			log.Printf("[ERROR] %s", msg)
		case smarthome.LogLevelWarning:
			log.Printf("[WARN] %s", msg)
		case smarthome.LogLevelInfo:
			log.Printf("[INFO] %s", msg)
		case smarthome.LogLevelDebug:
			log.Printf("[DEBUG] %s", msg)
		}
	})

	// 设置错误回调
	client.SetErrorCallback(func(err error) {
		log.Printf("Critical error occurred: %v", err)
		// 可以添加自动恢复逻辑
	})
}

总结

smart-home库为Golang开发者提供了强大的智能家居控制能力，通过统一的API接口可以：

1. 控制多种智能设备（灯光、恒温器、插座等）
2. 创建自动化规则和场景模式
3. 监控设备状态变化
4. 集成语音控制等高级功能

开发者可以根据实际需求扩展这些基础功能，构建更复杂的智能家居自动化系统。