def gridguard(self, new_gg=None):
""" Read/Write SMA Grid Guard.
Params:
Grid Guard
:return: 0 or 1 for GG off or on.
"""
data = self.inv.read(43090, 2)
gg = util.data_to_u32(data)
if int(gg) == 1:
self.ts.log("Grid Guard is already set")
return True
if new_gg is not None:
self.ts.log('Writing new Grid Guard: %d' % new_gg)
self.inv.write(43090, util.u32_to_data(int(new_gg)))
self.ts.sleep(1)
data = self.inv.read(43090, 2)
gg = util.data_to_u32(data)
self.ts.log("gg %s" % gg)
if gg == 0:
print('Grid guard was not enabled')
return False
else:
print('Grid guard was enabled')
return True
def fixed_pf(self, params=None):
""" Get/set fixed power factor control settings.
Params:
Ena - Enabled (True/False)
PF - Power Factor set point
WinTms - Randomized start time delay in seconds
RmpTms - Ramp time in seconds to updated output level
RvrtTms - Reversion time in seconds
:param params: Dictionary of parameters to be updated.
:return: Dictionary of active settings for fixed factor.
"""
if self.inv is None:
der.DERError('DER not initialized')
try:
if params is not None:
pf = params.get('PF')
# Configuring Grid Management Services Control with Sunny Explorer
# Cos phi (if supported by the device): Read Modbus register 30825. If the value 1075 can be read
# from this register, the power factor is specified via system control.
if pf is not None:
if pf > 0:
reg = 1042 # leading
else:
reg = 1041 # lagging
self.inv.write(40025, util.u32_to_data(int(reg)))
reg = int(abs(round(pf, 4) * 10000))
self.inv.write(40024, util.u16_to_data(int(reg)))
ena = params.get('Ena')
if ena is not None:
if ena is True:
reg = 1075 # 1075 = cos phi, specified by PV system control
# reg = 1074 # 1075 = cos phi, direct specific.
else:
reg = 303
if reg != util.data_to_u32(self.inv.read(40200, 2)):
self.inv.write(40200, util.u32_to_data(int(reg)))
else:
params = {}
reg = self.inv.read(40200, 2)
if util.data_to_u32(reg) == 1075:
params['Ena'] = True
else:
params['Ena'] = False
pf = None
params['PF'] = pf
except Exception, e:
der.DERError(str(e))
def test_run():
result = script.RESULT_FAIL
gsim = None
ts.log_debug(' ')
ts.log_debug(
'Note: Please remove the Grid Guard Code from the test configuration after '
'it has been to run to avoid exposing your Grid Guard Code to others.')
ts.log_debug(' ')
try:
ipaddr = ts.param_value('gg.ipaddr')
new_gg = ts.param_value('gg.code')
# register = ts.param_value('gg.register')
# port = ts.param_value('gg.port')
# comm_id = ts.param_value('gg.id')
register = 43090
port = 502
comm_id = 3
if not new_gg or new_gg == 'None':
raise script.ScriptFail('No Grid Guard Code specified.')
device = client.ModbusClientDeviceTCP(comm_id, ipaddr, port)
data = device.read(register, 2)
gg = util.data_to_u32(data)
ts.log('Current grid guard code: %s' % hex(gg))
if gg == 0:
ts.log('Original grid guard was not enabled')
else:
ts.log('Original grid guard was enabled')
device.write(register, util.u32_to_data(int(new_gg)))
data = device.read(register, 2)
gg = util.data_to_u32(data)
ts.log('Updated grid guard code: = %s' % hex(gg))
if gg == 0:
ts.log_warning('Current grid guard is not enabled')
result = script.RESULT_FAIL
else:
ts.log('Current grid guard is enabled')
result = script.RESULT_PASS
except script.ScriptFail, e:
reason = str(e)
if reason:
ts.log_error(reason)
def connect(self, params=None):
""" Get/set connect/disconnect function settings.
Params:
Conn - Connected (True/False)
WinTms - Randomized start time delay in seconds
RvrtTms - Reversion time in seconds
:param params: Dictionary of parameters to be updated.
:return: Dictionary of active settings for connect.
"""
if self.inv is None:
raise der.DERError('DER not initialized')
try:
if params is not None:
conn = params.get('Conn')
if conn is not None:
if conn is True:
reg = 1467 # start
else:
reg = 1749 # Full stop (AC and DC side)
# reg = 381 # Stop (AC side)
self.inv.write(40018, util.u32_to_data(int(reg)))
else:
params = {}
reg = self.inv.read(40018, 2)
if util.data_to_u32(reg) == 1467:
params['Conn'] = True
else:
params['Conn'] = False
except Exception, e:
raise der.DERError(str(e))
def measurements(self):
""" Get measurement data.
Params:
:return: Dictionary of measurement data.
"""
try:
params = {}
params['A'] = util.data_to_u32(self.inv.read(30795, 2)) / 1000.
params['AphA'] = None
params['AphB'] = None
params['AphC'] = None
params['PPVphAB'] = None
params['PPVphBC'] = None
params['PPVphCA'] = None
params['PhVphA'] = None
params['PhVphB'] = None
params['PhVphC'] = None
params['W'] = util.data_to_s32(self.inv.read(30775, 2))
params['Hz'] = util.data_to_u32(self.inv.read(30803, 2)) / 100.
params['VA'] = util.data_to_s32(self.inv.read(30813, 2))
params['VAr'] = util.data_to_s32(self.inv.read(30805, 2))
pf = util.data_to_u32(self.inv.read(30821, 2))
if util.data_to_u32(self.inv.read(30823, 2)) == 1041:
params['PF'] = -pf # 1041 = Leading
else:
params['PF'] = pf
params['WH'] = None
params['DCA'] = None
params['DCV'] = None
params['DCW'] = None
params['TmpCab'] = None
params['TmpSnk'] = None
params['TmpTrns'] = None
params['TmpOt'] = None
params['St'] = None
params['StVnd'] = None
params['Evt1'] = None
params['Evt2'] = None
params['EvtVnd1'] = None
params['EvtVnd2'] = None
params['EvtVnd3'] = None
params['EvtVnd4'] = None
except Exception, e:
raise der.DERError(str(e))
def limit_max_power(self, params=None):
""" Get/set max active power control settings.
Params:
Ena - Enabled (True/False)
WMaxPct - Active power maximum as percentage of WMax
WinTms - Randomized start time delay in seconds
RmpTms - Ramp time in seconds to updated output level
RvrtTms - Reversion time in seconds
:param params: Dictionary of parameters to be updated.
:return: Dictionary of active settings for limit max power.
"""
if self.inv is None:
raise der.DERError('DER not initialized')
##### UNTESTED ####
try:
if params is not None:
ena = params.get('Ena')
if ena is not None:
if ena is True:
self.inv.write(40151, util.u32_to_data(802))
else:
self.inv.write(40151, util.u32_to_data(803))
power = int(params.get('WMaxPct'))
self.inv.write(
40016, util.s16_to_data(int(power))
) # Active power setpoint P, in % of the maximum active power (PMAX) of the inverter
# self.inv.write(40023, util.s16_to_data(int(power))) # Normalized active power limitation by PV system ctrl, in %
# self.inv.write(40143, util.s32_to_data(int(power))) # Active power setpoint for the operating mode "Active power limitation P via PV system control" (A)
# self.inv.write(40147, util.u32_to_data(int(power))) # Generator active power limitation for the operating mode "Active power limitation P via system control" (A)
# self.inv.write(40149, util.s32_to_data(int(power))) # Active power setpoint for the operating mode "Active power limitation P via system control" (W)
else:
params = {}
if util.data_to_u32(self.inv.read(40151, 2)) == 803:
params['Ena'] = False
else:
params['Ena'] = True
params['WMaxPct'] = util.data_to_s16(self.inv.read(40016, 1))
# params['WMaxPct'] = util.data_to_s16(self.inv.read(40023, 1))
# params['WMaxPct'] = util.data_to_s32(self.inv.read(40143, 2))
# params['WMaxPct'] = util.data_to_u32(self.inv.read(40147, 2))
# params['WMaxPct'] = util.data_to_s32(self.inv.read(40149, 2))
except Exception, e:
raise der.DERError(str(e))
def gridguard(self, new_gg=None):
""" Read/Write SMA Grid Guard.
Params:
Grid Guard
:return: 0 or 1 for GG off or on.
"""
if new_gg is not None:
print('Writing new Grid Guard: %d' % new_gg)
self.inv.write(43090, util.u32_to_data(int(new_gg)))
data = self.inv.read(43090, 2)
gg = util.data_to_u32(data)
if gg == 0:
print('Grid guard was not enabled')
return False
else:
print('Grid guard was enabled')
return True
def readFrtEn():
data = device.read(0xf144, 2) # read AdvancedPwrControlEn
FrtEn = util.data_to_u32(data)
print 'FrtEn = %s' % FrtEn
return FrtEn
def readAdvancedPwrControlEn():
data = device.read(0xf142, 2) # read AdvancedPwrControlEn
AdvancedPwrControlEn = util.data_to_u32(data)
print 'AdvancedPwrControlEn = %s' % (AdvancedPwrControlEn == 1)
return (AdvancedPwrControlEn == 1)
def active_power(self, params=None):
""" Get/set active power of EUT
Params:
Ena - Enabled (True/False)
P - Active power in %Wmax (positive is exporting (discharging), negative is importing (charging) power)
WinTms - Randomized start time delay in seconds
RmpTms - Ramp time in seconds to updated output level
RvrtTms - Reversion time in seconds
:param params: Dictionary of parameters to be updated.
:return: Dictionary of active settings for HFRT control.
"""
if self.inv is None:
raise der.DERError('DER not initialized')
try:
if params is not None:
ena = params.get('Ena')
if ena is not None:
if ena is True:
# self.inv.write(40151, util.u32_to_data(802))
self.inv.write(40210, util.u32_to_data(1078))
else:
# self.inv.write(40151, util.u32_to_data(803))
self.inv.write(40210, util.u32_to_data(303))
# Operating mode of active power limitation
# 303 = Off
# 1077 = Active power limitation P in W
# 1078 = Act. power lim. as % of Pmax
# 1079 = Act. power lim. via PV system ctrl
# 1390 = Active power limitation P via analogue input
# 1391 = Active power limitation P via digital inputs
power = int(params.get('P'))
# self.inv.write(40016, util.s16_to_data(int(power))) # Active power setpoint P, in % of the maximum active power (PMAX) of the inverter
# self.inv.write(40023, util.s16_to_data(int(power))) # Normalized active power limitation by PV system ctrl, in %
# self.inv.write(40143, util.s32_to_data(int(power))) # Active power setpoint for the operating mode "Active power limitation P via PV system control" (A)
# self.inv.write(40147, util.u32_to_data(int(power))) # Generator active power limitation for the operating mode "Active power limitation P via system control" (A)
# self.inv.write(40149, util.s32_to_data(int(power))) # Active power setpoint for the operating mode "Active power limitation P via system control" (W)
# self.inv.write(40212, util.u32_to_data(int(power))) # Active power setpoint (W)
self.inv.write(40214, util.u32_to_data(
int(power))) # Active power setpoint (%)
else:
params = {}
# enabled = util.data_to_u32(self.inv.read(40151, 1)) == 803
enabled = util.data_to_u32(self.inv.read(40210, 1)) == 1078
if enabled:
params['Ena'] = False
else:
params['Ena'] = True
# params['P'] = util.data_to_s16(self.inv.read(40016, 1))
# params['P'] = util.data_to_s16(self.inv.read(40023, 1))
# params['P'] = util.data_to_s32(self.inv.read(40143, 2))
# params['P'] = util.data_to_u32(self.inv.read(40147, 2))
# params['P'] = util.data_to_s32(self.inv.read(40149, 2))
params['P'] = util.data_to_u32(self.inv.read(40214, 2))
except Exception, e:
raise der.DERError(str(e))
def reactive_power(self, params=None):
""" Set the reactive power
Params:
Ena - Enabled (True/False)
Q - Reactive power as %Qmax (positive is overexcited, negative is underexcited)
WinTms - Randomized start time delay in seconds
RmpTms - Ramp time in seconds to updated output level
RvrtTms - Reversion time in seconds
:param params: Dictionary of parameters to be updated.
:return: Dictionary of active settings for Q control.
"""
# reactive_power_dept_ref = {
# 'None': 0,
# 'WMax': 1,
# 'VArMax': 2,
# 'VArAval': 3,
# 0: 'None',
# 1: 'WMax',
# 2: 'VArMax',
# 3: 'VArAval'
# }
if self.inv is None:
raise der.DERError('DER not initialized')
##### UNTESTED ####
try:
if params is not None:
ena = params.get('Ena')
if ena is not None:
if ena is True:
# self.inv.write(40151, util.u32_to_data(802))
self.inv.write(40200, util.u32_to_data(1070))
else:
# self.inv.write(40151, util.u32_to_data(803))
self.inv.write(40200, util.u32_to_data(303)) #wanbin
var_pct_mod = params.get('VArPct_Mod')
if var_pct_mod is not None:
if var_pct_mod == 'WMax':
var_w_max_pct = int(params.get('VArWMaxPct'))
self.inv.write(40015,
util.s16_to_data(int(var_w_max_pct)))
# self.inv.write(40153, util.s32_to_data(int(var_w_max_pct)))
else:
raise der.DERError(
'DER reactive power mode not supported')
else:
params = {}
# enabled = util.data_to_u32(self.inv.read(40151, 1)) == 803
enabled = util.data_to_u32(self.inv.read(
40200, 2)) == 1070 # Reactive power Q, direct spec.
# enabled = util.data_to_u32(self.inv.read(40200, 2)) == 1071 # React. power const. Q in kvar
if enabled:
params['Ena'] = False
else:
params['Ena'] = True
params['VArPct_Mod'] = 'WMax'
params['VArWMaxPct'] = util.data_to_s16(self.inv.read(
40015, 1))
# params['VArWMaxPct'] = util.data_to_s32(self.inv.read(40153, 2))
# params['VArWMaxPct'] = util.data_to_s32(self.inv.read(40202, 2)) # Reactive power setpoint (VAr)
params['VArWMaxPct'] = util.data_to_s32(
self.inv.read(40204, 2)) # Reactive power setpoint (%)
except Exception, e:
raise der.DERError(str(e))
def volt_var_curve(self, id=1, params=None):
""" Get/set volt/var curve
v [] - List of voltage curve points
var [] - List of var curve points based on DeptRef
DeptRef - Dependent reference type: 'VAR_MAX_PCT', 'VAR_AVAL_PCT', 'VA_MAX_PCT', 'W_MAX_PCT'
RmpTms - Ramp timer
RmpDecTmm - Ramp decrement timer
RmpIncTmm - Ramp increment timer
:param params: Dictionary of parameters to be updated.
:return: Dictionary of active settings for volt/var curve control.
"""
if self.inv is None:
raise der.DERError('DER not initialized')
#x1 = range(40282, 40306, 2) # X values 1 to 12 of the characteristic curve 1
#y1 = range(40306, 40330, 2) # Y values 1 to 12 of the characteristic curve 1
x1 = [41077, 41081, 41085, 41089] #wanbin
y1 = [41079, 41083, 41087, 41091] #wanbin
'''
x2 = range(40330, 40354, 2) # X values 1 to 12 of the characteristic curve 2
y2 = range(40354, 40378, 2) # Y values 1 to 12 of the characteristic curve 2
x3 = range(40378, 40402, 2) # X values 1 to 12 of the characteristic curve 3
y3 = range(40402, 40426, 2) # Y values 1 to 12 of the characteristic curve 3
'''
volt_var_dept_ref = {
'W_MAX_PCT': 1,
'VAR_MAX_PCT': 2,
'VAR_AVAL_PCT': 3,
1: 'W_MAX_PCT',
2: 'VAR_MAX_PCT',
3: 'VAR_AVAL_PCT'
}
try:
if int(id) > 3:
raise der.DERError('Curve id out of range: %s' % id)
if params is not None:
# self.ts.log_debug('Writing VV Curve to SMA....')
# set voltage points
v = params.get('v')
if v is not None:
v_len = len(v)
# if v_len > n_pt:
# raise der.DERError('Voltage point count out of range: %d' % (v_len))
for i in xrange(v_len): # SunSpec point index starts at 1
if id == 1:
v_val = int(
util.data_to_s32(self.inv.read(x1[i],
2))) # read
self.ts.log_debug('Voltage point %s is %s' %
(i, v_val))
if int(v_val) == int(round(v[i], 3) * 1000):
self.ts.log_debug(
'V points : Skip Writing: Same setting')
else:
self.ts.log_debug(
'Writing v point %s to reg %s with value %s'
% (i, x1[i], v[i]))
self.inv.write(
x1[i],
util.s32_to_data(int(
round(v[i], 3) * 1000)))
self.ts.log_debug('Wrote V points')
'''
elif id == 2:
self.inv.write(x2[i], util.s32_to_data(int(round(v[i], 3)*1000)))
else:
self.inv.write(x3[i], util.s32_to_data(int(round(v[i], 3)*1000)))
'''
# set var points
var = params.get('var')
if var is not None:
var_len = len(var)
# if var_len > n_pt:
# raise der.DERError('VAr point count out of range: %d' % (var_len))
self.inv.write(41075, util.u32_to_data(
1977)) # Var in percentages of Pmax #wanbin
for i in xrange(
var_len): # SunSpec point index starts at 1
if id == 1:
var_val = int(
util.data_to_s32(self.inv.read(y1[i],
2))) # read
if int(var_val) == int(round(var[i], 3) * 1000):
self.ts.log_debug(
'VAR : Skip Writing: Same Setting')
else:
self.inv.write(
y1[i],
util.s32_to_data(
int(round(var[i], 3) * 1000)))
self.ts.log_debug('Wrote Var points')
'''
elif id == 2:
self.inv.write(y2[i], util.s32_to_data(int(round(var[i], 3)*1000)))
self.inv.write(40979, util.u32_to_data(1977)) # Var in percentages of Pmax
else:
self.inv.write(y3[i], util.s32_to_data(int(round(var[i], 3)*1000)))
self.inv.write(40981, util.u32_to_data(1977)) # Var in percentages of Pmax
'''
else:
self.ts.log_debug('Reading VV curve in SMA')
params = {}
v = []
var = []
if id == 1:
n_pt = int(util.data_to_u32(self.inv.read(41071,
2))) #wanbin
for i in xrange(int(4)):
self.ts.log('Getting V%s' % i)
v.append(
util.data_to_s32(self.inv.read(x1[i], 2)) / 1000.)
self.ts.log('Getting Q%s' % i)
var.append(
util.data_to_s32(self.inv.read(y1[i], 2)) / 1000.)
'''
elif id == 2:
n_pt = int(util.data_to_u32(self.inv.read(40264, 2)))
self.ts.log_debug('n_pt %s' % n_pt)
if n_pt < 1 or n_pt > 12:
raise der.DERError('Unsupported number of VV points. n_pt: %s' % n_pt)
for i in xrange(int(n_pt)):
v.append(util.data_to_s32(self.inv.read(x2[i], 2))/1000)
var.append(util.data_to_s32(self.inv.read(y2[i], 2))/1000)
else:
n_pt = int(util.data_to_u32(self.inv.read(40266, 2)))
if n_pt < 1 or n_pt > 12:
raise der.DERError('Unsupported number of VV points. n_pt: %s' % n_pt)
for i in xrange(int(n_pt)):
v.append(util.data_to_s32(self.inv.read(x3[i], 2))/1000)
var.append(util.data_to_s32(self.inv.read(y3[i], 2))/1000)
'''
dept_ref = volt_var_dept_ref.get(1) # 'W_MAX_PCT'
params['DeptRef'] = dept_ref
params['id'] = id # also store the curve number
params['v'] = v
params['var'] = var
except Exception, e:
raise der.DERError(str(e))
def volt_var(self, params=None):
""" Get/set volt/var control
Params:
Ena - Enabled (True/False)
ActCrv - Active curve number (0 - no active curve)
NCrv - Number of curves supported
NPt - Number of points supported per curve
WinTms - Randomized start time delay in seconds
RmpTms - Ramp time in seconds to updated output level
RvrtTms - Reversion time in seconds
:param params: Dictionary of parameters to be updated.
:return: Dictionary of active settings for volt/var control.
"""
if self.inv is None:
raise der.DERError('DER not initialized')
try:
if params is not None:
curve = params.get(
'curve'
) ## Must write curve first because there is a read() in volt_var_curve
act_crv = params.get('ActCrv')
if curve is not None:
self.volt_var_curve(id=act_crv, params=curve)
ena = params.get('Ena')
if ena is not None:
if ena is True:
reg = 2269 # React. power/volt. char. Q(U) #wanbin
else:
reg = 303
if reg != util.data_to_u32(self.inv.read(40200, 2)):
self.inv.write(40200, util.u32_to_data(int(reg)))
# Activation of the characteristic curve, configuration of characteristic curve mode
if ena is True:
reg = 308 # on
else:
reg = 303 # off
if reg != util.data_to_u32(self.inv.read(41063, 2)):
self.inv.write(41063, util.u32_to_data(
reg)) # Curve 1, 303 = off, 308 = on
if int(util.data_to_u32(self.inv.read(41061, 2))) != 2:
self.inv.write(41061, util.u32_to_data(
2)) # Curve 1, 303 = off, 308 = on
'''
if act_crv == 1:
if reg != util.data_to_u32(self.inv.read(40937, 2)):
self.inv.write(40937, util.u32_to_data(reg)) # Curve 1, 303 = off, 308 = on
if act_crv == 2:
if reg != util.data_to_u32(self.inv.read(40939, 2)):
self.inv.write(40939, util.u32_to_data(reg)) # Curve 2, 303 = off, 308 = on
if act_crv == 3:
if reg != util.data_to_u32(self.inv.read(40941, 2)):
self.inv.write(40941, util.u32_to_data(reg)) # Curve 3, 303 = off, 308 = on
'''
'''
if act_crv is not None:
# Characteristic curve number, configuration of the active power/voltage
# characteristic curve P(V). 0 = function is switched off.
if act_crv in [1, 2, 3]:
if act_crv != util.data_to_u32(self.inv.read(40260, 2)):
self.inv.write(40260, util.u32_to_data(act_crv))
else:
raise der.DERError('Unsupported characteristic curve number.')
else:
# Q(U) programmed into curve 2 by default
act_crv = 2
if act_crv != util.data_to_u32(self.inv.read(40260, 2)):
self.inv.write(40260, util.u32_to_data(act_crv))
'''
else:
params = {}
self.ts.sleep(1)
reg = self.inv.read(40200, 2)
if int(util.data_to_u32(reg)) == 2269:
params['Ena'] = True
else:
params['Ena'] = False
self.ts.log(util.data_to_u32(reg))
params['ActCrv'] = 2
'''
if util.data_to_u32(self.inv.read(40937, 2)) == 303:
if util.data_to_u32(self.inv.read(40977, 2)) == 1977 and \
util.data_to_u32(self.inv.read(40957, 2)) == 1976: # Voltage in %Vnom and Var in %Pmax
params['ActCrv'] = 1
elif util.data_to_u32(self.inv.read(40937, 2)) == 303:
if util.data_to_u32(self.inv.read(40979, 2)) == 1977 and \
util.data_to_u32(self.inv.read(40959, 2)) == 1976: # Voltage in %Vnom and Var in %Pmax
params['ActCrv'] = 2
elif util.data_to_u32(self.inv.read(40937, 2)) == 303:
if util.data_to_u32(self.inv.read(40981, 2)) == 1977 and \
util.data_to_u32(self.inv.read(40961, 2)) == 1976: # Voltage in %Vnom and Var in %Pmax
params['ActCrv'] = 3
else:
params['ActCrv'] = None
params['NCrv'] = 3 # SMA supports 3 curves
if params['ActCrv'] is not None:
params['curve'] = self.volt_var_curve(id=params['ActCrv'])
'''
except Exception, e:
der.DERError(str(e))
def test_data_to_u32(self):
self.assertEqual(util.data_to_u32(b'\x12\x34\x56\x78'), int(305419896))
self.assertEqual(util.data_to_u32(b'\x92\x34\x56\x78'),
int(2452903544))
def test_data_to_u32(self):
self.assertEqual(util.data_to_u32(b'\x12\x34\x56\x78'), int(305419896))
self.assertEqual(util.data_to_u32(b'\x92\x34\x56\x78'), int(2452903544))
