From daff83ee9a7366c23470a78d30d20df3881293c0 Mon Sep 17 00:00:00 2001 From: Kevin O'Connor Date: Thu, 13 Apr 2017 12:09:37 -0400 Subject: [PATCH] hub-ctrl: Add support for micro-controller reset via RPi usb power toggling Signed-off-by: Kevin O'Connor --- config/example.cfg | 9 +- docs/Installation.md | 2 +- klippy/chelper.py | 41 +++- klippy/mcu.py | 34 +++- lib/README | 4 + lib/hub-ctrl/hub-ctrl.c | 412 ++++++++++++++++++++++++++++++++++++++++ 6 files changed, 480 insertions(+), 22 deletions(-) create mode 100644 lib/hub-ctrl/hub-ctrl.c diff --git a/config/example.cfg b/config/example.cfg index 65b6ddee..08a778c9 100644 --- a/config/example.cfg +++ b/config/example.cfg @@ -245,9 +245,12 @@ pin_map: arduino # default is to not enable the aliases. #restart_method: arduino # This controls the mechanism the host will use to reset the -# micro-controller. The choices are 'arduino' and 'command'. The -# 'arduino' method (toggle DTR; set baud to 1200) is common on -# Arduino boards and clones. The 'command' method involves sending a +# micro-controller. The choices are 'arduino', 'rpi_usb', and +# 'command'. The 'arduino' method (toggle DTR; set baud to 1200) is +# common on Arduino boards and clones. The 'rpi_usb' method is +# useful on Raspberry Pi boards with micro-controllers powered over +# USB - it briefly disables power to all USB ports to accomplish a +# micro-controller reset. The 'command' method involves sending a # Klipper command to the micro-controller so that it can reset # itself. The default is 'arduino'. custom: diff --git a/docs/Installation.md b/docs/Installation.md index 7a219344..5c87d2e8 100644 --- a/docs/Installation.md +++ b/docs/Installation.md @@ -24,7 +24,7 @@ following commands: ``` sudo apt-get update -sudo apt-get install libncurses-dev +sudo apt-get install libncurses-dev libusb-dev sudo apt-get install avrdude gcc-avr binutils-avr avr-libc # AVR toolchain sudo apt-get install bossa-cli libnewlib-arm-none-eabi # ARM toolchain ``` diff --git a/klippy/chelper.py b/klippy/chelper.py index b05bc74c..7b4b510a 100644 --- a/klippy/chelper.py +++ b/klippy/chelper.py @@ -1,11 +1,16 @@ # Wrapper around C helper code # -# Copyright (C) 2016 Kevin O'Connor +# Copyright (C) 2016,2017 Kevin O'Connor # # This file may be distributed under the terms of the GNU GPLv3 license. import os, logging import cffi + +###################################################################### +# c_helper.so compiling +###################################################################### + COMPILE_CMD = "gcc -Wall -g -O2 -shared -fPIC -o %s %s" SOURCE_FILES = ['stepcompress.c', 'serialqueue.c', 'pyhelper.c'] DEST_LIB = "c_helper.so" @@ -79,14 +84,14 @@ def get_mtimes(srcdir, filelist): return out # Check if the code needs to be compiled -def check_build_code(srcdir): - src_times = get_mtimes(srcdir, SOURCE_FILES + OTHER_FILES) - obj_times = get_mtimes(srcdir, [DEST_LIB]) +def check_build_code(srcdir, target, sources, cmd, other_files=[]): + src_times = get_mtimes(srcdir, sources + other_files) + obj_times = get_mtimes(srcdir, [target]) if not obj_times or max(src_times) > min(obj_times): - logging.info("Building C code module") - srcfiles = [os.path.join(srcdir, fname) for fname in SOURCE_FILES] - destlib = os.path.join(srcdir, DEST_LIB) - os.system(COMPILE_CMD % (destlib, ' '.join(srcfiles))) + logging.info("Building C code module %s" % (target,)) + srcfiles = [os.path.join(srcdir, fname) for fname in sources] + destlib = os.path.join(srcdir, target) + os.system(cmd % (destlib, ' '.join(srcfiles))) FFI_main = None FFI_lib = None @@ -97,7 +102,8 @@ def get_ffi(): global FFI_main, FFI_lib, pyhelper_logging_callback if FFI_lib is None: srcdir = os.path.dirname(os.path.realpath(__file__)) - check_build_code(srcdir) + check_build_code(srcdir, DEST_LIB, SOURCE_FILES, COMPILE_CMD + , OTHER_FILES) FFI_main = cffi.FFI() FFI_main.cdef(defs_stepcompress) FFI_main.cdef(defs_serialqueue) @@ -110,3 +116,20 @@ def get_ffi(): "void(const char *)", logging_callback) FFI_lib.set_python_logging_callback(pyhelper_logging_callback) return FFI_main, FFI_lib + + +###################################################################### +# hub-ctrl hub power controller +###################################################################### + +HC_COMPILE_CMD = "gcc -Wall -g -O2 -o %s %s -lusb" +HC_SOURCE_FILES = ['hub-ctrl.c'] +HC_SOURCE_DIR = '../lib/hub-ctrl' +HC_TARGET = "hub-ctrl" +HC_CMD = "sudo %s/hub-ctrl -h 0 -P 2 -p %d" + +def run_hub_ctrl(enable_power): + srcdir = os.path.dirname(os.path.realpath(__file__)) + hubdir = os.path.join(srcdir, HC_SOURCE_DIR) + check_build_code(hubdir, HC_TARGET, HC_SOURCE_FILES, HC_COMPILE_CMD) + os.system(HC_CMD % (hubdir, enable_power)) diff --git a/klippy/mcu.py b/klippy/mcu.py index 4601e769..0f97205d 100644 --- a/klippy/mcu.py +++ b/klippy/mcu.py @@ -1,9 +1,9 @@ # Multi-processor safe interface to micro-controller # -# Copyright (C) 2016 Kevin O'Connor +# Copyright (C) 2016,2017 Kevin O'Connor # # This file may be distributed under the terms of the GNU GPLv3 license. -import sys, zlib, logging, math +import sys, os, zlib, logging, math import serialhdl, pins, chelper class error(Exception): @@ -381,7 +381,7 @@ class MCU: self._is_fileoutput = False self._timeout_timer = printer.reactor.register_timer( self.timeout_handler) - rmethods = {m: m for m in ['arduino', 'command']} + rmethods = {m: m for m in ['arduino', 'command', 'rpi_usb']} self._restart_method = config.getchoice( 'restart_method', rmethods, 'arduino') # Config building @@ -424,8 +424,19 @@ class MCU: self.serial.dump_debug() self._printer.note_shutdown(self._shutdown_msg) # Connection phase + def _check_restart(self, reason): + if self._printer.get_startup_state() == '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 not self._is_fileoutput: + 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) @@ -478,6 +489,13 @@ class MCU: self.send(self._clear_shutdown_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() @@ -539,6 +557,9 @@ class MCU: 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: @@ -551,12 +572,7 @@ class MCU: self._shutdown_msg,)) raise error("Unable to configure printer") if self._config_crc != config_params['crc']: - if self._printer.get_startup_state() != 'firmware_restart': - # Attempt a firmware restart to fix the CRC error - logging.info( - "Printer CRC mismatch - attempting firmware restart") - self._printer.request_exit('firmware_restart') - self._printer.reactor.pause(0.100) + 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,)) diff --git a/lib/README b/lib/README index 5006043f..6719b964 100644 --- a/lib/README +++ b/lib/README @@ -10,3 +10,7 @@ The cmsis-sam3x8e directory contains code from the Arduino project: version 1.5.1 (extracted on 20160608). It has been modified to compile with gcc's LTO feature. See cmsis-sam3x8e.patch for the modifications. + +The hub-ctrl directory contains code from: + https://github.com/codazoda/hub-ctrl.c/ +revision 42095e522859059e8a5f4ec05c1e3def01a870a9. diff --git a/lib/hub-ctrl/hub-ctrl.c b/lib/hub-ctrl/hub-ctrl.c new file mode 100644 index 00000000..6a0ff6af --- /dev/null +++ b/lib/hub-ctrl/hub-ctrl.c @@ -0,0 +1,412 @@ +/* + * Copyright (C) 2006 Free Software Initiative of Japan + * + * Author: NIIBE Yutaka + * + * This file can be distributed under the terms and conditions of the + * GNU General Public License version 2 (or later). + * + */ + +#include +#include +#include +#include + +#define USB_RT_HUB (USB_TYPE_CLASS | USB_RECIP_DEVICE) +#define USB_RT_PORT (USB_TYPE_CLASS | USB_RECIP_OTHER) +#define USB_PORT_FEAT_POWER 8 +#define USB_PORT_FEAT_INDICATOR 22 +#define USB_DIR_IN 0x80 /* to host */ + +#define COMMAND_SET_NONE 0 +#define COMMAND_SET_LED 1 +#define COMMAND_SET_POWER 2 +#define HUB_LED_GREEN 2 + +static void +usage (const char *progname) +{ + fprintf (stderr, + "Usage: %s [{-h HUBNUM | -b BUSNUM -d DEVNUM}] \\\n" + " [-P PORT] [{-p [VALUE]|-l [VALUE]}]\n", progname); +} + +static void +exit_with_usage (const char *progname) +{ + usage (progname); + exit (1); +} + +#define HUB_CHAR_LPSM 0x0003 +#define HUB_CHAR_PORTIND 0x0080 + +struct usb_hub_descriptor { + unsigned char bDescLength; + unsigned char bDescriptorType; + unsigned char bNbrPorts; + unsigned char wHubCharacteristics[2]; + unsigned char bPwrOn2PwrGood; + unsigned char bHubContrCurrent; + unsigned char data[0]; +}; + +#define CTRL_TIMEOUT 1000 +#define USB_STATUS_SIZE 4 + +#define MAX_HUBS 128 +struct hub_info { + int busnum, devnum; + struct usb_device *dev; + int nport; + int indicator_support; +}; + +static struct hub_info hubs[MAX_HUBS]; +static int number_of_hubs_with_feature; + +static void +hub_port_status (usb_dev_handle *uh, int nport) +{ + int i; + + printf(" Hub Port Status:\n"); + for (i = 0; i < nport; i++) + { + char buf[USB_STATUS_SIZE]; + int ret; + + ret = usb_control_msg (uh, + USB_ENDPOINT_IN | USB_TYPE_CLASS | USB_RECIP_OTHER, + USB_REQ_GET_STATUS, + 0, i + 1, + buf, USB_STATUS_SIZE, + CTRL_TIMEOUT); + if (ret < 0) + { + fprintf (stderr, + "cannot read port %d status, %s (%d)\n", + i + 1, strerror(errno), errno); + break; + } + + printf(" Port %d: %02x%02x.%02x%02x", i + 1, + buf[3], buf [2], + buf[1], buf [0]); + + printf("%s%s%s%s%s", + (buf[2] & 0x10) ? " C_RESET" : "", + (buf[2] & 0x08) ? " C_OC" : "", + (buf[2] & 0x04) ? " C_SUSPEND" : "", + (buf[2] & 0x02) ? " C_ENABLE" : "", + (buf[2] & 0x01) ? " C_CONNECT" : ""); + + printf("%s%s%s%s%s%s%s%s%s%s\n", + (buf[1] & 0x10) ? " indicator" : "", + (buf[1] & 0x08) ? " test" : "", + (buf[1] & 0x04) ? " highspeed" : "", + (buf[1] & 0x02) ? " lowspeed" : "", + (buf[1] & 0x01) ? " power" : "", + (buf[0] & 0x10) ? " RESET" : "", + (buf[0] & 0x08) ? " oc" : "", + (buf[0] & 0x04) ? " suspend" : "", + (buf[0] & 0x02) ? " enable" : "", + (buf[0] & 0x01) ? " connect" : ""); + } +} + +static int +usb_find_hubs (int listing, int verbose, int busnum, int devnum, int hub) +{ + struct usb_bus *busses; + struct usb_bus *bus; + + number_of_hubs_with_feature = 0; + busses = usb_get_busses(); + if (busses == NULL) + { + perror ("failed to access USB"); + return -1; + } + + for (bus = busses; bus; bus = bus->next) + { + struct usb_device *dev; + + for (dev = bus->devices; dev; dev = dev->next) + { + usb_dev_handle *uh; + int print = 0; + + if (dev->descriptor.bDeviceClass != USB_CLASS_HUB) + continue; + + if (listing + || (verbose + && ((atoi (bus->dirname) == busnum && dev->devnum == devnum) + || hub == number_of_hubs_with_feature))) + print = 1; + + uh = usb_open (dev); + + if (uh != NULL) + { + char buf[1024]; + int len; + int nport; + struct usb_hub_descriptor *uhd = (struct usb_hub_descriptor *)buf; + if ((len = usb_control_msg (uh, USB_DIR_IN | USB_RT_HUB, + USB_REQ_GET_DESCRIPTOR, + USB_DT_HUB << 8, 0, + buf, sizeof (buf), CTRL_TIMEOUT)) + > sizeof (struct usb_hub_descriptor)) + { + if (!(uhd->wHubCharacteristics[0] & HUB_CHAR_PORTIND) + && (uhd->wHubCharacteristics[0] & HUB_CHAR_LPSM) >= 2) + continue; + + if (print) + printf ("Hub #%d at %s:%03d\n", + number_of_hubs_with_feature, + bus->dirname, dev->devnum); + + switch ((uhd->wHubCharacteristics[0] & HUB_CHAR_LPSM)) + { + case 0: + if (print) + fprintf (stderr, " INFO: ganged switching.\n"); + break; + case 1: + if (print) + fprintf (stderr, " INFO: individual power switching.\n"); + break; + case 2: + case 3: + if (print) + fprintf (stderr, " WARN: No power switching.\n"); + break; + } + + if (print + && !(uhd->wHubCharacteristics[0] & HUB_CHAR_PORTIND)) + fprintf (stderr, " WARN: Port indicators are NOT supported.\n"); + } + else + { + perror ("Can't get hub descriptor"); + usb_close (uh); + continue; + } + + nport = buf[2]; + hubs[number_of_hubs_with_feature].busnum = atoi (bus->dirname); + hubs[number_of_hubs_with_feature].devnum = dev->devnum; + hubs[number_of_hubs_with_feature].dev = dev; + hubs[number_of_hubs_with_feature].indicator_support = + (uhd->wHubCharacteristics[0] & HUB_CHAR_PORTIND)? 1 : 0; + hubs[number_of_hubs_with_feature].nport = nport; + + number_of_hubs_with_feature++; + + if (verbose) + hub_port_status (uh, nport); + + usb_close (uh); + } + } + } + + return number_of_hubs_with_feature; +} + +int +get_hub (int busnum, int devnum) +{ + int i; + + for (i = 0; i < number_of_hubs_with_feature; i++) + if (hubs[i].busnum == busnum && hubs[i].devnum == devnum) + return i; + + return -1; +} + +/* + * HUB-CTRL - program to control port power/led of USB hub + * + * # hub-ctrl // List hubs available + * # hub-ctrl -P 1 // Power off at port 1 + * # hub-ctrl -P 1 -p 1 // Power on at port 1 + * # hub-ctrl -P 2 -l // LED on at port 1 + * + * Requirement: USB hub which implements port power control / indicator control + * + * Work fine: + * Elecom's U2H-G4S: www.elecom.co.jp (indicator depends on power) + * 04b4:6560 + * + * Sanwa Supply's USB-HUB14GPH: www.sanwa.co.jp (indicators don't) + * + * Targus, Inc.'s PAUH212: www.targus.com (indicators don't) + * 04cc:1521 + * + * Hawking Technology's UH214: hawkingtech.com (indicators don't) + * + */ + +int +main (int argc, const char *argv[]) +{ + int busnum = 0, devnum = 0; + int cmd = COMMAND_SET_NONE; + int port = 1; + int value = 0; + int request, feature, index; + int result = 0; + int listing = 0; + int verbose = 0; + int hub = -1; + usb_dev_handle *uh = NULL; + int i; + + if (argc == 1) + listing = 1; + + for (i = 1; i < argc; i++) + if (argv[i][0] == '-') + switch (argv[i][1]) + { + case 'h': + if (++i >= argc || busnum > 0 || devnum > 0) + exit_with_usage (argv[0]); + hub = atoi (argv[i]); + break; + + case 'b': + if (++i >= argc || hub >= 0) + exit_with_usage (argv[0]); + busnum = atoi (argv[i]); + break; + + case 'd': + if (++i >= argc || hub >= 0) + exit_with_usage (argv[0]); + devnum = atoi (argv[i]); + break; + + case 'P': + if (++i >= argc) + exit_with_usage (argv[0]); + port = atoi (argv[i]); + break; + + case 'l': + if (cmd != COMMAND_SET_NONE) + exit_with_usage (argv[0]); + if (++i < argc) + value = atoi (argv[i]); + else + value = HUB_LED_GREEN; + cmd = COMMAND_SET_LED; + break; + + case 'p': + if (cmd != COMMAND_SET_NONE) + exit_with_usage (argv[0]); + if (++i < argc) + value = atoi (argv[i]); + else + value= 0; + cmd = COMMAND_SET_POWER; + break; + + case 'v': + verbose = 1; + if (argc == 2) + listing = 1; + break; + + default: + exit_with_usage (argv[0]); + } + else + exit_with_usage (argv[0]); + + if ((busnum > 0 && devnum <= 0) || (busnum <= 0 && devnum > 0)) + /* BUS is specified, but DEV is'nt, or ... */ + exit_with_usage (argv[0]); + + /* Default is the hub #0 */ + if (hub < 0 && busnum == 0) + hub = 0; + + /* Default is POWER */ + if (cmd == COMMAND_SET_NONE) + cmd = COMMAND_SET_POWER; + + usb_init (); + usb_find_busses (); + usb_find_devices (); + + if (usb_find_hubs (listing, verbose, busnum, devnum, hub) <= 0) + { + fprintf (stderr, "No hubs found.\n"); + exit (1); + } + + if (listing) + exit (0); + + if (hub < 0) + hub = get_hub (busnum, devnum); + + if (hub >= 0 && hub < number_of_hubs_with_feature) + uh = usb_open (hubs[hub].dev); + + if (uh == NULL) + { + fprintf (stderr, "Device not found.\n"); + result = 1; + } + else + { + if (cmd == COMMAND_SET_POWER) + if (value) + { + request = USB_REQ_SET_FEATURE; + feature = USB_PORT_FEAT_POWER; + index = port; + } + else + { + request = USB_REQ_CLEAR_FEATURE; + feature = USB_PORT_FEAT_POWER; + index = port; + } + else + { + request = USB_REQ_SET_FEATURE; + feature = USB_PORT_FEAT_INDICATOR; + index = (value << 8) | port; + } + + if (verbose) + printf ("Send control message (REQUEST=%d, FEATURE=%d, INDEX=%d)\n", + request, feature, index); + + if (usb_control_msg (uh, USB_RT_PORT, request, feature, index, + NULL, 0, CTRL_TIMEOUT) < 0) + { + perror ("failed to control.\n"); + result = 1; + } + + if (verbose) + hub_port_status (uh, hubs[hub].nport); + + usb_close (uh); + } + + exit (result); +}