Robotics Foundation

You can explain the core mechanical, electrical, and computational components that form every modern robot.

1. What robots are and how they work90 min
   • Robot anatomy
   • Degrees of freedom
   • Kinematic chains
   • Industrial vs mobile systems
2. The sense–think–act loop90 min
   • Sensor telemetry
   • Microcontroller logic
   • Actuator response
   • Real-time feedback cycles
3. Types of robots and their applications90 min
   • AGVs and AMRs
   • Articulated arms
   • Drones and UAVs
   • Service robotics
4. Safety and workbench tools90 min
   • ESD precautions
   • Soldering safety
   • Bench power supplies
   • Multimeter handling
5. Your robotics kit and setup2 hrs
   • Component inventory check
   • IDE installation
   • USB drivers
   • First serial connection

Hands-on project: Map out the hardware components and block diagram for a custom mobile robot, specifying sensor inputs and actuator outputs for review.

You can calculate circuit parameters using Ohm's law and interpret basic electronic schematics safely.

1. Voltage, current and resistance90 min
   • Electrical potential
   • Electron flow
   • Resistive loads
   • Power dissipation
2. Ohm's law in practice90 min
   • Formula applications
   • Calculating current draw
   • Voltage drops
   • Safe operating limits
3. Breadboarding basics90 min
   • Internal bus connections
   • Power rails
   • Component placement
   • Avoiding short circuits
4. Reading simple schematics90 min
   • Circuit symbols
   • Ground references
   • Node connections
   • Datasheet pinouts
5. Common components explained2 hrs
   • Resistor color codes
   • Diodes and LEDs
   • Capacitors
   • Push buttons and switches

Hands-on project: Calculate resistor values for an LED circuit, verify drop voltages with a multimeter, and construct the circuit on a breadboard.

You can prototype, test, and troubleshoot low-voltage hardware circuits using digital simulation and physical multimeters.

1. Building your first circuits90 min
   • Series vs parallel circuits
   • Voltage dividers
   • Pull-up and pull-down resistors
   • Continuity testing
2. Using a multimeter90 min
   • Measuring DC voltage
   • Checking current in series
   • Resistance checks
   • Diode test mode
3. LEDs, buttons and resistors90 min
   • Current-limiting calculations
   • Debouncing switches
   • Active-high vs active-low logic
   • Signal state inspection
4. Powering your robot safely90 min
   • LiPo and NiMH battery chemistries
   • Voltage regulators
   • Current capacity limits
   • Power distribution boards
5. Simulating circuits in Tinkercad2 hrs
   • Component library usage
   • Virtual oscilloscope
   • Schematic verification
   • Debugging wiring faults

Hands-on project: Design a transistor-switched relay circuit in Tinkercad and assemble a physical prototype that triggers a load safely.

You can write and flash embedded code to microcontrollers, controlling digital and analog input/output pins.

1. Introduction to Arduino90 min
   • ATmega328P architecture
   • Arduino IDE setup
   • Board selection
   • Bootloader operation
2. Digital and analog I/O90 min
   • pinMode configuration
   • digitalRead and digitalWrite
   • analogRead ADC resolution
   • analogWrite PWM generation
3. Writing and uploading sketches90 min
   • setup and loop structure
   • Compilation process
   • Hex file upload
   • Error message troubleshooting
4. Loops, logic and timing90 min
   • for and while loops
   • Conditional branching
   • millis() vs delay()
   • Non-blocking timing patterns
5. Serial communication and debugging2 hrs
   • Serial.begin() baud rates
   • Serial.print debugging
   • Serial Plotter visualization
   • Parsing incoming byte streams

Hands-on project: Program an Arduino Uno to read an analog potentiometer value and modulate the blink rate of an onboard LED via PWM.

You can write structured C/C++ code implementing state machines, modular functions, and clean hardware abstraction.

1. C/C++ basics for Arduino90 min
   • Primitive data types
   • Memory scoping
   • Pointers and references
   • Header files
2. Variables, functions and control flow90 min
   • Parameter passing
   • Return values
   • Switch-case structures
   • Constants and macros
3. Controlling hardware from code90 min
   • Hardware abstraction layers
   • Register manipulation basics
   • Pin state caching
   • Event-driven execution
