Intelligent Systems for Robotics (AL-604 (C)) - Unit 4 Short Notes

UNIT 4: INTELLIGENT SYSTEMS FOR ROBOTICS

I. Foundations of Robotics

Definition: Robotics is the science and technology of designing, constructing, and operating intelligent mechanical systems (robots) to perform tasks autonomously or semi-autonomously.

Core Aspects:

1. Perception: Sensing the environment (vision, force, proximity).

2. Cognition/Planning: Decision-making, path planning, task sequencing.

3. Action: Manipulation, locomotion, interaction via actuators.

4. Integration: Combining hardware (kinematics/dynamics) with software (AI/control).

Robot Joints and Links:

• Link: Rigid body connecting joints.

• Joint: Provides relative motion between links.

  • Revolute (R): Rotary motion (1 DOF).

  • Prismatic (P): Linear sliding motion (1 DOF).

  • A robot's Degrees of Freedom (DOF) equals its number of independent joints.

Overall Architecture of Robotic Systems:

A typical layered architecture:

1. Task Level: High-level goal specification.

2. Planning Level: Path & motion planning.

3. Control Level: Low-level joint/force control (PID).

4. Actuation Level: Motors, servos, drives.

5. Sensing Level: Sensors providing feedback.

[!TIP] Exam Focus: Be prepared to draw a block diagram showing the information flow from Task → Planning → Control → Actuators → Robot → Sensors → Feedback.

II. Robot Programming Paradigms

Programming Methods:

1. Teach Pendant/Manual Guidance: Physically moving robot to teach points (lead-through).

2. Offline Programming (OLP): Programming in a simulated 3D environment.

3. Textual Programming: Using robot-specific languages (e.g., VAL, KRL, RAPID).

4. Graphical/Interactive Programming: Drag-and-drop interfaces, flowcharts.

5. Learning-Based Programming: Demonstration, imitation learning, reinforcement learning.

Problems Peculiar to Robot Programming Languages:

• Complexity of 3D Geometry: Specifying spatial paths and orientations is non-trivial.

• Real-Time Constraints: Programs must handle sensor feedback and timing.

• Sensor Integration: Difficulty in incorporating heterogeneous sensor data (vision, force) into code.

• Lack of Standardization: Proprietary languages, poor portability.

• Uncertainty Handling: Programming for unstructured, changing environments is hard.

• Kinematic/Dynamic Awareness: Programmer must often understand robot's inverse kinematics.

III. Artificial Intelligence Integration

Need for AI in Robotics:

To move beyond pre-programmed, repetitive tasks in structured environments to adaptive, intelligent behavior in unstructured, dynamic, and uncertain real-world scenarios. AI provides reasoning, learning, and perception capabilities.

Types of Intelligent Agents in Robotics:

• Simple Reflex Agents: Act based on current percept (if-then rules). No internal state.

• Model-based Reflex Agents: Maintain internal state (world model) to track unobserved aspects.

• Goal-based Agents: Act to achieve explicit goals (requires search/planning).

• Utility-based Agents: Choose actions to maximize expected utility (handle trade-offs).

• Learning Agents: Improve performance over time from experience.

Structure of Agents (PEAS Framework):

Define an agent by specifying:

• Performance Measure

• Environment

• Actuators

• Sensors

Game Playing Programs in AI:

• Major Components:

  1. State Representation: How to represent board/game positions.

  2. Move Generator: Legal moves from a state.

  3. Evaluation Function: Heuristic score for non-terminal states.

  4. Search Algorithm: Explores game tree (e.g., Minimax).

  5. Time/Depth Control: Manages computational limits.

• Basic Strategies:

  • Minimax Algorithm: Assumes opponent plays optimally. Maximize your minimum gain.

  • Alpha-Beta Pruning: Optimizes Minimax by pruning irrelevant branches.

  • Iterative Deepening: Repeatedly search with increasing depth, useful for time limits.

  • Heuristic Evaluation: Estimates winning chances from non-terminal states.

IV. Motion and Path Planning

Trajectory Planning Fundamentals:

Defining a time-parameterized path (position, velocity, acceleration vs. time) for a robot's end-effector or joints, satisfying:

• Kinematic constraints: Joint limits, velocity/acceleration limits.

• Dynamic constraints: Torque/force limits (in dynamic trajectory planning).

• Task constraints: Avoiding obstacles, passing through waypoints.

• Smoothness: Minimizing jerk for precision and mechanical stress.

Common Planning Types:

• Point-to-Point (PTP): Only start/end points matter (e.g., pick-and-place).

• Continuous Path (CP): Entire path must be followed precisely (e.g., welding, painting).

• Blending: Combining segments with smooth transitions (e.g., corner rounding).

V. Robot Kinematics

Kinematic Representations:

• Direct (Forward) Kinematics: Given joint angles $$\displaystyle \theta_1, \theta_2, ..., \theta_n $$, compute end-effector pose $(x, y, z, \phi, \theta, \psi)$.

• Inverse Kinematics (IK): Given desired end-effector pose, compute required joint angles. Often multiple solutions or none.

Inverse Kinematics for Manipulators:

1. Two-DOF Planar Arm (Revolute-Revolute):

• Equations:

