|
|
package Adl400Impl
|
|
|
|
|
|
import (
|
|
|
"fmt"
|
|
|
"tgk-touch/internal/global"
|
|
|
"tgk-touch/internal/library/ADL400"
|
|
|
"time"
|
|
|
)
|
|
|
|
|
|
func (a *Adl400Impl) ReadYear(commUid string, addr byte) (int, error) {
|
|
|
read, err := ADL400.H003E.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return 0, err
|
|
|
}
|
|
|
value := read[0]
|
|
|
|
|
|
bytes := []byte{byte(value >> 8), byte(value)}
|
|
|
_, year := int(bytes[0]), int(bytes[1])
|
|
|
return year, nil
|
|
|
}
|
|
|
func (a *Adl400Impl) ReadMonth(commUid string, addr byte) (int, error) {
|
|
|
read, err := ADL400.H003E.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return 0, err
|
|
|
}
|
|
|
value := read[0] // 低字节为月份
|
|
|
bytes := []byte{byte(value >> 8), byte(value)}
|
|
|
month, _ := int(bytes[0]), int(bytes[1])
|
|
|
return month, nil
|
|
|
}
|
|
|
func (a *Adl400Impl) ReadDay(commUid string, addr byte) (int, error) {
|
|
|
read, err := ADL400.H003D.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return 0, err
|
|
|
}
|
|
|
value := read[0]
|
|
|
//hour := value >> 8 // 高字节=小时（9）
|
|
|
day := value & 0xFF // 低字节=日（27）
|
|
|
return int(day), nil
|
|
|
}
|
|
|
func (a *Adl400Impl) ReadHour(commUid string, addr byte) (int, error) {
|
|
|
read, err := ADL400.H003D.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return 0, err
|
|
|
}
|
|
|
value := read[0]
|
|
|
hour := value >> 8 // 高字节=小时（9）
|
|
|
//day := value & 0xFF // 低字节=日（27）
|
|
|
return int(hour), nil
|
|
|
}
|
|
|
func (a *Adl400Impl) ReadMinute(commUid string, addr byte) (int, error) {
|
|
|
read, err := ADL400.H003C.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return 0, err
|
|
|
}
|
|
|
value := read[0]
|
|
|
//second := value >> 8 // 高字节=小时（9）
|
|
|
minute := value & 0xFF // 低字节=日（27）
|
|
|
return int(minute), nil
|
|
|
}
|
|
|
func (a *Adl400Impl) ReadSecond(commUid string, addr byte) (int, error) {
|
|
|
read, err := ADL400.H003C.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return 0, err
|
|
|
}
|
|
|
value := read[0]
|
|
|
second := value >> 8 // 高字节=小时（9）
|
|
|
//minute := value & 0xFF // 低字节=日（27）
|
|
|
return int(second), nil
|
|
|
}
|
|
|
func (a *Adl400Impl) ReadTime(commUid string, addr byte) (time.Time, error) {
|
|
|
// 读取各个时间组件
|
|
|
year, err := a.ReadYear(commUid, addr)
|
|
|
if err != nil {
|
|
|
return time.Time{}, fmt.Errorf("failed to read year: %v", err)
|
|
|
}
|
|
|
|
|
|
month, err := a.ReadMonth(commUid, addr)
|
|
|
if err != nil {
|
|
|
return time.Time{}, fmt.Errorf("failed to read month: %v", err)
|
|
|
}
|
|
|
|
|
|
day, err := a.ReadDay(commUid, addr)
|
|
|
if err != nil {
|
|
|
return time.Time{}, fmt.Errorf("failed to read day: %v", err)
|
|
|
}
|
|
|
|
|
|
hour, err := a.ReadHour(commUid, addr)
|
|
|
if err != nil {
|
|
|
return time.Time{}, fmt.Errorf("failed to read hour: %v", err)
|
|
|
}
|
|
|
|
|
|
minute, err := a.ReadMinute(commUid, addr)
|
|
|
if err != nil {
|
|
|
return time.Time{}, fmt.Errorf("failed to read minute: %v", err)
|
|
|
}
|
|
|
|
|
|
second, err := a.ReadSecond(commUid, addr)
|
|
|
if err != nil {
|
|
|
return time.Time{}, fmt.Errorf("failed to read second: %v", err)
|
|
|
}
|
|
|
// 构建时间对象
|
|
|
loc, _ := time.LoadLocation("Local") // 使用本地时区
|
|
|
t := time.Date(
|
|
|
year+2000, // 假设年份是2位数，加上2000
|
|
|
time.Month(month),
|
|
|
day,
|
|
|
hour,
|
|
|
minute,
|
|
|
second,
|
|
|
0, // 纳秒
|
|
|
loc,
|
|
|
)
|
|
|
return t, nil
|
|
|
}
|
|
|
|
|
|
func (a *Adl400Impl) ReadVoltage(commUid string, addr byte) (totalVoltage, aVoltage, bVoltage, cVoltage float64, err error) {
|
|
|
aRead, err := ADL400.H0061.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
aVoltage = float64(aRead[0]) * 0.1
|
|
|
bRead, err := ADL400.H0062.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
bVoltage = float64(bRead[0]) * 0.1
|
|
|
cRead, err := ADL400.H0063.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
cVoltage = float64(cRead[0]) * 0.1
|
|
|
return totalVoltage, aVoltage, bVoltage, cVoltage, err
|
|
|
}
|
|
|
func (a *Adl400Impl) ReadElectricCurrent(commUid string, addr byte) (totalElectricCurrent, aElectricCurrent, bElectricCurrent, cElectricCurrent float64, err error) {
|
|
|
aRead, err := ADL400.H0064.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
aElectricCurrent = float64(aRead[0]) * 0.01
|
|
|
bRead, err := ADL400.H0065.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
bElectricCurrent = float64(bRead[0]) * 0.01
|
|
|
|
|
|
cRead, err := ADL400.H0066.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
cElectricCurrent = float64(cRead[0]) * 0.01
|
|
|
|
|
|
return totalElectricCurrent, aElectricCurrent, bElectricCurrent, cElectricCurrent, err
|
|
|
}
|
|
|
func (a *Adl400Impl) ReadPower(commUid string, addr byte) (totalPower, aPower, bPower, cPower float64, err error) {
|
|
|
aRead, err := ADL400.H0067.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
aPower = float64(aRead[0]) * 0.001
|
|
|
bRead, err := ADL400.H0068.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
bPower = float64(bRead[0]) * 0.001
|
|
|
|
|
|
cRead, err := ADL400.H0069.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
cPower = float64(cRead[0]) * 0.001
|
|
|
tRead, err := ADL400.H006A.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return 0, 0, 0, 0, err
|
|
|
}
|
|
|
totalPower = float64(tRead[0]) * 0.001
|
|
|
return totalPower, aPower, bPower, cPower, err
|
|
|
}
|
|
|
func (a *Adl400Impl) ReadTotalPower(commUid string, addr byte) (totalPower float64, err error) {
|
|
|
tRead, err := ADL400.H006A.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return 0, err
|
|
|
}
|
|
|
totalPower = float64(tRead[0]) * 0.001
|
|
|
return totalPower, err
|
|
|
}
|
|
|
func (a *Adl400Impl) ReadEnergy(commUid string, addr byte) (totalEnergy, aEnergy, bEnergy, cEnergy float64, err error) {
|
|
|
read, err := ADL400.H000A.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
high := uint32(read[0]) // 高16位
|
|
|
low := uint32(read[1]) // 低16位
|
|
|
value := (high << 16) | low // 组合为32位整数
|
|
|
totalEnergy = float64(value) * 0.01
|
|
|
|
|
|
aRead, err := ADL400.H0087.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
ahigh := uint32(aRead[0]) // 高16位
|
|
|
alow := uint32(aRead[1]) // 低16位
|
|
|
avalue := (ahigh << 16) | alow // 组合为32位整数
|
|
|
aEnergy = float64(avalue) * 0.01
|
|
|
|
|
|
bRead, err := ADL400.H0089.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
bhigh := uint32(bRead[0]) // 高16位
|
|
|
blow := uint32(bRead[1]) // 低16位
|
|
|
bvalue := (bhigh << 16) | blow // 组合为32位整数
|
|
|
bEnergy = float64(bvalue) * 0.01
|
|
|
|
|
|
cRead, err := ADL400.H008B.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
chigh := uint32(cRead[0]) // 高16位
|
|
|
clow := uint32(cRead[1]) // 低16位
|
|
|
cvalue := (chigh << 16) | clow // 组合为32位整数
|
|
|
cEnergy = float64(cvalue) * 0.01
|
|
|
|
|
|
return totalEnergy, aEnergy, bEnergy, cEnergy, err
|
|
|
}
|
|
|
|
|
|
func (a *Adl400Impl) ReadPowerFactor(commUid string, addr byte) (totalPf, aPf, bPf, cPf float64, err error) {
|
|
|
aRead, err := ADL400.H0073.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
aPf = float64(aRead[0]) * 0.001
|
|
|
bRead, err := ADL400.H0074.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
bPf = float64(bRead[0]) * 0.001
|
|
|
|
|
|
cRead, err := ADL400.H0075.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return
|
|
|
}
|
|
|
cPf = float64(cRead[0]) * 0.001
|
|
|
tRead, err := ADL400.H0076.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return 0, 0, 0, 0, err
|
|
|
}
|
|
|
totalPf = float64(tRead[0]) * 0.001
|
|
|
return totalPf, aPf, bPf, cPf, err
|
|
|
}
|
|
|
func (a *Adl400Impl) ReadMsgAddr(commUid string, addr byte) (msgAddr byte, err error) {
|
|
|
read, err := ADL400.H003F.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return 0, err
|
|
|
}
|
|
|
|
|
|
// 调试日志：打印原始数据
|
|
|
g.Log().Infof("ReadMsgAddr raw data: len=%d, data=% X", len(read), read)
|
|
|
|
|
|
// 根据实际数据长度处理不同情况
|
|
|
switch len(read) {
|
|
|
case 1: // 单个 uint16 值 (2字节)
|
|
|
// 示例日志: [5C03] -> 0x5C03
|
|
|
value := read[0] // 假设返回的是 uint16 类型
|
|
|
msgAddr = byte(value >> 8) // 取高字节 (0x5C)
|
|
|
g.Log().Infof("Extracted from uint16: 0x%X -> msgAddr=0x%X (%d)", value, msgAddr, msgAddr)
|
|
|
/*
|
|
|
case 2: // 两个字节 [high, low]
|
|
|
// 示例: [5C 03] -> msgAddr=0x5C
|
|
|
msgAddr = read[0]
|
|
|
g.Log().Infof("Extracted from bytes: [% X] -> msgAddr=0x%X (%d)", read, msgAddr, msgAddr)
|
|
|
|
|
|
default:
|
|
|
return 0, fmt.Errorf("unexpected data length: %d bytes", len(read))*/
|
|
|
}
|
|
|
|
|
|
return msgAddr, nil
|
|
|
}
|
|
|
|
|
|
func (a *Adl400Impl) ReadMainAddr(commUid string, addr byte) (mainAddr byte, err error) {
|
|
|
/* read, err := ADL400.H0099_009E.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return "", err
|
|
|
}
|
|
|
|
|
|
// 调试日志
|
|
|
g.Log().Infof("ReadMainAddr raw data: len=%d, data=% X", len(read), read)
|
|
|
|
|
|
// 根据实际数据长度处理
|
|
|
var bcdData []byte
|
|
|
switch v := read.(type) {
|
|
|
case []uint16: // 返回的是 uint16 数组
|
|
|
// 示例: [0000 0000 0050] -> BCD "000000000050"
|
|
|
for _, reg := range v {
|
|
|
bcdData = append(bcdData, byte(reg>>8), byte(reg))
|
|
|
}
|
|
|
|
|
|
case []byte: // 直接返回字节数组
|
|
|
bcdData = v
|
|
|
|
|
|
default:
|
|
|
return "", fmt.Errorf("unexpected data type: %T", read)
|
|
|
}
|
|
|
|
|
|
// 验证数据长度
|
|
|
if len(bcdData) != 12 {
|
|
|
return "", fmt.Errorf("invalid BCD data length: expected 12 bytes, got %d", len(bcdData))
|
|
|
}
|
|
|
|
|
|
// 转换BCD码为字符串
|
|
|
var builder strings.Builder
|
|
|
for _, b := range bcdData {
|
|
|
high := b >> 4
|
|
|
low := b & 0x0F
|
|
|
|
|
|
if high > 9 || low > 9 {
|
|
|
return "", fmt.Errorf("invalid BCD digit: %X", b)
|
|
|
}
|
|
|
|
|
|
builder.WriteByte('0' + high)
|
|
|
builder.WriteByte('0' + low)
|
|
|
}
|
|
|
|
|
|
mainAddr = builder.String()
|
|
|
g.Log().Infof("Converted mainAddr: %s", mainAddr)*/
|
|
|
return
|
|
|
}
|
|
|
|
|
|
func (a *Adl400Impl) ReadDailyFreezingTime(commUid string, addr byte) (dailyFreezingTime string, err error) {
|
|
|
read, err := ADL400.H0121.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return "", err
|
|
|
}
|
|
|
value := read[0]
|
|
|
minute := value >> 8 // 高字节=小时（9）
|
|
|
hour := value & 0xFF // 低字节=日（27）
|
|
|
// 校验有效时间范围
|
|
|
if hour < 0 || hour > 23 || minute < 0 || minute > 59 {
|
|
|
return fmt.Sprintf("%03d:%02d", hour, minute), nil
|
|
|
}
|
|
|
return fmt.Sprintf("%02d:%02d", hour, minute), nil
|
|
|
|
|
|
}
|
|
|
|
|
|
func (a *Adl400Impl) ReadMonthlyFreezingTime(commUid string, addr byte) (dayStr, hourStr string, err error) {
|
|
|
read, err := ADL400.H0122.Read(commUid, addr)
|
|
|
if err != nil {
|
|
|
return "", "", err
|
|
|
}
|
|
|
value := read[0]
|
|
|
day := value >> 8 // 高字节=小时（9）
|
|
|
hour := value & 0xFF // 低字节=日（27）
|
|
|
|
|
|
return fmt.Sprintf("%02d", day), fmt.Sprintf("%02d", hour), err
|
|
|
}
|
