MECHANICAL
ENGINEERING

Konvensi DH adalah metode standar untuk mendeskripsikan kinematika robot lengan menggunakan 4 parameter per joint. Setiap link i memiliki frame koordinat yang didefinisikan relatif terhadap frame sebelumnya.

Contoh: Robot 3-DOF Planar

import numpy as np

def dh_matrix(a, alpha, d, theta):
    """Matriks transformasi DH standar 4x4"""
    ct, st = np.cos(theta), np.sin(theta)
    ca, sa = np.cos(alpha), np.sin(alpha)
    return np.array([
        [ct, -st*ca,  st*sa, a*ct],
        [st,  ct*ca, -ct*sa, a*st],
        [ 0,     sa,     ca,    d],
        [ 0,      0,      0,    1]
    ])

def forward_kinematics_3dof(theta1, theta2, theta3,
                             L1=0.15, L2=0.12, L3=0.08):
    """Robot 3-DOF planar, panjang link dalam meter"""
    T1 = dh_matrix(L1, 0, 0, theta1)
    T2 = dh_matrix(L2, 0, 0, theta2)
    T3 = dh_matrix(L3, 0, 0, theta3)
    T  = T1 @ T2 @ T3
    x, y = T[0,3], T[1,3]
    psi  = theta1 + theta2 + theta3  # total orientation
    return x, y, psi, T

# Test:
x,y,psi,T = forward_kinematics_3dof(np.radians(30), np.radians(45), np.radians(-15))
print(f"EE pos: ({x*1000:.1f}, {y*1000:.1f}) mm, orientasi: {np.degrees(psi):.1f}°")

import numpy as np

def ik_analytical_3dof(xd, yd, psi_d, L1=0.15, L2=0.12, L3=0.08, elbow_up=True):
    """Analytical IK 3-DOF planar. Returns (theta1,theta2,theta3) in rad."""
    # Wrist center (kurangi kontribusi L3)
    xw = xd - L3*np.cos(psi_d)
    yw = yd - L3*np.sin(psi_d)

    c2 = (xw**2 + yw**2 - L1**2 - L2**2) / (2*L1*L2)
    if abs(c2) > 1: raise ValueError("Target di luar jangkauan!")

    s2 = np.sqrt(1 - c2**2) * (1 if elbow_up else -1)
    theta2 = np.arctan2(s2, c2)
    theta1 = np.arctan2(yw, xw) - np.arctan2(L2*s2, L1+L2*c2)
    theta3 = psi_d - theta1 - theta2
    return theta1, theta2, theta3

def ik_numerical(target_pos, fk_fn, q0, alpha=0.5, iters=200, tol=1e-4):
    """Numerical IK dengan Jacobian finite difference"""
    q = np.array(q0, dtype=float)
    for _ in range(iters):
        x_cur = np.array(fk_fn(*q)[:2])
        err = np.array(target_pos) - x_cur
        if np.linalg.norm(err) < tol: break
        # Jacobian finite difference
        J = np.zeros((2, len(q))); eps=1e-5
        for i in range(len(q)):
            qp=q.copy(); qp[i]+=eps
            J[:,i] = (np.array(fk_fn(*qp)[:2]) - x_cur) / eps
        Jp = np.linalg.pinv(J)
        q += alpha * Jp @ err
    return q

Gear Ratio & Torsi

Perbandingan Aktuator

Perhitungan Motor Drive

def motor_sizing(J_load_kgm2, omega_max_rpm, accel_time_s,
                  gear_ratio, eta=0.85):
    omega_max = omega_max_rpm * 2 * np.pi / 60  # rpm → rad/s
    omega_motor = omega_max * gear_ratio
    J_ref = J_load_kgm2 / gear_ratio**2
    alpha_motor = (omega_motor / accel_time_s)  # max angular accel
    tau_accel = J_ref * alpha_motor
    tau_motor_min = tau_accel / eta
    power_min = tau_motor_min * omega_motor
    return {
        "omega_motor_rpm": omega_motor * 60 / (2*np.pi),
        "tau_min_Nm": tau_motor_min,
        "power_min_W": power_min
    }

Pemilihan Bearing

Umur Bearing (L10)

