moteus 0.3.71__py3-none-any.whl → 0.3.73__py3-none-any.whl

moteus/calibrate_encoder.py

@@ -14,6 +14,9 @@
 
 import json
 import math
+import scipy.optimize
+
+BIN_COUNT = 64
 
 class Entry:
     direction = 0
@@ -159,8 +162,8 @@ def _window_average(values, window_size):
         end = i + window_size // 2
         errs = [0] * (end - start)
         for j in range(start, end):
-            errs[j - start] = _wrap_neg_pi_to_pi(values[wrap(j)] - values[wrap(start)])
-        result[i] = values[wrap(start)] + (sum(errs) / len(errs))
+            errs[j - start] = values[wrap(j)]
+        result[i] = sum(errs) / len(errs)
 
     return result
 
@@ -176,6 +179,8 @@ class CalibrationResult:
         self.total_delta = None
         self.ratio = None
 
+        self.fit_metric = None
+
         self.errors = []
 
     def __repr__(self):
@@ -184,6 +189,7 @@ class CalibrationResult:
             "phase_invert": self.phase_invert,
             "poles": self.poles,
             "offset": self.offset,
+            "fit_metric": self.fit_metric,
             "errors": self.errors,
             })
 
@@ -193,13 +199,16 @@ class CalibrationResult:
             'phase_invert': self.phase_invert,
             'poles': self.poles,
             'offset': self.offset,
