moteus 0.3.57__py3-none-any.whl → 0.3.59__py3-none-any.whl

moteus/command.py

@@ -19,6 +19,7 @@ class Command():
     reply_required = False
     data = b''
     can_prefix = 0x0000  # a 13 bit CAN prefix
+    expected_reply_size = 0
 
     # If True, then the following parameters are used directly instead
     # of being calculated from destination and source (i.e. for

moteus/fdcanusb.py

@@ -173,8 +173,11 @@ class Fdcanusb:
             bus_id = (command.destination |
                       (0x8000 if command.reply_required else 0) |
                       (command.can_prefix << 16))
+        hexdata = _hexify(command.data)
+        on_wire_size = self._round_up_dlc(len(command.data))
+        hexdata += '50' * (on_wire_size - len(command.data))
         cmd = "can send {:04x} {}{}\n".format(
-            bus_id, _hexify(command.data), self._send_flags).encode('latin1')
+            bus_id, hexdata, self._send_flags).encode('latin1')
         self._serial.write(cmd)
         if self._debug_log:
             self._debug_log.write(f'{time.time()} > '.encode('latin1') +
@@ -197,3 +200,22 @@ class Fdcanusb:
             message.data = _dehexify(fields[2])
             message.arbitration_id = int(fields[1], 16)
             return message
+
+    def _round_up_dlc(self, size):
+        if size <= 8:
+            return size
+        if size <= 12:
+            return 12
+        if size <= 16:
+            return 16
+        if size <= 20:
+            return 20
+        if size <= 24:
+            return 24
+        if size <= 32:
+            return 32
+        if size <= 48:
+            return 48
+        if size <= 64:
+            return 64
+        return size

moteus/moteus.py

@@ -14,6 +14,7 @@
 
 import asyncio
 import argparse
+import copy
 import enum
 import importlib_metadata
 import io
@@ -606,7 +607,7 @@ class Controller:
         self._can_prefix = can_prefix
 
         # Pre-compute our query string.
-        self._query_data = self._make_query_data()
+        self._query_data, self._default_query_reply_size = self._make_query_data()
 
     def _get_transport(self):
         if self.transport:
@@ -617,10 +618,15 @@ class Controller:
         self.transport = get_singleton_transport()
         return self.transport
 
-    def _make_query_data(self):
+    def _make_query_data(self, query_resolution=None):
+        if query_resolution is None:
+            query_resolution = self.query_resolution
+
+        expected_reply_size = 0
+
         buf = io.BytesIO()
         writer = Writer(buf)
-        qr = self.query_resolution
+        qr = query_resolution
         c1 = mp.WriteCombiner(writer, 0x10, int(Register.MODE), [
             qr.mode,
             qr.position,
@@ -633,6 +639,8 @@ class Controller:
         for i in range(c1.size()):
             c1.maybe_write()
 
+        expected_reply_size += c1.reply_size
+
         c2 = mp.WriteCombiner(writer, 0x10, int(Register.MOTOR_TEMPERATURE), [
             qr.motor_temperature,
             qr.trajectory_complete,
@@ -644,6 +652,8 @@ class Controller:
         for i in range(c2.size()):
             c2.maybe_write()
 
+        expected_reply_size += c2.reply_size
+
         c3 = mp.WriteCombiner(writer, 0x10, int(Register.AUX1_GPIO_STATUS), [
             qr.aux1_gpio,
             qr.aux2_gpio,
@@ -651,6 +661,8 @@ class Controller:
         for i in range(c3.size()):
             c3.maybe_write()
 
+        expected_reply_size += c3.reply_size
+
         if len(qr._extra):
             min_val = int(min(qr._extra.keys()))
             max_val = int(max(qr._extra.keys()))
@@ -660,23 +672,41 @@ class Controller:
                  for i in range(min_val, max_val +1)])
             for _ in range(c4.size()):
                 c4.maybe_write()
+            expected_reply_size += c4.reply_size
+
+        return buf.getvalue(), expected_reply_size
 
-        return buf.getvalue()
+    def _format_query(self, query, query_override, data_buf, result):
+        if query_override is not None:
+            query_data, expected_reply_size = \
+                self._make_query_data(query_override)
+            data_buf.write(query_data)
+            result.expected_reply_size = expected_reply_size
+        elif query:
+            data_buf.write(self._query_data)
+            result.expected_reply_size = self._default_query_reply_size
 
-    def _make_command(self, *, query, source=0):
+    def _make_command(self, *, query, query_override=None, source=0):
         result = cmd.Command()
 
         result.destination = self.id
         result.source = source
-        result.reply_required = query
+        result.reply_required = query or (query_override is not None)
         result.parse = self._parser
         result.can_prefix = self._can_prefix
+        result.expected_reply_size = self._default_query_reply_size if query else 0
 
         return result
 
-    def make_query(self):
-        result = self._make_command(query=True)
-        result.data = self._query_data
+    def make_query(self, query_override=None):
+        result = self._make_command(
+            query=True, query_override=query_override)
+        if query_override:
+            result.data, result.expected_reply_size = \
+                self._make_query_data(query_override)
+        else:
+            result.data = self._query_data
+            result.expected_reply_size = self._default_query_reply_size
         return result;
 
     async def query(self, **kwargs):
@@ -702,16 +732,18 @@ class Controller:
             c.maybe_write()
 
         result.data = buf.getvalue()
+        result.expected_reply_size = c.reply_size
         return result
 
     async def custom_query(self, *args, **kwargs):
         return await self.execute(self.make_custom_query(*args, **kwargs))
 
-    def make_stop(self, *, query=False):
+    def make_stop(self, *, query=False, query_override=None):
         """Return a moteus.Command structure with data necessary to send a
         stop mode command."""
 
-        result = self._make_command(query=query)
+        result = self._make_command(
+            query=query, query_override=query_override)
 
         data_buf = io.BytesIO()
         writer = Writer(data_buf)
@@ -719,8 +751,7 @@ class Controller:
         writer.write_int8(int(Register.MODE))
         writer.write_int8(int(Mode.STOPPED))
 
-        if query:
-            data_buf.write(self._query_data)
+        self._format_query(query, query_override, data_buf, result)
 
         result.data = data_buf.getvalue()
 
@@ -732,12 +763,14 @@ class Controller:
     def make_set_output(self, *,
                         position=0.0,
                         query=False,
+                        query_override=None,
                         cmd=None
     ):
         """Return a moteus.Command structure with data necessary to send a
         set output nearest command."""
 
-        result = self._make_command(query=query)
+        result = self._make_command(
+            query=query, query_override=query_override)
 
         data_buf = io.BytesIO()
         writer = Writer(data_buf)
@@ -745,23 +778,26 @@ class Controller:
         writer.write_varuint(cmd)
         writer.write_f32(position)
 
-        if query:
-            data_buf.write(self._query_data)
+        self._format_query(query, query_override, data_buf, result)
 
         result.data = data_buf.getvalue()
         return result
 
     def make_set_output_nearest(self, *,
                                 position=0.0,
-                                query=False):
+                                query=False,
+                                query_override=None):
         return self.make_set_output(
-            position=position, query=query, cmd=Register.SET_OUTPUT_NEAREST)
+            position=position, query=query, query_override=query_override,
+            cmd=Register.SET_OUTPUT_NEAREST)
 
     def make_set_output_exact(self, *,
                               position=0.0,
-                              query=False):
+                              query=False,
+                              query_override=None):
         return self.make_set_output(
-            position=position, query=query, cmd=Register.SET_OUTPUT_EXACT)
+            position=position, query=query, query_override=query_override,
+            cmd=Register.SET_OUTPUT_EXACT)
 
     async def set_output(self, *args, cmd=None, **kwargs):
         return await self.execute(self.make_set_output(**kwargs, cmd=cmd))
@@ -777,15 +813,20 @@ class Controller:
     # "make/set_rezero".
     def make_rezero(self, *,
                     rezero=0.0,
-                    query=False):
+                    query=False,
+                    query_override=None):
         return self.make_set_output(
-            position=rezero, query=query, cmd=Register.SET_OUTPUT_NEAREST)
+            position=rezero, query=query, query_override=query_override,
+            cmd=Register.SET_OUTPUT_NEAREST)
 
     async def set_rezero(self, *args, **kwargs):
         return await self.execute(self.make_rezero(**kwargs))
 
