From 245917bf034804acfa3039ac308c7d4308e79e86 Mon Sep 17 00:00:00 2001 From: Kevin O'Connor Date: Wed, 19 Feb 2020 16:46:06 -0500 Subject: 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 --- klippy/mcu.py | 88 ++++++++++++++++++++++++++++++++++------------------------- 1 file changed, 51 insertions(+), 37 deletions(-) (limited to 'klippy/mcu.py') diff --git a/klippy/mcu.py b/klippy/mcu.py index 4be952f2..4064b8e0 100644 --- a/klippy/mcu.py +++ b/klippy/mcu.py @@ -1,6 +1,6 @@ # Interface to Klipper micro-controller code # -# Copyright (C) 2016-2019 Kevin O'Connor +# Copyright (C) 2016-2020 Kevin O'Connor # # 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 command sending -class CommandWrapper: - def __init__(self, mcu, serial, clocksync, cmd, cmd_queue): - self._mcu = mcu +# Wrapper around query commands +class CommandQueryWrapper: + def __init__(self, serial, msgformat, respformat, oid=None, + cmd_queue=None, async=False): self._serial = serial - self._clocksync = clocksync - self._cmd = cmd + 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, 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): + def send(self, data=(), minclock=0): cmd = self._cmd.encode(data) - src = serialhdl.SerialRetryCommand(self._serial, response, response_oid) + xh = self._xmit_helper(self._serial, self._response, self._oid) try: - return src.get_response(cmd, self._cmd_queue, minclock=minclock) + return xh.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) + +# Wrapper around command sending +class CommandWrapper: + def __init__(self, serial, msgformat, cmd_queue=None): + self._serial = serial + 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) - src = RetryAsyncCommand(self._mcu, self._serial, response, response_oid) - return src.get_response(cmd, self._cmd_queue, minclock, minsystime) + self._serial.raw_send(cmd, minclock, reqclock, self._cmd_queue) 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) -- cgit v1.2.3-70-g09d2