+            'fit_metric': self.fit_metric,
         }
 
 
 def calibrate(parsed,
               desired_direction=1,
               max_remainder_error=0.1,
-              allow_phase_invert=True):
+              allow_phase_invert=True,
+              allow_optimize=True,
+              force_optimize=False):
     '''Calibrate the motor.
 
     :param desired_direction: For positive unwrapped_position, should
@@ -315,19 +324,90 @@ def calibrate(parsed,
 
     expected = [(2.0 * math.pi / 65536.0) * (result.poles / 2) * x for x in xpos]
 
-    err = [_wrap_neg_pi_to_pi(a - b) for a, b in zip(avg_interp, expected)]
+    err = [a - b for a, b in zip(avg_interp, expected)]
 
-    # Make the error seem reasonable, so unwrap if we happen to span
-    # the pi boundary.
-    if (max(err) - min(err)) > 1.5 * math.pi:
-        err = [x if x > 0 else x + 2 * math.pi for x in err]
+    # Make the error balanced about 0.
+    mean_err = sum(err) / len(err)
+    wrapped_mean_err = _wrap_neg_pi_to_pi(mean_err)
+    delta_mean_err = mean_err - wrapped_mean_err
+    err = [x - delta_mean_err for x in err]
 
     avg_window = int(len(err) / result.poles)
     avg_err = _window_average(err, avg_window)
 
-    offset_x = list(range(0, 65536, 1024))
+    offset_x = list(range(0, 65536, 65536 // BIN_COUNT))
     offset = _interpolate(offset_x, xpos, avg_err)
 
+    MAX_ERROR = 0.8
+
+    # The firmware will complain if individual steps are more
+    # than this apart.
+    MAX_STEP_CHANGE = 3.5
+
+    # Penalize solutions that have error greater than this.
+    PENALTY_RATIO = 0.80
+
+    def full_metric(x, *args):
+        errors = 0
+        result = 0
+        resampled = _interpolate(xpos, offset_x + [65536],
+                                 list(x) + [x[0]])
+        for a, b in zip(err, resampled):
+            this_err = abs(_wrap_neg_pi_to_pi(a - b))
+            # Heavily penalize if we would have an error.
+            if this_err > PENALTY_RATIO * MAX_ERROR:
+                this_err = (PENALTY_RATIO * MAX_ERROR +
+                            (this_err - PENALTY_RATIO * MAX_ERROR) * 10)
+            if this_err > MAX_ERROR:
+                errors += 1
+            result += this_err ** 2
+
+        for i in range(0, len(list(x))):
+            nexti = (i + 1) % len(list(x))
+            delta = abs(x[nexti] - x[i])
+            if delta > (PENALTY_RATIO * MAX_STEP_CHANGE):
+                result += (
+                    10 * (delta - PENALTY_RATIO * MAX_STEP_CHANGE) ** 2)
+        return result, errors
+
+    def metric(x, *args):
+        result = full_metric(x, *args)[0]
+        print(f"optimizing - metric={result:.5f}     ", end='\r', flush=True)
+        return result
+
+    starting_metric, starting_errors = full_metric(offset)
+
+    if (force_optimize or (
+            allow_optimize and
+            (starting_metric > 30 or
+             starting_errors > 0))):
+        print()
+        print(f"Initial metric: {starting_metric}")
+        # Optimize these initial offsets.
+        optimres = scipy.optimize.minimize(metric, offset, tol=1e1)
+
+        if not optimres.success:
+            result.errors.append(
+                f"optimization failed {result.message}")
+
+        print()
+        offset = list(optimres.x)
+
+    result.fit_metric, _ = full_metric(offset)
+
+    # Now double check our results.
+    resampled_offset = _interpolate(xpos, offset_x + [65536],
+                                    offset + [offset[0]])
+    any_sample_error = False
+    sample_errors = []
+    for a, b in zip(err, resampled_offset):
+        sample_error = _wrap_neg_pi_to_pi(a - b)
+        sample_errors.append(sample_error)
+        if not any_sample_error and abs(sample_error) > MAX_ERROR:
+            result.errors.append(
+                f"excessive error in curve fit |{sample_error}| > {MAX_ERROR}")
+            any_sample_error = True
+
     result.offset = offset
 
     result.debug = {
@@ -340,6 +420,9 @@ def calibrate(parsed,
         'avg_interp' : avg_interp,
         'err' : err,
         'avg_err' : avg_err,
+        'offset_x' : offset_x,
+        'offset' : offset,
+        'sample_errors' : sample_errors,
     }
 
     return result

moteus/moteus.py

@@ -252,6 +252,17 @@ class Register(enum.IntEnum):
     MILLISECOND_COUNTER = 0x070
     CLOCK_TRIM = 0x071
 
+    AUX1_PWM1 = 0x076,
+    AUX1_PWM2 = 0x077,
+    AUX1_PWM3 = 0x078,
+    AUX1_PWM4 = 0x079,
+    AUX1_PWM5 = 0x07a,
+    AUX2_PWM1 = 0x07b,
+    AUX2_PWM2 = 0x07c,
+    AUX2_PWM3 = 0x07d,
+    AUX2_PWM4 = 0x07e,
+    AUX2_PWM5 = 0x07f,
+
     REGISTER_MAP_VERSION = 0x102
     SERIAL_NUMBER = 0x120
     SERIAL_NUMBER1 = 0x120
@@ -267,6 +278,16 @@ class Register(enum.IntEnum):
     DRIVER_FAULT1 = 0x140
     DRIVER_FAULT2 = 0x141
 
+    UUID1 = 0x150
+    UUID2 = 0x151
+    UUID3 = 0x152
+    UUID4 = 0x153
+
+    UUID_MASK1 = 0x0154
+    UUID_MASK2 = 0x0155
+    UUID_MASK3 = 0x0156
+    UUID_MASK4 = 0x0157
+
 
 class Mode(enum.IntEnum):
     """Valid values for the Register.MODE register"""
@@ -347,6 +368,19 @@ class CurrentResolution:
     q_A = mp.F32
 
 
+class PwmResolution:
+    aux1_pwm1 = mp.INT16
+    aux1_pwm2 = mp.INT16
+    aux1_pwm3 = mp.INT16
+    aux1_pwm4 = mp.INT16
+    aux1_pwm5 = mp.INT16
+    aux2_pwm1 = mp.INT16
+    aux2_pwm2 = mp.INT16
+    aux2_pwm3 = mp.INT16
+    aux2_pwm4 = mp.INT16
+    aux2_pwm5 = mp.INT16
+
+
 class Parser(mp.RegisterParser):
     def read_position(self, resolution):
         return self.read_mapped(resolution, 0.01, 0.0001, 0.00001)
@@ -507,6 +541,9 @@ def parse_register(parser, register, resolution):
         return parser.read_int(resolution)
     elif register == Register.CLOCK_TRIM:
         return parser.read_int(resolution)
+    elif (register >= Register.AUX1_PWM1 and
+          register <= Register.AUX2_PWM5):
+        return parser.read_pwm(resolution)
     else:
         # We don't know what kind of value this is, so we don't know
         # the units.
@@ -530,7 +567,7 @@ class Result:
     id = None
     arbitration_id = None
     bus = None
-    values = []
+    values = {}
 
     def __repr__(self):
         value_str = ', '.join(['{}(0x{:03x}): {}'.format(Register(key).name, key, value)
@@ -609,6 +646,7 @@ class Controller:
                  position_resolution=PositionResolution(),
                  vfoc_resolution=VFOCResolution(),
                  current_resolution=CurrentResolution(),
+                 pwm_resolution=PwmResolution(),
                  transport=None,
                  can_prefix=0x0000):
         self.id = id
@@ -616,6 +654,7 @@ class Controller:
         self.position_resolution = position_resolution
         self.vfoc_resolution = vfoc_resolution
         self.current_resolution = current_resolution
+        self.pwm_resolution = pwm_resolution
         self.transport = transport
         self._parser = make_parser(id)
         self._can_prefix = can_prefix
@@ -1315,6 +1354,70 @@ class Controller:
     async def set_trim(self, *args, **kwargs):
         return await self.execute(self.make_set_trim(*args, **kwargs))
 
+    def make_aux_pwm(self, *,
+                     aux1_pwm1=None,
+                     aux1_pwm2=None,
+                     aux1_pwm3=None,
+                     aux1_pwm4=None,
+                     aux1_pwm5=None,
+                     aux2_pwm1=None,
+                     aux2_pwm2=None,
+                     aux2_pwm3=None,
+                     aux2_pwm4=None,
+                     aux2_pwm5=None,
+                     query=False,
+                     query_override=None):
+        result = self._make_command(query=query, query_override=query_override)
+
+        pr = self.pwm_resolution
+        resolutions = [
+            pr.aux1_pwm1 if aux1_pwm1 is not None else mp.IGNORE,
+            pr.aux1_pwm2 if aux1_pwm2 is not None else mp.IGNORE,
+            pr.aux1_pwm3 if aux1_pwm3 is not None else mp.IGNORE,
+            pr.aux1_pwm4 if aux1_pwm4 is not None else mp.IGNORE,
+            pr.aux1_pwm5 if aux1_pwm5 is not None else mp.IGNORE,
+            pr.aux2_pwm1 if aux2_pwm1 is not None else mp.IGNORE,
+            pr.aux2_pwm2 if aux2_pwm2 is not None else mp.IGNORE,
+            pr.aux2_pwm3 if aux2_pwm3 is not None else mp.IGNORE,
+            pr.aux2_pwm4 if aux2_pwm4 is not None else mp.IGNORE,
+            pr.aux2_pwm5 if aux2_pwm5 is not None else mp.IGNORE,
+        ]
+
+        data_buf = io.BytesIO()
+        writer = Writer(data_buf)
+        combiner = mp.WriteCombiner(
+            writer, 0x00, int(Register.AUX1_PWM1), resolutions)
+
+        if combiner.maybe_write():
+            writer.write_pwm(aux1_pwm1, pr.aux1_pwm1)
+        if combiner.maybe_write():
+            writer.write_pwm(aux1_pwm2, pr.aux1_pwm2)
+        if combiner.maybe_write():
+            writer.write_pwm(aux1_pwm3, pr.aux1_pwm3)
+        if combiner.maybe_write():
+            writer.write_pwm(aux1_pwm4, pr.aux1_pwm4)
+        if combiner.maybe_write():
+            writer.write_pwm(aux1_pwm5, pr.aux1_pwm5)
+        if combiner.maybe_write():
+            writer.write_pwm(aux2_pwm1, pr.aux2_pwm1)
+        if combiner.maybe_write():
+            writer.write_pwm(aux2_pwm2, pr.aux2_pwm2)
+        if combiner.maybe_write():
+            writer.write_pwm(aux2_pwm3, pr.aux2_pwm3)
+        if combiner.maybe_write():
+            writer.write_pwm(aux2_pwm4, pr.aux2_pwm4)
+        if combiner.maybe_write():
+            writer.write_pwm(aux2_pwm5, pr.aux2_pwm5)
+
+        self._format_query(query, query_override, data_buf, result)
+
+        result.data = data_buf.getvalue()
+
+        return result
+
+    async def set_aux_pwm(self, *args, **kwargs):
+        return await self.execute(self.make_aux_pwm(*args, **kwargs))
+
     def _extract(self, value):
         if len(value):
             return value[0]

moteus/moteus_tool.py

@@ -44,6 +44,26 @@ MAX_FLASH_BLOCK_SIZE = 32
 FIND_TARGET_TIMEOUT = 0.01 if sys.platform != 'win32' else 0.05
 
 
+def _wrap_neg_pi_to_pi(value):
+    while value > math.pi:
+        value -= 2.0 * math.pi
+    while value < -math.pi:
+        value += 2.0 * math.pi
+    return value
+
+
+def lerp(array, ratio):
+    array_size = len(array)
+
+    left_index = int(math.floor(ratio * array_size))
+    right_index = (left_index + 1) % array_size
+    fraction = (ratio - left_index / array_size) * array_size
+    left_comp = array[left_index]
+    right_comp = array[right_index]
+
+    return (left_comp * (1.0 - fraction)) + (right_comp * fraction)
+
+
 class FirmwareUpgrade:
     '''This encodes "magic" rules about upgrading firmware, largely about
     how to munge configuration options so as to not cause behavior
