dynamixel-sdk 3.6.0__py3-none-any.whl → 3.8.4__py3-none-any.whl

dynamixel_sdk/group_bulk_read.py

@@ -17,7 +17,7 @@
 # limitations under the License.
 ################################################################################
 
-# Author: Ryu Woon Jung (Leon)
+# Author: Ryu Woon Jung (Leon), Wonho Yun
 
 from .robotis_def import *
 
@@ -39,22 +39,21 @@ class GroupBulkRead:
         self.clearParam()
 
     def makeParam(self):
-        if not self.data_dict:
+        if not self.is_param_changed or not self.data_dict:
             return
 
         self.param = []
 
-        for dxl_id in self.data_dict:
+        for dxl_id, (_, start_addr, data_length) in self.data_dict.items():
             if self.ph.getProtocolVersion() == 1.0:
-                self.param.append(self.data_dict[dxl_id][2])  # LEN
-                self.param.append(dxl_id)  # ID
-                self.param.append(self.data_dict[dxl_id][1])  # ADDR
+                self.param.extend([data_length, dxl_id, start_addr])
             else:
-                self.param.append(dxl_id)  # ID
-                self.param.append(DXL_LOBYTE(self.data_dict[dxl_id][1]))  # ADDR_L
-                self.param.append(DXL_HIBYTE(self.data_dict[dxl_id][1]))  # ADDR_H
-                self.param.append(DXL_LOBYTE(self.data_dict[dxl_id][2]))  # LEN_L
-                self.param.append(DXL_HIBYTE(self.data_dict[dxl_id][2]))  # LEN_H
+                self.param.extend([
+                    dxl_id,
+                    DXL_LOBYTE(start_addr), DXL_HIBYTE(start_addr),
+                    DXL_LOBYTE(data_length), DXL_HIBYTE(data_length)
+                ])
+        self.is_param_changed = False
 
     def addParam(self, dxl_id, start_address, data_length):
         if dxl_id in self.data_dict:  # dxl_id already exist
@@ -86,9 +85,18 @@ class GroupBulkRead:
             self.makeParam()
 
         if self.ph.getProtocolVersion() == 1.0:
-            return self.ph.bulkReadTx(self.port, self.param, len(self.data_dict.keys()) * 3)
+            return self.ph.bulkReadTx(self.port, self.param, len(self.data_dict.keys()) * 3, False)
         else:
-            return self.ph.bulkReadTx(self.port, self.param, len(self.data_dict.keys()) * 5)
+            return self.ph.bulkReadTx(self.port, self.param, len(self.data_dict.keys()) * 5, False)
+
+    def fastBulkReadTxPacket(self):
+        if len(self.data_dict.keys()) == 0:
+            return COMM_NOT_AVAILABLE
+
+        if self.is_param_changed is True or not self.param:
+            self.makeParam()
+
+        return self.ph.bulkReadTx(self.port, self.param, len(self.data_dict.keys()) * 5, True)
 
     def rxPacket(self):
         self.last_result = False
@@ -109,6 +117,44 @@ class GroupBulkRead:
 
         return result
 
+    def fastBulkReadRxPacket(self):
+        self.last_result = False
+
+        if self.ph.getProtocolVersion() == 1.0:
+            return COMM_NOT_AVAILABLE
+
+        if not self.data_dict:
+            return COMM_NOT_AVAILABLE
+
+        # Receive bulk read response
+        raw_data, result = self.ph.fastBulkReadRx(self.port, self.param)
+
+        if result != COMM_SUCCESS:
+            return result
+
+        valid_ids = set(self.data_dict.keys())
+
+        # Map received data to each Dynamixel ID
+        for dxl_id, data in raw_data.items():
+            if dxl_id not in valid_ids:
+                return COMM_RX_CORRUPT
+
+            expected_length = self.data_dict[dxl_id][PARAM_NUM_LENGTH]
+            received_length = len(data)
+
+            # If received data is longer than expected, trim the extra bytes
+            if received_length > expected_length:
+                data = data[:expected_length]  # Trim excess data
+
+            elif received_length < expected_length:
+                return COMM_RX_CORRUPT
+
+            # Store data in the dictionary
+            self.data_dict[dxl_id][PARAM_NUM_DATA] = bytearray(data)
+
+        self.last_result = True
+        return COMM_SUCCESS
+
     def txRxPacket(self):
         result = self.txPacket()
         if result != COMM_SUCCESS:
