ldc: allow enable high current drive

On my cartographer with LDC there is a low voltage amplitude
with current default values. Which makes homing often not possible.
Because sensor reports aplitude errors.
Without high current drive my calibrated current: 29
With high current drive: 19
Which roughtly fits within 1.2v..1.8v
Under full sensing range ~40..3 mm

Signed-off-by: Timofey Titovets <[email protected]>

Author: nefelim4ag

klippy/extras/ldc1612.py

@@ -38,6 +38,7 @@ def __init__(self, config, sensor):
         self.sensor = sensor
         self.drive_cur = config.getint("reg_drive_current", DRIVECUR,
                                        minval=0, maxval=31)
+        self.high_cur = config.getboolean("high_current_drive", False)
         self.name = config.get_name()
         gcode = self.printer.lookup_object('gcode')
         gcode.register_mux_command("LDC_CALIBRATE_DRIVE_CURRENT",
@@ -46,6 +47,8 @@ def __init__(self, config, sensor):
                                    desc=self.cmd_LDC_CALIBRATE_help)
     def get_drive_current(self):
         return self.drive_cur
+    def get_high_cur_flag(self):
+        return self.high_cur
     cmd_LDC_CALIBRATE_help = "Calibrate LDC1612 DRIVE_CURRENT register"
     def cmd_LDC_CALIBRATE(self, gcmd):
         is_in_progress = True
@@ -56,20 +59,43 @@ def handle_batch(msg):
         toolhead.dwell(0.100)
         toolhead.wait_moves()
         old_config = self.sensor.read_reg(REG_CONFIG)
-        self.sensor.set_reg(REG_CONFIG, 0x001 | (1<<9))
+        REF_CLK_SRC = 1 << 9
+        CFG = 0x001 | REF_CLK_SRC
+        self.sensor.set_reg(REG_CONFIG, CFG)
         toolhead.wait_moves()
         toolhead.dwell(0.100)
         toolhead.wait_moves()
         reg_drive_current0 = self.sensor.read_reg(REG_DRIVE_CURRENT0)
+        drive_cur_low = (reg_drive_current0 >> 6) & 0x1f
+        drive_cur_high = 0
+        # Test high current drive if necessary
+        if drive_cur_low >= 27:
+            HIGH_CURRENT_DRV = 1 << 6
+            CFG = 0x001 | REF_CLK_SRC | HIGH_CURRENT_DRV
+            self.sensor.set_reg(REG_CONFIG, CFG)
+            toolhead.wait_moves()
+            toolhead.dwell(0.100)
+            toolhead.wait_moves()
+            reg_drive_current0 = self.sensor.read_reg(REG_DRIVE_CURRENT0)
+            drive_cur_high = (reg_drive_current0 >> 6) & 0x1f
+        # Stop measurements
         self.sensor.set_reg(REG_CONFIG, old_config)
         is_in_progress = False
+        drive_cur = drive_cur_low
+        # High current > 1.5 mA
+        if drive_cur_high >= 19:
+            drive_cur = drive_cur_high
+        use_high_cur = (drive_cur == drive_cur_high)
         # Report found value to user
-        drive_cur = (reg_drive_current0 >> 6) & 0x1f
         gcmd.respond_info(
+            "%s: high_current_drive: %s\n"
             "%s: reg_drive_current: %d\n"
             "The SAVE_CONFIG command will update the printer config file\n"
-            "with the above and restart the printer." % (self.name, drive_cur))
+            "with the above and restart the printer." % (
+                self.name, use_high_cur,
+                self.name, drive_cur))
         configfile = self.printer.lookup_object('configfile')
+        configfile.set(self.name, 'high_current_drive', "%s" % (use_high_cur,))
         configfile.set(self.name, 'reg_drive_current', "%d" % (drive_cur,))
 
 # Interface class to LDC1612 mcu support
@@ -183,7 +209,13 @@ def _start_measurements(self):
         self.set_reg(REG_CLOCK_DIVIDERS0, (1 << 12) | 1)
         self.set_reg(REG_ERROR_CONFIG, (0x1f << 11) | 1)
         self.set_reg(REG_MUX_CONFIG, 0x0208 | DEGLITCH)
-        self.set_reg(REG_CONFIG, 0x001 | (1<<12) | (1<<10) | (1<<9))
+        HIGH_CURRENT_DRV = int(self.dccal.get_high_cur_flag()) << 6
+        REF_CLK_SRC = 1 << 9
+        AUTO_AMP_DIS = 1 << 10
+        RP_OVERRIDE_EN = 1 << 12
+        CFG = 0x001 # constant
+        CFG |= RP_OVERRIDE_EN | AUTO_AMP_DIS | REF_CLK_SRC | HIGH_CURRENT_DRV
+        self.set_reg(REG_CONFIG, CFG)
         self.set_reg(REG_DRIVE_CURRENT0, self.dccal.get_drive_current() << 11)
         # Start bulk reading
         rest_ticks = self.mcu.seconds_to_clock(0.5 / self.data_rate)