kuavo-humanoid-sdk 0.1.0__py3-none-any.whl

kuavo_humanoid_sdk/__init__.py

@@ -0,0 +1,3 @@
+from .interfaces import *
+from .kuavo import *
+from kuavo_humanoid_sdk.common.logger import SDKLogger, disable_sdk_logging

kuavo_humanoid_sdk/common/logger.py

@@ -0,0 +1,42 @@
+import logging
+import os
+from pathlib import Path
+from logging.handlers import RotatingFileHandler
+def setup_logger():
+    logger = logging.getLogger('kuavo-humanoid-sdk')
+    logger.setLevel(logging.DEBUG)
+    log_suffix = f'log/kuavo_humanoid_sdk'
+    log_dir = f'/var/{log_suffix}'
+    try:
+        Path(log_dir).mkdir(parents=True, exist_ok=True)
+    except Exception as e:
+        # If creation in /var fails, create in current directory
+        log_dir = f'./{log_suffix}'
+        Path(log_dir).mkdir(parents=True, exist_ok=True)        
+    log_file = f'{log_dir}/kuavo_humanoid_sdk.log'
+
+    print(f'kuavo-humanoid-sdk log_file: {log_file}')
+
+    fh = RotatingFileHandler(log_file, maxBytes=2*1024*1024, backupCount=5)  # 每个日志文件最大 2 MB，保留 5 个备份文件
+    fh.setLevel(logging.DEBUG)
+    
+    ch = logging.StreamHandler()
+    ch.setLevel(logging.DEBUG)
+    
+    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+    fh.setFormatter(formatter)
+    ch.setFormatter(formatter)
+    
+    logger.addHandler(fh)
+    logger.addHandler(ch)
+    return logger
+
+def disable_sdk_logging():
+    """
+        Disable SDK logging.
+    """
+    logging.disable()
+
+
+""" Logger """
+SDKLogger = setup_logger()

kuavo_humanoid_sdk/interfaces/__init__.py

@@ -0,0 +1,4 @@
+from .data_types import *
+from .robot import *
+from .end_effector import *
+from .robot_info import *

kuavo_humanoid_sdk/interfaces/data_types.py

@@ -0,0 +1,122 @@
+from typing import Tuple
+from enum import Enum
+from dataclasses import dataclass
+
+@dataclass
+class KuavoJointData:
+    """Data class representing joint states of the robot.
+
+    Args:
+        position (list): List of joint positions (angles) in radians
+        velocity (list): List of joint velocities in radians/second
+        torque (list): List of joint torques/efforts in Newton-meters or Amperes
+        acceleration (list): List of joint accelerations in radians/second^2
+    """
+    position: list
+    velocity: list
+    torque: list
+    acceleration:list
+
+@dataclass
+class KuavoImuData:
+    """Data class representing IMU (Inertial Measurement Unit) data from the robot.
+
+    Args:
+        gyro (Tuple[float, float, float]): Angular velocity around x, y, z axes in rad/s
+        acc (Tuple[float, float, float]): Linear acceleration in x, y, z axes in m/s^2
+        free_acc (Tuple[float, float, float]): Free acceleration (gravity compensated) in x, y, z axes in m/s^2
+        quat (Tuple[float, float, float, float]): Orientation quaternion (x, y, z, w)
+    """
+    gyro : Tuple[float, float, float]
+    acc : Tuple[float, float, float]
+    free_acc: Tuple[float, float, float]
+    quat: Tuple[float, float, float, float]
+
+@dataclass
+class KuavoOdometry:
+    """Data class representing odometry data from the robot.
+
+    Args:
+        position (Tuple[float, float, float]): Robot position (x, y, z) in world coordinates in meters
+        orientation (Tuple[float, float, float, float]): Robot orientation as quaternion (x, y, z, w)
+        linear (Tuple[float, float, float]): Linear velocity (x, y, z) in world coordinates in m/s
+        angular (Tuple[float, float, float]): Angular velocity (x, y, z) in world coordinates in rad/s
+    """
+    position: Tuple[float, float, float]
+    orientation: Tuple[float, float, float, float]
+    linear: Tuple[float, float, float]
+    angular: Tuple[float, float, float]
+
+class KuavoArmCtrlMode(Enum):
+    """Enum class representing the control modes for the Kuavo robot arm.
+
+    Attributes:
+        ArmFixed: The robot arm is fixed in position (value: 0)
+        AutoSwing: The robot arm is in automatic swinging mode (value: 1)
+        ExternalControl: The robot arm is controlled by external commands (value: 2)
+    """
+    ArmFixed = 0
+    AutoSwing = 1 
+    ExternalControl = 2
+
+
+@dataclass
+class EndEffectorState:
+    """Data class representing the state of the end effector.
+
+    Args:
+        position (float): Position of the end effector, [0, 100]
+        velocity (float): ...
+        effort (float): ...
+    """
+    position: float
+    velocity: float
+    effort: float
+    class GraspingState(Enum):
+        """Enum class representing the grasping states of the end effector.
+
+        Attributes:
+            ERROR: Error state (value: -1)
+            UNKNOWN: Unknown state (value: 0)
+            REACHED: Target position reached (value: 1)
+            MOVING: Moving to target position (value: 2)
+            GRABBED: Object successfully grasped (value: 3)
+        """
+        ERROR = -1
+        UNKNOWN = 0
+        MOVING = 1
+        REACHED = 2
+        GRABBED = 3
+
+    state: GraspingState # gripper grasping states
+
+class EndEffectorSide(Enum):
+    """Enum class representing the sides of the end effector.
+
+    Attributes:
+        LEFT: The left side of the end effector (value: 'left')
+        RIGHT: The right side of the end effector (value: 'right')
+        BOTH: Both sides of the end effector (value: 'both')
+    """
+    LEFT = 'left'
+    RIGHT = 'right'
+    BOTH = 'both'
+
+@dataclass
+class KuavoPose:
+    """Data class representing the pose of the robot."""
+    position: Tuple[float, float, float] # x, y, z
+    orientation: Tuple[float, float, float, float] # x, y, z, w
+
+@dataclass
+class KuavoIKParams:
+    """Data class representing the parameters for the IK node."""
+    # snopt params
+    major_optimality_tol: float = 1e-3
+    major_feasibility_tol: float = 1e-3  
+    minor_feasibility_tol: float = 1e-3
+    major_iterations_limit: float = 100
+    # constraint and cost params
+    oritation_constraint_tol: float = 1e-3
+    pos_constraint_tol: float = 1e-3 # 0.001m, work when pos_cost_weight==0.0
+    pos_cost_weight: float = 0.0 # If U need high accuracy, set this to 0.0 !!!

