From 2de170018684dc4aff2b0072c9cc1eb4baaeb7fd Mon Sep 17 00:00:00 2001
From: Klippy-Tools-Bot <klippy-bot@haun.guru>
Date: Thu, 1 Aug 2024 03:06:58 +0000
Subject: [PATCH] Autogenerated - Upstream 171e3bf

---
 klippy/.version                    |   2 +-
 klippy/docs/API_Server.md          |  30 +++++
 klippy/docs/Config_Reference.md    |  89 ++++++++++++++
 klippy/extras/ads1220.py           | 187 +++++++++++++++++++++++++++++
 klippy/extras/hx71x.py             | 170 ++++++++++++++++++++++++++
 klippy/extras/load_cell.py         |  30 +++++
 testcases/configs/ar100.config     |   2 +
 testcases/configs/stm32f042.config |   2 +
 8 files changed, 511 insertions(+), 1 deletion(-)
 create mode 100644 klippy/extras/ads1220.py
 create mode 100644 klippy/extras/hx71x.py
 create mode 100644 klippy/extras/load_cell.py

diff --git a/klippy/.version b/klippy/.version
index ec910b8..b2b0e8d 100644
--- a/klippy/.version
+++ b/klippy/.version
@@ -1 +1 @@
-6f5b54c
+171e3bf
diff --git a/klippy/docs/API_Server.md b/klippy/docs/API_Server.md
index cc0922e..f29bbeb 100644
--- a/klippy/docs/API_Server.md
+++ b/klippy/docs/API_Server.md
@@ -364,6 +364,36 @@ and might later produce asynchronous messages such as:
 The "header" field in the initial query response is used to describe
 the fields found in later "data" responses.
 
+### hx71x/dump_hx71x
+
+This endpoint is used to subscribe to raw HX711 and HX717 ADC data.
+Obtaining these low-level ADC updates may be useful for diagnostic
+and debugging purposes. Using this endpoint may increase Klipper's
+system load.
+
+A request may look like:
+`{"id": 123, "method":"hx71x/dump_hx71x",
+"params": {"sensor": "load_cell", "response_template": {}}}`
+and might return:
+`{"id": 123,"result":{"header":["time","counts"]}}`
+and might later produce asynchronous messages such as:
+`{"params":{"data":[[3292.432935, 562534], [3292.4394937, 5625322]]}}`
+
+### ads1220/dump_ads1220
+
+This endpoint is used to subscribe to raw ADS1220 ADC data.
+Obtaining these low-level ADC updates may be useful for diagnostic
+and debugging purposes. Using this endpoint may increase Klipper's
+system load.
+
+A request may look like:
+`{"id": 123, "method":"ads1220/dump_ads1220",
+"params": {"sensor": "load_cell", "response_template": {}}}`
+and might return:
+`{"id": 123,"result":{"header":["time","counts"]}}`
+and might later produce asynchronous messages such as:
+`{"params":{"data":[[3292.432935, 562534], [3292.4394937, 5625322]]}}`
+
 ### pause_resume/cancel
 
 This endpoint is similar to running the "PRINT_CANCEL" G-Code command.
