You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
411 lines
8.6 KiB
411 lines
8.6 KiB
package m9zApi
|
|
|
|
import (
|
|
"fmt"
|
|
"github.com/gogf/gf/v2/errors/gerror"
|
|
"math"
|
|
"sort"
|
|
"sync"
|
|
"tgk-touch/internal/global"
|
|
"tgk-touch/internal/library/m9z"
|
|
"time"
|
|
|
|
"github.com/towgo/towgo/towgo"
|
|
)
|
|
|
|
func getDeviceId(rpc towgo.JsonRpcConnection) (string, []uint) {
|
|
var p struct {
|
|
CommUid string `json:"comm_uid"`
|
|
Idxs []uint `json:"idxs"`
|
|
}
|
|
rpc.ReadParams(&p)
|
|
if p.CommUid == "" {
|
|
panic(gerror.New("comm_uid is empty"))
|
|
}
|
|
return p.CommUid, p.Idxs
|
|
}
|
|
|
|
// // 获取设备输出状态参数
|
|
func getOutStatus(rpc towgo.JsonRpcConnection) {
|
|
cuid, _ := getDeviceId(rpc)
|
|
|
|
read, err := m9z.DeviceOutStatusRead(cuid)
|
|
if err != nil {
|
|
panic(err)
|
|
|
|
}
|
|
rpc.WriteResult(read)
|
|
}
|
|
|
|
// todo 有问题 不管写入什么模式返回都是FF 获取设备编程模式 1-3 对应模式01~模式03 编程模式0~2
|
|
func getDeviceMode(rpc towgo.JsonRpcConnection) {
|
|
cuid, _ := getDeviceId(rpc)
|
|
|
|
read, err := m9z.ModeRead(cuid)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
rpc.WriteResult(read)
|
|
}
|
|
|
|
// 读取手动控制信息
|
|
func getDeviceManualInfo(rpc towgo.JsonRpcConnection) {
|
|
cuid, _ := getDeviceId(rpc)
|
|
|
|
manual, err := m9z.ManualRead(cuid)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
if !manual.Able {
|
|
// 如果当前非手动控制模式就读取设备状态后赋值给手动控制对象
|
|
//读取设备状态
|
|
time.Sleep(time.Second)
|
|
read, err := m9z.DeviceStatusRead(cuid)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
for i, _ := range manual.Loops {
|
|
manual.Loops[i].IsOpen = read.Relays[i]
|
|
manual.Loops[i].Pwm = int(read.PWMOutputs[i])
|
|
}
|
|
}
|
|
rpc.WriteResult(manual)
|
|
}
|
|
|
|
// 获取设备上的时间
|
|
func getDeviceTime(rpc towgo.JsonRpcConnection) {
|
|
cuid, _ := getDeviceId(rpc)
|
|
|
|
deviceTime, timestampSec, err := m9z.DeviceTimeRead(cuid)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
result := make(map[string]interface{})
|
|
result["deviceTime"] = deviceTime.Format("2006-01-02 15:04:05")
|
|
result["timestampSec"] = timestampSec
|
|
rpc.WriteResult(result)
|
|
|
|
}
|
|
|
|
// 获取设备经纬度信息
|
|
func getLgnLatData(rpc towgo.JsonRpcConnection) {
|
|
cuid, _ := getDeviceId(rpc)
|
|
|
|
manual, err := m9z.LgnLatRead(cuid)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
r := map[string]interface{}{}
|
|
r["lgn"] = manual.Lgn
|
|
r["lat"] = manual.Lat
|
|
r["loc"] = manual.Loc.String()
|
|
rpc.WriteResult(r)
|
|
}
|
|
|
|
// 获取日出日落时间偏差
|
|
func getSunRiseSet(rpc towgo.JsonRpcConnection) {
|
|
cuid, _ := getDeviceId(rpc)
|
|
read, err := m9z.SunRiseSetRead(cuid)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
rpc.WriteResult(read)
|
|
}
|
|
|
|
// 获取设备的状态
|
|
func getDeviceStatus(rpc towgo.JsonRpcConnection) {
|
|
cuid, _ := getDeviceId(rpc)
|
|
|
|
read, err := m9z.DeviceStatusRead(cuid)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
rpc.WriteResult(read)
|
|
}
|
|
|
|
type DeviceStatusLoop struct {
|
|
m9z.Loop
|
|
V float32
|
|
A float32
|
|
Kw float32
|
|
}
|
|
type DeviceStatus struct {
|
|
m9z.DeviceStatus
|
|
Loops []DeviceStatusLoop
|
|
}
|
|
|
|
// 实时监控数据
|
|
func getDeviceStatus2(rpc towgo.JsonRpcConnection) {
|
|
cuid, _ := getDeviceId(rpc)
|
|
|
|
read, err := m9z.DeviceStatusRead(cuid)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
d := new(DeviceStatus)
|
|
d.DeviceStatus = *read
|
|
var wg sync.WaitGroup
|
|
for i := 0; i < 10; i++ {
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
var loop DeviceStatusLoop
|
|
loop.Name = fmt.Sprintf("#%+v", i+1)
|
|
loop.Index = i
|
|
loop.IsOpen = read.Relays[i]
|
|
loop.Pwm = int(read.PWMOutputs[i])
|
|
parametersRead, err := m9z.SubLoopParametersRead(cuid, uint(i))
|
|
if err != nil {
|
|
g.Log().Error(err)
|
|
return
|
|
}
|
|
if parametersRead != nil {
|
|
kw := float32(0.0)
|
|
loop.V = (parametersRead.DCVoltage * 10) / 10
|
|
for _, v := range parametersRead.Modules {
|
|
loop.A = loop.A + v.OutputCurrent
|
|
kw = float32(math.Round(float64(v.OutputCurrent*v.OutputVoltage*1000))/1000) + kw
|
|
}
|
|
loop.Kw = ((kw / 1000) * 1000) / 1000
|
|
loop.A = (loop.A * 100) / 100
|
|
}
|
|
d.Loops = append(d.Loops, loop)
|
|
}()
|
|
|
|
}
|
|
wg.Wait()
|
|
// 按 Timestamp 排序（最早的在前）
|
|
sort.Slice(d.Loops, func(i, j int) bool {
|
|
return d.Loops[i].Index < d.Loops[j].Index
|
|
})
|
|
rpc.WriteResult(d)
|
|
|
|
}
|
|
|
|
// 获取设备的配置
|
|
func getDeviceConfig(rpc towgo.JsonRpcConnection) {
|
|
cuid, _ := getDeviceId(rpc)
|
|
|
|
read, err := m9z.DeviceConfigRead(cuid)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
rpc.WriteResult(read)
|
|
}
|
|
|
|
// 获取日出日落时间
|
|
func getDeviceSunRiseTime(rpc towgo.JsonRpcConnection) {
|
|
cuid, _ := getDeviceId(rpc)
|
|
|
|
read, err := m9z.SunRiseTimeRead(cuid)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
rpc.WriteResult(read)
|
|
|
|
}
|
|
|
|
// 读取开始任务 (优化指令 CMD=0x13)
|
|
func getStartTask(rpc towgo.JsonRpcConnection) {
|
|
var p struct {
|
|
CommUid string `json:"comm_uid"`
|
|
Mode uint8 `json:"mode"` // 0x00-0x02
|
|
}
|
|
rpc.ReadParams(&p)
|
|
if p.CommUid == "" {
|
|
panic(gerror.New("comm_uid is empty"))
|
|
}
|
|
|
|
read, err := m9z.StartTaskRead(p.CommUid, p.Mode)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
/*program, err := m9z.ControlTaskToTaskProgram(m9z.DefaultStopTask, p.Mode)
|
|
if err != nil {
|
|
panic(err)
|
|
}*/
|
|
/*err = m9z.StartTaskWriteByTaskCfg(p.CommUid, p.Mode, m9z.DefaultStartTask)
|
|
if err != nil {
|
|
panic(err)
|
|
}*/
|
|
|
|
rpc.WriteResult(read)
|
|
}
|
|
|
|
// 读取中间任务 (优化指令 CMD=0x14)
|
|
func getMiddleTaskRead(rpc towgo.JsonRpcConnection) {
|
|
var p struct {
|
|
CommUid string `json:"comm_uid"`
|
|
Mode uint8 `json:"mode"` // 0x00-0x02
|
|
}
|
|
rpc.ReadParams(&p)
|
|
if p.CommUid == "" {
|
|
panic(gerror.New("comm_uid is empty"))
|
|
}
|
|
|
|
read, err := m9z.MiddleTaskRead(p.CommUid, p.Mode)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
rpc.WriteResult(read)
|
|
}
|
|
|
|
// 读取结束任务 (优化指令 CMD=0x15)
|
|
func getStopTaskRead(rpc towgo.JsonRpcConnection) {
|
|
var p struct {
|
|
CommUid string `json:"comm_uid"`
|
|
Mode uint8 `json:"mode"` // 0x00-0x02
|
|
}
|
|
rpc.ReadParams(&p)
|
|
if p.CommUid == "" {
|
|
panic(gerror.New("comm_uid is empty"))
|
|
}
|
|
|
|
read, err := m9z.StopTaskRead(p.CommUid, p.Mode)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
rpc.WriteResult(read)
|
|
}
|
|
func getStartTask2(rpc towgo.JsonRpcConnection) {
|
|
var p struct {
|
|
CommUid string `json:"comm_uid"`
|
|
Mode uint8 `json:"mode"` // 0x00-0x02
|
|
}
|
|
rpc.ReadParams(&p)
|
|
if p.CommUid == "" {
|
|
panic(gerror.New("comm_uid is empty"))
|
|
}
|
|
|
|
read, err := m9z.StartTaskRead(p.CommUid, p.Mode)
|
|
if err != nil {
|
|
panic(gerror.Wrap(err, ""))
|
|
}
|
|
task, err := m9z.TaskProgramToControlTask(read)
|
|
if err != nil {
|
|
panic(err)
|
|
|
|
}
|
|
if task.TimeType == 1 {
|
|
timeRead, err := m9z.SunRiseTimeRead(p.CommUid)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
task.ExecTime = timeRead.Sunrise
|
|
}
|
|
rpc.WriteResult(task)
|
|
|
|
}
|
|
func getStopTask2(rpc towgo.JsonRpcConnection) {
|
|
var p struct {
|
|
CommUid string `json:"comm_uid"`
|
|
Mode uint8 `json:"mode"` // 0x00-0x02
|
|
}
|
|
rpc.ReadParams(&p)
|
|
if p.CommUid == "" {
|
|
panic(gerror.New("comm_uid is empty"))
|
|
}
|
|
|
|
read, err := m9z.StopTaskRead(p.CommUid, p.Mode)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
task, err := m9z.TaskProgramToControlTask(read)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
if task.TimeType == 1 {
|
|
timeRead, err := m9z.SunRiseTimeRead(p.CommUid)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
task.ExecTime = timeRead.Sunset
|
|
}
|
|
|
|
rpc.WriteResult(task)
|
|
}
|
|
|
|
func getMiddleTask2(rpc towgo.JsonRpcConnection) {
|
|
|
|
var p struct {
|
|
CommUid string `json:"comm_uid"`
|
|
Mode uint8 `json:"mode"` // 0x00-0x02
|
|
}
|
|
rpc.ReadParams(&p)
|
|
if p.CommUid == "" {
|
|
panic(gerror.New("comm_uid is empty"))
|
|
}
|
|
|
|
read, err := m9z.MiddleTaskRead(p.CommUid, p.Mode)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
/*program, err := m9z.MiddleControlTaskToTaskProgram(m9z.DefaultMiddleTask, p.Mode)
|
|
if err != nil {
|
|
panic(err)
|
|
}*/
|
|
task, err := m9z.TaskProgramToMiddleControlTask(read)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
rpc.WriteResult(task)
|
|
}
|
|
|
|
func getSubLoopParameters(rpc towgo.JsonRpcConnection) {
|
|
var p struct {
|
|
CommUid string `json:"comm_uid"`
|
|
Idx uint `json:"idx"`
|
|
}
|
|
rpc.ReadParams(&p)
|
|
if p.CommUid == "" {
|
|
panic(gerror.New("comm_uid is empty"))
|
|
}
|
|
|
|
r, err := m9z.SubLoopParametersRead(p.CommUid, p.Idx)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
rpc.WriteResult(r)
|
|
}
|
|
|
|
func getAllSubLoopParameter(rpc towgo.JsonRpcConnection) {
|
|
var p struct {
|
|
CommUid string `json:"comm_uid"`
|
|
}
|
|
rpc.ReadParams(&p)
|
|
if p.CommUid == "" {
|
|
panic(gerror.New("comm_uid is empty"))
|
|
}
|
|
|
|
result := make(map[string]interface{})
|
|
subLoopData := make([]*m9z.LoopFullParameters, 0)
|
|
subLoopMap := make(map[string]*m9z.LoopFullParameters)
|
|
var wg sync.WaitGroup
|
|
for i := 0; i < 10; i++ {
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
subLoop, err := m9z.SubLoopParametersRead(p.CommUid, uint(i))
|
|
if err != nil || subLoop == nil {
|
|
return
|
|
}
|
|
subLoopMap[subLoop.LoopAddress] = subLoop
|
|
}()
|
|
}
|
|
|
|
wg.Wait()
|
|
for _, v := range subLoopMap {
|
|
subLoopData = append(subLoopData, v)
|
|
}
|
|
result["subLoopData"] = subLoopData
|
|
totalP := 0.0
|
|
|
|
for _, subLoop := range subLoopData {
|
|
totalP = totalP + float64(subLoop.DCVoltage*subLoop.DCCurrent)
|
|
}
|
|
result["totalP"] = totalP
|
|
rpc.WriteResult(result)
|
|
}
|