@@ -54,7 +74,7 @@ class FirmwareUpgrade:
         self.old = old
         self.new = new
 
-        SUPPORTED_ABI_VERSION = 0x0108
+        SUPPORTED_ABI_VERSION = 0x0109
 
         if new > SUPPORTED_ABI_VERSION:
             raise RuntimeError(f"\nmoteus_tool needs to be upgraded to support this firmware\n\n (likely 'python -m pip install --upgrade moteus')\n\nThe provided firmare is ABI version 0x{new:04x} but this moteus_tool only supports up to 0x{SUPPORTED_ABI_VERSION:04x}")
@@ -66,6 +86,42 @@ class FirmwareUpgrade:
         lines = old_config.split(b'\n')
         items = dict([line.split(b' ') for line in lines if b' ' in line])
 
+        if self.new <= 0x0108 and self.old >= 0x0109:
+            # When downgrading, we should warn if a motor thermistor
+            # value other than 47k is configured and enabled.
+            if (int(items.get(b'servo.enable_motor_temperature', '0')) != 0 and
+                int(float(items.get(b'servo.motor_thermistor_ohm', b'0.0'))) != 47000):
+                print("Motor thermistor values other than 47000 ohm not supported in firmware <= 0x0108, disabling")
+                items[b'servo.enable_motor_temperature'] = b'0'
+
+            items.pop(b'servo.motor_thermistor_ohm')
+
+            # Aux PWM out is not supported on <= 0x0108.
+            items.pop(b'aux1.pwm_period_us')
+            items.pop(b'aux2.pwm_period_us')
+
+            def make_key(mpsource, index):
+                return f'motor_position.sources.{mpsource}.compensation_table.{index}'.encode('utf8')
+
+            if make_key(0, 0) in items:
+                # Downsample encoder compensation bins.
+                print("Downsampling encoder compensation tables from version >= 0x0109")
+                for mpsource in range(0, 3):
+                    bins = []
+
+                    scale = float(items.pop(f'motor_position.sources.{mpsource}.compensation_scale'.encode('utf8'), 0.0)) / 127.0
+                    new_size = 256
+                    old_size = 32
+                    ratio = new_size // old_size
+
+                    for i in range(0, new_size):
+                        key = make_key(mpsource, i)
+                        bins.append(float(items.get(key)) * scale)
+                        del items[key]
+
+                    for i in range(0, old_size):
+                        items[make_key(mpsource, i)] = str(bins[i*ratio]).encode('utf8')
+
         if self.new <= 0x0107 and self.old >= 0x0108:
             if float(items.get(b'servo.bemf_feedforward', '0')) == 0.0:
                 print("Reverting servo.bemf_feedforward to 1.0")