@@ -116,6 +162,16 @@ class GroupBulkRead:
 
         return self.rxPacket()
 
+    def fastBulkRead(self):
+        if self.ph.getProtocolVersion() == 1.0:
+            return COMM_NOT_AVAILABLE
+
+        result = self.fastBulkReadTxPacket()
+        if result != COMM_SUCCESS:
+            return result
+
+        return self.fastBulkReadRxPacket()
+
     def isAvailable(self, dxl_id, address, data_length):
         if self.last_result is False or dxl_id not in self.data_dict:
             return False
@@ -132,16 +188,14 @@ class GroupBulkRead:
             return 0
 
         start_addr = self.data_dict[dxl_id][PARAM_NUM_ADDRESS]
+        data = self.data_dict[dxl_id][PARAM_NUM_DATA]
+        idx = address - start_addr
 
         if data_length == 1:
-            return self.data_dict[dxl_id][PARAM_NUM_DATA][address - start_addr]
+            return data[idx]
         elif data_length == 2:
-            return DXL_MAKEWORD(self.data_dict[dxl_id][PARAM_NUM_DATA][address - start_addr],
-                                self.data_dict[dxl_id][PARAM_NUM_DATA][address - start_addr + 1])
+            return data[idx] | (data[idx + 1] << 8)
         elif data_length == 4:
-            return DXL_MAKEDWORD(DXL_MAKEWORD(self.data_dict[dxl_id][PARAM_NUM_DATA][address - start_addr + 0],
-                                              self.data_dict[dxl_id][PARAM_NUM_DATA][address - start_addr + 1]),
-                                 DXL_MAKEWORD(self.data_dict[dxl_id][PARAM_NUM_DATA][address - start_addr + 2],
-                                              self.data_dict[dxl_id][PARAM_NUM_DATA][address - start_addr + 3]))
-        else:
-            return 0
+            return (data[idx] | (data[idx + 1] << 8) |
+                    (data[idx + 2] << 16) | (data[idx + 3] << 24))
+        return 0

dynamixel_sdk/group_sync_read.py

@@ -17,7 +17,7 @@
 # limitations under the License.
 ################################################################################
 
-# Author: Ryu Woon Jung (Leon)
+# Author: Ryu Woon Jung (Leon), Wonho Yun
 
 from .robotis_def import *
 
@@ -40,22 +40,25 @@ class GroupSyncRead:
         if self.ph.getProtocolVersion() == 1.0:
             return
 
-        if not self.data_dict:  # len(self.data_dict.keys()) == 0:
+        if not self.is_param_changed:
             return
 
-        self.param = []
+        if not self.data_dict:
+            return
+
+        self.param = list(self.data_dict.keys())
+
+        self.is_param_changed = False
 
-        for dxl_id in self.data_dict:
-            self.param.append(dxl_id)
 
     def addParam(self, dxl_id):
         if self.ph.getProtocolVersion() == 1.0:
             return False
 
-        if dxl_id in self.data_dict:  # dxl_id already exist
+        if dxl_id in self.data_dict:
             return False
 
-        self.data_dict[dxl_id] = []  # [0] * self.data_length
+        self.data_dict[dxl_id] = []
 
         self.is_param_changed = True
         return True
@@ -64,7 +67,7 @@ class GroupSyncRead:
         if self.ph.getProtocolVersion() == 1.0:
             return
 
-        if dxl_id not in self.data_dict:  # NOT exist
+        if dxl_id not in self.data_dict:
             return
 
         del self.data_dict[dxl_id]
@@ -84,8 +87,28 @@ class GroupSyncRead:
         if self.is_param_changed is True or not self.param:
             self.makeParam()
 
