Robotic Arms: Kinematics, OpenCV & Control

Learning Goal: Design, simulate, and program a 3-axis robotic arm to perform automated sorting using inverse kinematics and computer vision (OpenCV) for object detection.

• Prerequisites: High school physics (basic mechanics and vector math), trigonometry, and an introduction to basic programming concepts.
• Estimated Total Study Time: 48 hours

Module 1: Foundations of Python & Microcontrollers for Robotics

This module establishes the core hardware and software foundations necessary for robotics. You will learn the basics of Python programming structured for robotic systems, interface with microcontrollers, prototype circuits using breadboards, and master physical motor actuation. A critical focus of this module is understanding Pulse-Width Modulation (PWM) and multi-channel servo control using the PCA9685 driver board to drive multi-axis systems without overloading microcontroller pins.

Recommended Videos

Introduction to Python Programming with Emphasis on Robotics Applications

@mecharithm-robotics01:09:453,944

Introduction to Python Programming with Emphasis on Robotics Applications

This lesson covers essential Python programming concepts tailored for robotics applications, including variable and data type handling (numbers, strings, lists, 2D lists, tuples, dictionaries), control structures (if statements, while loops, for loops, nested loops), object-oriented programming (classes and inheritance), file operations, modules, and error handling with try-except blocks, all demonstrated through practical robotics examples such as robot arm control, sensor data processing, and

@mecharithm-robotics · 01:09:45

• Why this video: This lecture serves as the absolute software baseline. Instead of generic Python scripting, it directly targets data types, control loops, and data structures (such as lists, tuples, and dictionaries) in the context of robot manipulation, motion planning, and handling sensor coordinates.
• Knowledge Checkpoint:
  • Write a Python script that stores 3D target coordinates as tuples inside a list and loops through them.
  • Define custom functions that take variable inputs (like angles) and return processed commands.
  • Demonstrate how to manipulate arrays and dictionaries to store state representations of a robot's joints.

Tested In-Depth: Getting Started with Arduino

@tested30:37763,848

Tested In-Depth: Getting Started with Arduino

Arduino is an open-source hardware and software platform consisting of microcontrollers—small embedded processors (typically ARM-based)—designed for interacting with the real world by taking input from sensors and outputting data to control devices like lights, motors, or switches; it features both analog and digital input/output pins, with digital pins supporting PWM (Pulse Width Modulation) for simulating analog control, and offers various board types with different capabilities including nati

@tested · 30:37

• Why this video: Before programming physical joints, you must understand your microcontroller's architecture. This hands-on breakdown introduces you to the Arduino platform, the integrated development environment (IDE), write-compile-upload cycles, and how digital/analog I/O pins function.
• Knowledge Checkpoint:
  • Explain the difference between an ARM-based microcontroller and a microprocessor like a Raspberry Pi.
  • Set up the Arduino IDE and write a simple script utilizing the setup() and loop() structures.
  • Interface with digital input pins and capture real-time button state modifications.

How To Use a Breadboard - Breadboard Basics

@circuitemakes03:27115,885

How To Use a Breadboard - Breadboard Basics

A breadboard is a reusable prototyping tool that uses interconnected metal rails to create temporary electronic circuits without soldering; the central horizontal rails connect across the board while the outer vertical rails (marked positive and negative) provide power distribution, enabling simple circuit assembly by connecting components like LEDs and resistors between these rails.

@circuitemakes · 03:27

• Why this video: You must prototype circuit connections safely without soldering. This video visually outlines the internal electrical connections of standard breadboards, guiding you on how to distribute power and ground safely to mechanical actuators.
• Knowledge Checkpoint:
  • Map out the internal metallic rails of a half-size breadboard (power buses vs. terminal strips).
  • Create a simple LED circuit on a breadboard driven by a microcontroller's digital pins.
  • Identify and prevent common electrical short circuits across the central divider.

16 channel servo controller with Arduino \| PCA9685 16 channel PWM servo motor driver tutorial

@sritu_hobby04:15178,076

16 channel servo controller with Arduino \| PCA9685 16 channel PWM servo motor driver tutorial

