def validate_pin_modes(online_rtus):
logger.info("Validating pin modes...")
problem_rtus = []
#return []
# Check pin mode settings
for rtu in online_rtus:
target_rtu = rtu_comm.RTUCommunicator()
pmode_from_rtu = target_rtu.send_to_rtu(rtu.address, 80, 1, "gpm")
pmode_from_rtu = pmode_from_rtu[0:str.find(pmode_from_rtu, "{")]
pmode_from_db = ""
for db_pin_mode in sorted(rtu.pin_modes.values(),
key=operator.attrgetter('pos')):
pmode_from_db += db_pin_mode.pin
pmode_from_db += str(db_pin_mode.mode)
pin_mode_ok = True
for i in range(0, len(pmode_from_rtu) - 2):
if pmode_from_rtu[i] != pmode_from_db[i]:
pin_mode_ok = False
print "Mismatch at", i
if pin_mode_ok == False:
logger.warning("RTU " + rtu.rtuid +
" has an incongruent pin mode.")
logger.warning("RTU pins: " + pmode_from_rtu)
logger.warning("DB pins: " + pmode_from_db)
problem_rtus.append(rtu)
else:
logger.info("Pin mode congruence verified between " + rtu.rtuid +
" and the database.")
return problem_rtus
def get_asset_value(self, asset_name):
value = ""
assets = get_assets()
try:
for asset in assets:
print "!" + asset_name + "!" + "!" + asset.name + "!"
if asset_name == asset.name.lower().strip():
for rtu in self.rtus:
print rtu.rtuid, asset.rtuid
if rtu.rtuid == asset.rtuid:
try:
print 'Getting asset value', asset.name, "from", asset.rtuid
command = "env"
target_rtu = rtu_comm.RTUCommunicator()
data = target_rtu.send_to_rtu(
rtu.address, 80, 5, command)
print data
parsed_json = json.loads(data)
asset.value = parsed_json[asset.pin]
asset.timestamp = datetime.datetime.now()
print asset.name, "is", asset.value
value = str(asset.value)
except Exception, excpt:
self.logger.exception(
"Error getting asset data: %s", excpt)
except Exception, excpt:
self.logger.exception("Error getting asset data: %s", excpt)
def check_alerts(self):
assets = self.get_assets()
alert_params = get_alert_params()
self.logger.info("Checking site for alert conditions.")
print "Found", len(alert_params), "alert parameters."
try:
for alert_param in alert_params:
for asset in assets:
if alert_param.asset_id == asset.asset_id:
for rtu in self.rtus:
if rtu.rtuid == asset.rtuid:
try:
print 'Getting asset status', asset.name, "from", asset.rtuid
command = "env"
target_rtu = rtu_comm.RTUCommunicator()
data = target_rtu.send_to_rtu(rtu.address, 80, 5, command)
print data
parsed_json = json.loads(data)
asset.value = parsed_json[asset.pin]
asset.timestamp = datetime.datetime.now()
print asset.name, "is", asset.value
print "Lower Threshold is", alert_param.lower_threshold
print "Upper Threshold is", alert_param.upper_threshold
if (float(asset.value) < alert_param.lower_threshold) or (float(asset.value) > alert_param.upper_threshold):
alert = Alert()
alert.asset_id = asset.asset_id
alert.value = asset.value
log_alert_condition(alert, self.logger)
send_alert_condition(self, asset, alert, alert_param, self.logger)
except Exception, excpt:
self.logger.exception("Error getting asset data: %s", excpt)
except Exception, excpt:
self.logger.exception("Error getting asset data: %s", excpt)
def process_sequence(self, seq_jobs, job, job_rtu, seq_result):
for row in seq_jobs:
seq_result.put("Running " + row[0] + ":" + row[2] + "(" + command + ")" + " on " + job.rtuid + " at " + job_rtu.address + ".")
command = row[1].encode("ascii")
timeout = int(row[3])
target_rtu = rtu_comm.RTUCommunicator()
seq_result.put(target_rtu.send_to_rtu(job_rtu.address, 80, 10, command) + "\r\n")
seq_result.put("Sleeping for", timeout, "seconds.")
time.sleep(timeout)
def command_cmd(self, params):
'''<command to be run on connected RTU>
Sends a command to the connected RTU
'''
if the_rtu == None:
self.writeresponse("You are not connected to an RTU.")
else:
command = params[0]
self.writeresponse("Executing " + command + " on " + the_rtu.rtuid + "...")
target_rtu = rtu_comm.RTUCommunicator()
response = target_rtu.send_to_rtu(the_rtu.address, 80, 1, command)
self.writeresponse(response)
job = IntervalJob()
job.job_name = command
job.rtuid = the_rtu.rtuid
log_command(job)
def discover_rtus(self):
valid_ip_addresses = self.scan_for_rtus()
self.rtus = []
for ip_address in valid_ip_addresses:
self.logger.info("Connecting to RTU at " + ip_address)
try:
target_rtu = rtu_comm.RTUCommunicator()
response = target_rtu.send_to_rtu(ip_address, 80, 5, "sta").split('\r\n')
self.logger.info(response[0] + " at " + ip_address + " is running " + response[1])
rtu = RemoteTerminalUnit()
rtu.rtuid = response[0]
rtu.address = ip_address
rtu.version = response[1]
rtu.online = True
# get_pin_modes(rtu)
self.rtus.append(rtu)
except Exception, excpt:
self.logger.exception("Error communicating with rtu at " + ip_address + ": %s", excpt)
def command_connect(self, params):
'''<Name of RTU>
Connects to the specified RTU
'''
global the_rtu
PROMPT = "HAPI> "
rtu_name = params[0]
the_rtu = None
for rtu in site.rtus:
if rtu.rtuid.lower() == rtu_name.lower():
the_rtu = rtu
if the_rtu != None:
self.writeresponse("Connecting to " + rtu_name + "...")
target_rtu = rtu_comm.RTUCommunicator()
response = target_rtu.send_to_rtu(the_rtu.address, 80, 3, "env")
self.writeresponse(response)
else:
self.writeresponse(rtu_name + " is not online at this site.")
def set_asset_value(self, asset_name, value):
data = ""
assets = self.get_assets()
try:
for asset in assets:
print "!" + asset_name + "!" + "!" + asset.name + "!"
if asset_name == asset.name.lower().strip():
for rtu in self.rtus:
print rtu.rtuid, asset.rtuid
if rtu.rtuid == asset.rtuid:
try:
print 'Setting asset value', asset.name, "from", asset.rtuid
command = "doc" + asset.pin + value
print "set_asset_value: " + command
target_rtu = rtu_comm.RTUCommunicator()
data = target_rtu.send_to_rtu(rtu.address, 80, 5, command)
except Exception, excpt:
self.logger.exception("Error getting asset data: %s", excpt)
except Exception, excpt:
self.logger.exception("Error getting asset data: %s", excpt)
def assets_by_context(self, context):
result_assets = []
assets = get_assets()
for asset in assets:
if asset.context.lower() == context.lower():
if asset.rtuid != "virtual":
for rtu in self.rtus:
if rtu.rtuid == asset.rtuid:
try:
print 'Getting asset status', asset.name, "from", asset.rtuid
command = "env"
target_rtu = rtu_comm.RTUCommunicator()
data = target_rtu.send_to_rtu(
rtu.address, 80, 5, command)
print data
parsed_json = json.loads(data)
asset.value = parsed_json[asset.pin]
asset.timestamp = datetime.datetime.now()
print asset.name, "is", asset.value
result_assets.append(asset)
except Exception, excpt:
self.logger.exception(
"Error getting asset data: %s", excpt)
else:
# For virtual assets, assume that the data is already parsed JSON
try:
for asset in assets:
if asset.rtuid == "virtual":
if asset.abbreviation == "weather":
asset.value = float(
str(data[asset.pin]).replace("%", ""))
asset.timestamp = '"' + str(
datetime.datetime.now()) + '"'
result_assets.append(asset)
except Exception, excpt:
error = "Error getting virtual asset data: " + excpt
print error
if logger != None:
logger.exception(error)
def run_job(self, job):
if self.running == True:
command = ""
response = ""
job_rtu = None
if job.enabled == 1:
print "Job enabled"
print "Job rtuid", job.rtuid
print "Job command", job.command
print "Job sequence", job.sequence
if job.sequence is None:
job.sequence = ""
if job.rtuid.lower() == "virtual":
print 'Running on virtual RTU', job.command, "on", job.rtuid
try:
response = eval(job.command)
# if job.command != "spin":
# log_sensor_data(response, True, self.logger)
except Exception, excpt:
error = "Error running job " + job.job_name + " on " + job_rtu.rtuid + ": " + excpt
print error
if self.logger != None:
self.logger.exception(error)
else:
try:
for rtu_el in self.site.rtus:
if rtu_el.rtuid == job.rtuid:
if rtu_el.online == 1:
job_rtu = rtu_el
if (job_rtu != None):
if str.strip(job.sequence) != "":
print 'Running sequence', job.sequence, "on", job.rtuid
conn = sqlite3.connect('hapi.db')
c = conn.cursor()
seq_jobs = c.execute(
'SELECT name, command, step_name, timeout FROM sequence WHERE name = "'
+ job.sequence + '" ORDER BY step ;')
print "len(seq_jobs) = " + str(len(seq_jobs))
p = Process(target=self.process_sequence,
args=(
seq_jobs,
job,
job_rtu,
seq_result,
))
p.start()
conn.close()
else:
print 'Running command', job.command, "on", job.rtuid
command = job.command
target_rtu = rtu_comm.RTUCommunicator()
response = target_rtu.send_to_rtu(
job_rtu.address, 80, job.timeout, command)
if (job.job_name == "Log Data"):
log_sensor_data(response, False,
self.logger)
elif (job.job_name == "Log Status"):
pass
else:
log_command(job)
else:
print "Could not find rtu."
if self.logger != None:
self.logger.info("Could not find rtu " +
job.rtuid)
except Exception, excpt:
logger.exception('Error running job: %s', excpt)