kuavo_humanoid_sdk/interfaces/end_effector.py

@@ -0,0 +1,43 @@
+from abc import ABC, abstractmethod
+from typing import Tuple
+from kuavo_humanoid_sdk.interfaces.data_types import EndEffectorSide, EndEffectorState
+    
+class EndEffector(ABC):
+    def __init__(self, joint_names: list):
+        self.joint_names = joint_names
+        
+    @abstractmethod
+    def control(self, target_positions:list, target_velocities:list, target_torques:list)->bool:
+        pass
+
+    @abstractmethod
+    def control_right(self, target_positions:list, target_velocities:list, target_torques:list)->bool:
+        pass
+
+    @abstractmethod
+    def control_left(self, target_positions:list, target_velocities:list, target_torques:list)->bool:
+        pass    
+
+    @abstractmethod
+    def open(self, side:EndEffectorSide)->bool:
+        pass
+
+    @abstractmethod
+    def get_state(self)->Tuple[EndEffectorState, EndEffectorState]:
+        pass
+
+    @abstractmethod
+    def get_position(self)->Tuple[float, float]:
+        pass
+
+    @abstractmethod
+    def get_velocity(self)->Tuple[float, float]:
+        pass
+
+    @abstractmethod
+    def get_effort(self)->Tuple[float, float]:
+        pass
+
+    @abstractmethod
+    def get_grasping_state(self)->Tuple[EndEffectorState.GraspingState, EndEffectorState.GraspingState]:
+        pass

kuavo_humanoid_sdk/interfaces/robot.py

@@ -0,0 +1,22 @@
+
+from abc import ABC, abstractmethod
+
+class RobotBase(ABC):
+    def __init__(self, robot_type: str = "kuavo"):
+        self._robot_type = robot_type
+
+    @property
+    def robot_type(self) -> str:
+        return self._robot_type
+
+    @abstractmethod
+    def trot(self):
+        pass
+
+    @abstractmethod
+    def stance(self):
+        pass
+
+    @abstractmethod
+    def jump(self):
+        pass

kuavo_humanoid_sdk/interfaces/robot_info.py

@@ -0,0 +1,56 @@
+from abc import ABC, abstractmethod
+
+class RobotInfoBase(ABC):
+    def __init__(self, robot_type: str = "kuavo"):
+        self._robot_type = robot_type
+
+    @property
+    def robot_type(self) -> str:
+        """
+            Get the robot type, e.g. "kuavo"
+        """
+        return self._robot_type
+    
+    @property
+    @abstractmethod
+    def robot_version(self) -> str:
+        """
+            Get the robot version, e.g. "42", "43"
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def end_effector_type(self) -> str:
+        """
+            Get the end effector type, e.g. "lejuclaw"...
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def joint_names(self) -> list:
+        """
+            Get the joint names, e.g. ["joint1", "joint2", ...]
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def joint_dof(self) -> int:
+        """
+            Get the joint degrees of freedom, e.g. 28
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def arm_joint_dof(self) -> int:
+        """
+            Get the arm joint degrees of freedom, e.g. 14
+        """
+        pass
+
+    def __str__(self) -> str:
+       pass
+    

kuavo_humanoid_sdk/kuavo/__init__.py

@@ -0,0 +1,7 @@
+from .robot import KuavoSDK, KuavoRobot  
+from .robot_info import KuavoRobotInfo
+from .robot_state import KuavoRobotState
+from .robot_arm import KuavoRobotArm
+from .robot_head import KuavoRobotHead
+from .dexterous_hand import DexterousHand
+from .leju_claw import LejuClaw