-        return self.ph.syncReadTx(self.port, self.start_address, self.data_length, self.param,
-                                  len(self.data_dict.keys()) * 1)
+        return self.ph.syncReadTx(
+            self.port,
+            self.start_address,
+            self.data_length,
+            self.param,
+            len(self.data_dict.keys()) * 1,
+            False)
+
+    def fastSyncReadTxPacket(self):
+        if self.ph.getProtocolVersion() == 1.0 or len(self.data_dict.keys()) == 0:
+            return COMM_NOT_AVAILABLE
+
+        if self.is_param_changed is True or not self.param:
+            self.makeParam()
+
+        return self.ph.syncReadTx(
+            self.port,
+            self.start_address,
+            self.data_length,
+            self.param,
+            len(self.data_dict.keys()) * 1,
+            True)
 
     def rxPacket(self):
         self.last_result = False
@@ -108,16 +131,55 @@ class GroupSyncRead:
 
         return result
 
-    def txRxPacket(self):
+    def fastSyncReadRxPacket(self):
+        self.last_result = False
+
         if self.ph.getProtocolVersion() == 1.0:
             return COMM_NOT_AVAILABLE
 
-        result = self.txPacket()
+        if not self.data_dict:
+            return COMM_NOT_AVAILABLE
+
+        num_devices = len(self.data_dict)
+        rx_param_length = (self.data_length + 4) * num_devices  # Error(1) + ID(1) + Data(N) + CRC(2))
+        raw_data, result, _ = self.ph.fastSyncReadRx(self.port, BROADCAST_ID, rx_param_length)
         if result != COMM_SUCCESS:
             return result
 
+        raw_data = bytearray(raw_data)
+        start_index = 0
+
+        valid_ids = set(self.data_dict.keys())
+        for _ in range(num_devices):
+            dxl_id = raw_data[start_index + 1]
+            if dxl_id not in valid_ids:
+                return COMM_RX_CORRUPT
+
+            self.data_dict[dxl_id] = bytearray(raw_data[start_index + 2 : start_index + 2 + self.data_length])
+            start_index += self.data_length + 4
+
+        self.last_result = True
+        return COMM_SUCCESS
+
+    def txRxPacket(self):
+        if self.ph.getProtocolVersion() == 1.0:
+            return COMM_NOT_AVAILABLE
+
+        if (result := self.txPacket()) != COMM_SUCCESS:
+            return result
+
         return self.rxPacket()
 
+    def fastSyncRead(self):
+        if self.ph.getProtocolVersion() == 1.0:
+            return COMM_NOT_AVAILABLE
+
+        result = self.fastSyncReadTxPacket()
+        if result != COMM_SUCCESS:
+            return result
+
+        return self.fastSyncReadRxPacket()
+
     def isAvailable(self, dxl_id, address, data_length):
         if self.ph.getProtocolVersion() == 1.0 or self.last_result is False or dxl_id not in self.data_dict:
             return False
@@ -131,15 +193,15 @@ class GroupSyncRead:
         if not self.isAvailable(dxl_id, address, data_length):
             return 0
 
+        start_idx = address - self.start_address
+        data = self.data_dict[dxl_id]
+
         if data_length == 1:
-            return self.data_dict[dxl_id][address - self.start_address]
+            return data[start_idx]
         elif data_length == 2:
-            return DXL_MAKEWORD(self.data_dict[dxl_id][address - self.start_address],
-                                self.data_dict[dxl_id][address - self.start_address + 1])
+            return (data[start_idx] | (data[start_idx + 1] << 8))
         elif data_length == 4:
-            return DXL_MAKEDWORD(DXL_MAKEWORD(self.data_dict[dxl_id][address - self.start_address + 0],
-                                              self.data_dict[dxl_id][address - self.start_address + 1]),
-                                 DXL_MAKEWORD(self.data_dict[dxl_id][address - self.start_address + 2],
-                                              self.data_dict[dxl_id][address - self.start_address + 3]))
+            return ((data[start_idx] | (data[start_idx + 1] << 8)) |
+                    ((data[start_idx + 2] | (data[start_idx + 3] << 8)) << 16))
         else:
             return 0

dynamixel_sdk/protocol2_packet_handler.py

@@ -17,12 +17,12 @@
 # limitations under the License.
 ################################################################################
 
-# Author: Ryu Woon Jung (Leon)
+# Author: Ryu Woon Jung (Leon), Wonho Yun
 
 from .robotis_def import *
 
