def pre_cool_setup(self, e_start, e_end):
if self.state == 'OVERRIDE':
self._log.info("Override today")
return
if self.pre_cool_idle == False:
return
now = datetime.datetime.now()
day = now.weekday()
if not schedule[day]:
self._log.info("Unoccupied today")
return
if self.state == 'PRECOOL' and self.pre_cool_idle == True:
for event in self.currently_running_dr_event_handlers:
event.cancel()
self.currently_running_dr_event_handlers = []
self.state = 'PRECOOL'
e_start_unix = time.mktime(e_start.timetuple())
e_end_unix = time.mktime(e_end.timetuple())
event_start = now + datetime.timedelta(minutes=15)
event = sched.Event(self.pre_cool_setup, args=[e_start, e_end])
self.schedule(event_start, event)
self.all_scheduled_events[e_start] = event
self.schedule_builder(e_start_unix, e_end_unix)
def handle_new(self, headers, message):
'''Send schedule request response.'''
self._log.info('handle new schedule request')
requester = headers.get('requesterID')
self.task_id = headers.get('taskID')
# priority = headers.get('priority')
requests = []
try:
requests = jsonapi.loads(message[0])
requests = requests[0]
except (ValueError, IndexError) as ex:
self._log.info('error, message not in expected format (json)')
self._log.error('bad request: {request}, {error}'
.format(request=requests, error=str(ex)))
requests = []
_, start, end = requests
self.start_time = parser.parse(start, fuzzy=True)
self.end_time = parser.parse(end, fuzzy=True)
event = sched.Event(self.announce, args=[requests, requester])
self.scheduled_event = event
self.schedule(self.start_time, event)
topic = topics.ACTUATOR_SCHEDULE_RESULT()
headers = self.get_headers(requester, task_id=self.task_id)
headers['type'] = SCHEDULE_ACTION_NEW
self.publish_json(topic, headers,
{
'result': 'SUCCESS',
'data': 'NONE',
'info': 'NONE'
})
def handle_new(self, headers, message, now):
print 'handle new'
requester = headers.get('requesterID')
self.task_id = headers.get('taskID')
# priority = headers.get('priority')
try:
requests = jsonapi.loads(message[0])
requests = requests[0]
except (ValueError, IndexError) as ex:
# Could be ValueError of JSONDecodeError depending
# on if simples json was used. JSONDecodeError
# inherits from ValueError
# We let the schedule manager tell us this is a bad request.
self._log.error('bad request: {request}, {error}'
.format(request=requests, error=str(ex)))
requests = []
device, start, end = requests
self.start_time = parser.parse(start, fuzzy=True)
self.end_time = parser.parse(end, fuzzy=True)
event = sched.Event(self.announce)
self.schedule(self.start_time, event)
topic = topics.ACTUATOR_SCHEDULE_RESULT()
headers = self.get_headers(requester, task_id=self.task_id)
headers['type'] = SCHEDULE_ACTION_NEW
self.publish_json(topic, headers,
{
'result': 'SUCCESS',
'data': 'NONE',
'info': 'NONE'
})
def announce(self, device_path, requester):
'''Emulate Actuator agent schedule announce.'''
self._log.info('announce')
now = datetime.datetime.now()
header = self.get_headers(requester,
time=str(now), task_id=self.task_id)
header['window'] = str(self.end_time - now)
topic = topics.ACTUATOR_SCHEDULE_ANNOUNCE_RAW.replace('{device}',
device_path)
self.publish_json(topic, header, {})
next_time = now + datetime.timedelta(seconds=60)
event = sched.Event(self.announce)
self.scheduled_event = event
self.schedule(next_time, event)
def get_signal(self):
"""get and format DR signal and schedule DR proc."""
time_now = time.mktime(datetime.datetime.now().timetuple())
time_pre = time.mktime(
datetime.datetime.now().replace(hour=settings.pre_cpp_hour,
minute=0,
second=0,
microsecond=0).timetuple())
time_event = time.mktime(datetime.datetime.now().replace(
hour=settings.during_cpp_hour,
minute=12,
second=0,
microsecond=0).timetuple())
time_after = time.mktime(datetime.datetime.now().replace(
hour=settings.after_cpp_hour,
minute=14,
second=0,
microsecond=0).timetuple())
if (settings.signal and time_now < time_pre):
_log.debug("Scheduling1")
time_step = settings.pre_time / 3600
#self.cooling_slope = (self.csp_norm - settings.csp_pre) / ((((time_event - time_pre) / 3600) - 0.5) * time_step)
self.cooling_slope = 1 # for testing use a constant
temp = ((time_event - time_pre) / 3600)
_log.debug("cooling slope: " + repr(self.cooling_slope))
self.schedule(time_pre, sched.Event(self._pre_cpp_timer))
self.schedule(time_event, sched.Event(self._during_cpp_timer))
after_cpp_time = datetime.datetime.now().replace(
hour=settings.after_cpp_hour,
minute=59,
second=0,
microsecond=0)
self.schedule(time_after, sched.Event(self._after_cpp_timer))
#self.start_timer.cancel()
elif (settings.signal and time_now > time_pre
and time_now < time_event):
_log.debug("Scheduling2")
#self.start_timer.cancel()
#self.accel_slope = (self.csp_norm - settings.csp_pre) / ((time_event - time_now) / (3600))
self.accel_slope = 2 #for testing use a constant
#self.cooling_slope = (self.csp_norm - settings.csp_pre) / ((((time_event - time_pre) / 3600) - 0.5) * time_step)
self.cooling_slope = 1 # for testing use a constant
self.schedule(time_event, sched.Event(self._during_cpp_timer))
self.schedule(time_after, sched.Event(self._after_cpp_timer))
self._accelerated_pre_cpp_timer()
elif (settings.signal and time_now > time_event
and time_now < time_after):
_log.debug("Too late to pre-cool!")
#self.start_timer.cancel()
self.schedule(time_after, sched.Event(self._after_cpp_timer))
self._during_cpp()
else:
_log.debug("CPP Event Is Over")
#self.start_timer.cancel()
self._sleep(60)
self.get_signal()
def scheduled_task(self):
'''
Schedule re-occuring diagnostics
'''
_log.debug('Schedule Dx')
headers = {
'type': 'NEW_SCHEDULE',
'requesterID': agent_id,
'taskID': agent_id,
'priority': 'LOW_PREEMPT'
}
min_run_hour = math.floor(min_run_window / 3600)
min_run_minute = int((min_run_window / 3600 - min_run_hour) * 60)
self.start = datetime.datetime.now().replace(hour=start_hour,
minute=start_minute)
self.end = self.start + datetime.timedelta(hours=2, minutes=30)
run_start = self.end - datetime.datetime.now()
required_diagnostic_time = datetime.timedelta(
hours=min_run_hour, minutes=min_run_minute)
if run_start < required_diagnostic_time:
self.start = self.start + datetime.timedelta(days=1)
self.end = self.start + datetime.timedelta(hours=2, minutes=30)
sched_time = datetime.datetime.now() + datetime.timedelta(
days=day_run_interval + 1)
sched_time = sched_time.replace(hour=0, minute=1)
else:
sched_time = datetime.datetime.now() + datetime.timedelta(
days=day_run_interval)
self.start = str(self.start)
self.end = str(self.end)
self.task_timer = self.periodic_timer(
60, self.publish_json, topics.ACTUATOR_SCHEDULE_REQUEST(),
headers, [[
"{campus}/{building}/{unit}".format(**rtu_path),
self.start, self.end
]])
event = sched.Event(self.scheduled_task)
self.next = self.schedule(sched_time, event)
def schedule_result(self, topic, headers, message, match):
msg = jsonapi.loads(message[0])
self._log.info('Schedule Request Acknowledged')
self.task_timer.cancel()
task_id = headers.get('taskID', 0)
response_type = headers.get('type', 0)
schedule_start = self.device_schedule[task_id]["schedule_start"]
event_start = schedule_start + datetime.timedelta(minutes=1)
schedule_end = self.device_schedule[task_id]["schedule_end"]
e_start = self.device_schedule[task_id]["event_start"]
e_end = self.device_schedule[task_id]["event_end"]
if response_type == 'NEW_SCHEDULE' and self.error_handler == None:
if msg.get('result', 0) == 'SUCCESS':
event = sched.Event(self.pre_cool_setup,
args=[e_start, e_end])
self.schedule(event_start, event)
self.all_scheduled_events[e_start] = event
elif msg.get('result',
0) == 'FAILURE' and schedule_start < schedule_end:
schedule_start = schedule_start + datetime.timedelta(
minutes=10)
headers = {
'type': 'NEW_SCHEDULE',
'requesterID': agent_id,
'taskID': task_id,
'priority': 'High'
}
self.task_timer = self.periodic_timer(
20, self.publish_json,
topics.ACTUATOR_SCHEDULE_REQUEST(), headers, [[
"{campus}/{building}/{unit}".format(**rtu_path),
str(schedule_start), schedule_end
]])
elif schedule_start >= schedule_end:
return
if self.error_handler is not None:
self.error_handler()
def get_signal(self):
#Pull signal from source
time_now=time.mktime(datetime.datetime.now().timetuple())
time_pre=time.mktime(datetime.datetime.now().replace(hour=settings.pre_cpp_hour,minute=0,second=0, microsecond=0).timetuple())
time_event=time.mktime(datetime.datetime.now().replace(hour=settings.during_cpp_hour,minute=51,second=0, microsecond=0).timetuple())
time_after=time.mktime(datetime.datetime.now().replace(hour=settings.after_cpp_hour,minute=54,second=0, microsecond=0).timetuple())
print(time_now)
print(time_event)
#PULL NORMAL COOLING SETPOINT
csp_normal=settings.csp_norm
if (settings.signal and time_now<time_pre):
print ("Scheduling")
pre_cpp_time=datetime.datetime.now().replace(hour=settings.pre_cpp_hour,minute=25,second=10, microsecond=0)
self.schedule(pre_cpp_time,sched.Event(self.pre_cpp_timer, (csp_normal,)))
during_cpp_time=datetime.datetime.now().replace(hour=settings.during_cpp_hour,minute=26,second=20, microsecond=0)
self.schedule(during_cpp_time,sched.Event(self.during_cpp))
after_cpp_time=datetime.datetime.now().replace(hour=settings.after_cpp_hour,minute=27,second=30, microsecond=0)
self.schedule(after_cpp_time,sched.Event(self.after_cpp_timer, (csp_normal,)))
self.start_timer.cancel()
elif(settings.signal and time_now>time_pre and time_now<time_event):
print("Scheduling")
self.start_timer.cancel()
pre_slope=(time_event-time_now)/(3600)
during_cpp_time=datetime.datetime.now().replace(hour=settings.during_cpp_hour,minute=46,second=20, microsecond=0)
self.schedule(during_cpp_time,sched.Event(self.during_cpp))
after_cpp_time=datetime.datetime.now().replace(hour=settings.after_cpp_hour,minute=47,second=10, microsecond=0)
self.schedule(after_cpp_time,sched.Event(self.after_cpp_timer, (csp_normal,)))
self.accelerated_pre_cooling_timer(pre_slope,csp_normal)
elif(settings.signal and time_now>time_event and time_now<time_after):
print("Too late to pre-cool!")
self.start_timer.cancel()
after_cpp_time=datetime.datetime.now().replace(hour=settings.after_cpp_hour,minute=54,second=10, microsecond=0)
self.schedule(after_cpp_time,sched.Event(self.after_cpp_timer, (csp_normal,)))
self.during_cpp()
print("CPP Event Missed")
self.setup()
def datahandler(self, topic, header, message, match):
'''Subscribes to data and assembles raw data arrays.
data_handler subscribes to a device or simulated device on the
message bus and assembles the array (lists) of data to be aggregated
for analysis.
'''
data = jsonapi.loads(message[0])
_log.info('Getting Data from message bus')
publisher_id = header.get('AgentID', 0)
if ((self.run_aggregate is False or self.run_aggregate is None)
and publisher_id != 'publisher'):
_log.info('Real-time device data.')
self.run_aggregate = True
event_time = (datetime.datetime.now().replace(
hour=0, minute=0, second=0) + datetime.timedelta(days=1))
event = sched.Event(self.process_data)
self.schedule(event_time, event)
self.oaf_raw = []
self.timestamp_raw = []
self.matemp_raw = []
self.oatemp_raw = []
self.ratemp_raw = []
self.compressor_raw = []
self.heating_raw = []
self.damper_raw = []
self.fan_status_raw = []
elif publisher_id == 'publisher':
_log.info('Simulated device data.')
if self.run_aggregate is None:
self.prev_time = dateutil.parser.parse(
data[self.timestamp_name])
self.run_aggregate = True
time = dateutil.parser.parse(data[self.timestamp_name],
fuzzy=True)
time_delta = time - self.prev_time
time_check = time + time_delta
self.timestamp_raw.append(time)
self.fan_status_raw.append(data[self.fan_status_name])
self.compressor_raw.append(data[self.coolcmd1_name])
self.heating_raw.append(data[self.heat_cmd1_name])
self.damper_raw.append(data[self.damper_name])
self.oatemp_raw.append(data[self.oat_name])
self.ratemp_raw.append(data[self.rat_name])
self.matemp_raw.append(data[self.mat_name])
if time.day < time_check.day:
self.timestamp_raw.append(time_check)
self.process_data()
self.oaf_raw = []
self.timestamp_raw = []
self.oatemp_raw = []
self.ratemp_raw = []
self.compressor_raw = []
self.heating_raw = []
self.damper_raw = []
self.fan_status_raw = []
self.prev_time = time
if publisher_id != 'publisher':
self.timestamp_raw.append(datetime.datetime.now())
self.fan_status_raw.append(data[self.fan_status_name])
self.compressor_raw.append(data[self.coolcmd1_name])
self.heating_raw.append(data[self.heat_cmd1_name])
self.damper_raw.append(data[self.damper_name])
self.oatemp_raw.append(data[self.oat_name])
self.ratemp_raw.append(data[self.rat_name])
self.matemp_raw.append(data[self.mat_name])
def schedule_builder(self, start_time, end_time, current_spacetemp,
pre_csp, building_thermal_constant,
normal_coolingstpt, timestep_length, dr_csp):
"""schedule all events for a DR event."""
print 'Scheduling all DR actions'
pre_hsp = pre_csp - 5.0
current_time = time.time()
ideal_cooling_window = int(
((current_spacetemp - pre_csp) / building_thermal_constant) *
3600)
ideal_precool_start_time = start_time - ideal_cooling_window
max_cooling_window = start_time - current_time
cooling_window = ideal_cooling_window if ideal_cooling_window < max_cooling_window else max_cooling_window
precool_start_time = start_time - cooling_window
if (max_cooling_window > 0):
print "Schedule Pre Cooling"
num_cooling_timesteps = int(
math.ceil(float(cooling_window) / float(timestep_length)))
cooling_step_delta = (normal_coolingstpt -
pre_csp) / num_cooling_timesteps
for step_index in range(1, num_cooling_timesteps + 1):
event_time = start_time - (step_index * timestep_length)
csp = pre_csp + ((step_index - 1) * cooling_step_delta)
print 'Precool step:', datetime.datetime.fromtimestamp(
event_time), csp
event = sched.Event(self.modify_temp_set_point,
args=[csp, pre_hsp])
self.schedule(event_time, event)
self.currently_running_dr_event_handlers.append(event)
else:
print "Too late to pre-cool!"
restore_window = int(
((dr_csp - normal_coolingstpt) / building_thermal_constant) *
3600)
restore_start_time = end_time
num_restore_timesteps = int(
math.ceil(float(restore_window) / float(timestep_length)))
restore_step_delta = (dr_csp -
normal_coolingstpt) / num_restore_timesteps
print 'Schedule DR Event:', datetime.datetime.fromtimestamp(
start_time), dr_csp
event = sched.Event(self.start_dr_event)
self.schedule(start_time, event)
self.currently_running_dr_event_handlers.append(event)
print 'Schedule Restore Event:', datetime.datetime.fromtimestamp(
end_time), dr_csp - restore_step_delta
event = sched.Event(
self.start_restore_event,
args=[dr_csp - restore_step_delta, self.default_heatingstpt])
self.schedule(end_time, event)
self.currently_running_dr_event_handlers.append(event)
for step_index in range(1, num_restore_timesteps):
event_time = end_time + (step_index * timestep_length)
csp = dr_csp - ((step_index + 1) * restore_step_delta)
print 'Restore step:', datetime.datetime.fromtimestamp(
event_time), csp
event = sched.Event(self.modify_temp_set_point,
args=[csp, self.default_heatingstpt])
self.schedule(event_time, event)
self.currently_running_dr_event_handlers.append(event)
event_time = end_time + (num_restore_timesteps * timestep_length)
print 'Schedule Cleanup Event:', datetime.datetime.fromtimestamp(
event_time)
event = sched.Event(self.cancel_event)
self.schedule(event_time, event)
self.currently_running_dr_event_handlers.append(event)
def _on_dr_event(self, topic, headers, message, match):
if self.state == 'STARTUP':
print "DR event ignored because of startup."
return
"""handle openADR events"""
msg = jsonapi.loads(message[0])
print('EVENT Received')
print(msg)
e_id = msg['id']
e_status = msg['status']
e_start = msg['start']
e_start = datetime.datetime.strptime(e_start, datefmt)
today = datetime.datetime.now().date()
#e_start_day = e_start.date()
#e_end = e_start.replace(hour=cpp_end_hour, minute =0, second = 0)
current_datetime = datetime.datetime.now()
e_end = e_start + datetime.timedelta(minutes=2)
if current_datetime > e_end:
print 'Too Late Event is Over'
return
if e_status == 'cancelled':
if e_start in self.all_scheduled_events:
print 'Event Cancelled'
self.all_scheduled_events[e_start].cancel()
del self.all_scheduled_events[e_start]
if e_start.date() == today and (self.state == 'PRECOOL'
or self.state == 'DR_EVENT'):
self.cancel_event()
return
#TODO: change this to UTC later
#utc_now = datetime.datetime.utcnow()
if today > e_start.date():
if e_start in self.all_scheduled_events:
self.all_scheduled_events[e_start].cancel()
del self.all_scheduled_events[e_start]
return
for item in self.all_scheduled_events.keys():
if e_start.date() == item.date():
if e_start.time() != item.time():
print "Updating Event"
self.all_scheduled_events[item].cancel()
del self.all_scheduled_events[item]
if e_start.date() == today and (self.state == 'PRECOOL'
or self.state
== 'DR_EVENT'):
self.update_running_event()
self.state = 'IDLE'
break
elif e_start.time() == item.time():
print "same event"
return
#if e_id in self.all_scheduled_dr_events and update is None:
# if e_id == self.currently_running_msg:
# return
#return
#Minutes used for testing
#event_start = e_start - datetime.timedelta(hours = max_precool_hours)
event_start = e_start - datetime.timedelta(
minutes=max_precool_hours)
event = sched.Event(self.pre_cool_get_lock, args=[e_start, e_end])
self.schedule(event_start, event)
self.all_scheduled_events[e_start] = event
def schedule_builder(self, start_time, end_time):
"""schedule all events for a DR event."""
current_time = time.time()
if current_time > end_time:
return
self._log.info('Scheduling all DR actions')
pre_hsp = self.csp_pre - 5.0
ideal_cooling_window = int(
((self.current_spacetemp - self.csp_pre) /
self.building_thermal_constant) * 3600)
ideal_precool_start_time = start_time - ideal_cooling_window
max_cooling_window = start_time - current_time
cooling_window = ideal_cooling_window if ideal_cooling_window < max_cooling_window else max_cooling_window
precool_start_time = start_time - cooling_window
pre_cool_step = 0
if (max_cooling_window > 0):
self._log.info('Schedule Pre Cooling')
num_cooling_timesteps = int(
math.ceil(
float(cooling_window) / float(self.timestep_length)))
cooling_step_delta = (self.normal_coolingstpt -
self.csp_pre) / num_cooling_timesteps
if num_cooling_timesteps <= 0:
num_cooling_timesteps = 1
for step_index in range(1, num_cooling_timesteps):
if step_index == 1:
pre_cool_step = 2 * self.timestep_length
else:
pre_cool_step += self.timestep_length
event_time = start_time - pre_cool_step
csp = self.csp_pre + (
(step_index - 1) * cooling_step_delta)
self._log.info(
'Precool step: ' +
str(datetime.datetime.fromtimestamp(event_time)) +
' CSP: ' + str(csp))
event = sched.Event(self.modify_temp_set_point,
args=[csp, pre_hsp])
self.schedule(event_time, event)
self.currently_running_dr_event_handlers.append(event)
else:
self._log.info('Too late to pre-cool!')
restore_start_time = end_time
num_restore_timesteps = int(
math.ceil(
float(self.restore_window) / float(self.timestep_length)))
restore_step_delta = (
self.csp_pre - self.normal_coolingstpt) / num_restore_timesteps
self._log.info('Schedule DR Event: ' +
str(datetime.datetime.fromtimestamp(start_time)) +
' CSP: ' + str(self.csp_cpp))
event = sched.Event(self.start_dr_event)
self.schedule(start_time, event)
self.currently_running_dr_event_handlers.append(event)
self._log.info('Schedule Restore Event: ' +
str(datetime.datetime.fromtimestamp(end_time)) +
' CSP: ' +
str(self.csp_pre - restore_step_delta))
event = sched.Event(self.start_restore_event,
args=[
self.csp_pre - restore_step_delta,
self.normal_heatingstpt
])
self.schedule(end_time, event)
self.currently_running_dr_event_handlers.append(event)
for step_index in range(1, num_restore_timesteps):
event_time = end_time + (step_index * self.timestep_length)
csp = self.csp_pre - ((step_index + 1) * restore_step_delta)
self._log.info(
'Restore step: ' +
str(datetime.datetime.fromtimestamp(event_time)) +
' CSP: ' + str(csp))
event = sched.Event(self.modify_temp_set_point,
args=[csp, self.normal_heatingstpt])
self.schedule(event_time, event)
self.currently_running_dr_event_handlers.append(event)
event_time = end_time + (num_restore_timesteps *
self.timestep_length)
self._log.info('Schedule Cleanup Event: ' +
str(datetime.datetime.fromtimestamp(event_time)))
event = sched.Event(self.cancel_event)
self.schedule(event_time, event)
self.currently_running_dr_event_handlers.append(event)
def cancel_event(self, cancel_type='NORMAL'):
if cancel_type == 'OVERRIDE':
self.state = 'OVERRIDE'
smap_input = 3.0
elif cancel_type != 'UPDATING':
self.state = 'CLEANUP'
smap_input = 2.0
self.publish(topics.ACTUATOR_SET(point=cooling_stpt, **rtu_path),
self.headers, str(self.normal_coolingstpt))
self.publish(topics.ACTUATOR_SET(point=heating_stpt, **rtu_path),
self.headers, str(self.normal_heatingstpt))
self.publish(
topics.ACTUATOR_SET(point=cooling_fan_sp1, **rtu_path),
self.headers, str(self.normal_firststage_fanspeed))
self.publish(
topics.ACTUATOR_SET(point=cooling_fan_sp2, **rtu_path),
self.headers, str(self.normal_secondstage_fanspeed))
self.publish(
topics.ACTUATOR_SET(point=min_damper_stpt, **rtu_path),
self.headers, str(self.normal_damper_stpt))
self.publish(
topics.ACTUATOR_SET(point=cooling_stage_diff, **rtu_path),
self.headers, str(self.default_cooling_stage_differential))
self.publish(topics.ACTUATOR_SET(point=volttron_flag, **rtu_path),
self.headers, str(0))
for event in self.currently_running_dr_event_handlers:
event.cancel()
if cancel_type != 'UPDATING':
mytime = int(time.time())
content = {
"Demand Response Event": {
"Readings": [[mytime, smap_input]],
"Units": "TU",
"data_type": "double"
}
}
self.publish(self.smap_path, self.headers,
jsonapi.dumps(content))
self.device_schedule = {}
self.all_scheduled_events = {}
self.currently_running_dr_event_handlers = []
def backup_run():
self.cancel_event()
self.error_handler = None
self.error_handler = backup_run
expected_values = {
cooling_stpt: self.normal_coolingstpt,
heating_stpt: self.normal_heatingstpt,
cooling_fan_sp1: self.normal_firststage_fanspeed,
cooling_fan_sp2: self.normal_secondstage_fanspeed,
min_damper_stpt: self.normal_damper_stpt,
cooling_stage_diff: self.default_cooling_stage_differential
}
EPSILON = 0.5 #allowed difference from expected value
def result_handler(point, value):
#print "actuator point being handled:", point, value
expected_value = expected_values.pop(point, None)
if expected_value is not None:
diff = abs(expected_value - value)
if diff > EPSILON:
self._log.info(
"Did not get back expected value for: " +
str(point))
if not expected_values:
self.actuator_handler = None
self.error_handler = None
self.state = 'IDLE' if not cancel_type == 'OVERRIDE' else 'OVERRIDE'
if cancel_type != 'UPDATING':
self.actuator_handler = result_handler
else:
self.actuator_handler = None
if cancel_type == 'OVERRIDE':
def on_reset():
self.error_handler = None
self.state = 'IDLE'
today = datetime.datetime.now()
reset_time = today + datetime.timedelta(days=1)
reset_time = reset_time.replace(hour=0, minute=0, second=0)
event = sched.Event(on_reset)
self.schedule(reset_time, event)
def get_signal(self):
"""get and format DR signal and schedule DR proc."""
#Pull signal from source
self.__sleep(2) #remove after testing
global csp_norm
global cooling_slope
global accel_slope
time_now = time.mktime(datetime.datetime.now().timetuple())
time_pre = time.mktime(
datetime.datetime.now().replace(hour=settings.pre_cpp_hour,
minute=23,
second=0,
microsecond=0).timetuple())
time_event = time.mktime(datetime.datetime.now().replace(
hour=settings.during_cpp_hour,
minute=25,
second=0,
microsecond=0).timetuple())
time_after = time.mktime(datetime.datetime.now().replace(
hour=settings.after_cpp_hour,
minute=27,
second=0,
microsecond=0).timetuple())
if (settings.signal and time_now < time_pre):
_log.debug("Scheduling1")
time_step = settings.pre_cooling_time / 3600
#cooling_slope = (csp_norm-settings.csp_pre)/((((time_event-time_pre)/3600)-0.5)*time_step)
cooling_slope = 1 # for testing use a constant
temp = ((time_event - time_pre) / 3600)
_log.debug("cooling slope: " + repr(cooling_slope))
pre_cpp_time = datetime.datetime.now().replace(
hour=settings.pre_cpp_hour,
minute=23,
second=0,
microsecond=0)
self.schedule(pre_cpp_time, sched.Event(self.__pre_cpp_timer))
during_cpp_time = datetime.datetime.now().replace(
hour=settings.during_cpp_hour,
minute=25,
second=0,
microsecond=0)
self.schedule(during_cpp_time,
sched.Event(self.__during_cpp_timer))
after_cpp_time = datetime.datetime.now().replace(
hour=settings.after_cpp_hour,
minute=27,
second=0,
microsecond=0)
self.schedule(after_cpp_time,
sched.Event(self.__after_cpp_timer))
#self.start_timer.cancel()
elif (settings.signal and time_now > time_pre
and time_now < time_event):
_log.debug("Scheduling2")
#self.start_timer.cancel()
#accel_slope = (csp_norm-settings.csp_pre)/((time_event-time_now)/(3600))
accel_slope = 2 #for testing use a constant
during_cpp_time = datetime.datetime.now().replace(
hour=settings.during_cpp_hour,
minute=36,
second=20,
microsecond=0)
self.schedule(during_cpp_time,
sched.Event(self.__during_cpp_timer))
after_cpp_time = datetime.datetime.now().replace(
hour=settings.after_cpp_hour,
minute=39,
second=10,
microsecond=0)
self.schedule(after_cpp_time,
sched.Event(self.__after_cpp_timer))
self.__accelerated_pre_cpp_timer()
elif (settings.signal and time_now > time_event
and time_now < time_after):
_log.debug("Too late to pre-cool!")
#self.start_timer.cancel()
after_cpp_time = datetime.datetime.now().replace(
hour=settings.after_cpp_hour,
minute=17,
second=0,
microsecond=0)
self.schedule(after_cpp_time,
sched.Event(self.__after_cpp_timer))
self.tasklet = greenlet.greenlet(self.__during_cpp)
self.tasklet.switch()
else:
_log.debug("CPP Event Is Over")
#self.start_timer.cancel()
self.__sleep(60)
self.get_signal()
