mirror of https://github.com/Desuuuu/klipper.git
749 lines
33 KiB
Python
749 lines
33 KiB
Python
# Multi-processor safe interface to micro-controller
|
|
#
|
|
# Copyright (C) 2016,2017 Kevin O'Connor <kevin@koconnor.net>
|
|
#
|
|
# This file may be distributed under the terms of the GNU GPLv3 license.
|
|
import sys, os, zlib, logging, math
|
|
import serialhdl, pins, chelper
|
|
|
|
class error(Exception):
|
|
pass
|
|
|
|
STEPCOMPRESS_ERROR_RET = -989898989
|
|
|
|
class MCU_stepper:
|
|
def __init__(self, mcu, pin_params):
|
|
self._mcu = mcu
|
|
self._oid = self._mcu.create_oid()
|
|
self._step_pin = pin_params['pin']
|
|
self._invert_step = pin_params['invert']
|
|
self._dir_pin = self._invert_dir = None
|
|
self._commanded_pos = 0
|
|
self._step_dist = self._inv_step_dist = 1.
|
|
self._velocity_factor = self._accel_factor = 0.
|
|
self._mcu_position_offset = 0
|
|
self._mcu_freq = self._min_stop_interval = 0.
|
|
self._reset_cmd = self._get_position_cmd = None
|
|
self._ffi_lib = self._stepqueue = None
|
|
self.print_to_mcu_time = mcu.print_to_mcu_time
|
|
def get_mcu(self):
|
|
return self._mcu
|
|
def setup_dir_pin(self, pin_params):
|
|
if pin_params['chip'] is not self._mcu:
|
|
raise pins.error("Stepper dir pin must be on same mcu as step pin")
|
|
self._dir_pin = pin_params['pin']
|
|
self._invert_dir = pin_params['invert']
|
|
def setup_min_stop_interval(self, min_stop_interval):
|
|
self._min_stop_interval = min_stop_interval
|
|
def setup_step_distance(self, step_dist):
|
|
self._step_dist = step_dist
|
|
self._inv_step_dist = 1. / step_dist
|
|
def build_config(self):
|
|
self._mcu_freq = self._mcu.get_mcu_freq()
|
|
self._velocity_factor = 1. / (self._mcu_freq * self._step_dist)
|
|
self._accel_factor = 1. / (self._mcu_freq**2 * self._step_dist)
|
|
max_error = self._mcu.get_max_stepper_error()
|
|
min_stop_interval = max(0., self._min_stop_interval - max_error)
|
|
self._mcu.add_config_cmd(
|
|
"config_stepper oid=%d step_pin=%s dir_pin=%s"
|
|
" min_stop_interval=%d invert_step=%d" % (
|
|
self._oid, self._step_pin, self._dir_pin,
|
|
min_stop_interval * self._mcu_freq, self._invert_step))
|
|
step_cmd = self._mcu.lookup_command(
|
|
"queue_step oid=%c interval=%u count=%hu add=%hi")
|
|
dir_cmd = self._mcu.lookup_command(
|
|
"set_next_step_dir oid=%c dir=%c")
|
|
self._reset_cmd = self._mcu.lookup_command(
|
|
"reset_step_clock oid=%c clock=%u")
|
|
self._get_position_cmd = self._mcu.lookup_command(
|
|
"stepper_get_position oid=%c")
|
|
ffi_main, self._ffi_lib = chelper.get_ffi()
|
|
max_error = int(max_error * self._mcu_freq)
|
|
self._stepqueue = ffi_main.gc(self._ffi_lib.stepcompress_alloc(
|
|
max_error, step_cmd.msgid, dir_cmd.msgid,
|
|
self._invert_dir, self._oid),
|
|
self._ffi_lib.stepcompress_free)
|
|
self._mcu.register_stepqueue(self._stepqueue)
|
|
def get_oid(self):
|
|
return self._oid
|
|
def set_position(self, pos):
|
|
if pos >= 0.:
|
|
steppos = int(pos * self._inv_step_dist + 0.5)
|
|
else:
|
|
steppos = int(pos * self._inv_step_dist - 0.5)
|
|
self._mcu_position_offset += self._commanded_pos - steppos
|
|
self._commanded_pos = steppos
|
|
def get_commanded_position(self):
|
|
return self._commanded_pos * self._step_dist
|
|
def get_mcu_position(self):
|
|
return self._commanded_pos + self._mcu_position_offset
|
|
def note_homing_start(self, homing_clock):
|
|
ret = self._ffi_lib.stepcompress_set_homing(
|
|
self._stepqueue, homing_clock)
|
|
if ret:
|
|
raise error("Internal error in stepcompress")
|
|
def note_homing_finalized(self):
|
|
ret = self._ffi_lib.stepcompress_set_homing(self._stepqueue, 0)
|
|
if ret:
|
|
raise error("Internal error in stepcompress")
|
|
ret = self._ffi_lib.stepcompress_reset(self._stepqueue, 0)
|
|
if ret:
|
|
raise error("Internal error in stepcompress")
|
|
def note_homing_triggered(self):
|
|
params = self._mcu.serial.send_with_response(
|
|
self._get_position_cmd.encode(self._oid),
|
|
'stepper_position', self._oid)
|
|
pos = params['pos']
|
|
if self._invert_dir:
|
|
pos = -pos
|
|
self._mcu_position_offset = pos - self._commanded_pos
|
|
def reset_step_clock(self, mcu_time):
|
|
clock = int(mcu_time * self._mcu_freq)
|
|
ret = self._ffi_lib.stepcompress_reset(self._stepqueue, clock)
|
|
if ret:
|
|
raise error("Internal error in stepcompress")
|
|
data = (self._reset_cmd.msgid, self._oid, clock & 0xffffffff)
|
|
ret = self._ffi_lib.stepcompress_queue_msg(
|
|
self._stepqueue, data, len(data))
|
|
if ret:
|
|
raise error("Internal error in stepcompress")
|
|
def step(self, mcu_time, sdir):
|
|
count = self._ffi_lib.stepcompress_push(
|
|
self._stepqueue, mcu_time * self._mcu_freq, sdir)
|
|
if count == STEPCOMPRESS_ERROR_RET:
|
|
raise error("Internal error in stepcompress")
|
|
self._commanded_pos += count
|
|
def step_const(self, mcu_time, start_pos, dist, start_v, accel):
|
|
inv_step_dist = self._inv_step_dist
|
|
step_offset = self._commanded_pos - start_pos * inv_step_dist
|
|
count = self._ffi_lib.stepcompress_push_const(
|
|
self._stepqueue, mcu_time * self._mcu_freq, step_offset,
|
|
dist * inv_step_dist, start_v * self._velocity_factor,
|
|
accel * self._accel_factor)
|
|
if count == STEPCOMPRESS_ERROR_RET:
|
|
raise error("Internal error in stepcompress")
|
|
self._commanded_pos += count
|
|
def step_delta(self, mcu_time, dist, start_v, accel
|
|
, height_base, startxy_d, arm_d, movez_r):
|
|
inv_step_dist = self._inv_step_dist
|
|
height = self._commanded_pos - height_base * inv_step_dist
|
|
count = self._ffi_lib.stepcompress_push_delta(
|
|
self._stepqueue, mcu_time * self._mcu_freq, dist * inv_step_dist,
|
|
start_v * self._velocity_factor, accel * self._accel_factor,
|
|
height, startxy_d * inv_step_dist, arm_d * inv_step_dist, movez_r)
|
|
if count == STEPCOMPRESS_ERROR_RET:
|
|
raise error("Internal error in stepcompress")
|
|
self._commanded_pos += count
|
|
|
|
class MCU_endstop:
|
|
error = error
|
|
RETRY_QUERY = 1.000
|
|
def __init__(self, mcu, pin_params):
|
|
self._mcu = mcu
|
|
self._steppers = []
|
|
self._pin = pin_params['pin']
|
|
self._pullup = pin_params['pullup']
|
|
self._invert = pin_params['invert']
|
|
self._cmd_queue = mcu.alloc_command_queue()
|
|
self._oid = self._home_cmd = self._query_cmd = None
|
|
self._homing = False
|
|
self._min_query_time = self._mcu_freq = 0.
|
|
self._next_query_clock = self._home_timeout_clock = 0
|
|
self._retry_query_ticks = 0
|
|
self._last_state = {}
|
|
def get_mcu(self):
|
|
return self._mcu
|
|
def add_stepper(self, stepper):
|
|
self._steppers.append(stepper)
|
|
def build_config(self):
|
|
self._mcu_freq = self._mcu.get_mcu_freq()
|
|
self._oid = self._mcu.create_oid()
|
|
self._mcu.add_config_cmd(
|
|
"config_end_stop oid=%d pin=%s pull_up=%d stepper_count=%d" % (
|
|
self._oid, self._pin, self._pullup, len(self._steppers)))
|
|
for i, s in enumerate(self._steppers):
|
|
self._mcu.add_config_cmd(
|
|
"end_stop_set_stepper oid=%d pos=%d stepper_oid=%d" % (
|
|
self._oid, i, s.get_oid()), is_init=True)
|
|
self._retry_query_ticks = int(self._mcu_freq * self.RETRY_QUERY)
|
|
self._home_cmd = self._mcu.lookup_command(
|
|
"end_stop_home oid=%c clock=%u rest_ticks=%u pin_value=%c")
|
|
self._query_cmd = self._mcu.lookup_command("end_stop_query oid=%c")
|
|
self._mcu.register_msg(self._handle_end_stop_state, "end_stop_state"
|
|
, self._oid)
|
|
def home_start(self, mcu_time, rest_time):
|
|
clock = int(mcu_time * self._mcu_freq)
|
|
rest_ticks = int(rest_time * self._mcu_freq)
|
|
self._homing = True
|
|
self._min_query_time = self._mcu.monotonic()
|
|
self._next_query_clock = clock + self._retry_query_ticks
|
|
msg = self._home_cmd.encode(
|
|
self._oid, clock, rest_ticks, 1 ^ self._invert)
|
|
self._mcu.send(msg, reqclock=clock, cq=self._cmd_queue)
|
|
for s in self._steppers:
|
|
s.note_homing_start(clock)
|
|
def home_finalize(self, mcu_time):
|
|
for s in self._steppers:
|
|
s.note_homing_finalized()
|
|
self._home_timeout_clock = int(mcu_time * self._mcu_freq)
|
|
def home_wait(self):
|
|
eventtime = self._mcu.monotonic()
|
|
while self._check_busy(eventtime):
|
|
eventtime = self._mcu.pause(eventtime + 0.1)
|
|
def _handle_end_stop_state(self, params):
|
|
logging.debug("end_stop_state %s" % (params,))
|
|
self._last_state = params
|
|
def _check_busy(self, eventtime):
|
|
# Check if need to send an end_stop_query command
|
|
if self._mcu.is_fileoutput():
|
|
return False
|
|
last_sent_time = self._last_state.get('#sent_time', -1.)
|
|
if last_sent_time >= self._min_query_time:
|
|
if not self._homing:
|
|
return False
|
|
if not self._last_state.get('homing', 0):
|
|
for s in self._steppers:
|
|
s.note_homing_triggered()
|
|
self._homing = False
|
|
return False
|
|
if (self._mcu.serial.get_clock(last_sent_time)
|
|
> self._home_timeout_clock):
|
|
# Timeout - disable endstop checking
|
|
msg = self._home_cmd.encode(self._oid, 0, 0, 0)
|
|
self._mcu.send(msg, reqclock=0, cq=self._cmd_queue)
|
|
raise error("Timeout during endstop homing")
|
|
if self._mcu.is_shutdown:
|
|
raise error("MCU is shutdown")
|
|
last_clock, last_clock_time = self._mcu.get_last_clock()
|
|
if last_clock >= self._next_query_clock:
|
|
self._next_query_clock = last_clock + self._retry_query_ticks
|
|
msg = self._query_cmd.encode(self._oid)
|
|
self._mcu.send(msg, cq=self._cmd_queue)
|
|
return True
|
|
def query_endstop(self, mcu_time):
|
|
clock = int(mcu_time * self._mcu_freq)
|
|
self._homing = False
|
|
self._min_query_time = self._mcu.monotonic()
|
|
self._next_query_clock = clock
|
|
def query_endstop_wait(self):
|
|
eventtime = self._mcu.monotonic()
|
|
while self._check_busy(eventtime):
|
|
eventtime = self._mcu.pause(eventtime + 0.1)
|
|
return self._last_state.get('pin', self._invert) ^ self._invert
|
|
|
|
class MCU_digital_out:
|
|
def __init__(self, mcu, pin_params):
|
|
self._mcu = mcu
|
|
self._oid = None
|
|
self._static_value = None
|
|
self._pin = pin_params['pin']
|
|
self._invert = pin_params['invert']
|
|
self._max_duration = 2.
|
|
self._last_clock = 0
|
|
self._last_value = None
|
|
self._mcu_freq = 0.
|
|
self._cmd_queue = mcu.alloc_command_queue()
|
|
self._set_cmd = None
|
|
def get_mcu(self):
|
|
return self._mcu
|
|
def setup_max_duration(self, max_duration):
|
|
self._max_duration = max_duration
|
|
def setup_static(self):
|
|
self._static_value = not self._invert
|
|
def build_config(self):
|
|
self._mcu_freq = self._mcu.get_mcu_freq()
|
|
if self._static_value is not None:
|
|
self._mcu.add_config_cmd("set_digital_out pin=%s value=%d" % (
|
|
self._pin, self._static_value))
|
|
return
|
|
self._oid = self._mcu.create_oid()
|
|
self._mcu.add_config_cmd(
|
|
"config_digital_out oid=%d pin=%s default_value=%d"
|
|
" max_duration=%d" % (
|
|
self._oid, self._pin, self._invert,
|
|
self._max_duration * self._mcu_freq))
|
|
self._set_cmd = self._mcu.lookup_command(
|
|
"schedule_digital_out oid=%c clock=%u value=%c")
|
|
def set_digital(self, mcu_time, value):
|
|
clock = int(mcu_time * self._mcu_freq)
|
|
msg = self._set_cmd.encode(
|
|
self._oid, clock, not not (value ^ self._invert))
|
|
self._mcu.send(msg, minclock=self._last_clock, reqclock=clock
|
|
, cq=self._cmd_queue)
|
|
self._last_clock = clock
|
|
self._last_value = value
|
|
def get_last_setting(self):
|
|
return self._last_value
|
|
def set_pwm(self, mcu_time, value):
|
|
self.set_digital(mcu_time, value >= 0.5)
|
|
|
|
class MCU_pwm:
|
|
def __init__(self, mcu, pin_params):
|
|
self._mcu = mcu
|
|
self._hard_pwm = False
|
|
self._cycle_time = 0.100
|
|
self._max_duration = 2.
|
|
self._oid = None
|
|
self._static_value = None
|
|
self._pin = pin_params['pin']
|
|
self._invert = pin_params['invert']
|
|
self._last_clock = 0
|
|
self._mcu_freq = 0.
|
|
self._pwm_max = 0.
|
|
self._cmd_queue = mcu.alloc_command_queue()
|
|
self._set_cmd = None
|
|
def get_mcu(self):
|
|
return self._mcu
|
|
def setup_max_duration(self, max_duration):
|
|
self._max_duration = max_duration
|
|
def setup_cycle_time(self, cycle_time):
|
|
self._cycle_time = cycle_time
|
|
self._hard_pwm = False
|
|
def setup_hard_pwm(self, hard_cycle_ticks):
|
|
if not hard_cycle_ticks:
|
|
return
|
|
self._cycle_time = hard_cycle_ticks
|
|
self._hard_pwm = True
|
|
def setup_static_pwm(self, value):
|
|
if self._invert:
|
|
value = 1. - value
|
|
self._static_value = max(0., min(1., value))
|
|
def build_config(self):
|
|
self._mcu_freq = self._mcu.get_mcu_freq()
|
|
if self._hard_pwm:
|
|
self._pwm_max = self._mcu.serial.msgparser.get_constant_float(
|
|
"PWM_MAX")
|
|
if self._static_value is not None:
|
|
value = int(self._static_value * self._pwm_max + 0.5)
|
|
self._mcu.add_config_cmd(
|
|
"set_pwm_out pin=%s cycle_ticks=%d value=%d" % (
|
|
self._pin, self._cycle_time, value))
|
|
return
|
|
self._oid = self._mcu.create_oid()
|
|
self._mcu.add_config_cmd(
|
|
"config_pwm_out oid=%d pin=%s cycle_ticks=%d default_value=%d"
|
|
" max_duration=%d" % (
|
|
self._oid, self._pin, self._cycle_time, self._invert,
|
|
self._max_duration * self._mcu_freq))
|
|
self._set_cmd = self._mcu.lookup_command(
|
|
"schedule_pwm_out oid=%c clock=%u value=%hu")
|
|
else:
|
|
self._pwm_max = self._mcu.serial.msgparser.get_constant_float(
|
|
"SOFT_PWM_MAX")
|
|
if self._static_value is not None:
|
|
if self._static_value != 0. and self._static_value != 1.:
|
|
raise pins.error("static value on soft pwm not supported")
|
|
self._mcu.add_config_cmd("set_digital_out pin=%s value=%d" % (
|
|
self._pin, self._static_value >= 0.5))
|
|
return
|
|
self._oid = self._mcu.create_oid()
|
|
self._mcu.add_config_cmd(
|
|
"config_soft_pwm_out oid=%d pin=%s cycle_ticks=%d"
|
|
" default_value=%d max_duration=%d" % (
|
|
self._oid, self._pin, self._cycle_time * self._mcu_freq,
|
|
self._invert, self._max_duration * self._mcu_freq))
|
|
self._set_cmd = self._mcu.lookup_command(
|
|
"schedule_soft_pwm_out oid=%c clock=%u value=%hu")
|
|
def set_pwm(self, mcu_time, value):
|
|
clock = int(mcu_time * self._mcu_freq)
|
|
if self._invert:
|
|
value = 1. - value
|
|
value = int(max(0., min(1., value)) * self._pwm_max + 0.5)
|
|
msg = self._set_cmd.encode(self._oid, clock, value)
|
|
self._mcu.send(msg, minclock=self._last_clock, reqclock=clock
|
|
, cq=self._cmd_queue)
|
|
self._last_clock = clock
|
|
|
|
class MCU_adc:
|
|
def __init__(self, mcu, pin_params):
|
|
self._mcu = mcu
|
|
self._pin = pin_params['pin']
|
|
self._min_sample = self._max_sample = 0.
|
|
self._sample_time = self._report_time = 0.
|
|
self._sample_count = 0
|
|
self._report_clock = 0
|
|
self._oid = self._callback = None
|
|
self._inv_max_adc = 0.
|
|
self._mcu_freq = 0.
|
|
self._cmd_queue = mcu.alloc_command_queue()
|
|
def get_mcu(self):
|
|
return self._mcu
|
|
def setup_minmax(self, sample_time, sample_count, minval=0., maxval=1.):
|
|
self._sample_time = sample_time
|
|
self._sample_count = sample_count
|
|
self._min_sample = minval
|
|
self._max_sample = maxval
|
|
def setup_adc_callback(self, report_time, callback):
|
|
self._report_time = report_time
|
|
self._callback = callback
|
|
def build_config(self):
|
|
if not self._sample_count:
|
|
return
|
|
self._mcu_freq = self._mcu.get_mcu_freq()
|
|
self._oid = self._mcu.create_oid()
|
|
self._mcu.add_config_cmd("config_analog_in oid=%d pin=%s" % (
|
|
self._oid, self._pin))
|
|
last_clock, last_clock_time = self._mcu.get_last_clock()
|
|
clock = last_clock + int(self._mcu_freq * (1.0 + self._oid * 0.01)) # XXX
|
|
sample_ticks = int(self._sample_time * self._mcu_freq)
|
|
mcu_adc_max = self._mcu.serial.msgparser.get_constant_float("ADC_MAX")
|
|
max_adc = self._sample_count * mcu_adc_max
|
|
self._inv_max_adc = 1.0 / max_adc
|
|
self._report_clock = int(self._report_time * self._mcu_freq)
|
|
min_sample = max(0, min(0xffff, int(self._min_sample * max_adc)))
|
|
max_sample = max(0, min(0xffff, int(
|
|
math.ceil(self._max_sample * max_adc))))
|
|
self._mcu.add_config_cmd(
|
|
"query_analog_in oid=%d clock=%d sample_ticks=%d sample_count=%d"
|
|
" rest_ticks=%d min_value=%d max_value=%d" % (
|
|
self._oid, clock, sample_ticks, self._sample_count,
|
|
self._report_clock, min_sample, max_sample), is_init=True)
|
|
self._mcu.register_msg(self._handle_analog_in_state, "analog_in_state"
|
|
, self._oid)
|
|
def _handle_analog_in_state(self, params):
|
|
last_value = params['value'] * self._inv_max_adc
|
|
next_clock = self._mcu.serial.translate_clock(params['next_clock'])
|
|
last_read_time = (next_clock - self._report_clock) / self._mcu_freq
|
|
if self._callback is not None:
|
|
self._callback(last_read_time, last_value)
|
|
|
|
class MCU:
|
|
error = error
|
|
COMM_TIMEOUT = 3.5
|
|
def __init__(self, printer, config):
|
|
self._printer = printer
|
|
# Serial port
|
|
self._serialport = config.get('serial', '/dev/ttyS0')
|
|
if self._serialport.startswith("/dev/rpmsg_"):
|
|
# Beaglbone PRU
|
|
baud = 0
|
|
else:
|
|
baud = config.getint('baud', 250000, minval=2400)
|
|
self.serial = serialhdl.SerialReader(
|
|
printer.reactor, self._serialport, baud)
|
|
self.is_shutdown = False
|
|
self._shutdown_msg = ""
|
|
self._timeout_timer = printer.reactor.register_timer(
|
|
self.timeout_handler)
|
|
self._restart_method = 'command'
|
|
if baud:
|
|
rmethods = {m: m for m in ['arduino', 'command', 'rpi_usb']}
|
|
self._restart_method = config.getchoice(
|
|
'restart_method', rmethods, 'arduino')
|
|
# Config building
|
|
if printer.bglogger is not None:
|
|
printer.bglogger.set_rollover_info("mcu", None)
|
|
pins.get_printer_pins(printer).register_chip("mcu", self)
|
|
self._emergency_stop_cmd = None
|
|
self._reset_cmd = self._config_reset_cmd = None
|
|
self._oid_count = 0
|
|
self._config_objects = []
|
|
self._init_cmds = []
|
|
self._config_cmds = []
|
|
self._config_crc = None
|
|
self._pin_map = config.get('pin_map', None)
|
|
self._custom = config.get('custom', '')
|
|
self._mcu_freq = 0.
|
|
# Move command queuing
|
|
ffi_main, self._ffi_lib = chelper.get_ffi()
|
|
self._max_stepper_error = config.getfloat(
|
|
'max_stepper_error', 0.000025, minval=0.)
|
|
self._stepqueues = []
|
|
self._steppersync = None
|
|
# Stats
|
|
self._stats_sumsq_base = 0.
|
|
self._mcu_tick_avg = 0.
|
|
self._mcu_tick_stddev = 0.
|
|
self._mcu_tick_awake = 0.
|
|
def handle_mcu_stats(self, params):
|
|
count = params['count']
|
|
tick_sum = params['sum']
|
|
c = 1.0 / (count * self._mcu_freq)
|
|
self._mcu_tick_avg = tick_sum * c
|
|
tick_sumsq = params['sumsq'] * self._stats_sumsq_base
|
|
self._mcu_tick_stddev = c * math.sqrt(count*tick_sumsq - tick_sum**2)
|
|
self._mcu_tick_awake = tick_sum / self._mcu_freq
|
|
def handle_shutdown(self, params):
|
|
if self.is_shutdown:
|
|
return
|
|
self.is_shutdown = True
|
|
self._shutdown_msg = msg = params['#msg']
|
|
logging.info("%s: %s" % (params['#name'], self._shutdown_msg))
|
|
self.serial.dump_debug()
|
|
prefix = "MCU shutdown: "
|
|
if params['#name'] == 'is_shutdown':
|
|
prefix = "Previous MCU shutdown: "
|
|
self._printer.note_shutdown(prefix + msg + error_help(msg))
|
|
# Connection phase
|
|
def _check_restart(self, reason):
|
|
start_reason = self._printer.get_start_args().get("start_reason")
|
|
if start_reason == 'firmware_restart':
|
|
return
|
|
logging.info("Attempting automated firmware restart: %s" % (reason,))
|
|
self._printer.request_exit('firmware_restart')
|
|
self._printer.reactor.pause(self._printer.reactor.monotonic() + 2.000)
|
|
raise error("Attempt firmware restart failed")
|
|
def connect(self):
|
|
if self.is_fileoutput():
|
|
self._connect_file()
|
|
else:
|
|
if (self._restart_method == 'rpi_usb'
|
|
and not os.path.exists(self._serialport)):
|
|
# Try toggling usb power
|
|
self._check_restart("enable power")
|
|
self.serial.connect()
|
|
self._printer.reactor.update_timer(
|
|
self._timeout_timer, self.monotonic() + self.COMM_TIMEOUT)
|
|
self._mcu_freq = self.serial.msgparser.get_constant_float('CLOCK_FREQ')
|
|
self._stats_sumsq_base = self.serial.msgparser.get_constant_float(
|
|
'STATS_SUMSQ_BASE')
|
|
self._emergency_stop_cmd = self.lookup_command("emergency_stop")
|
|
self._reset_cmd = self.try_lookup_command("reset")
|
|
self._config_reset_cmd = self.try_lookup_command("config_reset")
|
|
self.register_msg(self.handle_shutdown, 'shutdown')
|
|
self.register_msg(self.handle_shutdown, 'is_shutdown')
|
|
self.register_msg(self.handle_mcu_stats, 'stats')
|
|
self._build_config()
|
|
self._send_config()
|
|
def _connect_file(self, pace=False):
|
|
# In a debugging mode. Open debug output file and read data dictionary
|
|
out_fname = self._printer.get_start_args().get('debugoutput')
|
|
outfile = open(out_fname, 'wb')
|
|
dict_fname = self._printer.get_start_args().get('dictionary')
|
|
dfile = open(dict_fname, 'rb')
|
|
dict_data = dfile.read()
|
|
dfile.close()
|
|
self.serial.connect_file(outfile, dict_data)
|
|
# Handle pacing
|
|
if not pace:
|
|
def dummy_estimated_print_time(eventtime):
|
|
return 0.
|
|
self.estimated_print_time = dummy_estimated_print_time
|
|
def timeout_handler(self, eventtime):
|
|
last_clock, last_clock_time = self.serial.get_last_clock()
|
|
timeout = last_clock_time + self.COMM_TIMEOUT
|
|
if eventtime < timeout:
|
|
return timeout
|
|
logging.info("Timeout with firmware (eventtime=%f last_status=%f)" % (
|
|
eventtime, last_clock_time))
|
|
self._printer.note_mcu_error("Lost communication with firmware")
|
|
return self._printer.reactor.NEVER
|
|
def disconnect(self):
|
|
self.serial.disconnect()
|
|
if self._steppersync is not None:
|
|
self._ffi_lib.steppersync_free(self._steppersync)
|
|
self._steppersync = None
|
|
def stats(self, eventtime):
|
|
return "%s mcu_awake=%.03f mcu_task_avg=%.06f mcu_task_stddev=%.06f" % (
|
|
self.serial.stats(eventtime),
|
|
self._mcu_tick_awake, self._mcu_tick_avg, self._mcu_tick_stddev)
|
|
def force_shutdown(self):
|
|
self.send(self._emergency_stop_cmd.encode())
|
|
def microcontroller_restart(self):
|
|
reactor = self._printer.reactor
|
|
if self._restart_method == 'rpi_usb':
|
|
logging.info("Attempting a microcontroller reset via rpi usb power")
|
|
self.disconnect()
|
|
chelper.run_hub_ctrl(0)
|
|
reactor.pause(reactor.monotonic() + 2.000)
|
|
chelper.run_hub_ctrl(1)
|
|
return
|
|
if self._restart_method == 'command':
|
|
last_clock, last_clock_time = self.serial.get_last_clock()
|
|
eventtime = reactor.monotonic()
|
|
if ((self._reset_cmd is None and self._config_reset_cmd is None)
|
|
or eventtime > last_clock_time + self.COMM_TIMEOUT):
|
|
logging.info("Unable to issue reset command")
|
|
return
|
|
if self._reset_cmd is None:
|
|
# Attempt reset via config_reset command
|
|
logging.info("Attempting a microcontroller config_reset command")
|
|
self.is_shutdown = True
|
|
self.force_shutdown()
|
|
reactor.pause(reactor.monotonic() + 0.015)
|
|
self.send(self._config_reset_cmd.encode())
|
|
reactor.pause(reactor.monotonic() + 0.015)
|
|
self.disconnect()
|
|
return
|
|
# Attempt reset via reset command
|
|
logging.info("Attempting a microcontroller reset command")
|
|
self.send(self._reset_cmd.encode())
|
|
reactor.pause(reactor.monotonic() + 0.015)
|
|
self.disconnect()
|
|
return
|
|
# Attempt reset via arduino mechanism
|
|
logging.info("Attempting a microcontroller reset")
|
|
self.disconnect()
|
|
serialhdl.arduino_reset(self._serialport, reactor)
|
|
def is_fileoutput(self):
|
|
return self._printer.get_start_args().get('debugoutput') is not None
|
|
# Configuration phase
|
|
def _add_custom(self):
|
|
for line in self._custom.split('\n'):
|
|
line = line.strip()
|
|
cpos = line.find('#')
|
|
if cpos >= 0:
|
|
line = line[:cpos].strip()
|
|
if not line:
|
|
continue
|
|
self.add_config_cmd(line)
|
|
def _build_config(self):
|
|
# Build config commands
|
|
for co in self._config_objects:
|
|
co.build_config()
|
|
self._add_custom()
|
|
self._config_cmds.insert(0, "allocate_oids count=%d" % (
|
|
self._oid_count,))
|
|
|
|
# Resolve pin names
|
|
mcu = self.serial.msgparser.get_constant('MCU')
|
|
pnames = pins.get_pin_map(mcu, self._pin_map)
|
|
updated_cmds = []
|
|
for cmd in self._config_cmds:
|
|
try:
|
|
updated_cmds.append(pins.update_command(cmd, pnames))
|
|
except:
|
|
raise pins.error("Unable to translate pin name: %s" % (cmd,))
|
|
self._config_cmds = updated_cmds
|
|
|
|
# Calculate config CRC
|
|
self._config_crc = zlib.crc32('\n'.join(self._config_cmds)) & 0xffffffff
|
|
self.add_config_cmd("finalize_config crc=%d" % (self._config_crc,))
|
|
def _send_config(self):
|
|
msg = self.create_command("get_config")
|
|
if self.is_fileoutput():
|
|
config_params = {
|
|
'is_config': 0, 'move_count': 500, 'crc': self._config_crc}
|
|
else:
|
|
config_params = self.serial.send_with_response(msg, 'config')
|
|
if not config_params['is_config']:
|
|
if self._restart_method == 'rpi_usb':
|
|
# Only configure mcu after usb power reset
|
|
self._check_restart("full reset before config")
|
|
# Send config commands
|
|
logging.info("Sending printer configuration...")
|
|
for c in self._config_cmds:
|
|
self.send(self.create_command(c))
|
|
if not self.is_fileoutput():
|
|
config_params = self.serial.send_with_response(msg, 'config')
|
|
if not config_params['is_config']:
|
|
if self.is_shutdown:
|
|
raise error("Firmware error during config: %s" % (
|
|
self._shutdown_msg,))
|
|
raise error("Unable to configure printer")
|
|
else:
|
|
start_reason = self._printer.get_start_args().get("start_reason")
|
|
if start_reason == 'firmware_restart':
|
|
raise error("Failed automated reset of micro-controller")
|
|
if self._config_crc != config_params['crc']:
|
|
self._check_restart("CRC mismatch")
|
|
raise error("Printer CRC does not match config")
|
|
move_count = config_params['move_count']
|
|
logging.info("Configured (%d moves)" % (move_count,))
|
|
if self._printer.bglogger is not None:
|
|
msgparser = self.serial.msgparser
|
|
info = [
|
|
"Configured (%d moves)" % (move_count,),
|
|
"Loaded %d commands (%s)" % (
|
|
len(msgparser.messages_by_id), msgparser.version),
|
|
"MCU config: %s" % (" ".join(
|
|
["%s=%s" % (k, v) for k, v in msgparser.config.items()]))]
|
|
self._printer.bglogger.set_rollover_info("mcu", "\n".join(info))
|
|
self._steppersync = self._ffi_lib.steppersync_alloc(
|
|
self.serial.serialqueue, self._stepqueues, len(self._stepqueues),
|
|
move_count)
|
|
for c in self._init_cmds:
|
|
self.send(self.create_command(c))
|
|
# Config creation helpers
|
|
def setup_pin(self, pin_params):
|
|
pcs = {'stepper': MCU_stepper, 'endstop': MCU_endstop,
|
|
'digital_out': MCU_digital_out, 'pwm': MCU_pwm, 'adc': MCU_adc}
|
|
pin_type = pin_params['type']
|
|
if pin_type not in pcs:
|
|
raise pins.error("pin type %s not supported on mcu" % (pin_type,))
|
|
co = pcs[pin_type](self, pin_params)
|
|
self.add_config_object(co)
|
|
return co
|
|
def create_oid(self):
|
|
self._oid_count += 1
|
|
return self._oid_count - 1
|
|
def add_config_object(self, co):
|
|
self._config_objects.append(co)
|
|
def add_config_cmd(self, cmd, is_init=False):
|
|
if is_init:
|
|
self._init_cmds.append(cmd)
|
|
else:
|
|
self._config_cmds.append(cmd)
|
|
def register_msg(self, cb, msg, oid=None):
|
|
self.serial.register_callback(cb, msg, oid)
|
|
def register_stepqueue(self, stepqueue):
|
|
self._stepqueues.append(stepqueue)
|
|
def alloc_command_queue(self):
|
|
return self.serial.alloc_command_queue()
|
|
def lookup_command(self, msgformat):
|
|
return self.serial.msgparser.lookup_command(msgformat)
|
|
def try_lookup_command(self, msgformat):
|
|
try:
|
|
return self.serial.msgparser.lookup_command(msgformat)
|
|
except self.serial.msgparser.error as e:
|
|
return None
|
|
def create_command(self, msg):
|
|
return self.serial.msgparser.create_command(msg)
|
|
# Clock syncing
|
|
def print_to_mcu_time(self, print_time):
|
|
return print_time
|
|
def print_time_to_clock(self, print_time):
|
|
return int(print_time * self._mcu_freq)
|
|
def clock_to_print_time(self, clock):
|
|
return clock / self._mcu_freq
|
|
def estimated_print_time(self, eventtime):
|
|
return self.clock_to_print_time(self.serial.get_clock(eventtime))
|
|
def get_mcu_freq(self):
|
|
return self._mcu_freq
|
|
def get_last_clock(self):
|
|
return self.serial.get_last_clock()
|
|
def get_max_stepper_error(self):
|
|
return self._max_stepper_error
|
|
# Move command queuing
|
|
def send(self, cmd, minclock=0, reqclock=0, cq=None):
|
|
self.serial.send(cmd, minclock, reqclock, cq=cq)
|
|
def flush_moves(self, print_time):
|
|
if self._steppersync is None:
|
|
return
|
|
clock = self.print_time_to_clock(print_time)
|
|
ret = self._ffi_lib.steppersync_flush(self._steppersync, clock)
|
|
if ret:
|
|
raise error("Internal error in stepcompress")
|
|
def pause(self, waketime):
|
|
return self._printer.reactor.pause(waketime)
|
|
def monotonic(self):
|
|
return self._printer.reactor.monotonic()
|
|
def __del__(self):
|
|
self.disconnect()
|
|
|
|
Common_MCU_errors = {
|
|
("Timer too close", "No next step", "Missed scheduling of next "): """
|
|
This is generally indicative of an intermittent
|
|
communication failure between micro-controller and host.""",
|
|
("ADC out of range",): """
|
|
This generally occurs when a heater temperature exceeds
|
|
its configured min_temp or max_temp.""",
|
|
("Rescheduled timer in the past", "Stepper too far in past"): """
|
|
This generally occurs when the micro-controller has been
|
|
requested to step at a rate higher than it is capable of
|
|
obtaining.""",
|
|
("Command request",): """
|
|
This generally occurs in response to an M112 G-Code command
|
|
or in response to an internal error in the host software.""",
|
|
}
|
|
|
|
def error_help(msg):
|
|
for prefixes, help_msg in Common_MCU_errors.items():
|
|
for prefix in prefixes:
|
|
if msg.startswith(prefix):
|
|
return help_msg
|
|
return ""
|
|
|
|
def add_printer_objects(printer, config):
|
|
printer.add_object('mcu', MCU(printer, config.getsection('mcu')))
|