smart_tunnel_edge/service/devmgr.go

package service

import (
	"encoding/json"
	"smart_tunnel_edge/protocol/envSensor"
	"smart_tunnel_edge/protocol/lampControl"
	"smart_tunnel_edge/protocol/switchRelay"
	"smart_tunnel_edge/util/config"
	"smart_tunnel_edge/util/logger"
	"sync"
	"time"
)

var mu sync.Mutex

//var RelayStatus = "1000" //四路开关继电器状态

const (
	RegulateLight    = "regulateLight"
	RegulateSwitch   = "regulateSwitch"
	FullPower        = "fullPower"
	LowPower         = "lowPower"
	MediumPower      = "mediumPower"
	LowLightLevel    = 30
	MediumLightLevel = 60
	FullLightLevel   = 90
)

// 初始化时单灯或者开关继电器
func InitControl() {
	if config.Instance().Policy.Control == RegulateLight {
		go SetLampBright([]int8{1, 2}, LowLightLevel)
	} else {
		go SetSwitchRelay([]int8{1, 2}, 1, 1)
		time.Sleep(500 * time.Millisecond)
		go SetSwitchRelay([]int8{1, 2}, 2, 0)
	}
}

func StartDeviceCollection(dev *config.EnvDev) {
	coverTime := dev.TaskTime
	ticker := time.NewTicker(time.Duration(coverTime) * time.Minute)
	defer ticker.Stop()

	for {
		select {
		case <-ticker.C:
			if dev.WaitTime > 0 {
				time.Sleep(time.Duration(dev.WaitTime) * time.Second)
			}
			//获取指令
			dataPack := envSensor.DataPack{Address: dev.Address, Start: []byte{0x01, 0xF8}, DataLen: []byte{0x00, 0x08}}
			if dev.Name == "光传感器" {
				dataPack = envSensor.DataPack{Address: dev.Address, Start: []byte{0x00, 0x06}, DataLen: []byte{0x00, 0x01}}
			}
			if dev.Name == "光感" {
				dataPack = envSensor.DataPack{Address: dev.Address, Start: []byte{0x00, 0x00}, DataLen: []byte{0x00, 0x28}}
			}
			buffer := dataPack.GetEnvGatherCommand()
			mu.Lock()
			port, err := GetSerialPort(dev.SerialId)
			if err != nil {
				logger.Logger.Infof(err.Error())
				continue
			}
			write, err := port.Write(buffer.Bytes())
			mu.Unlock()
			if write < 0 || err != nil {
				logger.Logger.Errorf("设备：%v采集数据失败，错误：%v", dev.Sn, err)
				continue
			}
		}
	}
}

// 处理灯光开关逻辑
func OperationLampSwitchJudge(radarId []int8, brightness int, power string) {
	switch config.Instance().Policy.Control {
	case RegulateLight:
		// 如果是单灯控制器，直接调整亮度
		SetLampBright(radarId, brightness)
	case RegulateSwitch:
		// 对于开关继电器控制，根据亮度调整回路状态
		switch power {
		case FullPower:
			// 满功率：打开回路1和回路2
			go SetSwitchRelay(radarId, 1, 1) // 打开回路1
			time.Sleep(500 * time.Millisecond)
			go SetSwitchRelay(radarId, 2, 1) // 打开回路2
		case LowPower:
			// 三分之一功率：打开回路1，关闭回路2
			go SetSwitchRelay(radarId, 1, 1)
			time.Sleep(500 * time.Millisecond)
			go SetSwitchRelay(radarId, 2, 0)
		case MediumPower:
			// 三分之二功率：打开回路2，关闭回路1
			go SetSwitchRelay(radarId, 2, 1) // 打开回路2
			time.Sleep(500 * time.Millisecond)
			go SetSwitchRelay(radarId, 1, 0) // 关闭回路1
		}
	}
}

// 单灯控制器调光方法
func SetLampBright(radarId []int8, brightness int) {
	var wg sync.WaitGroup
	for _, id := range radarId {
		for _, dev := range config.DevConfig.LampDevs {
			if dev.RadarId != id {
				continue
			}
			wg.Add(1)
			newDev := dev
			go func() {
				defer wg.Done()
				// 获取对应的串口
				port, err := GetSerialPort(newDev.SerialId)
				if err != nil {
					logger.Logger.Infof("获取串口失败，设备编号：%v，错误：%v", newDev.Sn, err)
					return
				}
				buffer := lampControl.DataPack{Addr: newDev.Address}.GetLampSetBrightCommand(brightness)
				mu.Lock() // 锁定串口操作
				write, err := port.Write(buffer.Bytes())
				mu.Unlock()
				if write < 0 || err != nil {
					logger.Logger.Errorf("单灯：%v操作失败，错误：%v", newDev.Sn, err)
					return
				}
			}()
			time.Sleep(time.Millisecond * 150)
		}
		//上报单灯亮度 根据路数
		topic := MqttService.GetTopic(TopicLampBrightNess)
		state := LampBrightNess{Way: id, BrightNess: brightness}
		jsonData, _ := json.Marshal(state)
		err := MqttService.Publish(topic, jsonData)
		if err != nil {
			logger.Logger.Errorf("MQTT Publish err = %s", err.Error())
		}
	}
	wg.Wait()
}

// 开关继电器开关方法(单路)
func SetSwitchRelay(radarId []int8, way, turnOf int) {
	for _, id := range radarId {
		for _, dev := range config.DevConfig.SwitchDevs {
			if dev.RadarId != id {
				continue
			}
			port, err := GetSerialPort(dev.SerialId)
			if err != nil {
				logger.Logger.Infof("获取串口失败，设备编号：%v，错误：%v", dev.Sn, err)
				return
			}
			command := switchRelay.DataPack{Address: dev.Address, Way: way, Command: turnOf}.GetSwitchRelayCommand()
			mu.Lock() // 锁定串口操作
			write, err := port.Write(command.Bytes())
			mu.Unlock() // 锁定串口操作

			if write < 0 || err != nil {
				logger.Logger.Errorf("控制单路开关继电器：%v操作失败，错误：%v", dev.Sn, err)
				continue
			}
			time.Sleep(time.Millisecond * 150)
			//上报回路状态
			topic := MqttService.GetTopic(TopicSwitchStates)
			state := RelayState{Sn: dev.Sn, Way: way, TurnOf: turnOf}
			jsonData, _ := json.Marshal(state)
			err = MqttService.Publish(topic, jsonData)
			if err != nil {
				logger.Logger.Errorf("MQTT Publish err = %s", err.Error())
			}
		}
	}
}

// 开关继电器开关方法(多路)
func SetSwitchMultiRelay(radarId int8, turnOf int, ways []int) {
	for _, dev := range config.DevConfig.SwitchDevs {
		if dev.RadarId != radarId {
			continue
		}
		port, err := GetSerialPort(dev.SerialId)
		if err != nil {
			logger.Logger.Infof("获取串口失败，设备编号：%v，错误：%v", dev.Sn, err)
			return
		}
		command := switchRelay.MultiLoopDataPack{Address: dev.Address, TurnOff: turnOf, State: ways}.GetControlMuchSwitchRelayCommand()
		mu.Lock() // 锁定串口操作
		write, err := port.Write(command.Bytes())
		mu.Unlock() // 锁定串口操作

		if write < 0 || err != nil {
			logger.Logger.Errorf("控制多路开关继电器：%v操作失败，错误：%v", dev.Sn, err)
			continue
		}
		time.Sleep(time.Millisecond * 150)
	}
}