4. Simple state machines90 min
   • State transition diagrams
   • Enum definitions
   • State handlers
   • Handling timeout conditions
5. Writing clean, readable code2 hrs
   • Naming conventions
   • Commenting complex logic
   • Code modularity
   • Refactoring repetitive blocks

Hands-on project: Refactor a monolithic Arduino script into modular C++ functions governed by a strict finite state machine for robot operational states.

You can interface environmental sensors with microcontrollers and filter noisy sensor data streams in code.

1. How sensors work90 min
   • Transducers and signal conversion
   • Active vs passive sensors
   • Signal-to-noise ratio
   • Quantization errors
2. The ultrasonic distance sensor90 min
   • TRIG and ECHO pin timing
   • Speed of sound calculations
   • PulseIn timeout handling
   • Beam angle limitations
3. IR and line-following sensors90 min
   • Infrared emitter and phototransistor pairs
   • Surface reflectivity contrast
   • Digital threshold tuning
   • Ambient light interference
4. Light and temperature sensors90 min
   • Photoresistors (LDRs)
   • Thermistor voltage dividers
   • Steinhart-Hart equation basics
   • Calibration curves
5. Reading and filtering sensor data2 hrs
   • Moving average filters
   • Median filtering
   • Outlier rejection
   • Sampling rate optimization

Hands-on project: Integrate an HC-SR04 ultrasonic sensor and IR reflectance modules, applying a moving average filter to stabilize raw distance readings.

You can drive DC and servo motors with external motor drivers, controlling speed, torque, and rotational angle.

1. DC motors and the L298N driver90 min
   • H-bridge fundamentals
   • L298N pinout and logic inputs
   • ENA/ENB PWM speed control
   • Back-EMF protection
2. Servo motors90 min
   • PWM pulse width for positioning
   • Servo library integration
   • Torque ratings
   • Power supply isolation
3. Controlling speed and direction90 min
   • Forward and reverse rotation logic
   • Duty cycle scaling
   • Motor stalling prevention
   • Dynamic braking
4. Basic movement and steering90 min
   • Differential drive kinematics
   • Pivot turns vs arc turns
   • Wheel slip compensation
   • Path straightening
5. Calibrating your robot2 hrs
   • Motor speed balancing
   • PWM deadband tuning
   • Straight-line drift correction
   • Turn angle calibration

Hands-on project: Wire an L298N motor driver to dual DC motors and a servo, writing speed-ramping and steering control functions.

You can assemble a complete differential-drive robot chassis, integrate power, sensors, and actuators, and program reactive behaviours.

1. Chassis assembly and wiring90 min
   • Mechanical mounting of motors
   • Caster wheel alignment
   • Cable management
   • Secure battery placement
2. Combining sensors and motors90 min
   • Sensor positioning on chassis
   • Shared power bus management
   • Avoiding ground loops
   • Pin conflict resolution
3. Obstacle avoidance90 min
   • Distance threshold logic
   • Evasion maneuvers
   • Backup and turn sequences
   • Scan-and-decide loops
4. Line following90 min
   • Multi-sensor array processing
   • Proportional error calculation
   • Steering correction algorithms
   • Junction and gap handling
5. Testing and tuning behaviour2 hrs
   • Empirical parameter tuning
   • Handling low battery states
   • Sensor blind spot mitigation
   • Field testing iterations

Hands-on project: Build an obstacle-avoiding mobile robot that uses ultrasonic distance measurements to dynamically navigate a confined maze.

You can establish wireless serial communication over Bluetooth to remotely control robot actuators from external devices.

1. Bluetooth and wireless modules90 min
   • UART serial bridging
   • HC-05 AT command configuration
   • Baud rate matching
   • Pairing security PINs
2. Controlling a robot from your phone90 min
   • Bluetooth terminal apps
   • Command packet design
   • Parsing single-character inputs
   • Async command handling
3. Building a simple remote control90 min
   • Custom control interface design
   • Button-down and button-up events
   • Continuous motion streaming
   • Emergency stop signaling
4. Feedback loops90 min
   • Telemetry transmission back to host
   • Sensor status broadcasting
   • Closed-loop setpoint tracking
   • Error state logging