This tutorial demonstrates how to use the PCA9685 16-channel PWM servo motor driver board with Arduino to control multiple servo motors simultaneously through I2C communication, enabling precise position control for robotics and automation applications.

@sritu_hobby · 04:15

• Why this video: Standard microcontrollers lack the processing power and current capacity to drive multiple robotic joint servos simultaneously. This video covers the PCA9685 16-channel PWM driver board, demonstrating how to use I2C communication to offload PWM calculations and coordinate multi-axis movements with an external power source.
• Knowledge Checkpoint:
  • Wire the PCA9685 driver to the Arduino using SDA/SCL (I2C) pins and an external 5V/6V power supply.
  • Explain how PWM duty cycles correspond to exact angular positions (0 to 180 degrees) for hobby servos.
  • Write a script using the Adafruit PWM Servo Driver library to sweep multiple connected servos to designated safe joint limits.

Module 2: CAD Design & Mechanical Assembly of a 3-Axis Arm

Designing a functional 3-axis robotic arm requires an understanding of structural engineering, joint configurations, and motor constraints. In this module, you will learn to navigate Autodesk Fusion 360 to construct solid models, define rotational constraints (revolute joints), run basic stress and assembly testing, and mathematically calculate the motor torque required to lift active payloads at maximum arm extension.

Recommended Videos

Everything About the Degrees of Freedom of a Robot

@mecharithm-robotics04:1220,376

Everything About the Degrees of Freedom of a Robot

Different joint types provide specific numbers of degrees of freedom in robotic mechanisms. Revolute (rotary/hinge) joints provide one DOF through rotation around a single axis, determined using the right-hand rule. Prismatic (sliding/linear) joints provide one DOF through linear motion along a single axis. Universal joints consist of two orthogonal rotational joints and provide two DOF (roll and pitch). Spherical joints (ball-and-socket) provide three DOF through rotation around any axis. Cylin

@mecharithm-robotics · 04:12

• Why this video: You cannot design a physical manipulator without understanding its kinematic boundaries. This video explains how mechanical joints (revolute, prismatic) restrict or enable motion, defining the total degrees of freedom (DOF) of your robot workspace.
• Knowledge Checkpoint:
  • Calculate the DOF of a planar mechanism using Grubler’s formula.
  • Distinguish between revolute joints and prismatic joints in terms of motion constraints.
  • Map out the 3D workspace envelope of a 3-axis revolute configuration (anthropomorphic arm).

Building a V22 Osprey - Part 2

@TomStantonEngineering00:424,310,139

Building a V22 Osprey - Part 2

Servo torque requirements for mechanical systems can be calculated using gear ratios. A servo rated for 20 kg at a 1 cm radius produces approximately 2 Newton meters of torque. With a 3:1 gear ratio, this becomes approximately 6 Newton meters of output torque. This calculation is essential for selecting appropriate actuators for tilting mechanisms that must move heavy loads, such as tilting both motors simultaneously in a V/STOL aircraft.

@TomStantonEngineering · 00:42

• Why this video: Real-world servos fail if their physical joint load exceeds their stall torque rating. This clip breaks down how mechanical leverage and gear ratios amplify or reduce required torque, providing a visual case study on torque calculation and linkage advantages.
• Knowledge Checkpoint:
  • Calculate the torque required at a robot shoulder joint supporting a $200\text{g}$ arm link of length $15\text{cm}$ and a $50\text{g}$ end-effector payload.
  • Explain how a gear ratio (e.g., 3:1) alters output torque and rotational velocity.
  • Identify how physical linkages can distribute the weight of servos down to the static base to reduce load on distal joints.

Lesson 6 Assembly and Colour

@idtyoutube240406:15189

Lesson 6 Assembly and Colour

This comprehensive segment covers the complete process of assembling parts in Fusion 360. The instructor demonstrates creating a new design, inserting parts into the current design, and fixing the first piece in space using the Ground constraint. Key techniques include using alignment arrows to position parts roughly before applying joints, and the step-by-step process of creating joints between components by selecting matching locating points. The instructor emphasizes following the physical ki

@idtyoutube2404 · 06:15