-TXPACKET_MAX_LEN = 4 * 1024
-RXPACKET_MAX_LEN = 4 * 1024
+TXPACKET_MAX_LEN = 1 * 1024
+RXPACKET_MAX_LEN = 1 * 1024
 
 # for Protocol 2.0 Packet
 PKT_HEADER0 = 0
@@ -246,8 +246,11 @@ class Protocol2PacketHandler(object):
 
         return COMM_SUCCESS
 
-    def rxPacket(self, port):
+    def rxPacket(self, port, fast_option):
         rxpacket = []
+        packet_id = MAX_ID
+        if fast_option:
+            packet_id = BROADCAST_ID
 
         result = COMM_TX_FAIL
         rx_length = 0
@@ -264,16 +267,19 @@ class Protocol2PacketHandler(object):
                         break
 
                 if idx == 0:
-                    if (rxpacket[PKT_RESERVED] != 0x00) or (rxpacket[PKT_ID] > 0xFC) or (
-                            DXL_MAKEWORD(rxpacket[PKT_LENGTH_L], rxpacket[PKT_LENGTH_H]) > RXPACKET_MAX_LEN) or (
-                            rxpacket[PKT_INSTRUCTION] != 0x55):
+                    if (rxpacket[PKT_RESERVED] != 0x00) or \
+                        (rxpacket[PKT_ID] > packet_id) or \
+                        (DXL_MAKEWORD(rxpacket[PKT_LENGTH_L], rxpacket[PKT_LENGTH_H]) > RXPACKET_MAX_LEN) or \
+                        (rxpacket[PKT_INSTRUCTION] != 0x55):
                         # remove the first byte in the packet
                         del rxpacket[0]
                         rx_length -= 1
                         continue
 
                     if wait_length != (DXL_MAKEWORD(rxpacket[PKT_LENGTH_L], rxpacket[PKT_LENGTH_H]) + PKT_LENGTH_H + 1):
-                        wait_length = DXL_MAKEWORD(rxpacket[PKT_LENGTH_L], rxpacket[PKT_LENGTH_H]) + PKT_LENGTH_H + 1
+                        wait_length = \
+                            DXL_MAKEWORD(rxpacket[PKT_LENGTH_L], rxpacket[PKT_LENGTH_H]) + \
+                            PKT_LENGTH_H + 1
                         continue
 
                     if rx_length < wait_length:
@@ -309,7 +315,7 @@ class Protocol2PacketHandler(object):
 
         port.is_using = False
 
-        if result == COMM_SUCCESS:
+        if result == COMM_SUCCESS and fast_option == False:
             rxpacket = self.removeStuffing(rxpacket)
 
         return rxpacket, result
@@ -343,7 +349,7 @@ class Protocol2PacketHandler(object):
 
         # rx packet
         while True:
-            rxpacket, result = self.rxPacket(port)
+            rxpacket, result = self.rxPacket(port, False)
             if result != COMM_SUCCESS or txpacket[PKT_ID] == rxpacket[PKT_ID]:
                 break
 
@@ -383,6 +389,8 @@ class Protocol2PacketHandler(object):
         txpacket = [0] * 10
         rxpacket = []
 
+        tx_time_per_byte = (1000.0 / port.getBaudRate()) *10.0;
+
         txpacket[PKT_ID] = BROADCAST_ID
         txpacket[PKT_LENGTH_L] = 3
         txpacket[PKT_LENGTH_H] = 0
@@ -394,7 +402,8 @@ class Protocol2PacketHandler(object):
             return data_list, result
 
         # set rx timeout
-        port.setPacketTimeout(wait_length * 1)
+        #port.setPacketTimeout(wait_length * 1)
+        port.setPacketTimeoutMillis((wait_length * tx_time_per_byte) + (3.0 * MAX_ID) + 16.0);
 
         while True:
             rxpacket += port.readPort(wait_length - rx_length)
@@ -530,7 +539,7 @@ class Protocol2PacketHandler(object):
         data = []
 
         while True:
-            rxpacket, result = self.rxPacket(port)
+            rxpacket, result = self.rxPacket(port, False)
 
             if result != COMM_SUCCESS or rxpacket[PKT_ID] == dxl_id:
                 break
