joong925-sdk-python 0.1.0__py3-none-any.whl

joong925_sdk_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: joong925-sdk-python
+Version: 0.1.0
+Summary: Python SDK for Gripper
+Author: cjo
+Author-email: cjo@tesollo.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: opencv-python
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# delto-sdk-python
+
+```bash
+pip install delto-sdk-python

joong925_sdk_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+joong925_sdk_python-0.1.0.dist-info/licenses/LICENSE,sha256=GPSzzltdyZ3np8j_CFkrTJLIWL-ih1ea8D1Jiy47cGc,1063
+tesollo_sdk_python/__init__.py,sha256=uZ_f9kvUmUXXlhwWWbyGxBKT5S0BXM_gNydxCwCGu7k,192
+tesollo_sdk_python/constants.py,sha256=ePDPj8Mkxf60NyhR56M7UJo9CrrHbnu9yCo97bw7HUk,1846
+tesollo_sdk_python/controller.py,sha256=V65VoXl-8z86i2t3ptN6OCkgWqkSrJenCkuutD6GMgk,2991
+tesollo_sdk_python/delto.py,sha256=tLNVbuOSr4bRL24Qz7y1cK9SR1wLccH71K06M5ohf5Y,4295
+tesollo_sdk_python/visualize.py,sha256=u4S2XWEHDvCbSiBOPuOr-hFm-ktHvy2N_poYKZGiuTg,2081
+joong925_sdk_python-0.1.0.dist-info/METADATA,sha256=zblN7hV9app1SgXnCOsO_eRMYhIc2p8oOr2f1lXPxGk,677
+joong925_sdk_python-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+joong925_sdk_python-0.1.0.dist-info/top_level.txt,sha256=eFqgpSxjt-YIOvCQLVkM19AnS6zHgNFexN7-rrVfCFo,19
+joong925_sdk_python-0.1.0.dist-info/RECORD,,

joong925_sdk_python-0.1.0.dist-info/WHEEL

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

joong925_sdk_python-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tesollo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

joong925_sdk_python-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+tesollo_sdk_python

tesollo_sdk_python/__init__.py

@@ -0,0 +1,6 @@
+from .delto import DeltoController
+from .controller import PDController, PDControllerCfg
+from .visualize import init_window, render_tactile_data
+from .constants import *
+
+__version__ = "0.1.0"

tesollo_sdk_python/constants.py

@@ -0,0 +1,65 @@
+# DG_RESULT
+DG_RESULT_NONE = 0
+DG_RESULT_ERROR = 1
+
+# DG_MODEL
+DG_MODEL_NONE = 0x0000
+DG_MODEL_DG_5F_L = 0x5F12
+DG_MODEL_DG_5F_R = 0x5F22
+
+# BLEND_MOTION_STATUS
+BLEND_MOTION_STATUS_STOP = 0
+BLEND_MOTION_STATUS_RUN = 1
+BLEND_MOTION_STATUS_COMPLETE = 2
+
+# COMMUNICATION_MODE
+COMMUNICATION_MODE_ETHERNET = 0
+COMMUNICATION_MODE_RS485 = 1
+
+# CONTROL_MODE
+CONTROL_MODE_OPERATOR = 0
+CONTROL_MODE_DEVELOPER = 1
+
+# GAIN_MODE
+GAIN_MODE_PD = 0
+GAIN_MODE_PID = 1
+
+# DEVELOPER_MODE_COMMAND
+DEVELOPER_MODE_COMMAND_GET_DATA = 0x01
+DEVELOPER_MODE_COMMAND_SET_RECEIVED_DATA = 0x02
+DEVELOPER_MODE_COMMAND_SET_DUTY = 0x05
+DEVELOPER_MODE_COMMAND_SET_GPIO = 0x06
+DEVELOPER_MODE_COMMAND_SET_IP_ADDRESS = 0x07
+DEVELOPER_MODE_COMMAND_GET_ID_AND_VERSION = 0x08
+DEVELOPER_MODE_COMMAND_GET_JOINT_ID = 0x09
+DEVELOPER_MODE_COMMAND_SET_BOOT_MODE = 0x0A
+DEVELOPER_MODE_COMMAND_SET_FT_OFFSET_ZERO = 0x0B
+
+# DEVELOPER_MODE_RECEIVED_DATA_TYPE
+DEVELOPER_MODE_RECEIVED_DATA_TYPE_JOINT = 0x01
+DEVELOPER_MODE_RECEIVED_DATA_TYPE_CURRENT = 0x02
+DEVELOPER_MODE_RECEIVED_DATA_TYPE_TEMPERATURE = 0x03
+DEVELOPER_MODE_RECEIVED_DATA_TYPE_VELOCITY = 0x04
+DEVELOPER_MODE_RECEIVED_DATA_TYPE_FINGER_FT_SENSOR = 0x05
+DEVELOPER_MODE_RECEIVED_DATA_TYPE_GPIO = 0x06
+DEVELOPER_MODE_RECEIVED_DATA_TYPE_FINGER_TACTILE_SENSOR = 0x05
+
+
+# [5.2.1 개발자 모드 명령어]
+CMD_GET_DATA = 0x01
+CMD_SET_DUTY = 0x05
+CMD_SET_GPIO = 0x06
+CMD_SET_IP_PORT = 0x07
+CMD_GET_ID_VERSION = 0x08
+CMD_GET_COMM_ERROR = 0x09
+CMD_SET_BOOT_MODE = 0x0A
+CMD_SET_FT_OFFSET = 0x0B
+
+# [5.2.2 수신 데이터 종류 및 크기]
+TYPE_POSITION = 0x01      # 2 Byte, 0.1 Degree
+TYPE_CURRENT = 0x02       # 2 Byte, 1 mA
+TYPE_TEMPERATURE = 0x03   # 2 Byte, 0.1 °C
+TYPE_VELOCITY = 0x04      # 1 Byte, 1 RPM
+TYPE_FT_SENSOR = 0x05     # 12 Byte, 0.1 N / 0.1 Nm
+TYPE_GPIO = 0x06          # 4 Byte
+TYPE_TACTILE_SENSOR = 0x05     # 15 Byte

tesollo_sdk_python/controller.py

@@ -0,0 +1,86 @@
+import socket
+import struct
+import time
+from .constants import *
+
+class PDControllerCfg:
+    def __init__(self, kp, kd, output_limit):
+        self.kp = kp
+        self.kd = kd
+        self.output_limit = output_limit
+        self.prev_error = {}
+
+    def update(self, current_positions, target_positions, dt, duty_limits=None):
+        if dt <= 0.0: dt = 1e-5 
+        if duty_limits is None: duty_limits = {}
+
+        duties = {}
+        for joint_id, target_pos in target_positions.items():
+            if joint_id not in current_positions:
+                continue
+                
+            current_pos = current_positions[joint_id]
+            error = target_pos - current_pos
+
+            if joint_id not in self.prev_error:
+                self.prev_error[joint_id] = 0.0
+
+            p_term = self.kp * error
+            d_error = (error - self.prev_error[joint_id]) / dt
+            d_term = self.kd * d_error
+
+            output = p_term + d_term
+
+            joint_duty_limit = duty_limits.get(joint_id, self.output_limit)
+
+            if output > joint_duty_limit:
+                output = joint_duty_limit
+            elif output < -joint_duty_limit:
+                output = -joint_duty_limit
+
+            duties[joint_id] = output
+            self.prev_error[joint_id] = error
+        
+        return duties
+    
+class PDController:
+    def __init__(self, kp=20.0, kd=0.5, output_limit=450):
+        self.pd_controller = PDControllerCfg(kp, kd, output_limit)
+        
+        self.final_targets = {i: 0.0 for i in range(1, 21)}
+        self.current_setpoints = {i: 0.0 for i in range(1, 21)}
+        self.desired_speeds = {i: 450 for i in range(1, 21)}
+        self.is_initialized = False
+
+    def set_positions(self, targets, speeds=None):
+        for jid, pos in targets.items():
+            if 1 <= jid <= 20:
+                self.final_targets[jid] = pos
+        
+        if speeds is not None:
+            if isinstance(speeds, dict):
+                for jid, speed in speeds.items():
+                    if 1 <= jid <= 20: self.desired_speeds[jid] = speed
+            else:
+                for jid in targets.keys():
+                    self.desired_speeds[jid] = float(speeds)
+
+    def update(self, current_positions, dt):
+        if not self.is_initialized and current_positions:
+            for jid, pos in current_positions.items():
+                self.current_setpoints[jid] = pos
+            self.is_initialized = True
+
+        for jid in range(1, 21):
+            goal = self.final_targets[jid]
+            curr_set = self.current_setpoints[jid]
+            speed = self.desired_speeds[jid]
+            
+            max_step = speed * dt
+            
+            if curr_set < goal:
+                self.current_setpoints[jid] = min(curr_set + max_step, goal)
+            elif curr_set > goal:
+                self.current_setpoints[jid] = max(curr_set - max_step, goal)
+
+        return self.pd_controller.update(current_positions, self.current_setpoints, dt)

tesollo_sdk_python/delto.py

@@ -0,0 +1,122 @@
+import socket
+import struct
+import time
+from .constants import *
+
+class DeltoController:
+    def __init__(self, ip="192.168.1.119", port=502):
+        self.ip = ip
+        self.port = port
+        self.client = None
+        self.fingers = 5
+
+    def connect(self):
+        try:
+            self.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.client.settimeout(2.0)
+            self.client.connect((self.ip, self.port))
+            print(f"Connection success: {self.ip}")
+            return True
+        except Exception as e:
+            print(f"Connection failed: {e}")
+            return False
+        
+    def disconnect(self):
+        if self.client:
+            self.client.close()
+            print("Disconnected.")
+
+    def _send_packet(self, cmd, data_bytes=None, expect_response=True):
+        if data_bytes is None:
+            data_bytes = b''
+        
+        packet_len = 2 + 1 + len(data_bytes)
+        header = struct.pack('!HB', packet_len, cmd)
+        packet = header + data_bytes
+        
+        try:
+            self.client.send(packet)
+            if expect_response:
+                response = self.client.recv(1024)
+                return response
+            return None 
+            
+        except Exception as e:
+            print(f"Communication error: {e}")
+            return None
+        
+    def set_duty(self, duty_dict):
+        data_bytes = b""
+        for joint_id, duty_val in duty_dict.items():
+            raw_duty = (duty_val / 450.0) * 1000.0
+            
+            target_duty = int(raw_duty)
+            target_duty = max(-1000, min(1000, target_duty))
+            
+            data_bytes += struct.pack('!Bh', joint_id, target_duty)
+            
+        self._send_packet(CMD_SET_DUTY, data_bytes, expect_response=False)
+
+    def get_data(self, data_types):
+        response = self._send_packet(CMD_GET_DATA, bytes(data_types))
+        if response:
+            return self.parse_response(response, data_types)
+        return None
+
+    def parse_response(self, data, requested_types):
+        if len(data) < 3: return None
+        
+        total_len = struct.unpack('!H', data[0:2])[0]
+        cmd = data[2]
+        
+        packet = data[:total_len]
+
+        results = {"joints": {}, "sensors": [None] * self.fingers, "gpio": None}
+        
+        end_offset = total_len
+        
+        if TYPE_GPIO in requested_types:
+            end_offset -= 4
+            results["gpio"] = packet[end_offset:end_offset+4].hex()
+            
+        if TYPE_TACTILE_SENSOR in requested_types:
+            tactile_size = 15 * self.fingers
+            end_offset -= tactile_size
+            
+            tactile_data = packet[end_offset:end_offset+tactile_size]
+            
+            for i in range(self.fingers):
+                finger_bytes = tactile_data[i*15 : (i+1)*15]
+                finger_values = list(finger_bytes)
+                results["sensors"][i] = finger_values
+
+        joint_types = [t for t in requested_types if t in (TYPE_POSITION, TYPE_CURRENT, TYPE_TEMPERATURE, TYPE_VELOCITY)]
+        
+        offset = 3
+        if joint_types:
+            while offset < end_offset:
+                joint_id = packet[offset]
+                offset += 1
+                joint_info = {}
+
+                for t in joint_types:
+                    if t == TYPE_POSITION:
+                        val = struct.unpack('!h', packet[offset:offset+2])[0]
+                        joint_info['position'] = val * 0.1
+                        offset += 2
+                    elif t == TYPE_CURRENT:
+                        val = struct.unpack('!h', packet[offset:offset+2])[0]
+                        joint_info['current'] = val
+                        offset += 2
+                    elif t == TYPE_TEMPERATURE:
+                        val = struct.unpack('!h', packet[offset:offset+2])[0]
+                        joint_info['temperature'] = val * 0.1
+                        offset += 2
+                    elif t == TYPE_VELOCITY:
+                        raw_val = packet[offset]
+                        val = raw_val if raw_val < 128 else raw_val - 256
+                        joint_info['velocity'] = val * 6.0 
+                        offset += 1
+                results["joints"][joint_id] = joint_info
+
+        return results

tesollo_sdk_python/visualize.py

@@ -0,0 +1,56 @@
+import cv2
+import numpy as np
+
+def init_window(window_name="Tesollo Tactile Sensor Viewer"):
+    cv2.namedWindow(window_name, cv2.WINDOW_NORMAL)
+    cv2.resizeWindow(window_name, 1200, 600)
+    return window_name
+
+def render_tactile_data(window_name, tactile_data_list):
+    num_fingers = 5
+    nrows, ncols = 5, 3
+    
+    resolution = 30  
+    padding = 50
+
+    img_h = (nrows * resolution) + (padding * 2)
+    img_w = (num_fingers * ncols * resolution) + ((num_fingers - 1) * padding) + (padding * 2)
+    
+    vis_img = np.zeros((img_h, img_w, 3), dtype=np.uint8)
+
+    for f_idx in range(num_fingers):
+        finger_data = tactile_data_list[f_idx]
+        
+        start_x = padding + f_idx * (ncols * resolution + padding)
+        start_y = padding
+
+        cv2.putText(vis_img, f"Finger {f_idx + 1}", (start_x, start_y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.3, (255, 255, 255), 0)
+
+        for r in range(nrows):
+            for c in range(ncols):
+                idx = r * ncols + c
+                val = finger_data[idx]
+                
+                intensity = np.clip(val / 255.0, 0, 1)
+                
+                color_r = int(intensity * 255)
+                color_g = int((1 - intensity) * 255)
+                color_b = 0 
+                
+                center_x = start_x + (c * resolution) + (resolution // 2)
+                center_y = start_y + (r * resolution) + (resolution // 2)
+                
+                cv2.circle(vis_img, (center_x, center_y), radius=(resolution // 2) - 3,  color=(color_b, color_g, color_r),  thickness=-1)
+
+                text = str(val)
+                font = cv2.FONT_HERSHEY_SIMPLEX
+                font_scale = 0.3
+                thickness = 0
+                
+                text_size, _ = cv2.getTextSize(text, font, font_scale, thickness)
+                text_x = center_x - (text_size[0] // 2)
+                text_y = center_y + (text_size[1] // 2)
+                
+                cv2.putText(vis_img, text, (text_x, text_y), font, font_scale, (255, 255, 255), thickness)
+
+    cv2.imshow(window_name, vis_img)