• Why this video: This video demonstrates assembly design in Autodesk Fusion 360. It teaches how to insert separate parts, establish component hierarchies, ground a static foundation base, and apply physical joints to ensure realistic movement boundaries.
• Knowledge Checkpoint:
  • Ground the primary base of your robotic arm in Fusion 360 to prevent arbitrary floating in 3D space.
  • Create a rigid group assembly for components that move as a single combined body.
  • Apply revolute joints with specified angular limits (e.g., $-90^\circ$ to $+90^\circ$) to mimic physical servo limits.

How to make a Robotic Gripper In Fusion 360

@SPARKPLUG9838:41144,527

How to make a Robotic Gripper In Fusion 360

This tutorial demonstrates how to design a robotic gripper in Autodesk Fusion 360 by creating individual components (gripper flange, connecting rods, base, and gears) using sketch-based modeling techniques, then assembling them into a functional mechanism using joints, motion links, and rigid groups to enable coordinated movement of the gripper fingers.

@SPARKPLUG98 · 38:41

• Why this video: A robotic arm requires a terminal mechanical end-effector to manipulate objects. This extensive tutorial walks through the construction of a dual-jaw robotic gripper, showing how to sketch, extrude, and model complex gear teeth configurations that mesh perfectly.
• Knowledge Checkpoint:
  • Sketch and model an integrated gear and link design using projection and offset tools in CAD.
  • Apply motion links between gears to ensure symmetrical closing and opening of gripper jaws.
  • Prepare and export functional STL files optimized for 3D printing or fabrication.

Gap Note on CAD & Torque Calculations: High-quality videos detailing exact mathematical calculations for dynamic loads in multi-link robotic arms are rare. To calculate base/shoulder torque ($T$) at worst-case fully-extended static conditions, use: $T = (L_{link1\_center\_of\_mass} \times W_{link1}) + (L_{link2\_center\_of\_mass} \times W_{link2}) + (L_{total\_arm} \times W_{payload\_and\_gripper})$ Always multiply the resulting stall torque requirement by a minimum factor of safety of $1.5$ to $2.0$ when selecting active hobby servo motors.

Module 3: Mathematics of Robotics: Forward & Inverse Kinematics

Kinematics forms the mathematical bridge between a target coordinate in physical space and the motor commands sent to a robot's joints. This module covers Forward Kinematics (FK)—calculating the tool-tip position $(X, Y, Z)$ from known joint angles $(\theta_1, \theta_2, \theta_3)$—and Inverse Kinematics (IK)—deriving the unique joint angles required to reach a specific target coordinate. We will dissect geometric derivations using trigonometry, the Law of Cosines, and planar projections.

Joint 1 [Target Coordinate] (Shoulder)

Recommended Videos

Inverse Kinematics of 2 and 3 DOF Robots

@eliasbrassitos115:282,390

Inverse Kinematics of 2 and 3 DOF Robots

Inverse kinematics determines joint angles (θ₁, θ₂, θ₃) from end-effector Cartesian coordinates (X, Y, Z) for robots with rotational joints; for 2-DOF robots, solve θ₂ using the law of cosines (cos(θ₂) = (L² - L₁² - L₂²)/(2L₁L₂)) where L = √(XE² + YE²), then find θ₁ using arctan2 with α = arctan2(L₂sin(θ₂), L₁ + L₂cos(θ₂)) and β = arctan2(YE, XE); for 3-DOF robots, first solve θ₁ = arctan2(YC, XC), then compute θ₃ using the same law of cosines with modified virtual link L' = √(XC² + YC² + (ZC-L₁

@eliasbrassitos1 · 15:28

• Why this video: This video contains the core mathematical derivation for this module. It walks through the geometric and algebraic derivation of 2-DOF and 3-DOF planar systems, transforming coordinate positions into trigonometric expressions that solve for joint angles.
• Knowledge Checkpoint:
  • Derive $\theta_2$ (elbow angle) using the Law of Cosines based on link lengths $L_1$, $L_2$, and target distance.
  • Explain how the "elbow up" and "elbow down" configurations represent dual algebraic solutions.
  • Convert derived Cartesian coordinates $(X, Y, Z)$ into a planar subsystem to solve for $\theta_1$ (base joint rotation).