-    def make_require_reindex(self):
-        result = self._make_command(query=False)
+    def make_require_reindex(self,
+                             query=False,
+                             query_override=None):
+        result = self._make_command(
+            query=query, query_override=query_override)
 
         data_buf = io.BytesIO()
         writer = Writer(data_buf)
@@ -796,8 +837,9 @@ class Controller:
         result.data = data_buf.getvalue()
         return result
 
-    async def set_require_reindex(self):
-        return await self.execute(self.make_require_reindex())
+    async def set_require_reindex(self, query=False, query_override=None):
+        return await self.execute(self.make_require_reindex(
+            query=query, query_override=query_override))
 
     def make_position(self,
                       *,
@@ -812,11 +854,13 @@ class Controller:
                       velocity_limit=None,
                       accel_limit=None,
                       fixed_voltage_override=None,
-                      query=False):
+                      query=False,
+                      query_override=None):
         """Return a moteus.Command structure with data necessary to send a
         position mode command with the given values."""
 
-        result = self._make_command(query=query)
+        result = self._make_command(
+            query=query, query_override=query_override)
 
         pr = self.position_resolution
         resolutions = [
@@ -866,8 +910,7 @@ class Controller:
         if combiner.maybe_write():
             writer.write_voltage(fixed_voltage_override, pr.fixed_voltage_override)
 
-        if query:
-            data_buf.write(self._query_data)
+        self._format_query(query, query_override, data_buf, result)
 
         result.data = data_buf.getvalue()
 
@@ -876,16 +919,51 @@ class Controller:
     async def set_position(self, *args, **kwargs):
         return await self.execute(self.make_position(**kwargs))
 
+    async def set_position_wait_complete(
+            self,
+            period_s=0.025,
+            query_override=None,
+            *args, **kwargs):
+        """Repeatedly send a position mode command to a device until it
+        reports that the trajectory has been completed.
+
+        If the controller is unresponsive, this method will never return.
+        """
+
+        if query_override is None:
+            query_override = copy.deepcopy(self.query_resolution)
+        else:
+            query_override = copy.deepcopy(query_override)
+
+        query_override.trajectory_complete = mp.INT8
+
+        count = 2
+        while True:
+            result = await self.set_position(
+                query_override=query_override, *args, **kwargs)
+
+            if result is not None:
+                count = max(count - 1, 0)
+
+            if (count == 0 and
+                result is not None and
+                result.values[Register.TRAJECTORY_COMPLETE]):
+                return result
+
+            await asyncio.sleep(period_s)
+
     def make_vfoc(self,
                   *,
                   theta,
                   voltage,
                   theta_rate=0.0,
-                  query=False):
+                  query=False,
+                  query_override=None):
         """Return a moteus.Command structure with data necessary to send a
         voltage mode FOC command."""
 