@@ -75,7 +131,7 @@ class FirmwareUpgrade:
             # motor_position.output.sign was broken in older versions.
             if int(items[b'motor_position.output.sign']) != 1:
                 print("WARNING: motor_position.output.sign==-1 is broken in order versions, disabling")
-                items[b'motor_position.output.sign'] = '1'
+                items[b'motor_position.output.sign'] = b'1'
             pass
 
         if self.new <= 0x0105 and self.old >= 0x0106:
@@ -307,6 +363,67 @@ class FirmwareUpgrade:
                 print("Upgrading servo.bemf_feedforward to 0.0")
                 items[b'servo.bemf_feedforward'] = b'0.0'
 
+        if self.new >= 0x0109 and self.old <= 0x0108:
+            # Try to fix up the motor commutation offset tables.
+            old_offsets = []
+            i = 0
+            while True:
+                key = f'motor.offset.{i}'.encode('utf8')
+                if key not in items:
+                    break
+                old_offsets.append(float(items.get(key)))
+                i += 1
+
+            offsets = old_offsets[:]
+
+            # Unwrap this, then re-center the whole thing around 0.
+            for i in range(1, len(offsets)):
+                offsets[i] = (offsets[i - 1] +
+                              _wrap_neg_pi_to_pi(offsets[i] -
+                                                 offsets[i - 1]))
+            mean_offset = sum(offsets) / len(offsets)
+            delta = mean_offset - _wrap_neg_pi_to_pi(mean_offset)
+            offsets = [x - delta for x in offsets]
+
+            if any([abs(a - b) > 0.01
+                    for a, b in zip(offsets, old_offsets)]):
+                print("Re-wrapping motor commutation offsets")
+                for i in range(len(offsets)):
+                    key = f'motor.offset.{i}'.encode('utf8')
+                    items[key] = f'{offsets[i]}'.encode('utf8')
+
+        if self.new >= 0x0109 and self.old <= 0x0108:
+            # If we had a motor thermistor enabled in previous
+            # versions, it was with a value of 47000.
+            if int(items.get(b'servo.enable_motor_temperature', b'0')) != 0:
+                print("Thermistor from <= 0x0109 assumed to be 47000")
+                items[b'servo.motor_thermistor_ohm'] = b'47000'
+
+            def make_key(mpsource, index):
+                return f'motor_position.sources.{mpsource}.compensation_table.{index}'.encode('utf8')
+
+            new_size = 256
+            old_size = 32
+            ratio = new_size // old_size
+
+            if make_key(0, 0) in items:
+                print("Upsampling encoder compensation tables for version >= 0x0109")
+                for mpsource in range(0, 3):
+                    old_bins = [float(items.get(make_key(mpsource, i)).decode('latin1')) for i in range(0, 32)]
+                    scale = max([abs(x) for x in old_bins])
+                    bins = []
+                    for i in range(new_size):
+                        if scale != 0.0:
+                            old_i = i // ratio
+                            value = lerp(old_bins, i / new_size)
+                            int_value = int(127 * value / scale)
+                        else:
+                            int_value = 0
+                        items[make_key(mpsource, i)] = str(int_value).encode('utf8')
+
+                    items[f'motor_position.sources.{mpsource}.compensation_scale'.encode('utf8')] = str(scale).encode('utf8')
+
+
         lines = [key + b' ' + value for key, value in items.items()]
         return b'\n'.join(lines)
 