Inverse Kinematics of Articulated Manipulator

@asodemann303:3989,927

Inverse Kinematics of Articulated Manipulator

Solving inverse kinematics requires identifying and analyzing geometric triangles within the manipulator structure. Two types of triangles are essential: right triangles that determine end effector position, and non-right triangles where one side coincides with the hypotenuse of the right triangle. The purple right triangle helps find horizontal positioning, while the orange non-right triangle addresses vertical positioning. Auxiliary angles phi_1, phi_2, and phi_3 are introduced to break down c

@asodemann3 · 03:39

• Why this video: Real-world robotic arms operate in 3D, not just 2D planes. This video shows how to project a 3D articulated manipulator onto a 2D plane using planar right-triangles. Once projected, the 3D IK problem reduces to a simpler 2D coordinate solution.
• Knowledge Checkpoint:
  • Isolate the azimuthal base angle ($\theta_1$) using the target coordinates $X$ and $Y$ via the $\text{atan2}(Y, X)$ function.
  • Define the radial distance $R$ in the horizontal plane as $R = \sqrt{X^2 + Y^2}$.
  • Map the vertical $Z$ coordinate and horizontal $R$ coordinate into a 2D vertical plane to solve for joint angles $\theta_2$ and $\theta_3$.

Robot Inverse Kinematics With A Hexapod Leg

@JustAnotherMakerChannel14:24111,549

Robot Inverse Kinematics With A Hexapod Leg

Inverse kinematics determines the joint angles needed to position a robot's end effector at a desired location; for a hexapod leg with three joints (J1, J2, J3), the solution involves: (1) calculating the distance L using Pythagoras' theorem (L = √(Y² + Z²)), (2) finding angle J3 using the law of cosines (J3 = arccos((J2L² + J3L² - L²)/(2×J2L×J3L))), (3) calculating angles A and B using trigonometric ratios, and (4) determining J2 as B minus A. When implementing this with physical servos, adjust

@JustAnotherMakerChannel · 14:24

• Why this video: This video walks through the complete workflow of implementing derived trigonometric IK math into physical code. While demonstrating on a hexapod leg, the joints function as a 3-DOF serial chain identical to a 3-axis arm.
• Knowledge Checkpoint:
  • Translate derived algebraic expressions into readable Python and C++ code using libraries like math.h.
  • Handle domain errors when targeting coordinates outside the physical workspace boundary (e.g., values exceeding $\cos(\theta) = \pm 1$).
  • Code safety boundaries that automatically cap calculated angles before outputting to joint motors.

Easy inverse kinematics for robot arms

@roTechnic05:35135,486

Easy inverse kinematics for robot arms

This video demonstrates how to calculate inverse kinematics for a two-arm robot using only five lines of mathematics. The process involves: (1) calculating the base rotation angle using tan(v) = y/x and Pythagoras for distance; (2) determining the arm angles in 3D space using tan(phi) = z/l and Pythagoras for length; (3) solving the isosceles triangle formed by equal-length arms using cos(theta) = (h/2)/arm_length; (4) transforming these angles into actual joint positions using a1 = phi+theta an

@roTechnic · 05:35

• Why this video: This tutorial demonstrates how complex multi-link kinematics can be simplified into five straightforward lines of trigonometric operations. It provides a visual, intuitive explanation of geometric projections and relative angles.
• Knowledge Checkpoint:
  • Identify the five essential lines of trigonometry required to program a standard 3-axis robot arm.
  • Convert absolute joint angles relative to the horizon into relative angles required by adjacent motor linkages.
  • Write a calibration program that tests accuracy by commanding the arm tip to trace a straight linear axis.

Module 4: Computer Vision with OpenCV for Object Detection

To enable autonomous sorting, your robot needs to "see". In this module, you will learn to implement computer vision algorithms using Python and OpenCV. We will explore camera streams, transform standard BGR color arrays into the robust Hue-Saturation-Value (HSV) space, filter target objects by color and shape, isolate contours, extract 2D pixel centroids, and understand the planar transformations needed to map camera frames onto a physical coordinate workspace.

