diff --git a/klippy/extras/bus.py b/klippy/extras/bus.py index 19e278418..64cdd9c33 100644 --- a/klippy/extras/bus.py +++ b/klippy/extras/bus.py @@ -4,6 +4,7 @@ # # This file may be distributed under the terms of the GNU GPLv3 license. import mcu +import logging def resolve_bus_name(mcu, param, bus): # Find enumerations for the given bus @@ -155,12 +156,13 @@ def MCU_SPI_from_config(config, mode, pin_option="cs_pin", # Helper code for working with devices connected to an MCU via an I2C bus class MCU_I2C: - def __init__(self, mcu, bus, addr, speed, sw_pins=None): + def __init__(self, mcu, bus, addr, speed, sw_pins=None, write_only=False): self.mcu = mcu self.bus = bus self.i2c_address = addr self.oid = self.mcu.create_oid() self.speed = speed + self.write_only = write_only self.config_fmt_ticks = None mcu.add_config_cmd("config_i2c oid=%d" % (self.oid,)) # Generate I2C bus config message @@ -180,10 +182,13 @@ class MCU_I2C: self.cmd_queue = self.mcu.alloc_command_queue() self.mcu.register_config_callback(self.build_config) self.i2c_write_cmd = self.i2c_read_cmd = None + self.i2c_transfer_cmd = self.i2c_write_only_cmd = None printer = self.mcu.get_printer() printer.register_event_handler("klippy:connect", self._handle_connect) # backward support i2c_write inside the init section self._to_write = [] + # Host side I2C error handling + self._configured = False def _handle_connect(self): for data in self._to_write: self.i2c_write(data) @@ -195,6 +200,13 @@ class MCU_I2C: return self.i2c_address def get_command_queue(self): return self.cmd_queue + def _async_write_status(self, params): + status = params["i2c_bus_status"] + if status == "SUCCESS": + return + err_msg = "MCU '%s' I2C request to addr %i reports error %s" % ( + self.mcu.get_name(), self.i2c_address, status) + logging.error(err_msg) def build_config(self): if '%' in self.config_fmt: bus = resolve_bus_name(self.mcu, "i2c_bus", self.bus) @@ -206,25 +218,78 @@ class MCU_I2C: pulse_ticks = self.mcu.seconds_to_clock(1./self.speed/2) self.config_fmt = self.config_fmt_ticks % (pulse_ticks,) self.mcu.add_config_cmd(self.config_fmt) - 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_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) + if self.mcu.try_lookup_command("i2c_read oid=%c reg=%*s read_len=%u"): + self.i2c_write_cmd = self.mcu.lookup_command( + "i2c_write oid=%c data=%*s", cq=self.cmd_queue) + self.i2c_write_only_cmd = self.i2c_write_cmd + 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) + else: + self.i2c_transfer_cmd = self.mcu.lookup_query_command( + "i2c_transfer oid=%c write=%*s read_len=%u", + "i2c_response oid=%c i2c_bus_status=%c response=%*s", + oid=self.oid, cq=self.cmd_queue) + self.i2c_write_only_cmd = self.mcu.lookup_command( + "i2c_transfer oid=%c write=%*s read_len=%u", + cq=self.cmd_queue) + if self.mcu.is_fileoutput(): + self.i2c_transfer_cmd = self.mcu.lookup_command( + "i2c_transfer oid=%c write=%*s read_len=%u", + cq=self.cmd_queue) + if self.write_only: + self.mcu.register_response(self._async_write_status, + "i2c_response", self.oid) + self._configured = True def i2c_write_noack(self, data, minclock=0, reqclock=0): + if self.write_only: + self.i2c_write_only_cmd.send([self.oid, data, 0], + minclock=minclock, reqclock=reqclock) + return self.i2c_write_cmd.send([self.oid, data], minclock=minclock, reqclock=reqclock) - def i2c_write(self, data, minclock=0, reqclock=0): - if self.i2c_write_cmd is None: + def i2c_write(self, data, minclock=0, reqclock=0, retry=True): + if not self._configured: self._to_write.append(data) return + if self.write_only: + self.i2c_write_only_cmd.send([self.oid, data, 0], + minclock=minclock, reqclock=reqclock) + return + if self.i2c_transfer_cmd is not None: + self.i2c_transfer(data, minclock=minclock, reqclock=reqclock, + retry=retry) + return self.i2c_write_cmd.send_wait_ack([self.oid, data], minclock=minclock, reqclock=reqclock) def i2c_read(self, write, read_len, retry=True): - return self.i2c_read_cmd.send([self.oid, write, read_len], retry) + if self.write_only: + raise mcu.error("I2C dev is write only") + if self.i2c_transfer_cmd is not None: + return self.i2c_transfer(write, read_len, retry=retry) + return self.i2c_read_cmd.send([self.oid, write, read_len], + retry=retry) + def i2c_transfer(self, write, read_len=0, minclock=0, reqclock=0, + retry=True): + if self.write_only: + raise mcu.error("I2C dev is write only") + cmd = self.i2c_transfer_cmd + if self.mcu.is_fileoutput(): + cmd.send([self.oid, write, read_len], + minclock=minclock, reqclock=reqclock) + return + param = cmd.send([self.oid, write, read_len], + minclock=minclock, reqclock=reqclock, retry=retry) + status = param["i2c_bus_status"] + if status == "SUCCESS": + return param + err_msg = "MCU '%s' I2C request to addr %i reports error %s" % ( + self.mcu.get_name(), self.i2c_address, status) + self.mcu.get_printer().invoke_shutdown(err_msg) -def MCU_I2C_from_config(config, default_addr=None, default_speed=100000): +def MCU_I2C_from_config(config, default_addr=None, default_speed=100000, + write_only=False): # Load bus parameters printer = config.get_printer() i2c_mcu = mcu.get_printer_mcu(printer, config.get('i2c_mcu', 'mcu')) @@ -250,7 +315,7 @@ def MCU_I2C_from_config(config, default_addr=None, default_speed=100000): bus = config.get('i2c_bus', None) sw_pins = None # Create MCU_I2C object - return MCU_I2C(i2c_mcu, bus, addr, speed, sw_pins) + return MCU_I2C(i2c_mcu, bus, addr, speed, sw_pins, write_only) ###################################################################### diff --git a/klippy/extras/display/uc1701.py b/klippy/extras/display/uc1701.py index 85b74decd..a331f6ec2 100644 --- a/klippy/extras/display/uc1701.py +++ b/klippy/extras/display/uc1701.py @@ -130,7 +130,8 @@ class SPI4wire: class I2C: def __init__(self, config, default_addr): self.i2c = bus.MCU_I2C_from_config(config, default_addr=default_addr, - default_speed=400000) + default_speed=400000, + write_only=True) def send(self, cmds, is_data=False): if is_data: hdr = 0x40 diff --git a/klippy/extras/sx1509.py b/klippy/extras/sx1509.py index ce25bd027..dc476afc8 100644 --- a/klippy/extras/sx1509.py +++ b/klippy/extras/sx1509.py @@ -25,7 +25,8 @@ class SX1509(object): def __init__(self, config): self._printer = config.get_printer() self._name = config.get_name().split()[1] - self._i2c = bus.MCU_I2C_from_config(config, default_speed=400000) + self._i2c = bus.MCU_I2C_from_config(config, default_speed=400000, + write_only=True) self._ppins = self._printer.lookup_object("pins") self._ppins.register_chip("sx1509_" + self._name, self) self._mcu = self._i2c.get_mcu() diff --git a/src/i2ccmds.c b/src/i2ccmds.c index c51772f1d..d9996d93e 100644 --- a/src/i2ccmds.c +++ b/src/i2ccmds.c @@ -17,6 +17,12 @@ enum { IF_SOFTWARE = 1, IF_HARDWARE = 2 }; +DECL_ENUMERATION("i2c_bus_status", "SUCCESS", I2C_BUS_SUCCESS); +DECL_ENUMERATION("i2c_bus_status", "NACK", I2C_BUS_NACK); +DECL_ENUMERATION("i2c_bus_status", "START_NACK", I2C_BUS_START_NACK); +DECL_ENUMERATION("i2c_bus_status", "START_READ_NACK", I2C_BUS_START_READ_NACK); +DECL_ENUMERATION("i2c_bus_status", "BUS_TIMEOUT", I2C_BUS_TIMEOUT); + void command_config_i2c(uint32_t *args) { @@ -72,17 +78,6 @@ int i2c_dev_write(struct i2cdev_s *i2c, uint8_t write_len, uint8_t *data) return i2c_write(i2c->i2c_hw, write_len, data); } -void command_i2c_write(uint32_t *args) -{ - uint8_t oid = args[0]; - struct i2cdev_s *i2c = oid_lookup(oid, command_config_i2c); - uint8_t data_len = args[1]; - uint8_t *data = command_decode_ptr(args[2]); - int ret = i2c_dev_write(i2c, data_len, data); - i2c_shutdown_on_err(ret); -} -DECL_COMMAND(command_i2c_write, "i2c_write oid=%c data=%*s"); - int i2c_dev_read(struct i2cdev_s *i2c, uint8_t reg_len, uint8_t *reg , uint8_t read_len, uint8_t *read) { @@ -93,16 +88,20 @@ int i2c_dev_read(struct i2cdev_s *i2c, uint8_t reg_len, uint8_t *reg return i2c_read(i2c->i2c_hw, reg_len, reg, read_len, read); } -void command_i2c_read(uint32_t *args) +void command_i2c_transfer(uint32_t *args) { uint8_t oid = args[0]; struct i2cdev_s *i2c = oid_lookup(oid, command_config_i2c); - uint8_t reg_len = args[1]; - uint8_t *reg = command_decode_ptr(args[2]); - uint8_t data_len = args[3]; - uint8_t data[data_len]; - int ret = i2c_dev_read(i2c, reg_len, reg, data_len, data); - i2c_shutdown_on_err(ret); - sendf("i2c_read_response oid=%c response=%*s", oid, data_len, data); + uint8_t wlen = args[1]; + uint8_t *wdata = command_decode_ptr(args[2]); + uint8_t rlen = args[3]; + uint8_t rdata[rlen]; + uint8_t nack; + if (rlen > 0) + nack = i2c_dev_read(i2c, wlen, wdata, rlen, rdata); + else + nack = i2c_dev_write(i2c, wlen, wdata); + sendf("i2c_response oid=%c i2c_bus_status=%c response=%*s", + oid, nack, rlen, rdata); } -DECL_COMMAND(command_i2c_read, "i2c_read oid=%c reg=%*s read_len=%u"); +DECL_COMMAND(command_i2c_transfer, "i2c_transfer oid=%c write=%*s read_len=%u");