class TimedTimelapse(Timelapse): def __init__(self, post_roll=0, interval=1, fps=25): Timelapse.__init__(self, post_roll=post_roll, fps=fps) self._interval = interval if self._interval < 1: self._interval = 1 # force minimum interval of 1s self._postroll_captures = 0 self._timer = None self._logger.debug("TimedTimelapse initialized") @property def interval(self): return self._interval def config_data(self): return { "type": "timed", "options": { "interval": self._interval } } def on_print_started(self, event, payload): Timelapse.on_print_started(self, event, payload) if self._timer is not None: return self._logger.debug("Starting timer for interval based timelapse") from octoprint.util import RepeatedTimer self._timer = RepeatedTimer(self._interval, self._timer_task, run_first=True, condition=self._timer_active, on_finish=self._on_timer_finished) self._timer.start() def on_print_done(self, event, payload): self._postroll_captures = self.post_roll * self.fps Timelapse.on_print_done(self, event, payload) def calculate_post_roll(self): return self.post_roll * self.fps * self.interval def process_post_roll(self): pass def post_roll_finished(self): Timelapse.post_roll_finished(self) self._timer = None def _timer_active(self): return self._in_timelapse or self._postroll_captures > 0 def _timer_task(self): self.captureImage() if self._postroll_captures > 0: self._postroll_captures -= 1 def _on_timer_finished(self): self.post_roll_finished()
def test_condition(self): countdown = Countdown(5) timer_task = mock.MagicMock() timer_task.side_effect = countdown.step timer = RepeatedTimer(0.1, timer_task, condition=lambda: countdown.counter > 0) timer.start() # wait for it timer.join() self.assertEqual(5, timer_task.call_count)
def start_timer(self, interval, event_timer_interval): self._readPiPowerValuesTimer = RepeatedTimer(interval, self.getPiPowerValues, None, None, True) self._readPiPowerValuesTimer.start() self._logger.info("Started timer. Interval: {0}s".format(interval)) self._publishPiPowerValuesTimer = RepeatedTimer( event_timer_interval, self.publish_pi_power_event, None, None, True) self._publishPiPowerValuesTimer.start() self._logger.info( "Started event publisher timer. Interval: {0}s".format( event_timer_interval))
def test_finished_callback(self): countdown = Countdown(5) timer_task = mock.MagicMock() timer_task.side_effect = countdown.step on_finished = mock.MagicMock() timer = RepeatedTimer(0.1, timer_task, condition=lambda: countdown.counter > 0, on_finish=on_finished) timer.start() # wait for it timer.join() self.assertEqual(1, on_finished.call_count)
def start_repeated_timer(self, timer=None, callback=None): try: if timer is None and callback is not None: self._logger.debug("creating repeated timer") timer = RepeatedTimer( self.polling_interval, callback, run_first=True, condition=self._continue_polling, on_condition_false=self._polling_canceled) timer.start() return True, timer except Exception: return False, timer
def _restart_timer(self): # stop the timer if self._checkTempTimer: self._logger.debug(u"Stopping Timer...") self._checkTempTimer.cancel() self._checkTempTimer = None # start a new timer interval = self._settings.get_int(['temp_interval']) if interval: self._logger.debug(u"Starting Timer...") self._checkTempTimer = RepeatedTimer(interval, self.run_timer_job, None, None, True) self._checkTempTimer.start()
def _restartTimer(self): # stop the timer if self._checkTempTimer: self._logger.debug(u"Stopping Timer...") self._checkTempTimer.cancel() self._checkTempTimer = None # start a new timer interval = self._settings.get_int(['interval']) if self._settings.get_boolean(['enabled']) and interval: self._logger.debug(u"Starting Timer...") self._checkTempTimer = RepeatedTimer(interval, self.CheckTemps, None, None, True) self._checkTempTimer.start()
def test_cancelled_callback(self): countdown = Countdown(5) timer_task = mock.MagicMock() timer_task.side_effect = countdown.step on_cancelled = mock.MagicMock() on_condition_false = mock.MagicMock() timer = RepeatedTimer( 10, timer_task, condition=lambda: countdown.counter > 0, on_condition_false=on_condition_false, on_cancelled=on_cancelled, ) timer.start() # give it some time to run time.sleep(1) # then cancel it and wait for the thread to really finish timer.cancel() timer.join() self.assertEqual(0, on_condition_false.call_count) self.assertEqual(1, on_cancelled.call_count)
def startPrint(self, pos=None): """ Starts the printing operation :param pos: if the string 'memory' is passed the printer will print the last file in the printer's memory """ if not self.isOperational() or self.isPrinting(): return if self._currentFile is None and pos is None: raise ValueError("No file selected for printing") try: self._changeState(self.STATE_PREPARING_PRINT) if self.isSdFileSelected(): print_resp = self._beeCommands.startSDPrint(self._currentFile.getFilename()) if print_resp: self._sd_status_timer = RepeatedTimer(self._timeout_intervals.get("sdStatus", 1.0), self._poll_sd_status, run_first=True) self._sd_status_timer.start() elif pos == 'from_memory': print_resp = self._beeCommands.repeatLastPrint() else: print_resp = self._beeCommands.printFile(self._currentFile.getFilename()) if print_resp is True: self._heatupWaitStartTime = time.time() self._heatupWaitTimeLost = 0.0 self._pauseWaitStartTime = 0 self._pauseWaitTimeLost = 0.0 self._heating = True self._preparing_print = True self._prepare_print_thread = threading.Thread(target=self._preparePrintThread, name="comm._preparePrint") self._prepare_print_thread.daemon = True self._prepare_print_thread.start() else: self._errorValue = "Error while preparing the printing operation." self._logger.exception(self._errorValue) self._changeState(self.STATE_ERROR) eventManager().fire(Events.ERROR, {"error": self.getErrorString()}) return except: self._errorValue = get_exception_string() self._logger.exception("Error while trying to start printing: " + self.getErrorString()) self._changeState(self.STATE_ERROR) eventManager().fire(Events.ERROR, {"error": self.getErrorString()})
def _restart_timer(self): # stop the timer if self._updateStatusTimer: self._logger.info(u"Stopping Timer...") self._updateStatusTimer.cancel() self.updateStatusTimer = None # start a new timer interval = self._settings.get_int(['update_settings_interval']) if interval: self._logger.info(u"Starting Timer...") self._updateStatusTimer = RepeatedTimer(interval, self.run_timer_job, None, None, True) self._updateStatusTimer.start()
def on_event(self, event, payload): if event != Events.PRINT_DONE: return if not self._automatic_shutdown_enabled or not self._settings.global_get( ["server", "commands", "systemShutdownCommand"]): return if self._timer is not None: return self._timeout_value = 10 self._timer = RepeatedTimer(1, self._timer_task) self._timer.start() self._plugin_manager.send_plugin_message( self._identifier, dict(type="timeout", timeout_value=self._timeout_value))
def on_startup(self, *args, **kwargs): if self._settings.get_boolean(["vcgencmd_throttle_check_enabled"]): self._check_throttled_state() self._throttle_check = RepeatedTimer(self._check_throttled_state_interval, self._check_throttled_state, condition=self._check_throttled_state_condition) self._throttle_check.start()
def on_after_startup(self): ''' Upon server startup, we define the class variables and create our initial timer that constantly checks to see if a safety timeout is needed ''' self.countdowndefined = False self.initialstart = True self.initial = int(self._settings.get(["Time"])) self.timer = RepeatedTimer(1.0, self.condition, run_first=True) self.timer.start()
def __init__(self, logger, settings, event_bus): self._logger = logger self._settings = settings self._event_bus = event_bus self._left_button_pin = 26 self._left_led_pin = 16 self._right_button_pin = 21 self._right_led_pin = 20 self._im_alive_pin = 11 self._left_led_mode = 0 self._right_led_mode = 0 self._leds_flash_on = False self._timer = RepeatedTimer(0.25, self.timer_tick, None, None, True) self._timer.start()
def on_event(self, event, payload): if event == octoprint.events.Events.CONNECTED: self._logger.info('Printer connected') self.connected = True t = RepeatedTimer(5.0, self.send_M407_command, run_first=True, condition=self.timer_condition) t.start() elif event == octoprint.events.Events.PRINT_STARTED: self._logger.info('print started') elif event == octoprint.events.Events.PRINT_DONE: self._logger.info('print done') elif event == octoprint.events.Events.PRINT_FAILED or event == octoprint.events.Events.PRINT_CANCELLED: #self.connected = False self._logger.info('print failed or canceled') elif event == octoprint.events.Events.DISCONNECTED: self.connected = False self._logger.info('Printer disconnected')
def __init__(self, logger, settings, event_bus): self._logger = logger self._settings = settings self._event_bus = event_bus self._left_button_pin = 26 self._left_led_pin = 16 self._right_button_pin = 21 self._right_led_pin = 20 self._im_alive_pin = 11 self._left_led_mode = 0 self._right_led_mode = 0 self._both_puttons_pressed = False self._leds_flash_on = True self._timer = RepeatedTimer(0.25, self.timer_tick)
def on_print_started(self, event, payload): Timelapse.on_print_started(self, event, payload) if self._timer is not None: return self._logger.debug("Starting timer for interval based timelapse") from octoprint.util import RepeatedTimer self._timer = RepeatedTimer( self._interval, self._timer_task, run_first=True, condition=self._timer_active, on_finish=self._on_timer_finished, ) self._timer.start()
def connect(self, port=None, baudrate=None): if port == None: port = settings().get(["serial", "port"]) if baudrate == None: settings_baudrate = settings().getInt(["serial", "baudrate"]) if settings_baudrate is None: baudrate = 0 else: baudrate = settings_baudrate self._port = port self._baudrate = baudrate self._printer_uri = self._get_or_create_printer(port, baudrate) self._authentise_process = helpers.run_client(self._settings) #pylint: disable=no-member # monitoring thread self._monitoring_active = True self.monitoring_thread = threading.Thread(target=self._monitor_loop, name="comm._monitor") self.monitoring_thread.daemon = True self.monitoring_thread.start() self._printer_status_timer = RepeatedTimer( lambda: comm_helpers.get_interval("temperature", default_value=10.0), self._update_printer_data, run_first=True ) self._printer_status_timer.start() self._change_state(PRINTER_STATE['CONNECTING'])
def _start_periodic_timer(self, poll_period, num_offline): self._logger.info( "Starting connection polling timer at %r sec interval, reconnect after %r conseq. offline indications." % (poll_period, num_offline)) # Init the count of the number of consecutive printer offline states seen. self._consec_offline = 0 # If we have a polling period configured, then start up our # periodic checks of the serial connection. if (poll_period > 0): self._poll_timer = RepeatedTimer(poll_period, self._check_connection, (num_offline, ), run_first=True) self._poll_timer.start()
class TimedTimelapse(Timelapse): def __init__(self, interval=1, post_roll=0, fps=25): Timelapse.__init__(self, post_roll=post_roll, fps=fps) self._interval = interval if self._interval < 1: self._interval = 1 # force minimum interval of 1s self._timer = None self._logger.debug("TimedTimelapse initialized") @property def interval(self): return self._interval def config_data(self): return { "type": "timed", "options": { "interval": self._interval } } def on_print_started(self, event, payload): Timelapse.on_print_started(self, event, payload) if self._timer is not None: return self._logger.debug("Starting timer for interval based timelapse") from octoprint.util import RepeatedTimer self._timer = RepeatedTimer(self._interval, self._timer_task, run_first=True, condition=self._timer_active, on_finish=self._on_timer_finished) self._timer.start() def process_post_roll(self): # we only use the final image as post roll self._copying_postroll() self.post_roll_finished() def _timer_active(self): return self._in_timelapse def _timer_task(self): self.capture_image() def _on_timer_finished(self): # timer is done, delete it self._timer = None
class TimedTimelapse(Timelapse): def __init__(self, interval=1, post_roll=0, fps=25): Timelapse.__init__(self, post_roll=post_roll, fps=fps) self._interval = interval if self._interval < 1: self._interval = 1 # force minimum interval of 1s self._timer = None self._logger.debug("TimedTimelapse initialized") @property def interval(self): return self._interval def config_data(self): return {"type": "timed", "options": {"interval": self._interval}} def on_print_started(self, event, payload): Timelapse.on_print_started(self, event, payload) if self._timer is not None: return self._logger.debug("Starting timer for interval based timelapse") from octoprint.util import RepeatedTimer self._timer = RepeatedTimer( self._interval, self._timer_task, run_first=True, condition=self._timer_active, on_finish=self._on_timer_finished, ) self._timer.start() def process_post_roll(self): # we only use the final image as post roll self._copying_postroll() self.post_roll_finished() def _timer_active(self): return self._in_timelapse def _timer_task(self): self.capture_image() def _on_timer_finished(self): # timer is done, delete it self._timer = None
def _temperature_target(self): if self._abort_timer_temp is not None: # self._logger.info("_abort_timer_temp_destroyNotif") self._destroyNotif() return if self._abort_all_for_this_session == True or self.forcedAbort == True: # self._logger.info("_abort_all_for_this_session_destroyNotif") if self._abort_timer_temp is not None: self._abort_timer_temp.cancel() self._abort_timer_temp = None self._destroyNotif() return if self.temperatureTarget: self._abort_timer_temp = RepeatedTimer(2, self._temperature_task) self._abort_timer_temp.start() else: self._timer_start()
def updateCmds(self): for timer in self.cmd_timers: timer.cancel() del self.cmd_timers[:] index = 0 for command in self.cmd_commands: if (command.get("enabled")): t = RepeatedTimer(float(command.get("interval")), self.runCmd, [index], run_first=True) t.start() self.cmd_timers.append(t) index += 1
def on_settings_initialized(self): self.GPIOMode = self._settings.get(["GPIOMode"]) self._logger.debug("GPIOMode: %s" % self.GPIOMode) self.switchingMethod = self._settings.get(["switchingMethod"]) self._logger.debug("switchingMethod: %s" % self.switchingMethod) self.onoffGPIOPin = self._settings.get_int(["onoffGPIOPin"]) self._logger.debug("onoffGPIOPin: %s" % self.onoffGPIOPin) self.invertonoffGPIOPin = self._settings.get_boolean(["invertonoffGPIOPin"]) self._logger.debug("invertonoffGPIOPin: %s" % self.invertonoffGPIOPin) self._configure_gpio() self._checkFanTimer = RepeatedTimer(5.0, self.check_fan_state, None, None, True) self._checkFanTimer.start()
def on_event(self, event, payload): if event.startswith('Print'): if event not in {"PrintStarted", "PrintResumed"}: self.eta_string = "-" self.timer.cancel() else: self.eta_string = self.calculate_ETA() self.timer.cancel() self.timer = RepeatedTimer( 10.0, DisplayETAPlugin.fromTimer, args=[self], run_first=True, ) self.timer.start() self._plugin_manager.send_plugin_message( self._identifier, dict(eta_string=self.eta_string))
def initialize(self): # if the following returns None it makes no sense to create the # timer and fail every second if self.get_raspberry_core_temperature() is not None: self.timer = RepeatedTimer(1.0, self.report_raspberry_core_temperature) self.timer.start() else: self._logger.error('Failed to execute "sudo /usr/bin/vcgencmd"') self._logger.error( 'Raspberry core temperature will not be reported') self.parser = Gcode_parser() self.last_extrusion_counter = 0 self.print_progress_label = '' self.print_completion_timer = None self.print_time_start = 0 self.print_time_end = 0
def _onConnected(self): """ Post connection callback """ # starts the connection monitor thread self._beeConn.startConnectionMonitor() self._temperature_timer = RepeatedTimer(self._timeout_intervals.get("temperature", 4.0), self._poll_temperature, run_first=True) self._temperature_timer.start() if self._sdAvailable: self.refreshSdFiles() else: self.initSdCard() payload = dict(port=self._port, baudrate=self._baudrate) eventManager().fire(Events.CONNECTED, payload)
def _timer_start(self): if self._abort_timer is not None: self._destroyNotif() return if self._abort_all_for_this_session == True: if self._abort_timer is not None: self._abort_timer.cancel() self._abort_timer = None if self._abort_timer_temp is not None: self._abort_timer_temp.cancel() self._abort_timer_temp = None self._destroyNotif() return self._logger.info("Starting abort shutdown printer timer.") self._timeout_value = self.abortTimeout self._abort_timer = RepeatedTimer(1, self._timer_task) self._abort_timer.start()
def _start_tracking(self): if not self._settings.get_boolean(["enabled"]): return if self._ping_worker is None: ping = self._settings.get_int(["ping"]) if ping: self._ping_worker = RepeatedTimer(ping, self._track_ping, run_first=True) self._ping_worker.start() if self._helpers_get_throttle_state is None: # cautiously look for the get_throttled helper from pi_support pi_helper = self._plugin_manager.get_helpers("pi_support", "get_throttled") if pi_helper and 'get_throttled' in pi_helper: self._helpers_get_throttle_state = pi_helper['get_throttled'] # now that we have everything set up, phone home. self._track_startup()
def _gcode_M27(self, data): def report(): if self._sdCardReady: self._reportSdStatus() match = re.search("S([0-9]+)", data) if match: interval = int(match.group(1)) if self._sdstatus_reporter is not None: self._sdstatus_reporter.cancel() if interval > 0: self._sdstatus_reporter = RepeatedTimer(interval, report) self._sdstatus_reporter.start() else: self._sdstatus_reporter = None report()
def updateCmds(self): self.cmd_commands = self._settings.get(["commandWidgetArray"]) for timer in self.cmd_timers: timer.cancel() del self.cmd_timers[:] if self._settings.get_boolean(['showCommandWidgets']): index = 0 for command in self.cmd_commands: if command.get("enabled"): t = RepeatedTimer(float(command.get("interval")), self.runCmd, [index], run_first=True) t.start() self.cmd_timers.append(t) index += 1
def on_settings_save(self, data): if noAccessPermissions == False and Permissions.PLUGIN_DASHBOARD_ADMIN.can() == False: try: del data['commandWidgetArray'] except: pass octoprint.plugin.SettingsPlugin.on_settings_save(self, data) self.cmd_commands = self._settings.get(["commandWidgetArray"]) self.updateCmds() if self.psuTimer: self.psuTimer.cancel() if self._settings.get_boolean(["showSystemInfo"]): self.psuTimer = RepeatedTimer(3.0, self.psUtilGetStats) self.psuTimer.daemon = True self.psuTimer.start()
def makeTimer (self): ''' This function creates a timer instance by grabbing the most recent user specified time''' self.countdowndefined = True self.initial = int(self._settings.get(["Time"])) self._logger.info("The Timer Has Been Initiated!") seconds = self.initial * 60 self.countdown = RepeatedTimer(seconds, self.shutdown, run_first=False) self.initialstart = False self.countdown.start()
def _gcode_M155(self, data): interval = int(re.search("S([0-9]+)", data).group(1)) if self._temperature_reporter is not None: self._temperature_reporter.cancel() if interval > 0: self._temperature_reporter = RepeatedTimer(interval, lambda: self._send(self._generateTemperatureOutput())) self._temperature_reporter.start() else: self._temperature_reporter = None
def test_adjusted_interval(self): increasing_interval = IncreasingInterval(3, 1) timer_task = mock.MagicMock() timer_task.side_effect = increasing_interval.step timer = RepeatedTimer(increasing_interval.interval, timer_task, condition=lambda: increasing_interval.counter > 0) # this should take 1 + 2 + 3 = 6s start_time = time.time() timer.start() timer.join() duration = time.time() - start_time self.assertEqual(3, timer_task.call_count) self.assertGreaterEqual(duration, 6) self.assertLess(duration, 7)
def on_event(self, event, payload): if event not in ("Startup", "SettingsUpdated", "PrintFailed", "PrintDone"): return if self._settings.get_boolean(["daily", "enabled"]) or self._settings.get_boolean( ["weekly", "enabled"]) or self._settings.get_boolean(["monthly", "enabled"]): if event == "Startup": self.current_settings = {"daily": self._settings.get(["daily"]), "weekly": self._settings.get(["weekly"]), "monthly": self._settings.get(["monthly"])} backups_enabled = False self._logger.debug("Clearing scheduled jobs.") schedule.clear("backupscheduler") if self._settings.get_boolean(["daily", "enabled"]) and self._settings.get(["daily", "time"]) != "": backups_enabled = True self._logger.debug("Scheduling daily backup for %s." % self._settings.get(["daily", "time"])) schedule.every().day.at(self._settings.get(["daily", "time"])).do(self._perform_backup, backup_type="daily_backups").tag( "backupscheduler") if self._settings.get_boolean(["weekly", "enabled"]) and self._settings.get(["weekly", "time"]) != "": backups_enabled = True self._logger.debug("Scheduling weekly backup for %s." % self._settings.get(["weekly", "time"])) schedule.every().day.at(self._settings.get(["weekly", "time"])).do(self._perform_backup, backup_type="weekly_backups").tag( "backupscheduler") if self._settings.get_boolean(["monthly", "enabled"]) and self._settings.get(["monthly", "time"]) != "": backups_enabled = True self._logger.debug("Scheduling monthly backup for %s." % self._settings.get(["monthly", "time"])) schedule.every().day.at(self._settings.get(["monthly", "time"])).do(self._perform_backup, backup_type="monthly_backups").tag( "backupscheduler") if not self._repeatedtimer and backups_enabled is True: self._repeatedtimer = RepeatedTimer(60, schedule.run_pending) self._repeatedtimer.start() if event == "SettingsUpdated": if self.current_settings != {"daily": self._settings.get(["daily"]), "weekly": self._settings.get(["weekly"]), "monthly": self._settings.get(["monthly"])}: self._logger.debug("Settings updated.") self.on_event("Startup", {}) if event in ("PrintFailed", "PrintDone") and self.backup_pending is True: for backup in self.backup_pending_type: self._logger.debug("Starting {} after print completion.".format(backup)) self._perform_backup(backup_type=backup)
def createTimer(self, indx, interval, cmd, cmdtype): if indx in self.timers: self.debugOut("Stopping timer: " + indx) self.timers[indx].cancel() self.debugOut("Setting up custom timer for \"" + cmd + "(" + indx + " / " + cmdtype + ") running each " + str(interval) + " seconds") if cmdtype == "cmd": self.timers[indx] = RepeatedTimer(interval, self.runCustomMon, run_first=True, args=[indx, cmd]) else: self.timers[indx] = RepeatedTimer(interval, self.runPSUtil, run_first=True, args=[indx, cmd]) self.timers[indx].start()
def on_settings_save(self, data): old_debug_logging = self._settings.get_boolean(["debug_logging"]) old_polling_value = self._settings.get_boolean(["pollingEnabled"]) old_polling_timer = self._settings.get(["pollingInterval"]) old_powerOffWhenIdle = self._settings.get_boolean(["powerOffWhenIdle"]) old_idleTimeout = self._settings.get_int(["idleTimeout"]) old_idleIgnoreCommands = self._settings.get(["idleIgnoreCommands"]) old_idleTimeoutWaitTemp = self._settings.get_int(["idleTimeoutWaitTemp"]) octoprint.plugin.SettingsPlugin.on_settings_save(self, data) self.abortTimeout = self._settings.get_int(["abortTimeout"]) self.powerOffWhenIdle = self._settings.get_boolean(["powerOffWhenIdle"]) self.idleTimeout = self._settings.get_int(["idleTimeout"]) self.idleIgnoreCommands = self._settings.get(["idleIgnoreCommands"]) self._idleIgnoreCommandsArray = self.idleIgnoreCommands.split(',') self.idleTimeoutWaitTemp = self._settings.get_int(["idleTimeoutWaitTemp"]) if self.powerOffWhenIdle != old_powerOffWhenIdle: self._plugin_manager.send_plugin_message(self._identifier, dict(powerOffWhenIdle=self.powerOffWhenIdle, type="timeout", timeout_value=self._timeout_value)) if self.powerOffWhenIdle == True: self._tplinksmartplug_logger.debug("Settings saved, Automatic Power Off Endabled, starting idle timer...") self._start_idle_timer() new_debug_logging = self._settings.get_boolean(["debug_logging"]) new_polling_value = self._settings.get_boolean(["pollingEnabled"]) new_polling_timer = self._settings.get(["pollingInterval"]) if old_debug_logging != new_debug_logging: if new_debug_logging: self._tplinksmartplug_logger.setLevel(logging.DEBUG) else: self._tplinksmartplug_logger.setLevel(logging.INFO) if old_polling_value != new_polling_value or old_polling_timer != new_polling_timer: if self.poll_status: self.poll_status.cancel() if new_polling_value: self.poll_status = RepeatedTimer(int(self._settings.get(["pollingInterval"]))*60, self.check_statuses) self.poll_status.start()
def _start_auto_power_off_timer(self): self._timeout_value = self._settings.get_int(['timer_seconds']) if (self._timeout_value < 30) | (self._timeout_value > 1800): self._timeout_value = 600 self._logger.debug("Automatic Printer Power-off started: {} seconds.".format(self._timeout_value)) self._set_status_LED("POWERINGOFF") self._timer = RepeatedTimer(1, self._timer_task) self._timer.start() self._plugin_manager.send_plugin_message(self._identifier, dict(type="timeout", timeout_value=self._timeout_value))
def on_after_startup(self): self._firmware_plugin = self._plugin_manager.get_plugin_info( "firmwareupdate") self._automation_plugin = self._plugin_manager.get_plugin_info( "automation_scripts") self._enabled = self._settings.get_boolean(["enabled"]) self._timer = RepeatedTimer( 1.0, self._check_connection, run_first=True) self._timer.start()
def on_event(self,event, payload): _logger.debug('on_event called') _logger.debug('event is') _logger.debug(event) if event.startswith('Print'): _logger.debug('event starts with Print') if event not in {"PrintStarted","PrintResumed"}: self.eta_string="-" self.timer.cancel() _logger.debug('event is not equal to PrintStarted or PrintResumed.') else: _logger.debug('event is equal to PrintStarted or PrintResumed. Calling calculate_ETA') global CustomTimeFormat global doM117 global replaceColons value1 = self._settings.get(["time24hr"]) if (value1 == True): _logger.debug('24HR = True') CustomTimeFormat = "HH:mm:ss" else: _logger.debug('24HR = False') CustomTimeFormat = "hh:mm:ss a" ## See http://babel.pocoo.org/en/latest/dates.html#time-fields for details on the time format value2 = self._settings.get(["displayOnPrinter"]) if (value2 == True): _logger.debug('M117 = True') doM117 = True else: doM117 = False _logger.debug('M117 = False') value3 = self._settings.get(["removeColons"]) if (value3 == True): replaceColons = True _logger.debug('replaceColons = True') else: replaceColons = False self.eta_string = self.calculate_ETA() self.timer.cancel() self.timer = RepeatedTimer(10.0, DisplayETAPlugin.fromTimer, args=[self], run_first=True,) self.timer.start() self._plugin_manager.send_plugin_message(self._identifier, dict(eta_string=self.eta_string)) _logger.debug('reached end of on_event')
def on_print_started(self, event, payload): Timelapse.on_print_started(self, event, payload) if self._timer is not None: return self._logger.debug("Starting timer for interval based timelapse") from octoprint.util import RepeatedTimer self._timer = RepeatedTimer(self._interval, self._timer_task, run_first=True, condition=self._timer_active, on_finish=self._on_timer_finished) self._timer.start()
def on_event(self, event, payload): if event != "SlicingDone": return if not self._automatic_shutdown_enabled or not self._settings.global_get(["server", "commands", "systemShutdownCommand"]): return if self._timer is not None: return self._timeout_value = 10 self._timer = RepeatedTimer(1, self._timer_task) self._timer.start() self._plugin_manager.send_plugin_message(self._identifier, dict(type="timeout", timeout_value=self._timeout_value))
def _run(self): from octoprint.util import RepeatedTimer if not self._enabled: return if self._check_worker is not None: self._check_worker.cancel() self._check_worker = RepeatedTimer(self._interval, self._perform_check, run_first=True) self._check_worker.start()
def on_after_startup(self): self._logger.info("TPLinkSmartplug loaded!") if self._settings.get(["pollingEnabled"]): self.poll_status = RepeatedTimer(int(self._settings.get(["pollingInterval"]))*60, self.check_statuses) self.poll_status.start() self.abortTimeout = self._settings.get_int(["abortTimeout"]) self._tplinksmartplug_logger.debug("abortTimeout: %s" % self.abortTimeout) self.powerOffWhenIdle = self._settings.get_boolean(["powerOffWhenIdle"]) self._tplinksmartplug_logger.debug("powerOffWhenIdle: %s" % self.powerOffWhenIdle) self.idleTimeout = self._settings.get_int(["idleTimeout"]) self._tplinksmartplug_logger.debug("idleTimeout: %s" % self.idleTimeout) self.idleIgnoreCommands = self._settings.get(["idleIgnoreCommands"]) self._idleIgnoreCommandsArray = self.idleIgnoreCommands.split(',') self._tplinksmartplug_logger.debug("idleIgnoreCommands: %s" % self.idleIgnoreCommands) self.idleTimeoutWaitTemp = self._settings.get_int(["idleTimeoutWaitTemp"]) self._tplinksmartplug_logger.debug("idleTimeoutWaitTemp: %s" % self.idleTimeoutWaitTemp) self._reset_idle_timer()
def test_not_run_first(self): timer_task = mock.MagicMock() timer = RepeatedTimer(60, timer_task) timer.start() # give it some time to run - should hang in the sleep phase though time.sleep(1) # then cancel it and wait for the thread to really finish timer.cancel() timer.join() self.assertEqual(0, timer_task.call_count)
def on_after_startup(self): ping = self._settings.get_int(["ping"]) if ping: self._ping_worker = RepeatedTimer(ping, self._track_ping) self._ping_worker.start() # cautiously look for the get_throttled helper from pi_support pi_helper = self._plugin_manager.get_helpers("pi_support", "get_throttled") if pi_helper and 'get_throttled' in pi_helper: self._helpers_get_throttle_state = pi_helper['get_throttled'] # now that we have everything set up, phone home. self._track_startup()
class FinishedJobControlClass(octoprint.plugin.StartupPlugin): def on_after_startup(self): # self._logger.info("Started Timer...") self.startTimer(10.0) def startTimer(self, interval): self._checkTempTimer = RepeatedTimer(interval, self.checkHotEndTemp, None, None, True) self._checkTempTimer.start() def checkHotEndTemp(self): druckerDrucktGerade = self._printer.is_printing() if not druckerDrucktGerade: # self._logger.info("Drucker druckt nicht, Fan-Control soll Fan steuern") currentTemp = self._printer.get_current_temperatures() if float(currentTemp["tool0"]["actual"]) < 35: self._printer.commands("M106 S0") # self._logger.info("Ist unter 35 Grad, Setting Fan to 0") elif (float(currentTemp["tool0"]["actual"]) >= 35) and (float(currentTemp["tool0"]["actual"]) <= 100): self._printer.commands("M106 S60") # self._logger.info("Ist zwischen 30 Grad und 100, Setting Fan to 60") else: self._printer.commands("M106 S100")
def on_api_command(self, command, data): if command == "pwrOnRelayOne": GPIO.output(self.inOnePin, GPIO.LOW) self.updatePlugin() elif command == "pwrOffRelayOne": if self.warnOnPwrOffRelayOne: self._pwrOneTimeoutValue = 10 self._pwrOneTimer = RepeatedTimer(1, self._timerOne_task) self._pwrOneTimer.start() self._plugin_manager.send_plugin_message(self._identifier, dict(type="timeoutOne", timeout_value=self._pwrOneTimeoutValue)) else: GPIO.output(self.inOnePin, GPIO.HIGH) self.updatePlugin() elif command == "pwrOnRelayTwo": GPIO.output(self.inTwoPin, GPIO.LOW) self.updatePlugin() elif command == "pwrOffRelayTwo": if self.warnOnPwrOffRelayTwo: self._pwrTwoTimeoutValue = 10 self._pwrTwoTimer = RepeatedTimer(1, self._timerTwo_task) self._pwrTwoTimer.start() self._plugin_manager.send_plugin_message(self._identifier, dict(type="timeoutTwo", timeout_value=self._pwrTwoTimeoutValue)) else: GPIO.output(self.inTwoPin, GPIO.HIGH) self.updatePlugin() elif command == "cancelOne": self._pwrOneTimer.cancel() self._logger.info("Cancelled power off relay 1.") elif command == "cancelCooldownOne": self._cooldownOneTimer.cancel() self._logger.info("Cancelled cooldown power off relay 1.") elif command == "cancelTwo": self._pwrTwoTimer.cancel() self._logger.info("Cancelled power off relay 2.") elif command == "cancelCooldownTwo": self._cooldownTwoTimer.cancel() self._logger.info("Cancelled cooldown power off relay 2.")
def hook_m117(self, comm_instance, phase, cmd, cmd_type, gcode, *args, **kwargs): if gcode and gcode == "M117": self._logger.info("Got message: {0}".format(cmd)) self.pwrMessage = cmd[5:] if self.pwrMessage == self.onOneMessage: GPIO.output(self.inOnePin, GPIO.LOW) elif self.pwrMessage == self.offOneMessage: if self.relayOneCooldownEnabled: self._cooldownOneTimeoutValue = self.cooldownDelay self._cooldownOneTimer = RepeatedTimer(1, self._cooldownOne_task) self._cooldownOneTimer.start() self._plugin_manager.send_plugin_message(self._identifier, dict(type="cooldownOne", timeout_value=self._cooldownOneTimeoutValue)) else: GPIO.output(self.inOnePin, GPIO.HIGH) elif self.pwrMessage == self.onTwoMessage: GPIO.output(self.inTwoPin, GPIO.LOW) elif self.pwrMessage == self.offTwoMessage: if self.relayTwoCooldownEnabled: self._cooldownTwoTimeoutValue = self.cooldownDelay self._cooldownTwoTimer = RepeatedTimer(1, self._cooldownTwo_task) self._cooldownTwoTimer.start() self._plugin_manager.send_plugin_message(self._identifier, dict(type="cooldownTwo", timeout_value=self._cooldownTwoTimeoutValue)) else: GPIO.output(self.inTwoPin, GPIO.HIGH)
def on_api_command(self, command, data): import flask if command == "enable": self._automatic_shutdown_enabled = True elif command == "disable": self._automatic_shutdown_enabled = False elif command == "abort": self._timer.cancel() self._logger.info("Shutdown aborted.") elif command == "shutdown": self._logger.info("Shutdown Now.") self._timeout_value = 10 self._timer = RepeatedTimer(1, self._timer_task) self._timer.start() self._plugin_manager.send_plugin_message(self._identifier, dict(type="timeout", timeout_value=self._timeout_value))
def test_run_first(self): timer_task = mock.MagicMock() timer = RepeatedTimer(60, timer_task, run_first=True) timer.start() # give it some time to run time.sleep(1) # then cancel it and wait for the thread to really finish timer.cancel() timer.join() # should have run once self.assertEqual(1, timer_task.call_count)
def startPrint(self, pos=None): """ Starts the printing operation :param pos: unused parameter, just to keep the interface compatible with octoprint """ if not self.isOperational() or self.isPrinting(): return if self._currentFile is None: raise ValueError("No file selected for printing") try: self._changeState(self.STATE_PREPARING_PRINT) if self.isSdFileSelected(): print_resp = self._beeCommands.startSDPrint(self._currentFile.getFilename()) if print_resp: self._sd_status_timer = RepeatedTimer(self._timeout_intervals.get("sdStatus", 1.0), self._poll_sd_status, run_first=True) self._sd_status_timer.start() else: print_resp = self._beeCommands.printFile(self._currentFile.getFilename()) if print_resp is True: self._heatupWaitStartTime = time.time() self._heatupWaitTimeLost = 0.0 self._pauseWaitStartTime = 0 self._pauseWaitTimeLost = 0.0 self._heating = True self._prepare_print_thread = threading.Thread(target=self._preparePrintThread, name="comm._preparePrint") self._prepare_print_thread.daemon = True self._prepare_print_thread.start() else: self._errorValue = "Error while preparing the printing operation." self._logger.exception(self._errorValue) self._changeState(self.STATE_ERROR) eventManager().fire(Events.ERROR, {"error": self.getErrorString()}) return except: self._errorValue = get_exception_string() self._logger.exception("Error while trying to start printing: " + self.getErrorString()) self._changeState(self.STATE_ERROR) eventManager().fire(Events.ERROR, {"error": self.getErrorString()})
def _start_tracking(self): if not self._settings.get_boolean([b"enabled"]): return if self._ping_worker is None: ping = self._settings.get_int(["ping"]) if ping: self._ping_worker = RepeatedTimer(ping, self._track_ping, run_first=True) self._ping_worker.start() if self._helpers_get_throttle_state is None: # cautiously look for the get_throttled helper from pi_support pi_helper = self._plugin_manager.get_helpers("pi_support", "get_throttled") if pi_helper and 'get_throttled' in pi_helper: self._helpers_get_throttle_state = pi_helper['get_throttled'] # now that we have everything set up, phone home. self._track_startup()
def test_condition_change_during_task(self): def sleep(): time.sleep(2) timer_task = mock.MagicMock() timer_task.side_effect = sleep timer = RepeatedTimer(0.1, timer_task, run_first=True) timer.start() time.sleep(1) timer.condition = lambda: False timer.join() self.assertEqual(1, timer_task.call_count)
def on_after_startup(self): if sys.platform == "linux2": with open('/proc/cpuinfo', 'r') as infile: cpuinfo = infile.read() # Search for the cpu info match = re.search('Hardware\s+:\s+(\w+)$', cpuinfo, flags=re.MULTILINE | re.IGNORECASE) if match is None: # The hardware is not a pi self.isRaspi = False elif match.group(1) == 'BCM2708': self._logger.debug("Pi 1") self.isRaspi = True elif match.group(1) == 'BCM2709': self._logger.debug("Pi 2") self.isRaspi = True elif match.group(1) == 'BCM2710': self._logger.debug("Pi 3") self.isRaspi = True self.cooldownDelay = int(self._settings.get(["cooldownDelay"])) self.inOnePin = int(self._settings.get(["inOnePin"])) self.inTwoPin = int(self._settings.get(["inTwoPin"])) self.onOneMessage = self._settings.get(["onOneMessage"]) self.offOneMessage = self._settings.get(["offOneMessage"]) self.onTwoMessage = self._settings.get(["onTwoMessage"]) self.offTwoMessage = self._settings.get(["offTwoMessage"]) self._settings.set(["powerinfoActive"], self.powerinfoActive) self.relayOneName = self._settings.get(["relayOneName"]) self.relayOneCooldownEnabled = self._settings.get(["relayOneCooldownEnabled"]) self.relayTwoName = self._settings.get(["relayTwoName"]) self.relayTwoCooldownEnabled = self._settings.get(["relayTwoCooldownEnabled"]) self.showPwrOneRelay = self._settings.get(["showPwrOneRelay"]) self.showPwrTwoRelay = self._settings.get(["showPwrTwoRelay"]) self.warnOnPwrOffRelayOne = self._settings.get(["warnOnPwrOffRelayOne"]) self.warnOnPwrOffRelayTwo = self._settings.get(["warnOnPwrOffRelayTwo"]) self.updatePlugin() self._helperWaitTimer = RepeatedTimer(1, self._helper_wait_task) self._helperWaitTimer.start()
def connect(self, port=None, baudrate=None): try: self._session = helpers.session(self._settings) #pylint: disable=no-member helpers.claim_node(self.node_uuid, self._settings, self._logger) #pylint: disable=no-member except (helpers.ClaimNodeException, helpers.SessionException) as e: self._errorValue = e.message self._change_state(PRINTER_STATE['ERROR']) return if port == None: port = settings().get(["serial", "port"]) if baudrate == None: settings_baudrate = settings().getInt(["serial", "baudrate"]) if settings_baudrate is None: baudrate = 0 else: baudrate = settings_baudrate self._port = port self._baudrate = baudrate self._printer_uri = self._get_or_create_printer(port, baudrate) self._authentise_process = helpers.run_client(self._settings) #pylint: disable=no-member # monitoring thread self._monitoring_active = True self.monitoring_thread = threading.Thread(target=self._monitor_loop, name="comm._monitor") self.monitoring_thread.daemon = True self.monitoring_thread.start() self._printer_status_timer = RepeatedTimer( lambda: comm_helpers.get_interval("temperature", default_value=10.0), self._update_printer_data, run_first=True ) self._printer_status_timer.start() self._change_state(PRINTER_STATE['CONNECTING'])