Recommended Videos

LEARN OPENCV in 3 HOURS with Python

@murtazasworkshop03:09:073,573,333

LEARN OPENCV in 3 HOURS with Python

This comprehensive tutorial covers OpenCV Python programming for computer vision, including image fundamentals (pixels, color spaces, image formats), installation and setup, basic operations (reading images/videos/webcams, resizing, cropping, drawing shapes and text), advanced techniques (perspective transformation, color detection using HSV space with trackbars, contour detection and shape classification, face detection using cascade classifiers), and practical projects including virtual paint,

@murtazasworkshop · 03:09:07

• Why this video: This structured masterclass provides a deep dive into computer vision basics, covering installation, matrix manipulation, frame resizing, and threshold filtering. It serves as your comprehensive reference manual for the OpenCV framework.
• Knowledge Checkpoint:
  • Set up an OpenCV python script to capture continuous frames from a live USB webcam feed.
  • Explain how digital images are represented as multi-dimensional NumPy arrays of color channels.
  • Write a script to convert raw image frames into grayscale and apply a Gaussian blur to reduce noise.

OpenCV Python Tutorial #5 - Colors and Color Detection

@TechWithTim14:06131,200

OpenCV Python Tutorial #5 - Colors and Color Detection

This tutorial explains how to detect and extract specific colors from images or video feeds using OpenCV in Python. The process involves converting frames from BGR to HSV color space, defining lower and upper HSV bounds for the target color, creating a binary mask using cv2.inRange(), and applying the mask to the original frame using bitwise AND to isolate only the desired color regions.

@TechWithTim · 14:06

• Why this video: Computer vision engines struggle to track specific objects using basic Red-Green-Blue (RGB) profiles due to shadows and lighting fluctuations. This video demonstrates why and how to leverage Hue-Saturation-Value (HSV) space to isolate color boundaries reliably.
• Knowledge Checkpoint:
  • Explain the parameters of HSV color space and why it outperforms BGR/RGB under changing illumination.
  • Use OpenCV’s trackbars to dynamically isolate color profiles (e.g., bright blue sorting blocks) in real-time.
  • Construct a binary mask to separate target object boundaries from background environments.

Object Detection & Object Tracking Using HSV

@ProgrammingKnowledge19:52152,495

Object Detection & Object Tracking Using HSV

This tutorial demonstrates how to perform object detection and tracking using the HSV (Hue-Saturation-Value) color space in OpenCV with Python. HSV separates color information from luminance, making it easier to detect specific colors by defining lower and upper HSV boundaries. The process involves converting an image from BGR to HSV color space, applying inRange() function to create a binary mask for the target color, and using bitwise AND operation to isolate the detected object. Trackbars can

@ProgrammingKnowledge · 19:52

• Why this video: Once you've masked your target object, you need to extract its structural centroid. This video details how to chain HSV threshold masking with bitwise operations, contour detection, and centroid extraction.
• Knowledge Checkpoint:
  • Apply binary thresholding and morphology operations (erosion, dilation) to clean up noise from a masked feed.
  • Extract and draw bounding contours around detected objects.
  • Use contour moments (cv2.moments) to calculate the precise pixel centroid coordinate $(U, V)$ of a detected target block.

ENB339 lecture 9: Image geometry and planar homography

@PeterCorke04:32182,030

ENB339 lecture 9: Image geometry and planar homography

This section addresses the critical problem of mapping between camera image coordinates and robot workspace coordinates. In robot vision systems, the camera sees a distorted version of the robot's workspace (a plane), while the robot operates in Cartesian coordinates. Homography provides the mathematical bridge between these coordinate systems. The calibration process involves measuring known points (like the nine blue dots on calibration sheets) in both domains, building correspondence matrices

@PeterCorke · 04:32

