1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
# Support for disabling the printer on an idle timeout
#
# Copyright (C) 2018 Kevin O'Connor <kevin@koconnor.net>
#
# This file may be distributed under the terms of the GNU GPLv3 license.
import logging
DEFAULT_IDLE_GCODE = """
{% if 'heaters' in printer %}
TURN_OFF_HEATERS
{% endif %}
M84
"""
PIN_MIN_TIME = 0.100
READY_TIMEOUT = 0.500
class IdleTimeout:
def __init__(self, config):
self.printer = config.get_printer()
self.reactor = self.printer.get_reactor()
self.gcode = self.printer.lookup_object("gcode")
self.toolhead = self.timeout_timer = None
self.printer.register_event_handler("klippy:ready", self.handle_ready)
self.idle_timeout = config.getfloat("timeout", 600.0, above=0.0)
gcode_macro = self.printer.load_object(config, "gcode_macro")
self.idle_gcode = gcode_macro.load_template(config, "gcode", DEFAULT_IDLE_GCODE)
self.gcode.register_command(
"SET_IDLE_TIMEOUT",
self.cmd_SET_IDLE_TIMEOUT,
desc=self.cmd_SET_IDLE_TIMEOUT_help,
)
self.state = "Idle"
self.last_print_start_systime = 0.0
def get_status(self, eventtime):
printing_time = 0.0
if self.state == "Printing":
printing_time = eventtime - self.last_print_start_systime
return {"state": self.state, "printing_time": printing_time}
def handle_ready(self):
self.toolhead = self.printer.lookup_object("toolhead")
self.timeout_timer = self.reactor.register_timer(self.timeout_handler)
self.printer.register_event_handler(
"toolhead:sync_print_time", self.handle_sync_print_time
)
def transition_idle_state(self, eventtime):
self.state = "Printing"
try:
script = self.idle_gcode.render()
self.gcode.run_script(script)
except:
logging.exception("idle timeout gcode execution")
self.state = "Ready"
return eventtime + 1.0
print_time = self.toolhead.get_last_move_time()
self.state = "Idle"
self.printer.send_event("idle_timeout:idle", print_time)
return self.reactor.NEVER
def check_idle_timeout(self, eventtime):
# Make sure toolhead class isn't busy
print_time, est_print_time, lookahead_empty = self.toolhead.check_busy(
eventtime
)
idle_time = est_print_time - print_time
if not lookahead_empty or idle_time < 1.0:
# Toolhead is busy
return eventtime + self.idle_timeout
if idle_time < self.idle_timeout:
# Wait for idle timeout
return eventtime + self.idle_timeout - idle_time
if self.gcode.get_mutex().test():
# Gcode class busy
return eventtime + 1.0
# Idle timeout has elapsed
return self.transition_idle_state(eventtime)
def timeout_handler(self, eventtime):
if self.printer.is_shutdown():
return self.reactor.NEVER
if self.state == "Ready":
return self.check_idle_timeout(eventtime)
# Check if need to transition to "ready" state
print_time, est_print_time, lookahead_empty = self.toolhead.check_busy(
eventtime
)
buffer_time = min(2.0, print_time - est_print_time)
if not lookahead_empty:
# Toolhead is busy
return eventtime + READY_TIMEOUT + max(0.0, buffer_time)
if buffer_time > -READY_TIMEOUT:
# Wait for ready timeout
return eventtime + READY_TIMEOUT + buffer_time
if self.gcode.get_mutex().test():
# Gcode class busy
return eventtime + READY_TIMEOUT
# Transition to "ready" state
self.state = "Ready"
self.printer.send_event("idle_timeout:ready", est_print_time + PIN_MIN_TIME)
return eventtime + self.idle_timeout
def handle_sync_print_time(self, curtime, print_time, est_print_time):
if self.state == "Printing":
return
# Transition to "printing" state
self.state = "Printing"
self.last_print_start_systime = curtime
check_time = READY_TIMEOUT + print_time - est_print_time
self.reactor.update_timer(self.timeout_timer, curtime + check_time)
self.printer.send_event("idle_timeout:printing", est_print_time + PIN_MIN_TIME)
cmd_SET_IDLE_TIMEOUT_help = "Set the idle timeout in seconds"
def cmd_SET_IDLE_TIMEOUT(self, gcmd):
timeout = gcmd.get_float("TIMEOUT", self.idle_timeout, above=0.0)
self.idle_timeout = timeout
gcmd.respond_info("idle_timeout: Timeout set to %.2f s" % (timeout,))
if self.state == "Ready":
checktime = self.reactor.monotonic() + timeout
self.reactor.update_timer(self.timeout_timer, checktime)
def load_config(config):
return IdleTimeout(config)
|
