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_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 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 _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 _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 _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'])