$$x_e = L_1 \cos\theta_1 + L_2 \cos(\theta_1 + \theta_2)$$

$$y_e = L_1 \sin\theta_1 + L_2 \sin(\theta_1 + \theta_2)$$

• Solution:

$$r^2 = x_e^2 + y_e^2$$

$$\cos\theta_2 = \frac{r^2 - L_1^2 - L_2^2}{2 L_1 L_2}$$

$$\theta_2 = \text{atan2}(\pm\sqrt{1-\cos^2\theta_2}, \cos\theta_2) \quad (\text{elbow up/down})$$

$$\theta_1 = \text{atan2}(y_e, x_e) - \text{atan2}(L_2 \sin\theta_2, L_1 + L_2 \cos\theta_2)$$

2. Three-DOF Spherical Wrist (PPP or RRR):

Often decoupled: first 3 joints position the wrist center, last 3 orient the end-effector. Solve position IK for first 3 joints, then orientation IK for wrist.

Coordinate Transformations:

• Homogeneous Transformation Matrix (HTM): $$\displaystyle ^{i}T_{j} = \begin{bmatrix} ^{i}R_{j} & ^{i}P_{j} \\ 0 & 1 \end{bmatrix} $$ combines rotation $R$ and translation $P$.

• Line Coordinate Transformations: Standard method using DH (Denavit-Hartenberg) parameters (4 parameters per link: $\theta, d, a, \alpha$).

$$^{i-1}T_i = Rot_z(\theta_i) Trans_z(d_i) Trans_x(a_i) Rot_x(\alpha_i)$$

• Hayati-Roberts Coordinates: Alternative to DH for offset joints. Uses 5 parameters ($\theta, d, a, \alpha, \beta$) to handle joint axes that don't intersect. More general but more complex.

Composition of Rotations About Moving Axes:

• Rotations are not commutative: $$\displaystyle R_x(\phi)R_y(\theta) \neq R_y(\theta)R_x(\phi) $$.

• Moving Axes (Intrinsic): Rotations are about the current (rotated) coordinate system axes. Order matters critically.

• Fixed Axes (Extrinsic): Rotations are about the original coordinate system axes.

• Key Point: The HTM multiplication order follows the sequence of joint motions. $$\displaystyle ^{0}T_n = {^{0}T_1} {^{1}T_2} ... {^{n-1}T_n} $$.

Kinematic Chain Topologies:

• Serial Chain: Links connected end-to-end (e.g., typical manipulator). Advantage: Large workspace, simple forward kinematics. Disadvantage: Low stiffness, cumulative errors.

• Parallel Chain: End-effector connected to base by multiple independent chains (e.g., Stewart platform). Advantage: High stiffness, accuracy, load capacity. Disadvantage: Small workspace, complex IK.

• Hybrid (Serial-Parallel): Combines both (e.g., a serial arm with a parallel wrist).

VI. Robot Dynamics and Performance Metrics

Decoupling of Rigid Body Dynamics about the Center of Mass:

• Principle: The dynamics of a rigid body can be separated into:

  1. Translational Motion: Governed by Newton's 2nd Law: $$\displaystyle F = m \cdot a_{cm} $$, where $$\displaystyle a_{cm} $$ is acceleration of Center of Mass (CoM).

  2. Rotational Motion: Governed by Euler's Equation: $$\displaystyle \tau = I \cdot \alpha + \omega \times (I \omega) $$, where $I$ is inertia tensor about CoM.

• Significance: Simplifies modeling. Forces cause CoM translation; torques about CoM cause rotation. For robot links, dynamics equations are derived using Lagrangian or Newton-Euler methods, often decoupling translational and rotational kinetic energy.

Accuracy and Repeatability:

VII. Robotic Actuation Systems

[!TIP] Exam Focus: Be ready to compare all three in a table, highlighting precision (electric wins), power density (hydraulic wins), and efficiency (electric wins).

VIII. System-Level Design and Integration

Detailed Architecture of Robotic Systems:

A comprehensive view integrates all previous layers:

[Task Specification] 

        ↓

[High-Level Planner] (AI: Task planning, motion planning)

        ↓

[Trajectory Generator] (Time-parameterized paths)

        ↓

[Low-Level Controller] (PID, force/impedance control)

        ↓

[Power Amplifier/Drive] (Servo amplifiers, motor drives)

        ↓

[Actuators] (Motors, cylinders) → [Robot Mechanical Structure]

        ↑

[Sensor Interface] (Encoders, force-torque, vision) ← [Sensors]

Key: Closed-loop feedback at multiple levels (position, force, vision).

Agent-Based Design Principles for Intelligent Systems:

• Modularity: Design each functional block (perception, planning, control) as an autonomous agent with clear inputs/outputs.

• Perception-Action Loop: Each agent (or the system) follows: Sense → Perceive → Decide → Act → Sense...

• Decentralized Intelligence: Distribute processing (e.g., vision agent, navigation agent, manipulation agent).

• Communication: Agents communicate via well-defined messages/events (e.g., ROS topics/services/actions).

• Robustness: Failure of one agent doesn't crash the entire system (graceful degradation).

• Example: A service robot might have separate agents for SLAM, Path Planning, Object Recognition, and Arm Control, each running independently but coordinating.