@@ -542,6 +551,50 @@ class Protocol2PacketHandler(object):
 
         return data, result, error
 
+    def fastSyncReadRx(self, port, dxl_id, length):
+        result = COMM_TX_FAIL
+        error = 0
+
+        rxpacket = None
+        data = []
+
+        rxpacket, result = self.rxPacket(port, True)
+
+        if result == COMM_SUCCESS and rxpacket[PKT_ID] == dxl_id:
+            error = rxpacket[PKT_ERROR]
+
+            # data[] : ERR + ID + Param + CRC + ERR + ID + Param + CRC + ...
+            data.extend(rxpacket[PKT_PARAMETER0: PKT_PARAMETER0 + length])
+
+        return data, result, error
+
+    def fastBulkReadRx(self, port, param):
+        rxpacket, result = self.rxPacket(port, True)
+
+        if result != COMM_SUCCESS:
+            return {}, result
+
+        data_dict = {}
+        idx = PKT_PARAMETER0
+        packet_length = len(rxpacket)
+
+        while idx < packet_length - 2:
+            error = rxpacket[idx]
+            dxl_id = rxpacket[idx + 1]
+
+            try:
+                param_idx = param.index(dxl_id)
+                data_length = DXL_MAKEWORD(param[param_idx + 3], param[param_idx + 4])
+            except ValueError:
+                break
+
+            data_segment = rxpacket[idx + 2 : idx + 2 + data_length]
+            data_dict[dxl_id] = data_segment
+            idx += data_length + 4  # ERR(1) + ID(1) + Data(N) + CRC(2)
+
+        return data_dict, COMM_SUCCESS
+
+
     def readTxRx(self, port, dxl_id, address, length):
         error = 0
 
@@ -704,16 +757,20 @@ class Protocol2PacketHandler(object):
 
         return result, error
 
-    def syncReadTx(self, port, start_address, data_length, param, param_length):
+    def syncReadTx(self, port, start_address, data_length, param, param_length, fast_option):
         txpacket = [0] * (param_length + 14)
         # 14: HEADER0 HEADER1 HEADER2 RESERVED ID LEN_L LEN_H INST START_ADDR_L START_ADDR_H DATA_LEN_L DATA_LEN_H CRC16_L CRC16_H
 
         txpacket[PKT_ID] = BROADCAST_ID
-        txpacket[PKT_LENGTH_L] = DXL_LOBYTE(
-            param_length + 7)  # 7: INST START_ADDR_L START_ADDR_H DATA_LEN_L DATA_LEN_H CRC16_L CRC16_H
-        txpacket[PKT_LENGTH_H] = DXL_HIBYTE(
-            param_length + 7)  # 7: INST START_ADDR_L START_ADDR_H DATA_LEN_L DATA_LEN_H CRC16_L CRC16_H
-        txpacket[PKT_INSTRUCTION] = INST_SYNC_READ
+        # 7: INST START_ADDR_L START_ADDR_H DATA_LEN_L DATA_LEN_H CRC16_L CRC16_H
+        txpacket[PKT_LENGTH_L] = DXL_LOBYTE(param_length + 7)
+        txpacket[PKT_LENGTH_H] = DXL_HIBYTE(param_length + 7)
+
+        if fast_option:
+            txpacket[PKT_INSTRUCTION] = INST_FAST_SYNC_READ
+        else:
+            txpacket[PKT_INSTRUCTION] = INST_SYNC_READ
+
         txpacket[PKT_PARAMETER0 + 0] = DXL_LOBYTE(start_address)
         txpacket[PKT_PARAMETER0 + 1] = DXL_HIBYTE(start_address)
         txpacket[PKT_PARAMETER0 + 2] = DXL_LOBYTE(data_length)
@@ -748,14 +805,17 @@ class Protocol2PacketHandler(object):
 
         return result
 
-    def bulkReadTx(self, port, param, param_length):
+    def bulkReadTx(self, port, param, param_length, fast_option):
         txpacket = [0] * (param_length + 10)
         # 10: HEADER0 HEADER1 HEADER2 RESERVED ID LEN_L LEN_H INST CRC16_L CRC16_H
 
         txpacket[PKT_ID] = BROADCAST_ID
         txpacket[PKT_LENGTH_L] = DXL_LOBYTE(param_length + 3)  # 3: INST CRC16_L CRC16_H
         txpacket[PKT_LENGTH_H] = DXL_HIBYTE(param_length + 3)  # 3: INST CRC16_L CRC16_H