-        result = self._make_command(query=query)
+        result = self._make_command(
+            query=query, query_override=query_override)
         cr = self.vfoc_resolution
         resolutions = [
             cr.theta if theta is not None else mp.IGNORE,
@@ -921,8 +999,7 @@ class Controller:
         if combiner.maybe_write():
             writer.write_velocity(theta_rate / math.pi, cr.theta_rate)
 
-        if query:
-            data_buf.write(self._query_data)
+        self._format_query(query, query_override, data_buf, result)
 
         result.data = data_buf.getvalue()
 
@@ -935,12 +1012,14 @@ class Controller:
                      *,
                      d_A,
                      q_A,
-                     query=False):
+                     query=False,
+                     query_override=None):
         """Return a moteus.Command structure with data necessary to send a
         current mode command.
         """
 
-        result = self._make_command(query=query)
+        result = self._make_command(
+            query=query, query_override=query_override)
         cr = self.current_resolution
         resolutions = [
             cr.d_A if d_A is not None else mp.IGNORE,
@@ -965,8 +1044,7 @@ class Controller:
         if combiner.maybe_write():
             writer.write_current(d_A, cr.d_A)
 
-        if query:
-            data_buf.write(self._query_data)
+        self._format_query(query, query_override, data_buf, result)
 
         result.data = data_buf.getvalue()
 
@@ -986,11 +1064,13 @@ class Controller:
             maximum_torque=None,
             stop_position=None,
             watchdog_timeout=None,
-            query=False):
+            query=False,
+            query_override=None):
         """Return a moteus.Command structure with data necessary to send a
         within mode command with the given values."""
 