@@ -651,7 +768,13 @@ class Stream:
     async def write_config_stream(self, fp):
         errors = []
 
-        for line in fp.readlines():
+        config_lines = fp.readlines()
+
+        for i, line in enumerate(config_lines):
+            if i % 20 == 0:
+                print(f"Writing config {100*i/len(config_lines):.0f}%  ",
+                      end='\r', flush=True)
+
             line = line.rstrip()
             if len(line) == 0:
                 continue
@@ -661,6 +784,8 @@ class Stream:
             except moteus.CommandError as ce:
                 errors.append(line.decode('latin1'))
 
+        print()
+
         if len(errors):
             print("\nSome config could not be set:")
             for line in errors:
@@ -824,6 +949,19 @@ class Stream:
 
             return cal_voltage
 
+    async def clear_motor_offsets(self):
+        i = 0
+        while True:
+            try:
+                await self.command(f"conf set motor.offset.{i} 0")
+            except moteus.CommandError as ce:
+                if 'error setting' in ce.message:
+                    # This means we hit the end of the offsets.
+                    break
+                else:
+                    raise
+            i += 1
+
     async def do_calibrate(self):
         self.firmware = await self.read_data("firmware")
 
@@ -833,6 +971,11 @@ class Stream:
         print("This will move the motor, ensure it can spin freely!")
         await asyncio.sleep(2.0)
 