Diameter Poros Minimum

import numpy as np

def shaft_diameter(T_Nm, M_Nm=0, Sy_MPa=235, SF=2.0):
    tau_allow = (Sy_MPa * 1e6) / (2 * SF)
    d = (16/(np.pi*tau_allow) * np.sqrt(M_Nm**2 + T_Nm**2))**(1/3)
    return d * 1000  # mm

print(f"Diameter min: {shaft_diameter(T_Nm=5, M_Nm=3):.1f} mm")

Static Equilibrium — Robot Link

Persamaan Gerak Robot (Newton-Euler)

import numpy as np

def gravity_torques_2dof(theta1, theta2,
                          L1=0.15, L2=0.12,
                          m1=0.3, m2=0.2, g=9.81):
    """Gravity torques untuk 2-DOF planar robot vertical plane"""
    lc1 = L1/2; lc2 = L2/2  # CoM tiap link
    t1 = theta1; t12 = theta1 + theta2

    # Torsi joint 2: hanya support link 2
    tau2 = m2 * g * lc2 * np.cos(t12)

    # Torsi joint 1: support link 1 + link 2
    tau1 = (m1*lc1 + m2*L1) * g * np.cos(t1) + m2*g*lc2*np.cos(t12)
    return tau1, tau2

t1, t2 = gravity_torques_2dof(np.radians(30), np.radians(45))
print(f"τ1={t1:.3f} Nm, τ2={t2:.3f} Nm")

Workflow desain mekanik robot yang efisien menggunakan CAD parametrik.

Software CAD untuk Robotika

Aturan Desain FDM

Material Robotika

// OpenSCAD: Parametric robot wheel
module wheel(r=30, w=20, hub_r=8, shaft_d=5, spokes=6) {
  difference() {
    union() {
      cylinder(r=r, h=w, center=true, $fn=64);
      cylinder(r=hub_r+3, h=w+4, center=true, $fn=32);
    }
    cylinder(r=shaft_d/2+0.3, h=w+10, center=true, $fn=32);
    for(i=[0:spokes-1]) rotate([0,0,i*360/spokes])
      translate([r/2,0,0]) cylinder(r=(r-hub_r)/3, h=w-2, center=true, $fn=16);
  }
}

Von Mises Stress Criterion

FEA Tools

Material Struktur Robot

Specific Stiffness & Strength

import roboticstoolbox as rtb
import numpy as np

# Robotics Toolbox Python — Peter Corke
# pip install roboticstoolbox-python

# Load model robot standar
panda = rtb.models.Panda()
ur5   = rtb.models.UR5()

# Forward kinematics
q = np.array([0, -np.pi/4, 0, -np.pi/2, 0, np.pi/3, 0])
T = panda.fkine(q)
print("EE Pose:\n", T)

# Inverse kinematics (numerical)
target_T = rtb.SE3(0.4, 0.2, 0.5)
sol = panda.ik_LM(target_T)  # Levenberg-Marquardt
print("IK solution:", np.degrees(sol.q))

# Jacobian
J = panda.jacob0(q)  # 6×7 Jacobian di base frame
print("Jacobian shape:", J.shape)

# Manipulability measure (Yoshikawa)
w = np.sqrt(np.linalg.det(J @ J.T))
print(f"Manipulability: {w:.4f}")

# Trajectory generation
q_start = np.zeros(7)
q_end   = np.array([0.5, -0.5, 0.2, -1.0, 0.1, 0.8, -0.3])
traj = rtb.jtraj(q_start, q_end, 50)  # 50 waypoints, quintic
panda.plot(traj.q, movie='robot_motion.gif')

Singularity Detection

def check_singularity(J, threshold=0.01):
    """Cek singularity via condition number"""
    _, sv, _ = np.linalg.svd(J[:3,:])
    cond = sv[0] / (sv[-1] + 1e-10)
    near_singular = sv[-1] < threshold
    return near_singular, cond, sv

# Manip. ellipsoid: eigenvalues of J·J^T
# Principal axes = sqrt(eigenvalues)
JJt = J[:3,:] @ J[:3,:].T
eigvals, eigvecs = np.linalg.eig(JJt)
axes = np.sqrt(abs(eigvals))