diff --git a/klippy/docs/Config_Reference.md b/klippy/docs/Config_Reference.md
index 9be53df..f19f0eb 100644
--- a/klippy/docs/Config_Reference.md
+++ b/klippy/docs/Config_Reference.md
@@ -4645,6 +4645,95 @@ adc2:
 #   above parameters.
 ```
 
+## Load Cells
+
+### [load_cell]
+Load Cell. Uses an ADC sensor attached to a load cell to create a digital
+scale.
+
+```
+[load_cell]
+sensor_type:
+#   This must be one of the supported sensor types, see below.
+```
+
+#### XH711
+This is a 24 bit low sample rate chip using "bit-bang" communications. It is
+suitable for filament scales.
+```
+[load_cell]
+sensor_type: hx711
+sclk_pin:
+#   The pin connected to the HX711 clock line. This parameter must be provided.
+dout_pin:
+#   The pin connected to the HX711 data output line. This parameter must be
+#   provided.
+#gain: A-128
+#   Valid values for gain are: A-128, A-64, B-32. The default is A-128.
+#   'A' denotes the input channel and the number denotes the gain. Only the 3
+#   listed combinations are supported by the chip. Note that changing the gain
+#   setting also selects the channel being read.
+#sample_rate: 80
+#   Valid values for sample_rate are 80 or 10. The default value is 80.
+#   This must match the wiring of the chip. The sample rate cannot be changed
+#   in software.
+```
+
+#### HX717
+This is the 4x higher sample rate version of the HX711, suitable for probing.
+```
+[load_cell]
+sensor_type: hx717
+sclk_pin:
+#   The pin connected to the HX717 clock line. This parameter must be provided.
+dout_pin:
+#   The pin connected to the HX717 data output line. This parameter must be
+#   provided.
+#gain: A-128
+#   Valid values for gain are A-128, B-64, A-64, B-8.
+#   'A' denotes the input channel and the number denotes the gain setting.
+#   Only the 4 listed combinations are supported by the chip. Note that
+#   changing the gain setting also selects the channel being read.
+#sample_rate: 320
+#   Valid values for sample_rate are: 10, 20, 80, 320. The default is 320.
+#   This must match the wiring of the chip. The sample rate cannot be changed
+#   in software.
+```
+
+#### ADS1220
+The ADS1220 is a 24 bit ADC supporting up to a 2Khz sample rate configurable in
+software.
+```
+[load_cell]
+sensor_type: ads1220
+cs_pin:
+#   The pin connected to the ADS1220 chip select line. This parameter must
+#   be provided.
+#spi_speed: 512000
+#   This chip supports 2 speeds: 256000 or 512000. The faster speed is only
+#   enabled when one of the Turbo sample rates is used. The correct spi_speed
+#   is selected based on the sample rate.
+#spi_bus:
+#spi_software_sclk_pin:
+#spi_software_mosi_pin:
+#spi_software_miso_pin:
+#   See the "common SPI settings" section for a description of the
+#   above parameters.
+data_ready_pin:
+#   Pin connected to the ADS1220 data ready line. This parameter must be
+#   provided.
+#gain: 128
+#   Valid gain values are 128, 64, 32, 16, 8, 4, 2, 1
+#   The default is 128
+#sample_rate: 660
+#   This chip supports two ranges of sample rates, Normal and Turbo. In turbo
+#   mode the chips c internal clock runs twice as fast and the SPI communication
+#   speed is also doubled.
+#   Normal sample rates: 20, 45, 90, 175, 330, 600, 1000
+#   Turbo sample rates: 40, 90, 180, 350, 660, 1200, 2000
+#   The default is 660
+```
+
 ## Board specific hardware support
 
 ### [sx1509]
diff --git a/klippy/extras/ads1220.py b/klippy/extras/ads1220.py
new file mode 100644
index 0000000..fba7418
--- /dev/null
+++ b/klippy/extras/ads1220.py
@@ -0,0 +1,187 @@
+# ADS1220 Support
+#
+# Copyright (C) 2024 Gareth Farrington <gareth@waves.ky>
+#
+# This file may be distributed under the terms of the GNU GPLv3 license.
+import logging
+from . import bulk_sensor, bus
+
+#
+# Constants
+#
+BYTES_PER_SAMPLE = 4  # samples are 4 byte wide unsigned integers
+MAX_SAMPLES_PER_MESSAGE = bulk_sensor.MAX_BULK_MSG_SIZE // BYTES_PER_SAMPLE
+UPDATE_INTERVAL = 0.10
+RESET_CMD = 0x06
+START_SYNC_CMD = 0x08
+RREG_CMD = 0x20
+WREG_CMD = 0x40
+NOOP_CMD = 0x0
+RESET_STATE = bytearray([0x0, 0x0, 0x0, 0x0])
+
+# turn bytearrays into pretty hex strings: [0xff, 0x1]
+def hexify(byte_array):
+    return "[%s]" % (", ".join([hex(b) for b in byte_array]))
+
+
+class ADS1220():
+    def __init__(self, config):
+        self.printer = printer = config.get_printer()
+        self.name = config.get_name().split()[-1]
+        self.last_error_count = 0
+        self.consecutive_fails = 0
+        # Chip options
+        # Gain
+        self.gain_options = {'1': 0x0, '2': 0x1, '4': 0x2, '8': 0x3, '16': 0x4,
+                             '32': 0x5, '64': 0x6, '128': 0x7}
+        self.gain = config.getchoice('gain', self.gain_options, default='128')
+        # Sample rate
+        self.sps_normal = {'20': 20, '45': 45, '90': 90, '175': 175,
+                           '330': 330, '600': 600, '1000': 1000}
+        self.sps_turbo = {'40': 40, '90': 90, '180': 180, '350': 350,
+                          '660': 660, '1200': 1200, '2000': 2000}
+        self.sps_options = self.sps_normal.copy()
+        self.sps_options.update(self.sps_turbo)
+        self.sps = config.getchoice('sps', self.sps_options, default='660')
+        self.is_turbo = str(self.sps) in self.sps_turbo
+        # SPI Setup
+        spi_speed = 512000 if self.is_turbo else 256000
+        self.spi = bus.MCU_SPI_from_config(config, 1, default_speed=spi_speed)
+        self.mcu = mcu = self.spi.get_mcu()
+        self.oid = mcu.create_oid()
+        # Data Ready (DRDY) Pin
+        drdy_pin = config.get('data_ready_pin')
+        ppins = printer.lookup_object('pins')
+        drdy_ppin = ppins.lookup_pin(drdy_pin)
+        self.data_ready_pin = drdy_ppin['pin']
+        drdy_pin_mcu = drdy_ppin['chip']
+        if drdy_pin_mcu != self.mcu:
+            raise config.error("ADS1220 config error: SPI communication and"
+                               " data_ready_pin must be on the same MCU")
+        # Bulk Sensor Setup
+        self.bulk_queue = bulk_sensor.BulkDataQueue(self.mcu, oid=self.oid)
+        # Clock tracking
+        chip_smooth = self.sps * UPDATE_INTERVAL * 2
+        # Measurement conversion
+        self.ffreader = bulk_sensor.FixedFreqReader(mcu, chip_smooth, "<i")
+        # Process messages in batches
+        self.batch_bulk = bulk_sensor.BatchBulkHelper(
+            self.printer, self._process_batch, self._start_measurements,
+            self._finish_measurements, UPDATE_INTERVAL)
+        # publish raw samples to the socket
+        self.batch_bulk.add_mux_endpoint("ads1220/dump_ads1220", "sensor",
+                                         self.name,
+                                         {'header': ('time', 'counts')})
+        # Command Configuration
+        mcu.add_config_cmd(
+            "config_ads1220 oid=%d spi_oid=%d data_ready_pin=%s"
+            % (self.oid, self.spi.get_oid(), self.data_ready_pin))
+        mcu.add_config_cmd("query_ads1220 oid=%d rest_ticks=0"
+                           % (self.oid,), on_restart=True)
+        mcu.register_config_callback(self._build_config)
+        self.query_ads1220_cmd = None
+
+    def _build_config(self):
+        cmdqueue = self.spi.get_command_queue()
+        self.query_ads1220_cmd = self.mcu.lookup_command(
+            "query_ads1220 oid=%c rest_ticks=%u", cq=cmdqueue)
+        self.ffreader.setup_query_command("query_ads1220_status oid=%c",
+                                          oid=self.oid, cq=cmdqueue)
+
+    def get_mcu(self):
+        return self.mcu
+
+    def get_samples_per_second(self):
+        return self.sps
+
+    # returns a tuple of the minimum and maximum value of the sensor, used to
+    # detect if a data value is saturated
+    def get_range(self):
+        return -0x800000, 0x7FFFFF
+
+    # add_client interface, direct pass through to bulk_sensor API
+    def add_client(self, callback):
+        self.batch_bulk.add_client(callback)
+
+    # Measurement decoding
+    def _convert_samples(self, samples):
+        adc_factor = 1. / (1 << 23)
+        count = 0
+        for ptime, val in samples:
+            samples[count] = (round(ptime, 6), val, round(val * adc_factor, 9))
+            count += 1
+        del samples[count:]
+
+    # Start, stop, and process message batches
+    def _start_measurements(self):
+        self.last_error_count = 0
+        self.consecutive_fails = 0
+        # Start bulk reading
+        self.reset_chip()
+        self.setup_chip()
+        rest_ticks = self.mcu.seconds_to_clock(1. / (10. * self.sps))
+        self.query_ads1220_cmd.send([self.oid, rest_ticks])
+        logging.info("ADS1220 starting '%s' measurements", self.name)
+        # Initialize clock tracking
+        self.ffreader.note_start()
+
+    def _finish_measurements(self):
+        # don't use serial connection after shutdown
+        if self.printer.is_shutdown():
+            return
+        # Halt bulk reading
+        self.query_ads1220_cmd.send_wait_ack([self.oid, 0])
+        self.ffreader.note_end()
+        logging.info("ADS1220 finished '%s' measurements", self.name)
+
+    def _process_batch(self, eventtime):
+        samples = self.ffreader.pull_samples()
+        self._convert_samples(samples)
+        return {'data': samples, 'errors': self.last_error_count,
+                'overflows': self.ffreader.get_last_overflows()}
+
+    def reset_chip(self):
+        # the reset command takes 50us to complete
+        self.send_command(RESET_CMD)
+        # read startup register state and validate
+        val = self.read_reg(0x0, 4)
+        if val != RESET_STATE:
+            raise self.printer.command_error(
+                "Invalid ads1220 reset state (got %s vs %s).\n"
+                "This is generally indicative of connection problems\n"
+                "(e.g. faulty wiring) or a faulty ADS1220 chip."
+                % (hexify(val), hexify(RESET_STATE)))
+
+    def setup_chip(self):
+        continuous = 0x1  # enable continuous conversions
+        mode = 0x2 if self.is_turbo else 0x0  # turbo mode
+        sps_list = self.sps_turbo if self.is_turbo else self.sps_normal
+        data_rate = list(sps_list.keys()).index(str(self.sps))
+        reg_values = [(self.gain << 1),
+                      (data_rate << 5) | (mode << 3) | (continuous << 2)]
+        self.write_reg(0x0, reg_values)
+        # start measurements immediately
+        self.send_command(START_SYNC_CMD)
+
+    def read_reg(self, reg, byte_count):
+        read_command = [RREG_CMD | (reg << 2) | (byte_count - 1)]
+        read_command += [NOOP_CMD] * byte_count
+        params = self.spi.spi_transfer(read_command)
+        return bytearray(params['response'][1:])
+
+    def send_command(self, cmd):
+        self.spi.spi_send([cmd])
+
+    def write_reg(self, reg, register_bytes):
+        write_command = [WREG_CMD | (reg << 2) | (len(register_bytes) - 1)]
+        write_command.extend(register_bytes)
+        self.spi.spi_send(write_command)
+        stored_val = self.read_reg(reg, len(register_bytes))
+        if register_bytes != stored_val:
+            raise self.printer.command_error(
+                "Failed to set ADS1220 register [0x%x] to %s: got %s. "
+                "This may be a connection problem (e.g. faulty wiring)" % (
+                    reg, hexify(register_bytes), hexify(stored_val)))
+
+
+ADS1220_SENSOR_TYPE = {"ads1220": ADS1220}
diff --git a/klippy/extras/hx71x.py b/klippy/extras/hx71x.py
new file mode 100644
index 0000000..1b1128a
--- /dev/null
+++ b/klippy/extras/hx71x.py
@@ -0,0 +1,170 @@
+# HX711/HX717 Support
+#
+# Copyright (C) 2024 Gareth Farrington <gareth@waves.ky>
+#
+# This file may be distributed under the terms of the GNU GPLv3 license.
+import logging
+from . import bulk_sensor
+
+#
+# Constants
+#
+UPDATE_INTERVAL = 0.10
+SAMPLE_ERROR_DESYNC = -0x80000000
+SAMPLE_ERROR_LONG_READ = 0x40000000
+
+# Implementation of HX711 and HX717
+class HX71xBase():
+    def __init__(self, config, sensor_type,
+                 sample_rate_options, default_sample_rate,
+                 gain_options, default_gain):
+        self.printer = printer = config.get_printer()
+        self.name = config.get_name().split()[-1]
+        self.last_error_count = 0
+        self.consecutive_fails = 0
+        self.sensor_type = sensor_type
+        # Chip options
+        dout_pin_name = config.get('dout_pin')
+        sclk_pin_name = config.get('sclk_pin')
+        ppins = printer.lookup_object('pins')
+        dout_ppin = ppins.lookup_pin(dout_pin_name)
+        sclk_ppin = ppins.lookup_pin(sclk_pin_name)
+        self.mcu = mcu = dout_ppin['chip']
+        self.oid = mcu.create_oid()
+        if sclk_ppin['chip'] is not mcu:
+            raise config.error("%s config error: All pins must be "
+                               "connected to the same MCU" % (self.name,))
+        self.dout_pin = dout_ppin['pin']
+        self.sclk_pin = sclk_ppin['pin']
+        # Samples per second choices
+        self.sps = config.getchoice('sample_rate', sample_rate_options,
+                                    default=default_sample_rate)
+        # gain/channel choices
+        self.gain_channel = int(config.getchoice('gain', gain_options,
+                                                 default=default_gain))
+        ## Bulk Sensor Setup
+        self.bulk_queue = bulk_sensor.BulkDataQueue(mcu, oid=self.oid)
+        # Clock tracking
+        chip_smooth = self.sps * UPDATE_INTERVAL * 2
+        self.ffreader = bulk_sensor.FixedFreqReader(mcu, chip_smooth, "<i")
+        # Process messages in batches
+        self.batch_bulk = bulk_sensor.BatchBulkHelper(
+            self.printer, self._process_batch, self._start_measurements,
+            self._finish_measurements, UPDATE_INTERVAL)
+        # publish raw samples to the socket
+        dump_path = "%s/dump_%s" % (sensor_type, sensor_type)
+        self.batch_bulk.add_mux_endpoint(dump_path, "sensor", self.name,
+                                         {'header': ('time', 'counts')})
+        # Command Configuration
+        self.query_hx71x_cmd = None
+        mcu.add_config_cmd(
+            "config_hx71x oid=%d gain_channel=%d dout_pin=%s sclk_pin=%s"
+            % (self.oid, self.gain_channel, self.dout_pin, self.sclk_pin))
+        mcu.add_config_cmd("query_hx71x oid=%d rest_ticks=0"
+                           % (self.oid,), on_restart=True)
+
+        mcu.register_config_callback(self._build_config)
+
+    def _build_config(self):
+        self.query_hx71x_cmd = self.mcu.lookup_command(
+            "query_hx71x oid=%c rest_ticks=%u")
+        self.ffreader.setup_query_command("query_hx71x_status oid=%c",
+                                          oid=self.oid,
+                                          cq=self.mcu.alloc_command_queue())
+
+    def get_mcu(self):
+        return self.mcu
+
+    def get_samples_per_second(self):
+        return self.sps
+
+    # returns a tuple of the minimum and maximum value of the sensor, used to
+    # detect if a data value is saturated
+    def get_range(self):
+        return -0x800000, 0x7FFFFF
+
+    # add_client interface, direct pass through to bulk_sensor API
+    def add_client(self, callback):
+        self.batch_bulk.add_client(callback)
+
+    # Measurement decoding
+    def _convert_samples(self, samples):
+        adc_factor = 1. / (1 << 23)
+        count = 0
+        for ptime, val in samples:
+            if val == SAMPLE_ERROR_DESYNC or val == SAMPLE_ERROR_LONG_READ:
+                self.last_error_count += 1
+                break  # additional errors are duplicates
+            samples[count] = (round(ptime, 6), val, round(val * adc_factor, 9))
+            count += 1
+        del samples[count:]
+
+    # Start, stop, and process message batches
+    def _start_measurements(self):
+        self.consecutive_fails = 0
+        self.last_error_count = 0
+        # Start bulk reading
+        rest_ticks = self.mcu.seconds_to_clock(1. / (10. * self.sps))
+        self.query_hx71x_cmd.send([self.oid, rest_ticks])
+        logging.info("%s starting '%s' measurements",
+                     self.sensor_type, self.name)
+        # Initialize clock tracking
+        self.ffreader.note_start()
+
+    def _finish_measurements(self):
+        # don't use serial connection after shutdown
+        if self.printer.is_shutdown():
+            return
+        # Halt bulk reading
+        self.query_hx71x_cmd.send_wait_ack([self.oid, 0])
+        self.ffreader.note_end()
+        logging.info("%s finished '%s' measurements",
+                    self.sensor_type, self.name)
+
+    def _process_batch(self, eventtime):
+        prev_overflows = self.ffreader.get_last_overflows()
+        prev_error_count = self.last_error_count
+        samples = self.ffreader.pull_samples()
+        self._convert_samples(samples)
+        overflows = self.ffreader.get_last_overflows() - prev_overflows
+        errors = self.last_error_count - prev_error_count
+        if errors > 0:
+            logging.error("%s: Forced sensor restart due to error", self.name)
+            self._finish_measurements()
+            self._start_measurements()
+        elif overflows > 0:
+            self.consecutive_fails += 1
+            if self.consecutive_fails > 4:
+                logging.error("%s: Forced sensor restart due to overflows",
+                              self.name)
+                self._finish_measurements()
+                self._start_measurements()
+        else:
+            self.consecutive_fails = 0
+        return {'data': samples, 'errors': self.last_error_count,
+                'overflows': self.ffreader.get_last_overflows()}
+
+
+class HX711(HX71xBase):
+    def __init__(self, config):
+        super(HX711, self).__init__(config, "hx711",
+                                    # HX711 sps options
+                                    {80: 80, 10: 10}, 80,
+                                    # HX711 gain/channel options
+                                    {'A-128': 1, 'B-32': 2, 'A-64': 3}, 'A-128')
+
+
+class HX717(HX71xBase):
+    def __init__(self, config):
+        super(HX717, self).__init__(config, "hx717",
+                                    # HX717 sps options
+                                    {320: 320, 80: 80, 20: 20, 10: 10}, 320,
+                                    # HX717 gain/channel options
+                                    {'A-128': 1, 'B-64': 2, 'A-64': 3,
+                                     'B-8': 4}, 'A-128')
+
+
+HX71X_SENSOR_TYPES = {
+    "hx711": HX711,
+    "hx717": HX717
+}
diff --git a/klippy/extras/load_cell.py b/klippy/extras/load_cell.py
new file mode 100644
index 0000000..14f3c29
--- /dev/null
+++ b/klippy/extras/load_cell.py
@@ -0,0 +1,30 @@
+# Load Cell Implementation
+#
+# Copyright (C) 2024 Gareth Farrington <gareth@waves.ky>
+#
+# This file may be distributed under the terms of the GNU GPLv3 license.
+from . import hx71x
+from . import ads1220
+
+# Printer class that controls a load cell
+class LoadCell:
+    def __init__(self, config, sensor):
+        self.printer = printer = config.get_printer()
+        self.sensor = sensor   # must implement BulkAdcSensor
+
+    def _on_sample(self, msg):
+        return True
+
+    def get_sensor(self):
+        return self.sensor
+
+def load_config(config):
+    # Sensor types
+    sensors = {}
+    sensors.update(hx71x.HX71X_SENSOR_TYPES)
+    sensors.update(ads1220.ADS1220_SENSOR_TYPE)
+    sensor_class = config.getchoice('sensor_type', sensors)
+    return LoadCell(config, sensor_class(config))
+
+def load_config_prefix(config):
+    return load_config(config)
diff --git a/testcases/configs/ar100.config b/testcases/configs/ar100.config
index 6c91748..a133517 100644
--- a/testcases/configs/ar100.config
+++ b/testcases/configs/ar100.config
@@ -4,3 +4,5 @@ CONFIG_WANT_DISPLAYS=n
 CONFIG_WANT_SOFTWARE_I2C=n
 CONFIG_WANT_SOFTWARE_SPI=n
 CONFIG_WANT_LIS2DW=n
+CONFIG_WANT_HX71X=n
+CONFIG_WANT_ADS1220=n
diff --git a/testcases/configs/stm32f042.config b/testcases/configs/stm32f042.config
index 12cc092..53cf128 100644
--- a/testcases/configs/stm32f042.config
+++ b/testcases/configs/stm32f042.config
@@ -4,3 +4,5 @@ CONFIG_MACH_STM32F042=y
 CONFIG_WANT_SOFTWARE_I2C=n
 CONFIG_WANT_LIS2DW=n
 CONFIG_WANT_LDC1612=n
+CONFIG_WANT_HX71X=n
+CONFIG_WANT_ADS1220=n