+        # Force all existing offsets to 0, that way if we had a
+        # discontinuous offset error, sending the stop will be able to
+        # clear it (and we are about to overwrite them anyway).
+        await self.clear_motor_offsets()
+
         # Clear any faults that may be there.
         await self.command("d stop")
 
@@ -1002,6 +1145,10 @@ class Stream:
             raise RuntimeError(
                 'hall effect calibration requires specifying --cal-motor-poles')
 
+        if (self.args.cal_motor_poles % 2) == 1:
+            raise RuntimeError(
+                'only motors with even numbers of poles are supported')
+
         commutation_source = await self.read_config_int(
             "motor_position.commutation_source")
         aux_number = await self.read_config_int(
@@ -1062,21 +1209,26 @@ class Stream:
         await self.command("d stop")
 
     async def ensure_valid_theta(self, encoder_cal_voltage):
-        try:
-            # We might need to have some sense of pole count first.
-            if await self.read_config_double("motor.poles") == 0:
-                # Pick something arbitrary for now.
-                await self.command(f"conf set motor.poles 2")
+        # We might need to have some sense of pole count first.
+        if await self.read_config_double("motor.poles") == 0:
+            # Pick something arbitrary for now.
+            await self.command(f"conf set motor.poles 2")
 
+        try:
             motor_position = await self.read_data("motor_position")
-            if motor_position.homed == 0 and not motor_position.theta_valid:
-                # We need to find an index.
-                await self.find_index(encoder_cal_voltage)
         except RuntimeError:
             # Odds are we don't support motor_position, in which case
             # theta is always valid for the older versions that don't
             # support it.
-            pass
+            return
+
+        if motor_position.error != 0:
+            raise RuntimeError(
+                f"encoder error: {repr(motor_position.error)}")
+
+        if motor_position.homed == 0 and not motor_position.theta_valid:
+            # We need to find an index.
+            await self.find_index(encoder_cal_voltage)
 
     async def calibrate_encoder_mapping_absolute(self, encoder_cal_voltage):
         await self.ensure_valid_theta(encoder_cal_voltage)
@@ -1119,7 +1271,10 @@ class Stream:
             cal_file,
             desired_direction=1 if not self.args.cal_invert else -1,
             max_remainder_error=self.args.cal_max_remainder,
-            allow_phase_invert=allow_phase_invert)
+            allow_phase_invert=allow_phase_invert,
+            allow_optimize=not self.args.cal_disable_optimize,
+            force_optimize=self.args.cal_force_optimize,
+        )
 
         if cal_result.errors:
             raise RuntimeError(f"Error(s) calibrating: {cal_result.errors}")
@@ -1360,9 +1515,19 @@ class Stream:
             return 1 if x >= 0 else -1
 
         velocity_samples = []
+        power_samples = []
 
         while True:
             data = await self.read_servo_stats()
+
+            total_current_A = math.hypot(data.d_A, data.q_A)
+            total_power_W = voltage * total_current_A
+
+            power_samples.append(total_power_W)
+
+            if len(power_samples) > AVERAGE_COUNT:
+                del power_samples[0]
+
             velocity_samples.append(data.velocity)
 
             if len(velocity_samples) > (3 * AVERAGE_COUNT):
