150 lines
4.6 KiB
Go
150 lines
4.6 KiB
Go
/*
|
|
Copyright 2023 Josh Deprez
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package main
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"errors"
|
|
"fmt"
|
|
)
|
|
|
|
type register struct {
|
|
name string
|
|
conv func([]byte) (float64, error)
|
|
mult float64
|
|
unit string
|
|
}
|
|
|
|
func (r *register) read(data []byte) (float64, error) {
|
|
n, err := r.conv(data)
|
|
return n * r.mult, err
|
|
}
|
|
|
|
var sungrowInputRegs = map[uint16]*register{
|
|
// 4990 - 4999: serial number in ASCII
|
|
5001: {"nominal_power", u16req, 0.1, "kW"},
|
|
5003: {"daily_power_yield", u16req, 0.1, "kWh"},
|
|
5004: {"total_power_yield", u32req, 1, "kWh"},
|
|
5006: {"total_running_time", u32req, 1, "h"},
|
|
5008: {"internal_temperature", u16req, 0.1, "°C"},
|
|
5011: {"pv1_potential", u16req, 0.1, "V"},
|
|
5012: {"pv1_current", u16req, 0.1, "A"},
|
|
5013: {"pv2_potential", u16req, 0.1, "V"},
|
|
5014: {"pv2_current", u16req, 0.1, "A"},
|
|
5015: {"pv3_potential", u16opt, 0.1, "V"},
|
|
5016: {"pv3_current", u16opt, 0.1, "A"},
|
|
5017: {"total_dc_power", u32req, 1, "W"},
|
|
5019: {"phase_a_potential", u16req, 0.1, "V"},
|
|
5020: {"phase_b_potential", u16opt, 0.1, "V"},
|
|
5021: {"phase_c_potential", u16opt, 0.1, "V"},
|
|
5022: {"phase_a_current", u16req, 0.1, "A"},
|
|
5023: {"phase_b_current", u16opt, 0.1, "A"},
|
|
5024: {"phase_c_current", u16opt, 0.1, "A"},
|
|
|
|
5031: {"output_real_power", u32req, 1, "VA"},
|
|
5033: {"output_reactive_power", s32opt, 1, "VAr"},
|
|
5035: {"power_factor", s16opt, 0.001, ""},
|
|
5036: {"frequency", u16req, 0.1, "Hz"},
|
|
|
|
5049: {"nominal_reactive_power", s16opt, 0.1, "kVA"},
|
|
|
|
5083: {"meter_power", s32req, 1, "W"},
|
|
5085: {"meter_a_phase_power", s32opt, 1, "W"},
|
|
5087: {"meter_b_phase_power", s32opt, 1, "W"},
|
|
5089: {"meter_c_phase_power", s32opt, 1, "W"},
|
|
5091: {"usage_power", s32req, 1, "W"},
|
|
5093: {"daily_export_energy", u32req, 0.1, "kWh"},
|
|
5095: {"total_export_energy", u32req, 0.1, "kWh"},
|
|
5097: {"daily_import_energy", u32req, 0.1, "kWh"},
|
|
5099: {"total_import_energy", u32req, 0.1, "kWh"},
|
|
|
|
5113: {"daily_running_time", u16req, 1, "m"},
|
|
|
|
5144: {"total_power_yield_2", u32req, 0.1, "kWh"},
|
|
5148: {"frequency_2", frequency2, 0.01, "Hz"},
|
|
}
|
|
|
|
var errSkippableRead = errors.New("skippable misread")
|
|
|
|
func frequency2(data []byte) (float64, error) {
|
|
n := binary.BigEndian.Uint16(data)
|
|
if n == 0xFFFF {
|
|
// probably a misread
|
|
return 0, fmt.Errorf("likely misread: frequency_2 read %v", n)
|
|
}
|
|
if n <= 100 {
|
|
// 100 translates as 1 Hz, which is... unlikely
|
|
return 0, fmt.Errorf("%w: frequency_2 is %d", errSkippableRead, n)
|
|
}
|
|
return float64(n), nil
|
|
}
|
|
|
|
func u16opt(data []byte) (float64, error) {
|
|
return float64(binary.BigEndian.Uint16(data)), nil
|
|
}
|
|
|
|
func u16req(data []byte) (float64, error) {
|
|
n := binary.BigEndian.Uint16(data)
|
|
if n == 0xFFFF {
|
|
// probably a misread
|
|
return 0, fmt.Errorf("likely misread: u16req read %v", n)
|
|
}
|
|
return float64(n), nil
|
|
}
|
|
|
|
func s16opt(data []byte) (float64, error) {
|
|
return float64(int16(binary.BigEndian.Uint16(data))), nil
|
|
}
|
|
|
|
// func s16req(data []byte) (float64, error) {
|
|
// n := binary.BigEndian.Uint16(data)
|
|
// if n == 0x7FFF {
|
|
// // probably a misread
|
|
// return 0, fmt.Errorf("likely misread: s16req read %v", n)
|
|
// }
|
|
// return float64(int16(n)), nil
|
|
// }
|
|
|
|
// func u32opt(data []byte) (float64, error) {
|
|
// // Little-endian big-endian :#
|
|
// return float64(uint32(binary.BigEndian.Uint16(data)) + uint32(binary.BigEndian.Uint16(data[2:]))<<16), nil
|
|
// }
|
|
|
|
func u32req(data []byte) (float64, error) {
|
|
// Little-endian big-endian :#
|
|
n := uint32(binary.BigEndian.Uint16(data)) + uint32(binary.BigEndian.Uint16(data[2:]))<<16
|
|
if n == 0xFFFFFFFF {
|
|
// probably a misread
|
|
return 0, fmt.Errorf("likely misread: u32req read %v", n)
|
|
}
|
|
return float64(n), nil
|
|
}
|
|
|
|
func s32opt(data []byte) (float64, error) {
|
|
// Little-endian big-endian :#
|
|
return float64(int32(binary.BigEndian.Uint16(data)) + int32(binary.BigEndian.Uint16(data[2:]))<<16), nil
|
|
}
|
|
|
|
func s32req(data []byte) (float64, error) {
|
|
// Little-endian big-endian :#
|
|
n := uint32(binary.BigEndian.Uint16(data)) + uint32(binary.BigEndian.Uint16(data[2:]))<<16
|
|
if n == 0x7FFFFFFF {
|
|
// probably a misread
|
|
return 0, fmt.Errorf("likely misread: s32req read %v", n)
|
|
}
|
|
return float64(int32(n)), nil
|
|
}
|