def get_register(self, name):
"""
Get register from the register bank which has all its details.
:param name:
:return:
"""
if name in self.registers:
return self.registers[name]
logger.error("Invalid register name {}")
def get_registers_in_block(self, index):
name = ""
if index in blocks.blocks_name:
name = blocks.blocks_name[index]
else:
logger.error("index {} is not in blocks_name ".format({index}))
if name in blocks.blocks:
return blocks.blocks[name]
logger.error("name {} is not in blocks".format({name}))
def set_setpoints(self, arg_dict):
"""
:param arg_dict:
:return:
"""
flag = True
for reg_name in arg_dict:
if not self.write(reg_name, arg_dict.get(reg_name)):
logger.error("{} register write failed".format(reg_name))
flag = False
return flag
def __init__(self, inv_json=""):
inverter.Inverter.__init__(self, inv_json)
try:
logger.info("inv json {} ".format(inv_json))
self.type = inv_json["type"]
self.ip = inv_json["ip"]
except KeyError:
logger.error("inv_json {} is not valid".format(inv_json))
return
self.block = self.get_register_bank()
self.registers = self.get_register_bank()
self.blocks = self.get_blocks()
self.blocks_names = self.get_block_names()
def read(self, name):
"""
Read register of Outback
:param name:
:return:
"""
reg = self.get_register(name)
if reg is not None:
value = reg.read_reg(self.ip)
if value is not None:
return value
logger.error("Read register {} failed".format(name))
else:
logger.error("Invalid Register {}".format(name))
def read_single_reg(self, dict_fields):
if "field" in dict_fields:
field = dict_fields["field"]
else:
logger.error("invalid register fields")
return -1
if "block" in dict_fields:
block = dict_fields["block"]
else:
logger.error("invalid register fields")
return -1
return self.read_single(field, block)
def write(self, name, value):
"""
Write to given register
:param name:
:param value:
:return:
"""
reg = self.get_register(name)
if reg is not None:
if reg.write_reg(self.ip, value) is not None:
return True
logger.error("Write register {} failed".format(name))
else:
logger.error("Invalid Register {}".format(name))
return False
def write_single(self, field, block, value):
"""
Read register of Outback
:param name:
:return:
"""
name = "custom_read"
reg = register(name, field, block)
if reg is not None:
value = reg.write_reg(value, self.ip)
if value is not None:
return value
logger.error("write register {} failed".format(name))
else:
logger.error("Invalid Register {}".format(name))
def read_multiple(self, reg_names):
"""
Read multiple register of Outback
:param name:
:return:
"""
fields = []
blocks = []
for name in reg_names:
reg = self.get_register(name)
if reg is not None:
fields.append(reg.field)
blocks.append(reg.block)
else:
logger.error(name + " not present")
return register.read_multiple_reg(self.ip, fields, blocks)
def get_block(self, index):
"""
Function to return block registers by first getting index, its name and then its registers.
:param index:
:return:
"""
name = ""
try:
index = int(index)
except ValueError:
return blocks.blocks[index]
if index in blocks.blocks_name:
name = blocks.blocks_name[index]
else:
logger.error("No index {} in blocks_name".format(index))
if name in blocks.blocks:
return blocks.blocks[name]
logger.error("No {} in blocks.blocks".format(name))
def write_single_reg(self, dict_fields):
if "field" in dict_fields:
field = dict_fields["field"]
else:
logger.error("invalid register fields")
return -1
if "block" in dict_fields:
block = dict_fields["block"]
else:
logger.error("invalid register fields")
return -1
if "value" in dict_fields:
value = dict_fields["value"]
else:
logger.error("invalid register fields")
return -1
return self.write_single(field, block, value)