@@ -1374,6 +1539,24 @@ class Stream:
             if (time.time() - start_time) > 2.0:
                 return recent_average
 
+            if len(power_samples) >= AVERAGE_COUNT:
+                average_power_W = sum(power_samples) / len(power_samples)
+                max_power_W = (self.args.cal_max_kv_power_factor *
+                               self.args.cal_motor_power)
+
+                # This is a safety.  During speed measurement, current
+                # should always be near 0.  However, if the encoder
+                # commutation calibration failed, we can sometimes
+                # trigger large currents during the Kv detection phase
+                # while not actually moving.
+                if (abs(recent_average) < 0.2 and
+                    average_power_W > max_power_W):
+                    await self.command("d stop")
+
+                    raise RuntimeError(
+                        f"Motor failed to spin, {average_power_W} > " +
+                        f"{max_power_W}")
+
             if (len(velocity_samples) >= AVERAGE_COUNT and
                 abs(recent_average) < 0.2):
                 return recent_average
@@ -1765,11 +1948,17 @@ async def async_main():
     parser.add_argument('--cal-force-kv', metavar='Kv', type=float,
                         default=None,
                         help='do not calibrate Kv, but use the specified value')
+    parser.add_argument('--cal-force-optimize', action='store_true',
+                        help='require nonlinear commutation optimization')
+    parser.add_argument('--cal-disable-optimize', action='store_true',
+                        help='prevent nonlinear commutation optimization')
 
 
     parser.add_argument('--cal-max-remainder', metavar='F',
                         type=float, default=0.1,
                         help='maximum allowed error in calibration')
+    parser.add_argument('--cal-max-kv-power-factor', type=float,
+                        default=1.25)
     parser.add_argument('--cal-raw', metavar='FILE', type=str,
                         help='write raw calibration data')
 

moteus/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-VERSION="0.3.71"
+VERSION="0.3.73"

{moteus-0.3.71.dist-info → moteus-0.3.73.dist-info}/METADATA

@@ -1,21 +1,25 @@
 Metadata-Version: 2.1
 Name: moteus
-Version: 0.3.71
+Version: 0.3.73
 Summary: moteus brushless controller library and tools
 Home-page: https://github.com/mjbots/moteus
 Author: mjbots Robotic Systems
 Author-email: info@mjbots.com
+License: UNKNOWN
 Keywords: moteus
+Platform: UNKNOWN
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.7, <4
 Description-Content-Type: text/markdown
-Requires-Dist: pyserial >=3.5
-Requires-Dist: python-can >=3.3
-Requires-Dist: pyelftools >=0.26
-Requires-Dist: importlib-metadata >=3.6
+Requires-Dist: importlib-metadata (>=3.6)
+Requires-Dist: numpy (<2)
+Requires-Dist: pyelftools (>=0.26)
+Requires-Dist: pyserial (>=3.5)
+Requires-Dist: python-can (>=3.3)
+Requires-Dist: scipy (>=1.8.0)
 Requires-Dist: pywin32 ; platform_system == "Windows"
 
 # Python bindings for moteus brushless controller #