-        txpacket[PKT_INSTRUCTION] = INST_BULK_READ
+        if fast_option:
+            txpacket[PKT_INSTRUCTION] = INST_FAST_BULK_READ
+        else:
+            txpacket[PKT_INSTRUCTION] = INST_BULK_READ
 
         txpacket[PKT_PARAMETER0: PKT_PARAMETER0 + param_length] = param[0: param_length]
 

dynamixel_sdk/robotis_def.py

@@ -17,7 +17,7 @@
 # limitations under the License.
 ################################################################################
 
-# Author: Ryu Woon Jung (Leon)
+# Author: Ryu Woon Jung (Leon), Wonho Yun
 
 BROADCAST_ID = 0xFE  # 254
 MAX_ID = 0xFC  # 252
@@ -36,7 +36,9 @@ INST_BULK_READ = 146  # 0x92
 INST_REBOOT = 8
 INST_STATUS = 85  # 0x55
 INST_SYNC_READ = 130  # 0x82
+INST_FAST_SYNC_READ = 138  # 0x8A
 INST_BULK_WRITE = 147  # 0x93
+INST_FAST_BULK_READ = 154  # 0x9A
 
 # Communication Result
 COMM_SUCCESS = 0  # tx or rx packet communication success

dynamixel_sdk-3.8.4.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: dynamixel-sdk
+Version: 3.8.4
+Summary: Dynamixel SDK 3. python package
+Home-page: https://github.com/ROBOTIS-GIT/DynamixelSDK
+Author: Leon Jung, Wonho Yun
+Author-email: Leon Jung <rwjung@robotis.com>, Wonho Yun <ywh@robotis.com>
+License: Apache 2.0
+Project-URL: Homepage, https://github.com/ROBOTIS-GIT/DynamixelSDK
+Requires-Python: >=3.6
+Description-Content-Type: text/plain
+License-File: LICENSE.txt
+Requires-Dist: pyserial
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+
+Description is available at http://emanual.robotis.com/docs/en/software/dynamixel/dynamixel_sdk/overview/

dynamixel_sdk-3.8.4.dist-info/RECORD

@@ -0,0 +1,15 @@
+dynamixel_sdk/__init__.py,sha256=A9_QfUoJR0XidH1zOsEjnzIFyEA7zqNKxFYIUgab6Sg,1007
+dynamixel_sdk/group_bulk_read.py,sha256=1-XRdtarNgI8DJR7WZt-L_5z-D_ZJr77ECbvcZhLpe0,6309
+dynamixel_sdk/group_bulk_write.py,sha256=cjYEwPa-wAUrCSVB5uic4dgmb1ZTrm5I7uiQo8lotqM,3298
+dynamixel_sdk/group_sync_read.py,sha256=iAK4WeK4_fHLwrFX9CI0zWFqEsG3Y3k8Ot29T275Qg8,6077
+dynamixel_sdk/group_sync_write.py,sha256=g3sbEDv_SCIzH3cYae73_denZ9UHfVUUlY3UlaGf_c0,2752
+dynamixel_sdk/packet_handler.py,sha256=i6QcvS88fnAa6GsLJrf2dvpG5SVrzjlEWR5unotlqOQ,1213
+dynamixel_sdk/port_handler.py,sha256=9mWvNygn2oAxeiYqUC89_Cfvv4mWjinicv3Y2OIW9Oo,3937
+dynamixel_sdk/protocol1_packet_handler.py,sha256=mPmFY8RTH3kfTkc_6BCyjR3vkm9Ydiswj_YjudwgYfs,18292
+dynamixel_sdk/protocol2_packet_handler.py,sha256=tn1RXsXInHOskJbkYyU-H7TpX0f3pnu1mMcJkh75fz0,32482
+dynamixel_sdk/robotis_def.py,sha256=i1t1GXP_VO5MA5RAvHUB4K0v-vMTOH1_rVSM7Qok-ho,2117
+dynamixel_sdk-3.8.4.dist-info/licenses/LICENSE.txt,sha256=xazLvYVG6Uw0rtJK_miaYXYn0Y7tWmxIJ35I21fCOFE,11356
+dynamixel_sdk-3.8.4.dist-info/METADATA,sha256=n3zMuMkL8ZT-iJUmfzxDNEd8qcIlQ3gk1LE2q_oKgxU,617
+dynamixel_sdk-3.8.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dynamixel_sdk-3.8.4.dist-info/top_level.txt,sha256=2FxQOpLoRUHKlmiZ5IxzqnarSYA5_cj6i5AsIWCbxPg,14
+dynamixel_sdk-3.8.4.dist-info/RECORD,,