• Why this video: Your camera outputs pixel coordinates $(U, V)$, but your physical robot arm moves in millimeter coordinates $(X, Y, Z)$. This academic lecture by Peter Corke explains image projection geometry, lens distortions, and how planar homography transforms camera perspectives into physical flat coordinates.
• Knowledge Checkpoint:
  • Explain how focal length and camera mounting heights introduce geometric perspective skewing.
  • Define a $3\times3$ homography transformation matrix and explain its utility in perspective correction.
  • Map a skewed camera coordinate frame to a normalized rectangular workplane using reference markers.

Module 5: System Integration: Simulation and Automated Sorting

This final module integrates your hardware and software subsystems into a fully autonomous, closed-loop pick-and-place sorting robot. You will learn to perform empirical hand-eye calibration (mapping pixel coordinates directly to the robot's coordinates), establish robust serial communication protocols (via PySerial) to stream joint angles from Python to microcontrollers, program sequential state-machine logic for the sorting loop, and safely handle physical manipulation.

+------------------+ Pixel (U,V) +--------------------+ | Camera / OpenCV | ------------------> | Calibration Matrix | +------------------+ +--------------------+ | Workspace (X,Y) v +------------------+ Joint Angles +--------------------+ | Arduino Uno | <------------------ | IK Math Solver | | (PCA9685 Driver) | (PySerial) | (Python Workspace) | +------------------+ +--------------------+

Recommended Videos

Robotics 1 U2: Image Mapping

@asodemann315:506,364

Robotics 1 U2: Image Mapping

This comprehensive workflow demonstrates the full empirical calibration process: (1) Collect pixel-world coordinate pairs at known reference points; (2) Create Y-mapping using second-order polynomial regression with R² ≈ 0.999; (3) Derive X-conversion factors at each Y-position; (4) Build X-mapping using polynomial regression; (5) Combine both mappings for complete coordinate conversion. The process enables accurate transformation of any detected pixel location to precise world coordinates throu

@asodemann3 · 15:50

• Why this video: This video outlines how to run an empirical hand-eye calibration. It demonstrates how to collect matching coordinate pairs (pixel positions vs. corresponding physical robot touchpoints) and use second-order polynomial regressions to map camera coordinate pixels directly to physical space.
• Knowledge Checkpoint:
  • Collect 4–8 calibration coordinate pairs matching known pixel values to physical arm coordinate extensions.
  • Create mathematical mapping equations for both $X$ and $Y$ dimensions based on pixel inputs.
  • Write a mapping function that scales OpenCV $(U, V)$ centroids into physical millimeter coordinate targets.

Dobot Magician with Pixy2 Vision Sensor

@uptimefab741204:0877,819

Dobot Magician with Pixy2 Vision Sensor

This section explains the mathematical foundation enabling vision systems to guide robotic arms. The calibration routine transforms pixel coordinates from the camera's perspective to the robot's coordinate system through multiple geometric transformations: calculating angles and scaling factors for both systems, translating coordinates to align origins, rotating axes to achieve horizontal/vertical orientation, scaling axes to match target dimensions, and applying final translations. Three calibr

@uptimefab7412 · 04:08

• Why this video: This integration demo showcases the step-by-step physical coordinate conversion routine. It serves as a visual guide for configuring a camera looking down on a flat robotic sorting surface to drive pick-and-place routines.
• Knowledge Checkpoint:
  • Set up an overhead workspace camera aligned with the coordinate axes of your physical robot base.
  • Structure a software script that runs color tracking, triggers when an object is detected, and maps its coordinates.
  • Formulate a sequence of moves (approach, descend, grasp, lift, transfer, release) to manipulate the targets.

Robotic Hand-Eye Calibration: Precision Alignment Demo

@iandai-103:04315

Robotic Hand-Eye Calibration: Precision Alignment Demo

Hand-eye calibration is a technique that establishes the mathematical transformation between a camera mounted on a robot's end-effector and the robot's coordinate frame, enabling the robot to translate 2D pixel coordinates from camera images into precise 3D positions in the world frame, which is essential for achieving sub-millimeter precision in applications like automated assembly.

@iandai-1 · 03:04

• Why this video: For absolute pick accuracy, you must align the spatial origin of your optical sensor with the physical origin of your manipulator. This alignment demo walks through the mathematical transformation matrices needed to reconcile frame rotations and offsets.
• Knowledge Checkpoint:
  • Define the rotational and translational offset matrix from the physical robot base center to your camera lens center.
  • Transform derived target locations from the camera frame into coordinates relative to the base joint of your robot arm.
  • Validate transformation accuracy by commanding the arm to track a visual target moved dynamically around the workspace.

Design and development of Color sorting robotic ARM

@roboticsandmechatronicsres262500:201,663

Design and development of Color sorting robotic ARM

A server-based robotic arm capable of sorting objects by color (red, yellow, green, and blue) is demonstrated. The arm picks up colored buttons and drops them into corresponding color-specific holes. This project showcases the integration of mechanical engineering, electronics, and programming to create an automated sorting system.

@roboticsandmechatronicsres2625 · 00:20

• Why this video: This video demonstrates a successful end-to-end sorting implementation. It highlights color classification sorting (red, yellow, green, and blue targets) into dedicated regional bins, verifying that independent systems can work together smoothly.
• Knowledge Checkpoint:
  • Program conditional branching paths (e.g., if target is Red, drop at position A; if Blue, drop at position B).
  • Implement safety checks to verify that the robot arm returns to a home pose after completing a sorting operation.
  • Optimize system parameters to complete a full sorting sequence (pick, sort, and return) in under 10 seconds.

Course Map

Below is the recommended sequence of modules. Notice how Module 1 (Foundations) and Module 2 (Mechanical Design) branch out independently before combining with mathematics and computer vision to culminate in the final integrated sorting system.

Key People Index

• Peter Corke (Professor of Robotic Vision): Developer of the Peter Corke Robotics Toolbox and author of foundational papers on robotic image geometry, camera parameters, and planar homography tracking. (Featured in Module 4).
• Daniel Shiffman (Educator, The Coding Train): Renowned computational artist and developer who popularized the visual simulation of multi-segmented forward and inverse kinematics using geometric constraints. (Referenced in Module 3 / IK frameworks).
• Murtaza Hassan (Murtaza's Workshop): Industry software engineer and specialized content developer who simplifies OpenCV workflows, microcontrollers, and Python implementations for practical, hands-on robotics. (Featured in Modules 1 & 4).

Final Self-Assessment

To verify you have mastered the core competencies of this curriculum, you should be able to check off every milestone in this comprehensive project checklist:

• Hardware Setup: Build a 3-axis physical or simulated mechanical arm assembly, securing the base and verifying that joint servos can move smoothly without physical collisions.
• Power Management: Connect an external 5V/6V DC power supply to a PCA9685 driver board to power the servos, ensuring the ground rails are shared with the microcontroller.
• Workspace Calibration: Manually actuate each physical joint to verify minimum and maximum limits, updating your software limits in Python/Arduino to prevent structural binding.
• Inverse Kinematics Derivation: Derive the geometric formulas for your 3-axis robot arm, transforming target $(X, Y, Z)$ coordinates into base, shoulder, and elbow joint angles.
• IK Solver Implementation: Write a Python function that runs your IK math in real-time, outputting joint angles while handling out-of-range coordinates cleanly.
• OpenCV Camera Stream: Set up a python script that reads frames from an overhead camera, applies a bilateral filter, and converts the feed into the HSV color space.
• Color & Shape Filtering: Configure an HSV color mask and contour detector that filters for sorting blocks by color (e.g., separating green blocks from red blocks).
• Centroid Extraction: Extract the pixel centroids $(U, V)$ of detected target blocks, ignoring noise smaller than a defined pixel-area threshold.
• Camera-to-Robot Mapping: Perform hand-eye calibration to establish a coordinate transformation matrix, converting pixel coordinates into physical workspace coordinates $(X, Y)$ in millimeters.
• Serial Control Link: Program PySerial communication to package calculated joint angles into a robust payload (e.g., <angle1, angle2, angle3, gripper>) and stream it to the microcontroller.
• Closed-Loop Integration: Build a master script that runs the entire loop: detect target block, transform coordinates, solve IK, move to approach, grasp, lift, deposit in the target bin, and return to home pose.