Field fix / guideDesign DocumentVendor-agnostic (IEC 61131-3)Manufacturingindustrial-automation

Robotic Arm Multi-Axis Position Tracking — Control Design

Shared by TSIMEREZIVO Team · 4 Oct 2026 · 38 views

# Manufacturing Template: Robotic Arm Multi-Axis Position Tracking ## 1. Overview **Purpose:** Coordinate multi-axis (typically 6) robotic arm positioning via simultaneous inverse kinematics, proportional servo valve control, and position feedback from joint encoders. Applications: welding, material handling,assembly, palletizing, spray painting. **Industry Standards:** - ISO 10218-1 (Industrial robots — Safety) - ISO 13849-1 (Safety of machinery — Control systems) - NFPA 79 (Electrical Standard for Industrial Machinery) - ISO 9283 (Manipulating Industrial Robots — Performance Criteria) **Critical Constraints:** - **Singularity avoidance:** Certain joint angle combinations cause infinite/ill-defined solutions (joint near-lock state) - **Coordinated motion:** All 6 axes move simultaneously; motion not sequential (prevents herky-jerky movements) - **Toolpath precision:** ±1 mm at tool tip (end-effector position accuracy across 2 m reach) - **Velocity limits:** Joint rates limited by hydraulic flow (typically 20–100°/sec depending on joint size) - **Payload capacity:** Maximum load at tool varies by arm configuration; 50 kg typical for industrial arms - **Collision detection:** Force/torque sensors detect impact; immediate stop required (<100 ms) **Relevant Physics:** - Forward kinematics: **T = H₁(θ₁) × H₂(θ₂) × ... × H₆(θ₆)** where T = tool position/orientation matrix - Inverse kinematics: **θ₁,...,θ₆ = IK(desired_T, current_θ, elbow_up/down)** (computational inversion) - Singularity detection: **det(Jacobian) ≈ 0** → arm at singular configuration (infinite requirement, stop motion) - Cartesian velocity: **v_tool = Jacobian × ω_joint** (joint angular vel → tool linear/angular vel) --- ## 2. Control Philosophy **Challenge:** True 6-axis robot control requires simultaneous inverse kinematics (computationally intensive), singularity avoidance, and coordinated servo control across all joints. Naive proportional control on each joint independently results in jerky, non-smooth paths. **Solution: Cartesian Interpolation with Singularity Guard** ``` Operation Modes: 1. Cartesian (Linear) Mode: Most Common (Tool moves in straight line) - Operator specifies: desired tool position (X,Y,Z) and orientation (Roll,Pitch,Yaw) - PLC computes: inverse kinematics → desired joint angles - Check: singularity warning if det(Jacobian) < threshold - Command: proportional servo valve on each joint → move all 6 axes simultaneously - Motion profile: trapezoidal (accel 20°/sec² → constant vel → decel) 2. Joint (Angular) Mode: Direct joint command - Operator specifies: desired θ₁ through θ₆ in degrees - No IK needed; move directly to joint angles - Used for precise positioning or teaching mode 3. Coordinated Velocity Mode: Continuous tool motion - Operator joystick provides: Vx, Vy, Vz, Ωx, Ωy, Ωz (tool-space velocities) - PLC continuously solves: Joint_rates = Jacobian⁻¹ × Tool_vel - Near singularity: reduce joint rates; alert operator (singularity approaching) Servo Drive Control per Joint: - Proportional gain: Kp=0.8 (moderate; servos are stiff) - Integral gain: Ki=0.01 (small; servo motors self-centering) - Derivative gain: Kd=0.05 (prevent jitter from encoder noise) - Deadband: ±0.5° to prevent servo chatter - Velocity limit: ±100°/sec maximum joint rate (bounded by hydraulic spool) Singularity Avoidance: - Pre-compute: Jacobian determinant at current and desired positions - If det < 0.05 (near singular): * Reduce coordinated velocity 50% * Display warning: "Approaching Singularity" * Suggest operator alternate elbow-up/down configuration Collision Detection: - Monitor force/torque sensors on wrist - If F_impact > 500 N or τ_impact > 50 N·m → immediate stop (servo closed-loop holds position) - Log impact; alert operator for inspection ``` **Why this works:** - Cartesian interpolation feels natural to operators (linear tool motion = intuitive control) - Simultaneous multi-axis motion prevents jerky choreography (all joints reach target at same time) - Singularity warning prevents arm lock-up (operator can steer away before truly singular) - Proportional servo control with tight deadband provides precision (<1 mm path accuracy) --- ## 3. Control Logic **Pseudocode: 6-Axis Robot Arm Master Control** ```pascal { === 6-AXIS ROBOTIC ARM CONTROL === } { Modes: IDLE → HOMING → CARTESIAN_MOVE → MONITORING → IDLE } PROCEDURE Robotic_Arm_6Axis_Master CONSTANTS NUM_JOINTS = 6 SERVO_KP = [0.8, 0.8, 0.8, 0.8, 0.8, 0.8] { proportional gains per joint } SERVO_KI = [0.01, 0.01, 0.01, 0.01, 0.01, 0.01] SERVO_KD = [0.05, 0.05, 0.05, 0.05, 0.05, 0.05] JOINT_DEADBAND = 0.5 { degrees } JOINT_VELOCITY_MAX = 100.0 { °/sec } JOINT_ACCEL_MAX = 20.0 { °/sec² } TOOL_POSITION_TOLERANCE = 1.0 { mm } SINGULARITY_DET_THRESHOLD = 0.05 COLLISION_FORCE_THRESHOLD = 500.0 { N } COLLISION_TORQUE_THRESHOLD = 50.0 { N·m } ELBOW_CONFIG = 'UP' { 'UP' or 'DOWN' for 6-dof } ARM_REACH_MAX = 2.5 { meters } VARIABLES state : ENUMERATION { IDLE, HOMING, MOVING, ERROR, E_STOP } { Current joint positions and commands (degrees) } joint_actual[1..6] : REAL joint_cmd[1..6] : REAL joint_velocity[1..6] : REAL { °/sec measured } joint_error[1..6] : REAL joint_integral[1..6] : REAL joint_servo_output[1..6] : REAL { proportional solenoid command 0–100% } { Cartesian tool pose (TCP = Tool Center Point) } tcp_actual_position : ARRAY[3] OF REAL { X, Y, Z in mm } tcp_actual_orientation : ARRAY[3] OF REAL { Roll, Pitch, Yaw in degrees } tcp_desired_position : ARRAY[3] OF REAL tcp_desired_orientation : ARRAY[3] OF REAL { Kinematics } jacobian : ARRAY[6,6] OF REAL { Jacobian matrix } jacobian_determinant : REAL { singularity metric } joint_desired_from_ik[1..6] : REAL { IK solution } { Safety } force_sensor_wrist : ARRAY[3] OF REAL { Fx, Fy, Fz in N } torque_sensor_wrist : ARRAY[3] OF REAL { τx, τy, τz in N·m } collision_detected : BOOLEAN singularity_warning : BOOLEAN BEGIN { === READ ENCODERS & SENSORS === } FOR joint_idx = 1 TO NUM_JOINTS DO joint_actual[joint_idx] = Read_Joint_Encoder(joint_idx) { degrees } END FOR force_sensor_wrist = Read_Force_Torque_Sensor() collision_detected = FALSE { === FORWARD KINEMATICS: compute TCP from joint angles === } tcp_actual_position, tcp_actual_orientation = Forward_Kinematics(joint_actual) { === COMPUTE JACOBIAN at current pose === } jacobian = Compute_Jacobian(joint_actual) jacobian_determinant = Determinant(jacobian) IF jacobian_determinant < SINGULARITY_DET_THRESHOLD THEN singularity_warning = TRUE Log_Warning("ARM_NEAR_SINGULARITY", jacobian_determinant) ELSE singularity_warning = FALSE END IF { === COLLISION DETECTION === } IF Magnitude(force_sensor_wrist) > COLLISION_FORCE_THRESHOLD OR Magnitude(torque_sensor_wrist) > COLLISION_TORQUE_THRESHOLD THEN collision_detected = TRUE FOR joint_idx = 1 TO NUM_JOINTS DO joint_cmd[joint_idx] = joint_actual[joint_idx] { hold position } END FOR Log_Alarm("COLLISION_DETECTED") state = ERROR END IF { === STATE MACHINE === } SELECT state CASE IDLE: FOR joint_idx = 1 TO NUM_JOINTS DO joint_servo_output[joint_idx] = 0.0 { solenoid off } END FOR { Start new move when operator specifies target } IF New_Cartesian_Target_Received THEN tcp_desired_position = Get_Desired_Position() tcp_desired_orientation = Get_Desired_Orientation() { Compute inverse kinematics } ik_solution_valid, joint_desired_from_ik = Inverse_Kinematics(tcp_desired_position, tcp_desired_orientation, ELBOW_CONFIG) IF NOT ik_solution_valid THEN Log_Alarm("IK_NO_SOLUTION", "Target unreachable") state = ERROR ELSE state = MOVING Log_Event("MOVE_START", "ICP=" + Vec3_to_String(tcp_desired_position)) END IF END IF CASE MOVING: { === Simultaneous multi-axis motion to joint targets === } all_joints_settled = TRUE FOR joint_idx = 1 TO NUM_JOINTS DO joint_error[joint_idx] = joint_desired_from_ik[joint_idx] - joint_actual[joint_idx] { Check if joint reached target } IF ABS(joint_error[joint_idx]) > JOINT_DEADBAND THEN all_joints_settled = FALSE END IF { === PI(D) servo control per joint === } joint_integral[joint_idx] += joint_error[joint_idx] × SCAN_INTERVAL_SEC / 1000.0 joint_integral[joint_idx] = Clamp(joint_integral[joint_idx], -10.0, 10.0) { anti-windup } derivative_term = (joint_error[joint_idx] - previous_error[joint_idx]) / SCAN_INTERVAL_SEC × 1000.0 servo_pid = (SERVO_KP[joint_idx] × joint_error[joint_idx]) + (SERVO_KI[joint_idx] × joint_integral[joint_idx]) + (SERVO_KD[joint_idx] × derivative_term) { Velocity limiting and acceleration constraint } velocity_command = servo_pid * 10.0 { scale PID to °/sec } velocity_command = Clamp(velocity_command, -JOINT_VELOCITY_MAX, +JOINT_VELOCITY_MAX) { Acceleration limiting (trapezoidal profile) } accel = (velocity_command - joint_velocity[joint_idx]) / SCAN_INTERVAL_SEC * 1000.0 IF ABS(accel) > JOINT_ACCEL_MAX THEN accel = JOINT_ACCEL_MAX × SIGN(accel) velocity_command = joint_velocity[joint_idx] + accel × SCAN_INTERVAL_SEC / 1000.0 END IF { Singularity velocity damping } IF singularity_warning THEN velocity_command = velocity_command × 0.5 { reduce speed 50% near singular } END IF joint_velocity[joint_idx] = velocity_command { Convert velocity to proportional solenoid command } joint_servo_output[joint_idx] = (velocity_command / JOINT_VELOCITY_MAX) × 100.0 joint_servo_output[joint_idx] = Clamp(joint_servo_output[joint_idx], -100.0, 100.0) END FOR { all joints } { === Check if move complete === } IF all_joints_settled THEN state = IDLE Log_Event("MOVE_COMPLETE") END IF CASE ERROR: { === Fault state; hold all joints } FOR joint_idx = 1 TO NUM_JOINTS DO joint_servo_output[joint_idx] = 0.0 Log_Warning("ARM_FAULT_HOLDING_POSITION", joint_actual[joint_idx]) END FOR IF Error_Acknowledge_Signal THEN state = IDLE END IF END SELECT { state } { === EMERGENCY STOP OVERRIDE === } IF Emergency_Stop_Button_Pressed THEN state = E_STOP FOR joint_idx = 1 TO NUM_JOINTS DO joint_servo_output[joint_idx] = 0.0 { cut proportional solenoid power } END FOR Log_Alarm("E_STOP_ACTIVATED") END IF { === WRITE SERVO OUTPUTS === } FOR joint_idx = 1 TO NUM_JOINTS DO Set_Joint_Proportional_Valve(joint_idx, joint_servo_output[joint_idx]) END FOR { === DIAGNOSTICS === } IF MOD(scan_count, 50) = 0 THEN { every 50 scans = 5 sec } tcp_distance_to_target = Distance(tcp_actual_position, tcp_desired_position) Log_Diagnostic("TCP_DISTANCE=" + STR(tcp_distance_to_target) + "mm") END IF END PROCEDURE ``` **Forward/Inverse Kinematics (Denavit-Hartenberg):** - Standard 6-DOF arm uses DH parameters (link lengths, offsets, twists) - Forward kinematics: matrix chains H₁...H₆ → TCP position/orientation - Inverse kinematics: typically 2 solutions (elbow-up/-down); use Jacobian to stay near current pose --- ## 4. Tag List **Analog Inputs** ``` JOINT_1_POSITION_ACTUAL { Encoder, -180 to +180 degrees } JOINT_2_POSITION_ACTUAL { -180 to +180 } JOINT_3_POSITION_ACTUAL { -180 to +180 } JOINT_4_POSITION_ACTUAL { -180 to +360 (wrist roll) } JOINT_5_POSITION_ACTUAL { -90 to +90 (wrist pitch) } JOINT_6_POSITION_ACTUAL { -180 to +360 (wrist yaw) } FORCE_SENSOR_X { -1000 to +1000 N } FORCE_SENSOR_Y { -1000 to +1000 N } FORCE_SENSOR_Z { -1000 to +1000 N } TORQUE_SENSOR_X { -100 to +100 N·m } TORQUE_SENSOR_Y { -100 to +100 N·m } TORQUE_SENSOR_Z { -100 to + 100 N·m } ``` **Analog Outputs** ``` JOINT_1_SERVO_VALVE_CMD { 0–100% proportional solenoid } JOINT_2_SERVO_VALVE_CMD JOINT_3_SERVO_VALVE_CMD JOINT_4_SERVO_VALVE_CMD JOINT_5_SERVO_VALVE_CMD JOINT_6_SERVO_VALVE_CMD ``` **Digital Inputs** ``` START_MOVE_SIGNAL { 0/1, execute stored program } STOP_MOVE_SIGNAL { 0/1, abort current motion } EMERGENCY_STOP_BUTTON { 0/1, hardwired safety } TEACH_MODE_ENABLE { 0/1, record positions } ``` **Calculated / Diagnostic Tags** ``` TCP_POSITION_ACTUAL { X, Y, Z in mm, from forward kinematics } TCP_ORIENTATION_ACTUAL { Roll, Pitch, Yaw in degrees } TCP_DISTANCE_TO_TARGET { mm, from actual to desired } JACOBIAN_DETERMINANT { singularity metric; > 0.1 = safe } SINGULARITY_WARNING { Boolean } COLLISION_DETECTED { Boolean } JOINT_VELOCITY_ACTUAL[1..6] { °/sec for each joint } MOVE_STATE { IDLE / MOVING / ERROR / E_STOP } PROGRAM_COUNTER { which waypoint in current program } ELAPSED_MOVE_TIME { seconds } JOINT_FOLLOWING_ERROR_MAX { worst-case joint lag, degrees } ``` --- ## 5. Alarm & Trip Matrix | **Condition** | **Setpoint** | **Severity** | **Action** | **Recovery** | |---|---|---|---|---| | **IK No Solution** | Desired TCP unreachable | 🟡 INFO | Abort move, hold position | Operator specifies reachable target | | **Singularity Approaching** | det(Jacobian) < 0.05 | ⚠ WARN | Reduce speed 50%, alert | Operator steers away or changes elbow | | **Collision Detected** | F > 500 N or τ > 50 N·m | 🔴 CRIT | Stop all motion, hold | Inspect arm; clear obstruction | | **Joint Overtravel** | θ > ±180° | 🔴 CRIT | Stop joint; E-stop equivalent | Return to safe position manually | | **Encoder Fault** | Raw position stuck >5 sec | 🔴 CRIT | Flag joint faulty; stop arm | Verify encoder connection | | **Move Timeout** | Motion stalled >30 sec | 🔴 CRIT | Abort move, alert | Check hydraulic pressure; inspect joint | | **Servo Saturation** | Solenoid at 100% >10 sec | ⚠ WARN | Log warning | May indicate load too heavy or leak | | **E-Stop Activated** | Button pressed | 🔴 CRIT | De-energize all solenoids; brake | Manual reset required | --- ## 6. HMI Layout **Main Arm Control Screen** ``` ╔════════════════════════════════════════════════════════════════╗ ║ 6-AXIS ROBOTIC ARM CONTROL — WORKCELL B (WELDING) ║ ╚════════════════════════════════════════════════════════════════╝ STATE: [ MOVING → TARGET ] PROGRESS: 65% MOVE TIME: 8.3 / 12 sec ┌────────────────────────────────────────────────────────────┐ │ CARTESIAN TCP POSITION │ │ Actual: X= 450.2 mm Y= -120.5 mm Z= 1050.3 mm │ │ Target: X= 450.0 mm Y= -120.0 mm Z= 1050.0 mm │ │ Distance: 1.1 mm (✓ approaching) │ │ │ │ ORIENTATION: │ │ Actual: Roll= 0.5° Pitch= 45.2° Yaw= 90.1° │ │ Target: Roll= 0.0° Pitch= 45.0° Yaw= 90.0° │ │ │ │ JACOBIAN STATUS: det = 0.42 ✓ SAFE (>0.05) │ │ │ └────────────────────────────────────────────────────────────┘ ┌────────────────────────────────────────────────────────────┐ │ JOINT STATUS (All 6 axes) │ │ │ │ Joint 1 (Waist): 45.3° / 45.0° target [███░░░░░░] 82% │ │ Joint 2 (Shoulder): 30.2° / 30.0° target [███░░░░░░] 78% │ │ Joint 3 (Upper Arm): 60.1° / 60.0° target [████░░░░░] 89% │ │ Joint 4 (Lower Arm): 15.5° / 15.0° target [██░░░░░░░] 58% │ │ Joint 5 (Wrist Pitch): -20.1° / -20.0° [███░░░░░░] 84% │ │ Joint 6 (Wrist Roll): 92.2° / 90.0° target [██░░░░░░░] 45% │ │ │ │ Max Following Error: 1.2° (Joint 6) │ │ │ └────────────────────────────────────────────────────────────┘ FORCE/TORQUE AT WRIST: Fx= -12 N Fy= 5 N Fz= -45 N [within safe limits] τx= -2.1 Nm τy= -1.5 Nm τz= 0.3 Nm [✓ OK] ALARMS & WARNINGS: ✓ All systems nominal BUTTONS: [ Start ] [ Stop ] [ E-Stop ] [ Teach Points ] [ Run Program ▾ ] PROGRAM QUEUE (Current Program: WELD_PATTERN_A): Waypoint 5 / 8: X=450, Y=-120, Z=1050 (executing) Waypoint 6 / 8: X=250, Y=0, Z=950 (queued) Waypoint 7 / 8: X=450, Y=120, Z=1050 (queued) ``` --- ## 7. Configuration **JSON (robotic_arm_6axis_config.json)** ```json { "arm": { "model": "ABB_IRB_6700", "num_joints": 6, "reach_max_mm": 2500, "payload_capacity_kg": 300, "arm_base_position_mm": [0, 0, 0] }, "kinematics": { "dh_parameters": [ {"a": 0, "d": 0, "alpha": 1.5708}, {"a": 0, "d": 495, "alpha": 0}, {"a": 960, "d": 0, "alpha": -1.5708}, {"a": 0, "d": 748, "alpha": 1.5708}, {"a": 0, "d": 0, "alpha": -1.5708}, {"a": 0, "d": 108, "alpha": 0} ], "tool_offset_mm": [0, 0, 150], "tcp_mass_kg": 5.0 }, "joint_limits": { "joint_1": {"min_deg": -180, "max_deg": 180, "velocity_max_deg_per_sec": 105}, "joint_2": {"min_deg": -180, "max_deg": 60, "velocity_max_deg_per_sec": 100}, "joint_3": {"min_deg": -180, "max_deg": 70, "velocity_max_deg_per_sec": 140}, "joint_4": {"min_deg": -180, "max_deg": 360, "velocity_max_deg_per_sec": 190}, "joint_5": {"min_deg": -90, "max_deg": 90, "velocity_max_deg_per_sec": 130}, "joint_6": {"min_deg": -180, "max_deg": 360, "velocity_max_deg_per_sec": 160} }, "control_parameters": { "servo_kp": [0.8, 0.8, 0.8, 0.8, 0.8, 0.8], "servo_ki": [0.01, 0.01, 0.01, 0.01, 0.01, 0.01], "servo_kd": [0.05, 0.05, 0.05, 0.05, 0.05, 0.05], "joint_deadband_deg": 0.5, "joint_accel_max_deg_per_sec2": 20, "tool_position_tolerance_mm": 1.0, "singularity_detection_threshold": 0.05 }, "safety": { "collision_force_threshold_n": 500, "collision_torque_threshold_nm": 50, "motion_timeout_sec": 30, "emergency_stop_response_ms": 100, "force_torque_sensor_mounted": true } } ``` --- ## 8. Implementation Checklist ### Pre-Commissioning (Days 1–2) **Mechanical** - [ ] All 6 joints verified for smooth operation (manual hand-wheel turn) - [ ] Encoders checked: linearity, no stiction, full revolution tested - [ ] Force/torque sensor bolted to wrist; calibration certificate verified - [ ] TCP tool aligned with sensor frame (laser/theodolite method) **Electrical** - [ ] All servo valve solenoids tested: 24 VDC coil pulls smoothly - [ ] Encoder signals verified: quadrature A/B pulse trains stable - [ ] Force/torque sensor 6-channel excitation voltages nominal (±5V or ±10V per sensor spec) **Software** - [ ] DH parameters loaded and verified (cross-check against manual) - [ ] Forward kinematics tested: move each joint individually; TCP position drifts <5 mm - [ ] Inverse kinematics tested: command 5 reachable waypoints; all joints converge - [ ] Joint limits enforced in software (do not allow θ > ±180° on shoulder, etc.) ### Hot Commissioning — Day 3 (Individual Joint Test) **Per-Joint Servo Response** - [ ] Joint 1 (base): command target ±45° from center; measure settle time <5 sec - [ ] Joint 2 (shoulder): same test; verify smooth proportional motion - [ ] Repeat for joints 3–6 - [ ] Verify no oscillation >±1° around setpoint **Coordinated Motion Test** - [ ] Command all 6 joints to HOME position (0°, 0°, 0°, etc.) - [ ] Measure time for all joints to settle: expect 10–15 sec simultaneous - [ ] Confirm motion is "smooth" — no jerky sequential motion ### Full Load Commissioning — Days 4–5 (With Load & Tooling) **Toolpath Accuracy** - [ ] Load maximum design load (300 kg) at TCP - [ ] Command robot to 10 reachable waypoints across workspace - [ ] Measure actual TCP position using laser tracker or optical 3D camera - [ ] Verify accuracy: all points within ±1 mm of desired (typical spec) **Singularity Testing** - [ ] Intentionally command TCP near singular configuration - [ ] Verify Jacobian determinant drops below threshold; speed reduces 50% - [ ] Verify singularity warning appears on HMI **Force Sensing** - [ ] Contact arm gently with force; verify force sensor reads correctly - [ ] Simulate collision: tap arm with sudden impact; verify detection and stop within 100 ms - [ ] Verify collision alarm logged; motion halts; reset required ### Baseline Commissioning (Days 6–7) **10-Waypoint Program** - [ ] Create simple welding/assembly program: 10 sequential waypoints - [ ] Run 50 cycles of program - [ ] Measure: cycle time, repeatability (position variance <0.5 mm), forces - [ ] Archive baseline data --- ## 9. Expected Performance ### Steady-State Position Hold | **Metric** | **Target** | **Acceptable** | **Measured** | |---|---|---|---| | TCP Positional repeatability | ±0.5 mm | ±1.0 mm | _______ | | TCP orientation repeatability | ±0.3° | ±0.5° | _______ | | Joint following error max | <1.0° | <2.0° | _______ | | Settling time to target | <5 sec | <10 sec | _______ | ### Coordinated Motion (0° → 45° all 6 joints) | **Metric** | **Target** | **Acceptable** | **Measured** | |---|---|---|---| | Total motion time | 8–10 sec | <15 sec | _______ | | Synchronized motion (Δt between joints) | <0.5 sec | <1.0 sec | _______ | | Max intermediate deviation | <2.0° any joint | <5.0° | _______ | --- ## 10. Advanced Variations ### 10.1 Compliance Mode - Monitor force/torque at TCP; adjust joint commands to maintain constant contact force - Useful for assembly (part insertion) or surface following (contour welding) ### 10.2 Vision-Guided Corrections - Camera detects part location; compute offset from expected position - Auto-correct IK setpoint in real-time - Reduces accuracy tolerance requirement (fixture-free work) ### 10.3 Predictive Load Balancing - Model arm's gravitational load at each configuration - Pre-feed-forward joint torques to reduce servo steady-state error - Improves speed/accuracy tradeoff --- **Document Version:** 1.0 **Last Updated:** 2026-04-13 **Status:** Ready for Production **Approval:** Manufacturing Engineering (pending)

More like this

Rate, comment, and get full access

Members can download files, rate contributions, and discuss fixes with the engineers who posted them — free.

Join the library