| 
									
										
										
										
											2017-06-27 20:23:30 -04:00
										 |  |  | #!/usr/bin/env python2 | 
					
						
							| 
									
										
										
										
											2016-05-25 11:37:40 -04:00
										 |  |  | # Script to implement a test console with firmware over serial port | 
					
						
							|  |  |  | # | 
					
						
							| 
									
										
										
										
											2017-04-25 11:16:02 -04:00
										 |  |  | # Copyright (C) 2016,2017  Kevin O'Connor <kevin@koconnor.net> | 
					
						
							| 
									
										
										
										
											2016-05-25 11:37:40 -04:00
										 |  |  | # | 
					
						
							|  |  |  | # This file may be distributed under the terms of the GNU GPLv3 license. | 
					
						
							|  |  |  | import sys, optparse, os, re, logging | 
					
						
							| 
									
										
										
										
											2017-09-18 21:41:00 -04:00
										 |  |  | import reactor, serialhdl, pins, util, msgproto, clocksync | 
					
						
							| 
									
										
										
										
											2016-05-25 11:37:40 -04:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2017-08-07 20:05:19 -04:00
										 |  |  | help_txt = """
 | 
					
						
							|  |  |  |   This is a debugging console for the Klipper micro-controller. | 
					
						
							|  |  |  |   In addition to mcu commands, the following artificial commands are | 
					
						
							|  |  |  |   available: | 
					
						
							|  |  |  |     PINS  : Load pin name aliases (eg, "PINS arduino") | 
					
						
							|  |  |  |     DELAY : Send a command at a clock time (eg, "DELAY 9999 get_uptime") | 
					
						
							| 
									
										
										
										
											2017-09-06 15:40:23 -04:00
										 |  |  |     FLOOD : Send a command many times (eg, "FLOOD 22 .01 get_uptime") | 
					
						
							| 
									
										
										
										
											2018-11-16 17:16:14 -05:00
										 |  |  |     SUPPRESS : Suppress a response message (eg, "SUPPRESS analog_in_state 4") | 
					
						
							| 
									
										
										
										
											2017-08-07 20:05:19 -04:00
										 |  |  |     SET   : Create a local variable (eg, "SET myvar 123.4") | 
					
						
							| 
									
										
										
										
											2017-08-07 20:49:42 -04:00
										 |  |  |     STATS : Report serial statistics | 
					
						
							| 
									
										
										
										
											2017-08-07 20:40:32 -04:00
										 |  |  |     LIST  : List available mcu commands, local commands, and local variables | 
					
						
							| 
									
										
										
										
											2017-08-07 20:05:19 -04:00
										 |  |  |     HELP  : Show this text | 
					
						
							|  |  |  |   All commands also support evaluation by enclosing an expression in { }. | 
					
						
							|  |  |  |   For example, "reset_step_clock oid=4 clock={clock + freq}".  In addition | 
					
						
							|  |  |  |   to user defined variables (via the SET command) the following builtin | 
					
						
							|  |  |  |   variables may be used in expressions: | 
					
						
							|  |  |  |     clock : The current mcu clock time (as estimated by the host) | 
					
						
							|  |  |  |     freq  : The mcu clock frequency | 
					
						
							|  |  |  | """
 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2016-05-25 11:37:40 -04:00
										 |  |  | re_eval = re.compile(r'\{(?P<eval>[^}]*)\}') | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | class KeyboardReader: | 
					
						
							|  |  |  |     def __init__(self, ser, reactor): | 
					
						
							|  |  |  |         self.ser = ser | 
					
						
							|  |  |  |         self.reactor = reactor | 
					
						
							| 
									
										
										
										
											2018-05-16 09:27:50 -04:00
										 |  |  |         self.start_time = reactor.monotonic() | 
					
						
							| 
									
										
										
										
											2017-09-18 21:41:00 -04:00
										 |  |  |         self.clocksync = clocksync.ClockSync(self.reactor) | 
					
						
							| 
									
										
										
										
											2016-05-25 11:37:40 -04:00
										 |  |  |         self.fd = sys.stdin.fileno() | 
					
						
							|  |  |  |         util.set_nonblock(self.fd) | 
					
						
							| 
									
										
										
										
											2017-03-12 19:55:56 -04:00
										 |  |  |         self.mcu_freq = 0 | 
					
						
							| 
									
										
										
										
											2016-05-25 11:37:40 -04:00
										 |  |  |         self.pins = None | 
					
						
							|  |  |  |         self.data = "" | 
					
						
							| 
									
										
										
										
											2016-11-27 17:45:58 -05:00
										 |  |  |         reactor.register_fd(self.fd, self.process_kbd) | 
					
						
							| 
									
										
										
										
											2018-09-02 12:31:36 -04:00
										 |  |  |         reactor.register_callback(self.connect) | 
					
						
							| 
									
										
										
										
											2017-06-21 15:50:41 -04:00
										 |  |  |         self.local_commands = { | 
					
						
							| 
									
										
										
										
											2017-08-07 20:05:19 -04:00
										 |  |  |             "PINS": self.command_PINS, "SET": self.command_SET, | 
					
						
							| 
									
										
										
										
											2017-09-06 15:40:23 -04:00
										 |  |  |             "DELAY": self.command_DELAY, "FLOOD": self.command_FLOOD, | 
					
						
							| 
									
										
										
										
											2017-09-06 16:34:55 -04:00
										 |  |  |             "SUPPRESS": self.command_SUPPRESS, "STATS": self.command_STATS, | 
					
						
							|  |  |  |             "LIST": self.command_LIST, "HELP": self.command_HELP, | 
					
						
							| 
									
										
										
										
											2017-06-21 15:50:41 -04:00
										 |  |  |         } | 
					
						
							| 
									
										
										
										
											2016-05-25 11:37:40 -04:00
										 |  |  |         self.eval_globals = {} | 
					
						
							| 
									
										
										
										
											2016-11-27 17:45:58 -05:00
										 |  |  |     def connect(self, eventtime): | 
					
						
							| 
									
										
										
										
											2017-08-07 20:05:19 -04:00
										 |  |  |         self.output(help_txt) | 
					
						
							|  |  |  |         self.output("="*20 + " attempting to connect " + "="*20) | 
					
						
							| 
									
										
										
										
											2016-11-27 17:45:58 -05:00
										 |  |  |         self.ser.connect() | 
					
						
							| 
									
										
										
										
											2019-06-20 22:08:38 -04:00
										 |  |  |         msgparser = self.ser.get_msgparser() | 
					
						
							| 
									
										
										
										
											2018-04-03 12:13:06 -04:00
										 |  |  |         self.output("Loaded %d commands (%s / %s)" % ( | 
					
						
							|  |  |  |             len(msgparser.messages_by_id), | 
					
						
							|  |  |  |             msgparser.version, msgparser.build_versions)) | 
					
						
							|  |  |  |         self.output("MCU config: %s" % (" ".join( | 
					
						
							|  |  |  |             ["%s=%s" % (k, v) for k, v in msgparser.config.items()]))) | 
					
						
							| 
									
										
										
										
											2017-09-18 21:41:00 -04:00
										 |  |  |         self.clocksync.connect(self.ser) | 
					
						
							| 
									
										
										
										
											2017-04-25 11:15:15 -04:00
										 |  |  |         self.ser.handle_default = self.handle_default | 
					
						
							| 
									
										
										
										
											2019-06-20 17:36:46 -04:00
										 |  |  |         self.ser.register_response(self.handle_output, '#output') | 
					
						
							| 
									
										
										
										
											2018-04-03 12:13:06 -04:00
										 |  |  |         self.mcu_freq = msgparser.get_constant_float('CLOCK_FREQ') | 
					
						
							|  |  |  |         mcu_type = msgparser.get_constant('MCU') | 
					
						
							| 
									
										
										
										
											2019-03-31 20:30:14 -04:00
										 |  |  |         self.pins = pins.PinResolver(mcu_type, {}, validate_aliases=False) | 
					
						
							| 
									
										
										
										
											2017-08-07 20:05:19 -04:00
										 |  |  |         self.output("="*20 + "       connected       " + "="*20) | 
					
						
							| 
									
										
										
										
											2016-11-27 17:45:58 -05:00
										 |  |  |         return self.reactor.NEVER | 
					
						
							| 
									
										
										
										
											2017-04-25 11:16:02 -04:00
										 |  |  |     def output(self, msg): | 
					
						
							|  |  |  |         sys.stdout.write("%s\n" % (msg,)) | 
					
						
							|  |  |  |         sys.stdout.flush() | 
					
						
							| 
									
										
										
										
											2017-04-25 11:15:15 -04:00
										 |  |  |     def handle_default(self, params): | 
					
						
							| 
									
										
										
										
											2018-05-16 09:27:50 -04:00
										 |  |  |         tdiff = params['#receive_time'] - self.start_time | 
					
						
							| 
									
										
										
										
											2019-06-20 22:08:38 -04:00
										 |  |  |         msg = self.ser.get_msgparser().format_params(params) | 
					
						
							|  |  |  |         self.output("%07.3f: %s" % (tdiff, msg)) | 
					
						
							| 
									
										
										
										
											2018-05-16 09:27:50 -04:00
										 |  |  |     def handle_output(self, params): | 
					
						
							|  |  |  |         tdiff = params['#receive_time'] - self.start_time | 
					
						
							|  |  |  |         self.output("%07.3f: %s: %s" % (tdiff, params['#name'], params['#msg'])) | 
					
						
							| 
									
										
										
										
											2017-09-06 16:34:55 -04:00
										 |  |  |     def handle_suppress(self, params): | 
					
						
							|  |  |  |         pass | 
					
						
							| 
									
										
										
										
											2016-05-25 11:37:40 -04:00
										 |  |  |     def update_evals(self, eventtime): | 
					
						
							| 
									
										
										
										
											2017-03-12 19:55:56 -04:00
										 |  |  |         self.eval_globals['freq'] = self.mcu_freq | 
					
						
							| 
									
										
										
										
											2017-09-18 21:41:00 -04:00
										 |  |  |         self.eval_globals['clock'] = self.clocksync.get_clock(eventtime) | 
					
						
							| 
									
										
										
										
											2017-08-07 20:05:19 -04:00
										 |  |  |     def command_PINS(self, parts): | 
					
						
							| 
									
										
										
										
											2018-01-10 18:34:42 -05:00
										 |  |  |         self.pins.update_aliases(parts[1]) | 
					
						
							| 
									
										
										
										
											2017-08-07 20:05:19 -04:00
										 |  |  |     def command_SET(self, parts): | 
					
						
							| 
									
										
										
										
											2016-06-11 22:31:05 -04:00
										 |  |  |         val = parts[2] | 
					
						
							|  |  |  |         try: | 
					
						
							| 
									
										
										
										
											2017-04-25 11:19:35 -04:00
										 |  |  |             val = float(val) | 
					
						
							| 
									
										
										
										
											2016-06-11 22:31:05 -04:00
										 |  |  |         except ValueError: | 
					
						
							| 
									
										
										
										
											2017-04-25 11:19:35 -04:00
										 |  |  |             pass | 
					
						
							| 
									
										
										
										
											2016-06-11 22:31:05 -04:00
										 |  |  |         self.eval_globals[parts[1]] = val | 
					
						
							| 
									
										
										
										
											2017-08-07 20:05:19 -04:00
										 |  |  |     def command_DELAY(self, parts): | 
					
						
							| 
									
										
										
										
											2017-06-21 15:50:41 -04:00
										 |  |  |         try: | 
					
						
							|  |  |  |             val = int(parts[1]) | 
					
						
							|  |  |  |         except ValueError as e: | 
					
						
							|  |  |  |             self.output("Error: %s" % (str(e),)) | 
					
						
							|  |  |  |             return | 
					
						
							|  |  |  |         try: | 
					
						
							| 
									
										
										
										
											2018-02-27 14:16:16 -05:00
										 |  |  |             self.ser.send(' '.join(parts[2:]), minclock=val) | 
					
						
							| 
									
										
										
										
											2017-06-21 15:50:41 -04:00
										 |  |  |         except msgproto.error as e: | 
					
						
							|  |  |  |             self.output("Error: %s" % (str(e),)) | 
					
						
							|  |  |  |             return | 
					
						
							| 
									
										
										
										
											2017-09-06 15:40:23 -04:00
										 |  |  |     def command_FLOOD(self, parts): | 
					
						
							|  |  |  |         try: | 
					
						
							|  |  |  |             count = int(parts[1]) | 
					
						
							|  |  |  |             delay = float(parts[2]) | 
					
						
							|  |  |  |         except ValueError as e: | 
					
						
							|  |  |  |             self.output("Error: %s" % (str(e),)) | 
					
						
							|  |  |  |             return | 
					
						
							| 
									
										
										
										
											2018-02-27 14:16:16 -05:00
										 |  |  |         msg = ' '.join(parts[3:]) | 
					
						
							|  |  |  |         delay_clock = int(delay * self.mcu_freq) | 
					
						
							|  |  |  |         msg_clock = int(self.clocksync.get_clock(self.reactor.monotonic()) | 
					
						
							|  |  |  |                         + self.mcu_freq * .200) | 
					
						
							| 
									
										
										
										
											2017-09-06 15:40:23 -04:00
										 |  |  |         try: | 
					
						
							| 
									
										
										
										
											2018-02-27 14:16:16 -05:00
										 |  |  |             for i in range(count): | 
					
						
							|  |  |  |                 next_clock = msg_clock + delay_clock | 
					
						
							|  |  |  |                 self.ser.send(msg, minclock=msg_clock, reqclock=next_clock) | 
					
						
							|  |  |  |                 msg_clock = next_clock | 
					
						
							| 
									
										
										
										
											2017-09-06 15:40:23 -04:00
										 |  |  |         except msgproto.error as e: | 
					
						
							|  |  |  |             self.output("Error: %s" % (str(e),)) | 
					
						
							|  |  |  |             return | 
					
						
							| 
									
										
										
										
											2017-09-06 16:34:55 -04:00
										 |  |  |     def command_SUPPRESS(self, parts): | 
					
						
							|  |  |  |         oid = None | 
					
						
							|  |  |  |         try: | 
					
						
							|  |  |  |             name = parts[1] | 
					
						
							|  |  |  |             if len(parts) > 2: | 
					
						
							|  |  |  |                 oid = int(parts[2]) | 
					
						
							|  |  |  |         except ValueError as e: | 
					
						
							|  |  |  |             self.output("Error: %s" % (str(e),)) | 
					
						
							|  |  |  |             return | 
					
						
							| 
									
										
										
										
											2019-06-20 17:36:46 -04:00
										 |  |  |         self.ser.register_response(self.handle_suppress, name, oid) | 
					
						
							| 
									
										
										
										
											2017-08-07 20:49:42 -04:00
										 |  |  |     def command_STATS(self, parts): | 
					
						
							| 
									
										
										
										
											2017-09-18 21:41:00 -04:00
										 |  |  |         curtime = self.reactor.monotonic() | 
					
						
							|  |  |  |         self.output(' '.join([self.ser.stats(curtime), | 
					
						
							|  |  |  |                               self.clocksync.stats(curtime)])) | 
					
						
							| 
									
										
										
										
											2017-08-07 20:40:32 -04:00
										 |  |  |     def command_LIST(self, parts): | 
					
						
							|  |  |  |         self.update_evals(self.reactor.monotonic()) | 
					
						
							| 
									
										
										
										
											2019-06-20 22:08:38 -04:00
										 |  |  |         mp = self.ser.get_msgparser() | 
					
						
							| 
									
										
										
										
											2017-08-07 20:40:32 -04:00
										 |  |  |         out = "Available mcu commands:" | 
					
						
							|  |  |  |         out += "\n  ".join([""] + sorted([ | 
					
						
							|  |  |  |             mp.messages_by_id[i].msgformat for i in mp.command_ids])) | 
					
						
							|  |  |  |         out += "\nAvailable artificial commands:" | 
					
						
							|  |  |  |         out += "\n  ".join([""] + [n for n in sorted(self.local_commands)]) | 
					
						
							|  |  |  |         out += "\nAvailable local variables:" | 
					
						
							| 
									
										
										
										
											2019-02-27 13:00:30 -05:00
										 |  |  |         lvars = sorted(self.eval_globals.items()) | 
					
						
							|  |  |  |         out += "\n  ".join([""] + ["%s: %s" % (k, v) for k, v in lvars]) | 
					
						
							| 
									
										
										
										
											2017-08-07 20:40:32 -04:00
										 |  |  |         self.output(out) | 
					
						
							| 
									
										
										
										
											2017-08-07 20:05:19 -04:00
										 |  |  |     def command_HELP(self, parts): | 
					
						
							|  |  |  |         self.output(help_txt) | 
					
						
							| 
									
										
										
										
											2016-05-25 11:37:40 -04:00
										 |  |  |     def translate(self, line, eventtime): | 
					
						
							|  |  |  |         evalparts = re_eval.split(line) | 
					
						
							|  |  |  |         if len(evalparts) > 1: | 
					
						
							|  |  |  |             self.update_evals(eventtime) | 
					
						
							|  |  |  |             try: | 
					
						
							|  |  |  |                 for i in range(1, len(evalparts), 2): | 
					
						
							| 
									
										
										
										
											2017-08-07 20:40:32 -04:00
										 |  |  |                     e = eval(evalparts[i], dict(self.eval_globals)) | 
					
						
							| 
									
										
										
										
											2017-04-25 11:19:35 -04:00
										 |  |  |                     if type(e) == type(0.): | 
					
						
							|  |  |  |                         e = int(e) | 
					
						
							|  |  |  |                     evalparts[i] = str(e) | 
					
						
							| 
									
										
										
										
											2016-05-25 11:37:40 -04:00
										 |  |  |             except: | 
					
						
							| 
									
										
										
										
											2017-04-25 11:16:02 -04:00
										 |  |  |                 self.output("Unable to evaluate: %s" % (line,)) | 
					
						
							| 
									
										
										
										
											2016-05-25 11:37:40 -04:00
										 |  |  |                 return None | 
					
						
							|  |  |  |             line = ''.join(evalparts) | 
					
						
							| 
									
										
										
										
											2017-04-25 11:16:02 -04:00
										 |  |  |             self.output("Eval: %s" % (line,)) | 
					
						
							| 
									
										
										
										
											2016-05-25 11:37:40 -04:00
										 |  |  |         if self.pins is not None: | 
					
						
							|  |  |  |             try: | 
					
						
							| 
									
										
										
										
											2018-01-10 18:34:42 -05:00
										 |  |  |                 line = self.pins.update_command(line).strip() | 
					
						
							| 
									
										
										
										
											2016-05-25 11:37:40 -04:00
										 |  |  |             except: | 
					
						
							| 
									
										
										
										
											2017-04-25 11:16:02 -04:00
										 |  |  |                 self.output("Unable to map pin: %s" % (line,)) | 
					
						
							| 
									
										
										
										
											2016-05-25 11:37:40 -04:00
										 |  |  |                 return None | 
					
						
							|  |  |  |         if line: | 
					
						
							|  |  |  |             parts = line.split() | 
					
						
							|  |  |  |             if parts[0] in self.local_commands: | 
					
						
							|  |  |  |                 self.local_commands[parts[0]](parts) | 
					
						
							|  |  |  |                 return None | 
					
						
							| 
									
										
										
										
											2018-02-27 14:16:16 -05:00
										 |  |  |         return line | 
					
						
							| 
									
										
										
										
											2016-05-25 11:37:40 -04:00
										 |  |  |     def process_kbd(self, eventtime): | 
					
						
							|  |  |  |         self.data += os.read(self.fd, 4096) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |         kbdlines = self.data.split('\n') | 
					
						
							|  |  |  |         for line in kbdlines[:-1]: | 
					
						
							|  |  |  |             line = line.strip() | 
					
						
							|  |  |  |             cpos = line.find('#') | 
					
						
							|  |  |  |             if cpos >= 0: | 
					
						
							|  |  |  |                 line = line[:cpos] | 
					
						
							|  |  |  |                 if not line: | 
					
						
							|  |  |  |                     continue | 
					
						
							|  |  |  |             msg = self.translate(line.strip(), eventtime) | 
					
						
							|  |  |  |             if msg is None: | 
					
						
							|  |  |  |                 continue | 
					
						
							| 
									
										
										
										
											2018-02-27 14:16:16 -05:00
										 |  |  |             try: | 
					
						
							|  |  |  |                 self.ser.send(msg) | 
					
						
							|  |  |  |             except msgproto.error as e: | 
					
						
							|  |  |  |                 self.output("Error: %s" % (str(e),)) | 
					
						
							| 
									
										
										
										
											2016-05-25 11:37:40 -04:00
										 |  |  |         self.data = kbdlines[-1] | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | def main(): | 
					
						
							|  |  |  |     usage = "%prog [options] <serialdevice> <baud>" | 
					
						
							|  |  |  |     opts = optparse.OptionParser(usage) | 
					
						
							|  |  |  |     options, args = opts.parse_args() | 
					
						
							|  |  |  |     serialport, baud = args | 
					
						
							|  |  |  |     baud = int(baud) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  |     logging.basicConfig(level=logging.DEBUG) | 
					
						
							|  |  |  |     r = reactor.Reactor() | 
					
						
							|  |  |  |     ser = serialhdl.SerialReader(r, serialport, baud) | 
					
						
							|  |  |  |     kbd = KeyboardReader(ser, r) | 
					
						
							|  |  |  |     try: | 
					
						
							|  |  |  |         r.run() | 
					
						
							|  |  |  |     except KeyboardInterrupt: | 
					
						
							|  |  |  |         sys.stdout.write("\n") | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | if __name__ == '__main__': | 
					
						
							|  |  |  |     main() |