@@ -117,3 +121,5 @@ qr.torque = moteus.F32
 
 c = moteus.Controller(position_resolution=pr, query_resolution=qr)
 ```
+
+

{moteus-0.3.71.dist-info → moteus-0.3.73.dist-info}/RECORD

@@ -1,12 +1,12 @@
 moteus/__init__.py,sha256=DxasQre5HmK3BS3I35K8GEUvFZF3_OE_hjVzQy-seIE,739
 moteus/aioserial.py,sha256=GeWuvsZKCRrfBN33JZFjtBXPr-0sKpQv9shRn2ulcDA,1079
 moteus/aiostream.py,sha256=YAkVF6QWsA49vqO-GgXEohDghqm_-nnajJzhO_Q9qNQ,3696
-moteus/calibrate_encoder.py,sha256=R3pRgGqrDCcmKQqFE7Fr4p8TSie179iqNfBwEJS3pL0,12416
+moteus/calibrate_encoder.py,sha256=R3gWoKY-ikYlXViiCrhX_0BH7Ahx3T7zvDjX47go-Wc,15167
 moteus/command.py,sha256=UkOsbtkso6Oyex8CfbpAKpBNriik519ymxL86EZGkRs,1169
 moteus/export.py,sha256=vRIfldaqz1eHtWo3993SvatATtu73TZbejL0hzQe8YE,1646
 moteus/fdcanusb.py,sha256=7PrQiCTROY96gdT2zSZYU1bOCriw-I7H6NspaZpiEx4,7431
-moteus/moteus.py,sha256=gARNQ2_irh_1zp5YBTXmZK5U7SziBna8R140e_Wyfxk,48998
-moteus/moteus_tool.py,sha256=KBs5jhjbiJzPhDtLtG5v5e-JVd8Na6R1wXwshTORAQc,71806
+moteus/moteus.py,sha256=vImSRBn6VEmoijD6hvrSRVxuv1_xVaEJU3F_3Wi6GiE,52498
+moteus/moteus_tool.py,sha256=ALwXiDWVwiAx9yJu0o-2eKd47wyKH5mRPq264mZrn5E,79662
 moteus/multiplex.py,sha256=LF6MuelzYHqqsCJuCB9YeEyUA03eBaTYRwAVotX3qm8,10120
 moteus/posix_aioserial.py,sha256=2oDrw8TBEwuEQjY41g9rHeuFeffcPHqMwNS3nf5NVq8,3137
 moteus/pythoncan.py,sha256=ofotOrDuaFhTLvaokaO3EJK6quVc75Bq-ue70lDMtXI,4071
@@ -14,10 +14,10 @@ moteus/reader.py,sha256=9i1-h4aGd4syfqtWJcpg70Bl-bmunkGU4FmXmOLyRt8,12121
 moteus/regression.py,sha256=M5gjDBYJQ64iBXIrvBhMkD8TYhtlnQ85x8U4py0niGA,1196
 moteus/router.py,sha256=501W5GZ12rFoc1lmcH3S7IYsoc-Q_-FJ4B3i37RzE3Q,2061
 moteus/transport.py,sha256=WhkW2G9i25lkOlO55eI5_oXmU0PhDmxTeJ75Sg_7nTI,1021
-moteus/version.py,sha256=fRb1RjssxPcJGNsseW3PhLRKjIGLBI8Kcy8nFzG1RJA,627
+moteus/version.py,sha256=5_fWVR7dSRZGbeKSGDI9a1MBAxaHKTOCWtgVlCY30BE,627
 moteus/win32_aioserial.py,sha256=culdl-vYxBKD5n2s5LkIMGyUaHyCcEc8BL5-DWEaxX8,2025
-moteus-0.3.71.dist-info/METADATA,sha256=Aig2WFPGut825pNwrj1AbhlBHELoajjrMzoBMZSNrys,3388
-moteus-0.3.71.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-moteus-0.3.71.dist-info/entry_points.txt,sha256=accRcwir_K8wCf7i3qHb5R6CPh5SiSgd5a1A92ibb9E,56
-moteus-0.3.71.dist-info/top_level.txt,sha256=aZzmI_yecTaDrdSp29pTJuowaSQ9dlIZheQpshGg4YQ,7
-moteus-0.3.71.dist-info/RECORD,,
+moteus-0.3.73.dist-info/METADATA,sha256=HIVrIqvoZY517yT3s_Euh10uzoZjYn4KmSHj2r_7K04,3490
+moteus-0.3.73.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+moteus-0.3.73.dist-info/entry_points.txt,sha256=indCsEML1fmtWJU1WiV-d7UmmTaAMhyBLEc1iiKnexQ,57
+moteus-0.3.73.dist-info/top_level.txt,sha256=aZzmI_yecTaDrdSp29pTJuowaSQ9dlIZheQpshGg4YQ,7
+moteus-0.3.73.dist-info/RECORD,,

{moteus-0.3.71.dist-info → moteus-0.3.73.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: bdist_wheel (0.37.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{moteus-0.3.71.dist-info → moteus-0.3.73.dist-info}/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 moteus_tool = moteus.moteus_tool:main
+