Mirror
/
klipper-dgus
mirror of https://github.com/Desuuuu/klipper.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

mcu: Introduce new lookup_query_command() command wrapper 

Use new mcu.lookup_query_command() for all commands that query
information from the micro-controller.

Signed-off-by: Kevin O'Connor <kevin@koconnor.net>
This commit is contained in:
Kevin O'Connor 2020-02-19 16:46:06 -05:00
parent 332038ea01
commit 245917bf03
5 changed files with 73 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
klippy/extras/bus.py
View File

@ -79,8 +79,10 @@ class MCU_SPI:
self.mcu.add_config_cmd(self.config_fmt)
self.spi_send_cmd = self.mcu.lookup_command(
"spi_send oid=%c data=%*s", cq=self.cmd_queue)
self.spi_transfer_cmd = self.mcu.lookup_command(
"spi_transfer oid=%c data=%*s", cq=self.cmd_queue)
self.spi_transfer_cmd = self.mcu.lookup_query_command(
"spi_transfer oid=%c data=%*s",
"spi_transfer_response oid=%c response=%*s", oid=self.oid,
cq=self.cmd_queue)
def spi_send(self, data, minclock=0, reqclock=0):
if self.spi_send_cmd is None:
# Send setup message via mcu initialization
@ -91,8 +93,7 @@ class MCU_SPI:
self.spi_send_cmd.send([self.oid, data],
minclock=minclock, reqclock=reqclock)
def spi_transfer(self, data):
return self.spi_transfer_cmd.send_with_response(
[self.oid, data], 'spi_transfer_response', self.oid)
return self.spi_transfer_cmd.send([self.oid, data])
# Helper to setup an spi bus from settings in a config section
def MCU_SPI_from_config(config, mode, pin_option="cs_pin",
@ -155,8 +156,10 @@ class MCU_I2C:
self.mcu.add_config_cmd(self.config_fmt % (bus,))
self.i2c_write_cmd = self.mcu.lookup_command(
"i2c_write oid=%c data=%*s", cq=self.cmd_queue)
self.i2c_read_cmd = self.mcu.lookup_command(
"i2c_read oid=%c reg=%*s read_len=%u", cq=self.cmd_queue)
self.i2c_read_cmd = self.mcu.lookup_query_command(
"i2c_read oid=%c reg=%*s read_len=%u",
"i2c_read_response oid=%c response=%*s", oid=self.oid,
cq=self.cmd_queue)
self.i2c_modify_bits_cmd = self.mcu.lookup_command(
"i2c_modify_bits oid=%c reg=%*s clear_set_bits=%*s",
cq=self.cmd_queue)
@ -170,8 +173,7 @@ class MCU_I2C:
self.i2c_write_cmd.send([self.oid, data],
minclock=minclock, reqclock=reqclock)
def i2c_read(self, write, read_len):
return self.i2c_read_cmd.send_with_response(
[self.oid, write, read_len], 'i2c_read_response', self.oid)
return self.i2c_read_cmd.send([self.oid, write, read_len])
def i2c_modify_bits(self, reg, clear_bits, set_bits,
minclock=0, reqclock=0):
clearset = clear_bits + set_bits

13
klippy/extras/tmc_uart.py
View File

@ -75,8 +75,10 @@ class MCU_TMC_uart_bitbang:
self.mcu.add_config_cmd(
"config_tmcuart oid=%d rx_pin=%s pull_up=%d tx_pin=%s bit_time=%d"
% (self.oid, self.rx_pin, self.pullup, self.tx_pin, bit_ticks))
self.tmcuart_send_cmd = self.mcu.lookup_command(
"tmcuart_send oid=%c write=%*s read=%c", cq=self.cmd_queue)
self.tmcuart_send_cmd = self.mcu.lookup_query_command(
"tmcuart_send oid=%c write=%*s read=%c",
"tmcuart_response oid=%c read=%*s", oid=self.oid,
cq=self.cmd_queue, async=True)
def register_instance(self, rx_pin_params, tx_pin_params,
select_pins_desc, addr):
if (rx_pin_params['pin'] != self.rx_pin
@ -148,8 +150,7 @@ class MCU_TMC_uart_bitbang:
if self.analog_mux is not None:
self.analog_mux.activate(instance_id)
msg = self._encode_read(0xf5, addr, reg)
params = self.tmcuart_send_cmd.send_with_async_response(
[self.oid, msg, 10], 'tmcuart_response', self.oid)
params = self.tmcuart_send_cmd.send([self.oid, msg, 10])
return self._decode_read(reg, params['read'])
def reg_write(self, instance_id, addr, reg, val, print_time=None):
minclock = 0
@ -158,9 +159,7 @@ class MCU_TMC_uart_bitbang:
if self.analog_mux is not None:
self.analog_mux.activate(instance_id)
msg = self._encode_write(0xf5, addr, reg | 0x80, val)
self.tmcuart_send_cmd.send_with_async_response(
[self.oid, msg, 0], 'tmcuart_response', self.oid,
minclock=minclock)
self.tmcuart_send_cmd.send([self.oid, msg, 0], minclock=minclock)
# Lookup a (possibly shared) tmc uart
def lookup_tmc_uart_bitbang(config, max_addr):

88
klippy/mcu.py
View File

@ -1,6 +1,6 @@
# Interface to Klipper micro-controller code
#
# Copyright (C) 2016-2019 Kevin O'Connor <kevin@koconnor.net>
# Copyright (C) 2016-2020 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
@ -18,7 +18,7 @@ class MCU_endstop:
self._pullup = pin_params['pullup']
self._invert = pin_params['invert']
self._reactor = mcu.get_printer().get_reactor()
self._oid = self._home_cmd = self._query_cmd = None
self._oid = self._home_cmd = self._requery_cmd = self._query_cmd = None
self._mcu.register_config_callback(self._build_config)
self._min_query_time = self._last_sent_time = 0.
self._next_query_print_time = self._end_home_time = 0.
@ -49,8 +49,12 @@ class MCU_endstop:
self._home_cmd = self._mcu.lookup_command(
"endstop_home oid=%c clock=%u sample_ticks=%u sample_count=%c"
" rest_ticks=%u pin_value=%c", cq=cmd_queue)
self._query_cmd = self._mcu.lookup_command(
self._requery_cmd = self._mcu.lookup_command(
"endstop_query_state oid=%c", cq=cmd_queue)
self._query_cmd = self._mcu.lookup_query_command(
"endstop_query_state oid=%c",
"endstop_state oid=%c homing=%c pin_value=%c", oid=self._oid,
cq=cmd_queue)
def home_start(self, print_time, sample_time, sample_count, rest_time,
triggered=True):
clock = self._mcu.print_time_to_clock(print_time)
@ -94,7 +98,7 @@ class MCU_endstop:
est_print_time = self._mcu.estimated_print_time(eventtime)
if est_print_time >= self._next_query_print_time:
self._next_query_print_time = est_print_time + self.RETRY_QUERY
self._query_cmd.send([self._oid])
self._requery_cmd.send([self._oid])
def home_wait(self, home_end_time):
self._home_end_time = home_end_time
did_trigger = self._home_completion.wait()
@ -109,8 +113,7 @@ class MCU_endstop:
clock = self._mcu.print_time_to_clock(print_time)
if self._mcu.is_fileoutput():
return 0
params = self._query_cmd.send_with_response(
[self._oid], "endstop_state", self._oid, minclock=clock)
params = self._query_cmd.send([self._oid], minclock=clock)
return params['pin_value'] ^ self._invert
class MCU_digital_out:
@ -305,11 +308,11 @@ class MCU_adc:
class RetryAsyncCommand:
TIMEOUT_TIME = 5.0
RETRY_TIME = 0.500
def __init__(self, mcu, serial, name, oid=None):
self.reactor = mcu.get_printer().get_reactor()
def __init__(self, serial, name, oid=None):
self.serial = serial
self.name = name
self.oid = oid
self.reactor = serial.get_reactor()
self.completion = self.reactor.completion()
self.min_query_time = self.reactor.monotonic()
self.serial.register_response(self.handle_callback, name, oid)
@ -317,10 +320,10 @@ class RetryAsyncCommand:
if params['#sent_time'] >= self.min_query_time:
self.min_query_time = self.reactor.NEVER
self.reactor.async_complete(self.completion, params)
def get_response(self, cmd, cmd_queue, minclock=0, minsystime=0.):
first_query_time = query_time = max(self.min_query_time, minsystime)
def get_response(self, cmd, cmd_queue, minclock=0):
self.serial.raw_send_wait_ack(cmd, minclock, minclock, cmd_queue)
first_query_time = query_time = self.reactor.monotonic()
while 1:
self.serial.raw_send(cmd, minclock, minclock, cmd_queue)
params = self.completion.wait(query_time + self.RETRY_TIME)
if params is not None:
self.serial.register_response(None, self.name, self.oid)
@ -329,34 +332,42 @@ class RetryAsyncCommand:
if query_time > first_query_time + self.TIMEOUT_TIME:
self.serial.register_response(None, self.name, self.oid)
raise error("Timeout on wait for '%s' response" % (self.name,))
self.serial.raw_send(cmd, minclock, minclock, cmd_queue)
# Wrapper around query commands
class CommandQueryWrapper:
def __init__(self, serial, msgformat, respformat, oid=None,
cmd_queue=None, async=False):
self._serial = serial
self._cmd = serial.get_msgparser().lookup_command(msgformat)
serial.get_msgparser().lookup_command(respformat)
self._response = respformat.split()[0]
self._oid = oid
self._xmit_helper = serialhdl.SerialRetryCommand
if async:
self._xmit_helper = RetryAsyncCommand
if cmd_queue is None:
cmd_queue = serial.get_default_command_queue()
self._cmd_queue = cmd_queue
def send(self, data=(), minclock=0):
cmd = self._cmd.encode(data)
xh = self._xmit_helper(self._serial, self._response, self._oid)
try:
return xh.get_response(cmd, self._cmd_queue, minclock=minclock)
except serialhdl.error as e:
raise error(str(e))
# Wrapper around command sending
class CommandWrapper:
def __init__(self, mcu, serial, clocksync, cmd, cmd_queue):
self._mcu = mcu
def __init__(self, serial, msgformat, cmd_queue=None):
self._serial = serial
self._clocksync = clocksync
self._cmd = cmd
self._cmd = serial.get_msgparser().lookup_command(msgformat)
if cmd_queue is None:
cmd_queue = serial.get_default_command_queue()
self._cmd_queue = cmd_queue
def send(self, data=(), minclock=0, reqclock=0):
cmd = self._cmd.encode(data)
self._serial.raw_send(cmd, minclock, reqclock, self._cmd_queue)
def send_with_response(self, data=(), response=None, response_oid=None,
minclock=0):
cmd = self._cmd.encode(data)
src = serialhdl.SerialRetryCommand(self._serial, response, response_oid)
try:
return src.get_response(cmd, self._cmd_queue, minclock=minclock)
except serialhdl.error as e:
raise error(str(e))
def send_with_async_response(self, data=(),
response=None, response_oid=None, minclock=0):
minsystime = 0.
if minclock:
minsystime = self._clocksync.estimate_clock_systime(minclock)
cmd = self._cmd.encode(data)
src = RetryAsyncCommand(self._mcu, self._serial, response, response_oid)
return src.get_response(cmd, self._cmd_queue, minclock, minsystime)
class MCU:
error = error
@ -505,10 +516,12 @@ class MCU:
for c in self._init_cmds:
self._serial.send(c)
def _send_get_config(self):
get_config_cmd = self.lookup_command("get_config")
get_config_cmd = self.lookup_query_command(
"get_config",
"config is_config=%c crc=%u move_count=%hu is_shutdown=%c")
if self.is_fileoutput():
return { 'is_config': 0, 'move_count': 500, 'crc': 0 }
config_params = get_config_cmd.send_with_response(response='config')
config_params = get_config_cmd.send()
if self._is_shutdown:
raise error("MCU '%s' error during config: %s" % (
self._name, self._shutdown_msg))
@ -624,10 +637,11 @@ class MCU:
def alloc_command_queue(self):
return self._serial.alloc_command_queue()
def lookup_command(self, msgformat, cq=None):
if cq is None:
cq = self._serial.get_default_command_queue()
cmd = self._serial.get_msgparser().lookup_command(msgformat)
return CommandWrapper(self, self._serial, self._clocksync, cmd, cq)
return CommandWrapper(self._serial, msgformat, cq)
def lookup_query_command(self, msgformat, respformat, oid=None,
cq=None, async=False):
return CommandQueryWrapper(self._serial, msgformat, respformat, oid,
cq, async)
def try_lookup_command(self, msgformat):
try:
return self.lookup_command(msgformat)

2
klippy/serialhdl.py
View File

@ -145,6 +145,8 @@ class SerialReader:
self.ffi_lib.serialqueue_get_stats(
self.serialqueue, self.stats_buf, len(self.stats_buf))
return self.ffi_main.string(self.stats_buf)
def get_reactor(self):
return self.reactor
def get_msgparser(self):
return self.msgparser
def get_default_command_queue(self):

8
klippy/stepper.py
View File

@ -84,8 +84,9 @@ class MCU_stepper:
"set_next_step_dir oid=%c dir=%c")
self._reset_cmd_id = self._mcu.lookup_command_id(
"reset_step_clock oid=%c clock=%u")
self._get_position_cmd = self._mcu.lookup_command(
"stepper_get_position oid=%c")
self._get_position_cmd = self._mcu.lookup_query_command(
"stepper_get_position oid=%c",
"stepper_position oid=%c pos=%i", oid=self._oid)
self._ffi_lib.stepcompress_fill(
self._stepqueue, self._mcu.seconds_to_clock(max_error),
self._invert_dir, step_cmd_id, dir_cmd_id)
@ -134,8 +135,7 @@ class MCU_stepper:
raise error("Internal error in stepcompress")
if not did_trigger or self._mcu.is_fileoutput():
return
params = self._get_position_cmd.send_with_response(
[self._oid], response='stepper_position', response_oid=self._oid)
params = self._get_position_cmd.send([self._oid])
mcu_pos_dist = params['pos'] * self._step_dist
if self._invert_dir:
mcu_pos_dist = -mcu_pos_dist