-        result = self._make_command(query=query)
+        result = self._make_command(
+            query=query, query_override=query_override)
 
         pr = self.position_resolution
         resolutions = [
@@ -1029,8 +1109,7 @@ class Controller:
         if combiner.maybe_write():
             writer.write_time(watchdog_timeout, pr.watchdog_timeout)
 
-        if query:
-            data_buf.write(self._query_data)
+        self._format_query(query, query_override, data_buf, result)
 
         result.data = data_buf.getvalue()
 
@@ -1039,8 +1118,9 @@ class Controller:
     async def set_stay_within(self, *args, **kwargs):
         return await self.execute(self.make_stay_within(**kwargs))
 
-    def make_brake(self, *, query=False):
-        result = self._make_command(query=query)
+    def make_brake(self, *, query=False, query_override=None):
+        result = self._make_command(
+            query=query, query_override=query_override)
 
         data_buf = io.BytesIO()
         writer = Writer(data_buf)
@@ -1048,8 +1128,7 @@ class Controller:
         writer.write_int8(int(Register.MODE))
         writer.write_int8(int(Mode.BRAKE))
 
-        if query:
-            data_buf.write(self._query_data)
+        self._format_query(query, query_override, data_buf, result)
 
         result.data = data_buf.getvalue()
 
@@ -1058,7 +1137,8 @@ class Controller:
     async def set_brake(self, *args, **kwargs):
         return await self.execute(self.make_brake(**kwargs))
 
-    def make_write_gpio(self, aux1=None, aux2=None, query=False):
+    def make_write_gpio(self, aux1=None, aux2=None,
+                        query=False, query_override=None):
         """Return a moteus.Command structure with data necessary to set one or
         more GPIO registers.
 
@@ -1066,7 +1146,8 @@ class Controller:
         significant bit is pin 0 on the respective port.
         """
 
-        result = self._make_command(query=query)
+        result = self._make_command(
+            query=query, query_override=query_override)
 
         data_buf = io.BytesIO()
         writer = Writer(data_buf)
@@ -1082,8 +1163,7 @@ class Controller:
         if combiner.maybe_write():
             writer.write_int8(aux2)
 
-        if query:
-            data_buf.write(self._query_data)
+        self._format_query(query, query_override, data_buf, result)
 
         result.data = data_buf.getvalue()
         return result
@@ -1157,6 +1237,7 @@ class Controller:
         result.parse = make_diagnostic_parser(self.id, channel)
 
         result.data = data_buf.getvalue()
+        result.expected_reply_size = 3 + max_length
         return result
 
     async def diagnostic_read(self, *args, **kwargs):

moteus/moteus_tool.py

@@ -818,7 +818,8 @@ class Stream:
             await self.check_for_fault()
 
         enc_kp, enc_ki, enc_bw_hz = await self.set_encoder_filter(
-            torque_bw_hz, control_rate_hz=control_rate_hz)
+            torque_bw_hz, inductance,
+            control_rate_hz=control_rate_hz)
         await self.check_for_fault()
 
         v_per_hz = await self.calibrate_kv_rating(
@@ -1163,7 +1164,7 @@ class Stream:
         print(f"Calculated inductance: {inductance}H")
         return inductance
 
-    async def set_encoder_filter(self, torque_bw_hz, control_rate_hz = None):
+    async def set_encoder_filter(self, torque_bw_hz, inductance, control_rate_hz = None):
         # Check to see if our firmware supports encoder filtering.
         motor_position_style = await self.is_config_supported("motor_position.sources.0.pll_filter_hz")
         servo_style = await self.is_config_supported("servo.encoder_filter.enabled")
@@ -1173,18 +1174,17 @@ class Stream:
         if self.args.encoder_bw_hz:
             desired_encoder_bw_hz = self.args.encoder_bw_hz
         else:
-            if self.args.cal_hall:
-                # Hall effect configurations require a low encoder BW
-                # if the hall effects are also used for position and
-                # velocity control.  Since that is one of the most
-                # common ways of using hall effects, we by default cap
-                # the bw at 20Hz and use a lower one if the torque bw
-                # would otherwise have been lower.
-                desired_encoder_bw_hz = min(20, 2 * torque_bw_hz)
-            else:
-                # We default to an encoder bandwidth of 50Hz, or 2x the
-                # torque bw, whichever is larger.
-                desired_encoder_bw_hz = max(50, 2 * torque_bw_hz)
+            # Don't let the encoder bandwidth be less than 10Hz by default.
+            desired_encoder_bw_hz = max(10, 2 * torque_bw_hz)
+
+            # However, we limit the maximum encoder bandwidth for high
+            # inductance motors, because they shouldn't be able to
+            # accelerate that fast anyways.
+            if inductance:
+                # This is just a random constant that seems to work
+                # well in practice.
+                desired_encoder_bw_hz = min(
+                    desired_encoder_bw_hz, 2e-2 / inductance)
 
         # And our bandwidth with the filter can be no larger than
         # 1/10th the control rate.
@@ -1203,7 +1203,8 @@ class Stream:
             await self.command(f"conf set servo.encoder_filter.kp {kp}")
             await self.command(f"conf set servo.encoder_filter.ki {ki}")
         elif motor_position_style:
-            await self.command(f"conf set motor_position.sources.0.pll_filter_hz {encoder_bw_hz}")
+            commutation_source = await self.read_config_int("motor_position.commutation_source")
+            await self.command(f"conf set motor_position.sources.{commutation_source}.pll_filter_hz {encoder_bw_hz}")
         else:
             assert False
         return kp, ki, encoder_bw_hz

moteus/multiplex.py

@@ -244,21 +244,30 @@ class WriteFrame:
 
     def __init__(self, buf):
         self._buf = buf
+        self._size = 0
+
+    def size(self):
+        return self._size
 
     def write(self, value, resolution):
         self._buf.write(TYPES[resolution].pack(value))
+        self._size += TYPES[resolution].size
 
     def write_int8(self, value):
         self._buf.write(TYPES[INT8].pack(value))
+        self._size += 1
 
     def write_int16(self, value):
         self._buf.write(TYPES[INT16].pack(value))
+        self._size += 2
 
     def write_int32(self, value):
         self._buf.write(TYPES[INT32].pack(value))
+        self._size += 4
 
     def write_f32(self, value):
         self._buf.write(TYPES[F32].pack(value))
+        self._size += 4
 
     def write_varuint(self, value):
         while True:
@@ -266,6 +275,7 @@ class WriteFrame:
             value >>= 7
             this_byte |= 0x80 if value else 0x00
             self._buf.write(bytes([this_byte]))
+            self._size += 1
 
             if value == 0:
                 break
@@ -286,6 +296,7 @@ class WriteCombiner:
         self.base_command = base_command
         self.start_register = start_register
         self.resolutions = resolutions
+        self.reply_size = 0
         self._offset = 0
         self._current_resolution = -1
 
@@ -320,6 +331,8 @@ class WriteCombiner:
 
         write_command = [0x00, 0x04, 0x08, 0x0c][new_resolution] | self.base_command
 
+        start_size = self.writer.size()
+
         if count <= 3:
             # Use the shorthand formulation.
             self.writer.write_int8(write_command + count)
@@ -329,4 +342,10 @@ class WriteCombiner:
             self.writer.write_int8(count)
 
         self.writer.write_varuint(self.start_register + this_offset)
+
+        end_size = self.writer.size()
+
+        self.reply_size += end_size - start_size
+        self.reply_size += count * resolution_size(new_resolution)
+
         return True

moteus/pythoncan.py

@@ -87,10 +87,13 @@ class PythonCan:
         arbitration_id = (command.destination |
                           (0x8000 if reply_required else 0) |
                           (command.can_prefix << 16))
+        on_wire_size = self._round_up_dlc(len(command.data))
+        full_message = (command.data +
+                        bytes([0x50]) * (on_wire_size - len(command.data)))
         message = can.Message(arbitration_id=arbitration_id,
                               is_extended_id=(arbitration_id >= 0x7ff),
-                              dlc=len(command.data),
-                              data=bytearray(command.data),
+                              dlc=on_wire_size,
+                              data=full_message,
                               is_fd=True,
                               bitrate_switch=not self._disable_brs)
 
@@ -99,3 +102,22 @@ class PythonCan:
     async def read(self):
         self._maybe_setup()
         return await self._reader.get_message()
+
+    def _round_up_dlc(self, size):
+        if size <= 8:
+            return size
+        if size <= 12:
+            return 12
+        if size <= 16:
+            return 16
+        if size <= 20:
+            return 20
+        if size <= 24:
+            return 24
+        if size <= 32:
+            return 32
+        if size <= 48:
+            return 48
+        if size <= 64:
+            return 64
+        return size

moteus/version.py

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

{moteus-0.3.57.dist-info → moteus-0.3.59.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: moteus
-Version: 0.3.57
+Version: 0.3.59
 Summary: moteus brushless controller library and tools
 Home-page: https://github.com/mjbots/moteus
 Author: mjbots Robotic Systems

{moteus-0.3.57.dist-info → moteus-0.3.59.dist-info}/RECORD

@@ -2,22 +2,22 @@ moteus/__init__.py,sha256=1Prmih65X7Qz7WY8AUiSwUWXz3Dev8ggQS9xohL75M0,721
 moteus/aioserial.py,sha256=lOBFPXManRBMsjMc1zuyw-NRt6CNVMvnj_mQqIZLpyI,1061
 moteus/aiostream.py,sha256=SLDXwdBMHIWVTAmeUGG6ke7sntfNVxd9CqapzfniJOo,3678
 moteus/calibrate_encoder.py,sha256=kY6mV1WkgCrD9z2YpRoqTTK_BUrRfop4_YJym9AQI-I,12403
-moteus/command.py,sha256=YEtDNXX-TlkUSElsGVQoSYbGqcboneNEejZo06v8ZsI,1128
+moteus/command.py,sha256=IXb0ToAg74fm8FYKPiOdjlzxosqdafLhqADffCvw5OY,1156
 moteus/export.py,sha256=dI8QjdqrcI3pi5fKfP25PwLvsIlVJ695x0ta0PVMKx8,1628
-moteus/fdcanusb.py,sha256=AMwqdvIRz4X9yA4qz8REuyFBfs3OcLcVqbGX28sEx4s,6729
-moteus/moteus.py,sha256=W-ADEI1uAHF0j5A3s1CINTUYpwjEgO-xPRQS15C9Ewg,43410
-moteus/moteus_tool.py,sha256=WSJH5kRRF3SSsocGR_TFbRwAeGP0YlexMpes9iS_rt0,66794
-moteus/multiplex.py,sha256=0Hs63pFZpl1y7ciTcwEeg8F2JDjlhrkb2FcfUbdox-g,9637
+moteus/fdcanusb.py,sha256=6nfnqxwJqyqX0MOn7pj3-kqWq-Vzwx5M8I0wUux3RnA,7294
+moteus/moteus.py,sha256=7lObHdVYCELclm6JMg-QygbAmRgNyQrS0BxkOjERJlo,46993
+moteus/moteus_tool.py,sha256=L-7IBs9YHcbd2nc8SPwCEinHvzp09iVb_JeQCUtNM2U,66800
+moteus/multiplex.py,sha256=EBOhAE-DHkS_AXtqUl2YEs745evvLMPIMeXQSYxF8zk,10102
 moteus/posix_aioserial.py,sha256=3JFiY5p4dtC2ztg6N5SOffnNk9lNcjie02yjD3UlJWo,2971
-moteus/pythoncan.py,sha256=lawewmkd9zQuE-Z1LurmpFD2iSWATei65SZb42um_Vg,3309
+moteus/pythoncan.py,sha256=629d_DUfunyXpMZcaA6ICuvgodes-KH7OVDC7smco7s,3886
 moteus/reader.py,sha256=jGADQTmONSBMQ25I5AqXELLqil2TEha1KjraPdOsf78,11932
 moteus/regression.py,sha256=wpPlxAZ9nC9kfv0oX1K9W2AZNnBLbY8htAJz60SxIb8,1183
 moteus/router.py,sha256=k4Tf6hWtHSgzznmdnj4NySe84-y9feYRxGz0yTrJtoc,2043
 moteus/transport.py,sha256=3asI2A87eQDImLP74LNLtETaShQRiD9RuCjlxNY6AlE,1003
-moteus/version.py,sha256=MFTT8rAzrh1zN6v98RZRdgK04yThpVW45c1KwhhP0SU,609
+moteus/version.py,sha256=lYdyuBwllEdH5WL5gQPVzkIpGpTIZtY-1x9F1WUWUa8,609
 moteus/win32_aioserial.py,sha256=SZsnoBWE0Uwo4ZZF8ALB1WNPRY9NiaCOBz6VfvVcnxA,1841
-moteus-0.3.57.dist-info/METADATA,sha256=HNeottaB3MbXGZcq5Jn_knhHxdKt7I5o-93DKOwOivI,3417
-moteus-0.3.57.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-moteus-0.3.57.dist-info/entry_points.txt,sha256=indCsEML1fmtWJU1WiV-d7UmmTaAMhyBLEc1iiKnexQ,57
-moteus-0.3.57.dist-info/top_level.txt,sha256=aZzmI_yecTaDrdSp29pTJuowaSQ9dlIZheQpshGg4YQ,7
-moteus-0.3.57.dist-info/RECORD,,
+moteus-0.3.59.dist-info/METADATA,sha256=Wye8gTlX1__CYw-VJcnfC7w7ynANVPsjOkcGNtxGgOU,3417
+moteus-0.3.59.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+moteus-0.3.59.dist-info/entry_points.txt,sha256=indCsEML1fmtWJU1WiV-d7UmmTaAMhyBLEc1iiKnexQ,57
+moteus-0.3.59.dist-info/top_level.txt,sha256=aZzmI_yecTaDrdSp29pTJuowaSQ9dlIZheQpshGg4YQ,7
+moteus-0.3.59.dist-info/RECORD,,