{dynamixel_sdk-3.6.0.dist-info → dynamixel_sdk-3.8.4.dist-info}/WHEEL

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

dynamixel_sdk-3.6.0.dist-info/METADATA

@@ -1,14 +0,0 @@
-Metadata-Version: 2.1
-Name: dynamixel-sdk
-Version: 3.6.0
-Summary: Dynamixel SDK 3. python package
-Home-page: https://github.com/ROBOTIS-GIT/DynamixelSDK
-Author: Leon Jung
-Author-email: rwjung@robotis.com
-License: Apache 2.0
-Platform: UNKNOWN
-Requires-Dist: pyserial
-
-Description is available at http://emanual.robotis.com/docs/en/software/dynamixel/dynamixel_sdk/overview/
-
-

dynamixel_sdk-3.6.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-dynamixel_sdk/__init__.py,sha256=A9_QfUoJR0XidH1zOsEjnzIFyEA7zqNKxFYIUgab6Sg,1007
-dynamixel_sdk/group_bulk_read.py,sha256=8K1I-EMpFjpmTGtyyjfrlhzhseH7vFWStGhYJDZFzag,5135
-dynamixel_sdk/group_bulk_write.py,sha256=cjYEwPa-wAUrCSVB5uic4dgmb1ZTrm5I7uiQo8lotqM,3298
-dynamixel_sdk/group_sync_read.py,sha256=Mu_29ADKnj99fN9KLu5eaAwGNmOaTepRWK2xrcfaNYc,4667
-dynamixel_sdk/group_sync_write.py,sha256=g3sbEDv_SCIzH3cYae73_denZ9UHfVUUlY3UlaGf_c0,2752
-dynamixel_sdk/packet_handler.py,sha256=i6QcvS88fnAa6GsLJrf2dvpG5SVrzjlEWR5unotlqOQ,1213
-dynamixel_sdk/port_handler.py,sha256=9mWvNygn2oAxeiYqUC89_Cfvv4mWjinicv3Y2OIW9Oo,3937
-dynamixel_sdk/protocol1_packet_handler.py,sha256=mPmFY8RTH3kfTkc_6BCyjR3vkm9Ydiswj_YjudwgYfs,18292
-dynamixel_sdk/protocol2_packet_handler.py,sha256=9Nk4J2TH11iOmk8F_p5dP0D1SbY8_DXomjQaF5CpwHY,30652
-dynamixel_sdk/robotis_def.py,sha256=__Cy0ozTxmeRW-WKGjUNRXhdSanrqNJLVzyLjRjlpm0,2038
-dynamixel_sdk-3.6.0.dist-info/LICENSE.txt,sha256=xazLvYVG6Uw0rtJK_miaYXYn0Y7tWmxIJ35I21fCOFE,11356
-dynamixel_sdk-3.6.0.dist-info/METADATA,sha256=jcGftziScVJQR2QgeifOi-5XRs2y_yobof0qiLqNgvM,375
-dynamixel_sdk-3.6.0.dist-info/WHEEL,sha256=g4nMs7d-Xl9-xC9XovUrsDHGXt-FT0E17Yqo92DEfvY,92
-dynamixel_sdk-3.6.0.dist-info/top_level.txt,sha256=2FxQOpLoRUHKlmiZ5IxzqnarSYA5_cj6i5AsIWCbxPg,14
-dynamixel_sdk-3.6.0.dist-info/RECORD,,