Robotic arms and manipulation

Links, joints and degrees of freedom

An arm is a chain of rigid links connected by joints, ending in an end-effector — the hand or gripper. Each joint that can move independently adds one degree of freedom (DOF). A cheap hobby arm has 4 to 5 DOF; an industrial arm typically has 6, which is the number needed to place the hand at any position *and* any orientation in space. More DOF means more dexterity but more to control and more that can go wrong. When you look at an arm, count its independently moving joints — that number tells you how freely the hand can be posed, and it frames every motion problem you will solve with it. Most first arms use servos as joints because a servo naturally holds a commanded angle, which maps directly onto 'set this joint to 40 degrees'.

Joint space and task space

There are two ways to describe where an arm is, and moving between them is the central skill. Joint space is the list of joint angles — what the servos actually take as commands. Task space (or Cartesian space) is where the hand is in the real world — an (x, y, z) position and an orientation, which is how you naturally think about a task ('put the gripper here'). Connecting them is the kinematics from the earlier lesson. Forward kinematics turns joint angles into a hand position — easy, one answer. Inverse kinematics turns a desired hand position into the joint angles that achieve it — harder, possibly several solutions (elbow up or down) or none if the target is out of reach. Every 'move the hand to that spot' command is an inverse-kinematics problem whose output is a set of joint angles you then send to the servos.

import numpy as np

def forward_2link(a1, a2, L1, L2):
    """Two-joint planar arm: joint angles -> hand (x, y)."""
    x = L1*np.cos(a1) + L2*np.cos(a1 + a2)
    y = L1*np.sin(a1) + L2*np.sin(a1 + a2)
    return x, y

def inverse_2link(x, y, L1, L2):
    """Hand (x, y) -> joint angles (elbow-down solution)."""
    r2 = x*x + y*y
    cos_a2 = (r2 - L1*L1 - L2*L2) / (2*L1*L2)
    if abs(cos_a2) > 1:
        return None                     # target is out of reach
    a2 = np.arccos(cos_a2)
    a1 = np.arctan2(y, x) - np.arctan2(L2*np.sin(a2), L1 + L2*np.cos(a2))
    return a1, a2

print(inverse_2link(0.3, 0.1, 0.2, 0.2))   # angles to reach (0.3, 0.1)

Moving smoothly and grasping

Knowing the target joint angles is not enough — an arm must move to them *smoothly*, or it will jerk, overshoot, and knock things over. This is trajectory planning: instead of snapping each joint to its final angle, you ramp the angles over time along a smooth profile (accelerate, cruise, decelerate) so the whole arm glides. On top of that, closed-loop control (the PID from the control lesson) holds each joint on its planned path against gravity and load. The gripper is the business end: a simple servo-driven claw that opens and closes, and the real skill is knowing *when* to close and how hard — too little and the object slips, too much and you crush it or stall the servo. Vision often feeds this step, locating the object so inverse kinematics can aim the hand at it. Put together — see the object, solve IK for its position, plan a smooth trajectory, move under control, close the gripper — is a complete pick-and-place.

• Plan a smooth trajectory, don't snap joints to their target.
• Hold each joint on its path with closed-loop control against gravity.
• Close the gripper with enough force to hold but not crush.
• Use vision to locate the object, then solve IK to reach it.

Safety: an arm can hurt you

A moving arm carries real hazards that a small rover does not, and a safety mindset is not optional. A geared arm can move fast and with force — enough to pinch fingers, hit a face, or fling an object. Powerful arms have a workspace (the volume the hand can reach) that people must stay clear of while it runs. Practise these habits from your very first arm: keep an emergency stop — a way to cut power instantly — within reach whenever it is powered; test new motions slowly or at reduced power before running them at speed; keep your hands and face out of the workspace during a run; secure the arm's base so it cannot tip; and be aware that a power loss can make an arm drop under gravity, so never rest anything (including a hand) under a raised joint. These are the same instincts professionals use around industrial robots, scaled to your bench, and building them now keeps a fun project from becoming an injury.