5. Troubleshooting hardware and code2 hrs
   • Isolating power noise
   • Logic analyzer inspection
   • Serial buffer overflow fixes
   • Connection drop recovery

Hands-on project: Pair an HC-05 Bluetooth module with a smartphone control app to drive the robot wirelessly and adjust behavior flags in real time.

You can configure a single-board Linux computer, write Python scripts to interact with hardware, and capture camera streams.

1. Raspberry Pi vs Arduino90 min
   • Microcontroller vs microprocessor
   • Real-time execution vs OS scheduling
   • GPIO voltage differences
   • Choosing the right compute platform
2. Python on the Raspberry Pi90 min
   • Linux terminal navigation
   • Virtual environments and pip
   • RPi.GPIO or gpiozero libraries
   • Executing scripts as systemd services
3. Adding a camera90 min
   • CSI and USB camera interfaces
   • OpenCV video capture setup
   • Resolution and framerate tuning
   • Image buffer management
4. Simple autonomous behaviours90 min
   • Color thresholding in OpenCV
   • Finding object centroids
   • Visual servoing basics
   • Autonomous reactive loops
5. Where AI fits into robotics90 min
   • Edge AI accelerators
   • Introduction to ROS nodes
   • Computer vision pipelines
   • Transitioning to autonomous navigation

Hands-on project: Set up a Raspberry Pi headless, write a Python script to capture frames from a USB camera, and stream the feed locally.

You can architect, document, and rigorously test a complete robotics system before final deployment.

1. Planning a build90 min
   • Defining functional requirements
   • Weight and payload budgeting
   • Power consumption estimation
   • Milestone scheduling
2. Choosing the right components90 min
   • Sensor accuracy trade-offs
   • Actuator torque sizing
   • Microcontroller pin constraints
   • Cost and availability analysis
3. Documenting your design90 min
   • Fritzing wiring diagrams
   • Flowcharts for robot states
   • README documentation standards
   • Bill of materials (BOM)
4. Iterating and debugging90 min
   • Systematic hardware isolation
   • Log-driven software debugging
   • Version control for embedded code
   • Managing scope creep
5. Presenting your robot2 hrs
   • Demonstrating core capabilities
   • Explaining technical trade-offs
   • Preparing architecture overviews
   • Handling failure analysis

Hands-on project: Draft a comprehensive design document, wiring schematic, and test plan for an autonomous utility rover, detailing power budgets and validation metrics.

You can debug a robot that behaves wrongly and hand it over safely.

1. A method for debugging hardware90 min
   • Isolate mechanical vs electrical vs code
   • Multimeter measurements
   • Serial logging
2. Power problems90 min
   • Brownout symptoms
   • Current draw budget
   • Grounding and noise
3. Calibration90 min
   • Reference measurement
   • Offset and scale correction
   • Drift over time
4. Operating safely90 min
   • Emergency stop
   • Pre-run checklist
   • Safe shutdown and storage

Hands-on project: Diagnose three faults planted in a working robot — a wiring fault, a miscalibrated sensor and a power problem — using a multimeter and serial logs, calibrate the sensor against a known reference, and write the safety checklist for operating it.

You can build, test, and showcase an end-to-end operational robot that integrates sensors, actuators, and custom control software.

1. Designing your capstone robot90 min
   • Integrating prior module concepts
   • Finalizing chassis layout
   • Establishing test criteria
   • Safety check-offs
2. Building and wiring90 min
   • Permanent soldering and assembly
   • Strain relief on cabling
   • Secure mounting of sensors
   • Final multimeter continuity check
3. Programming the behaviour90 min
   • Flashing complete state machine code
   • Calibrating sensor thresholds
   • Tuning PID or reactive loops
   • Handling edge cases
4. Testing and improving90 min
   • Stress testing under varied lighting
   • Battery discharge behavior checks
   • Code profiling and optimization
   • Bug fixing final regressions
5. Showcase and next steps2 hrs
   • Live project demonstration
   • Peer code review
   • Transitioning to advanced platforms
   • Continuing into Applied Robotics and AI

Hands-on project: Assemble, program, and demonstrate a fully autonomous capstone robot capable of navigating a complex obstacle course without human intervention.