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()