170 lines
5.4 KiB
Python
170 lines
5.4 KiB
Python
from typing import Any
|
|
|
|
# from pymodbus.client.sync import ModbusSerialClient
|
|
from pymodbus.client import ModbusSerialClient
|
|
from datetime import date, datetime, timedelta
|
|
from struct import *
|
|
from solaxx3.registers import SolaxRegistersInfo
|
|
from time import sleep, perf_counter
|
|
|
|
|
|
class SolaxX3:
|
|
connected: bool = False
|
|
|
|
def __init__(
|
|
self,
|
|
method="rtu",
|
|
port="/dev/ttyUSB0",
|
|
baudrate=115200,
|
|
timeout=3,
|
|
parity="N",
|
|
stopbits=1,
|
|
bytesize=8,
|
|
) -> None:
|
|
self._input_registers_values_list = []
|
|
self._holding_registers_values_list = []
|
|
|
|
self.client = ModbusSerialClient(
|
|
method=method,
|
|
port=port,
|
|
baudrate=baudrate,
|
|
timeout=timeout,
|
|
parity=parity,
|
|
stopbits=stopbits,
|
|
bytesize=bytesize,
|
|
)
|
|
|
|
def connect(self) -> bool:
|
|
self.connected = self.client.connect()
|
|
return self.connected
|
|
|
|
def _join_msb_lsb(self, msb: int, lsb: int) -> int:
|
|
return (msb << 16) | lsb
|
|
|
|
def _unsigned16(self, type: str, addr: int, count: int = 1, unit: int = 1) -> int:
|
|
|
|
self._input_registers_values_list
|
|
if type == "input":
|
|
return self._input_registers_values_list[addr]
|
|
elif type == "holding":
|
|
return self._holding_registers_values_list[addr]
|
|
|
|
def _readRegisterRange(
|
|
self, type: str, addr: int, count: int = 1, unit: int = 1
|
|
) -> list:
|
|
if type == "input":
|
|
return self._input_registers_values_list[addr : addr + count]
|
|
elif type == "holding":
|
|
return self._holding_registers_values_list[addr : addr + count]
|
|
|
|
def _twos_complement(self, number: int, bits: int) -> int:
|
|
"""
|
|
Compute the 2's complement of the int value val
|
|
"""
|
|
|
|
# if sign bit is set e.g., 8bit: 128-255
|
|
if (number & (1 << (bits - 1))) != 0:
|
|
|
|
# compute negative value
|
|
number = number - (1 << bits)
|
|
|
|
return number
|
|
|
|
def _read_register(self, register_type: str, register_info: dict) -> Any:
|
|
"""Read the values from a register based on length and sign
|
|
|
|
Parameters:
|
|
|
|
register_info:dict - dictionary with register definition fields
|
|
"""
|
|
|
|
if "int" in register_info["data_format"]:
|
|
if register_info["data_length"] == 1:
|
|
val = self._unsigned16(register_type, register_info["address"])
|
|
|
|
if register_info["data_length"] == 2:
|
|
val = self._join_msb_lsb(
|
|
self._unsigned16(register_type, register_info["address"] + 1),
|
|
self._unsigned16(register_type, register_info["address"]),
|
|
)
|
|
|
|
if register_info["signed"]:
|
|
val = self._twos_complement(val, register_info["data_length"] * 16)
|
|
|
|
val = val / register_info["si_adj"]
|
|
|
|
elif "varchar" in register_info["data_format"]:
|
|
block = self._readRegisterRange(
|
|
register_type, register_info["address"], register_info["data_length"]
|
|
)
|
|
sn = []
|
|
for i in range(register_info["data_length"]):
|
|
first_byte, second_byte = unpack(
|
|
"BB", int.to_bytes(block[i], 2, "little")
|
|
)
|
|
if not second_byte == 0x0:
|
|
sn.append(chr(second_byte))
|
|
if not first_byte == 0x0:
|
|
sn.append(chr(first_byte))
|
|
val = "".join(sn)
|
|
|
|
elif "datetime" in register_info["data_format"]:
|
|
sec, min, hr, day, mon, year = self._readRegisterRange(
|
|
register_type, register_info["address"], register_info["data_length"]
|
|
)
|
|
|
|
inverter_datetime = (
|
|
f"{(year+2000):02}-{mon:02}-{day:02} {hr:02}:{min:02}:{sec:02}"
|
|
)
|
|
val = datetime.strptime(inverter_datetime, "%Y-%m-%d %H:%M:%S")
|
|
|
|
return val
|
|
|
|
def read_register(self, register_info: dict) -> tuple:
|
|
"""Read the values from a register based on length and sign
|
|
|
|
Parameters:
|
|
|
|
register_info:dict - dictionary with register definition fields
|
|
"""
|
|
|
|
val = self._read_register(register_info["register_type"], register_info)
|
|
|
|
if not "data_unit" in register_info:
|
|
return (val, "N/A")
|
|
|
|
return (val, register_info["data_unit"])
|
|
|
|
def read(self, name: str):
|
|
"""Retrieve the value for the register with the provided name"""
|
|
|
|
r = SolaxRegistersInfo()
|
|
|
|
register_info = r.get_register_info(name)
|
|
value = self.read_register(register_info)
|
|
|
|
return value
|
|
|
|
def list_register_names(self):
|
|
r = SolaxRegistersInfo()
|
|
return r.list_register_names()
|
|
|
|
def read_all_registers(self) -> None:
|
|
self._input_registers_values_list = []
|
|
self._holding_registers_values_list = []
|
|
|
|
read_block_length = 100
|
|
for i in range(3):
|
|
address = i * read_block_length
|
|
values_list = self.client.read_input_registers(
|
|
address=address, count=read_block_length, slave=1
|
|
).registers
|
|
self._input_registers_values_list.extend(values_list)
|
|
|
|
for i in range(3):
|
|
address = i * read_block_length
|
|
values_list = self.client.read_holding_registers(
|
|
address=address, count=read_block_length, slave=1
|
|
).registers
|
|
self._holding_registers_values_list.extend(values_list)
|