⚡Course Curriculum

Arduino & Embedded Systems

Robotics & Embedded· Intermediate· Ages 14–17· 28 Hours

Course At a Glance

Program Outcomes

By the end of this course, students will be able to:

1
Understand fundamental concepts of embedded systems and microcontrollers.
2
Program Arduino to interface with sensors and actuators.
3
Design and implement a functional embedded system project.
4
Apply logical thinking to build automated real-world solutions.

Module 1

Introduction to Embedded Systems & Arduino

Students set up the Arduino IDE, learn C/C++ syntax, and build progressively from digital output (LED blink) to analog I/O (potentiometers, PWM).

Approx. 7 hrs

#	Lesson Title	What Students Learn	Activity / Project	Key Code / Components
1.1	What are Embedded Systems?	Define embedded systems and microcontrollers vs. general computers. Explore the ATmega328P specifications.	Embedded Systems Identification: Identify input/output/processors in everyday objects. Research Uno vs. Raspberry Pi specs.	`Microcontroller, embedded system, input/output, ATmega328P, clock speed, flash/SRAM`
1.2	Arduino Hardware & IDE Setup	Identify board components (digital, analog, PWM, power pins). Install the IDE, connect via USB, and verify/upload sketches.	Hardware Tour & Setup: Label Uno diagram. Connect board, select port, and upload the built-in Blink sketch.	`Arduino IDE, Tools > Board, Tools > Port, Verify, Upload, Serial Monitor`
1.3	C/C++ for Arduino: Syntax & Structure	Learn the setup() and loop() structure. Cover C/C++ static typing, semicolons, variable types, and operators.	Code Conversion: Convert Python logic to valid Arduino C/C++ and compile to check for syntax errors.	`void setup(), void loop(), int, float, bool, String; semicolons, {}`
1.4	Digital Output: Blink & LED Control	Understand HIGH (5V) / LOW (0V). Configure pins as OUTPUT with pinMode(). Use digitalWrite() and delay().	Build: 'Traffic Light Controller' — connect LEDs on a breadboard and program a timed traffic sequence.	`pinMode(pin, OUTPUT), digitalWrite(pin, HIGH/LOW), delay(ms), 220Ω resistor`
1.5	Digital Input: Buttons & Pull-up Resistors	Configure pins as INPUT_PULLUP. Read states with digitalRead(). Address the floating pin problem and debounce logic.	Build: 'Multi-Mode LED' — button cycles LED through solid/slow/fast blink modes using if-else and tracking variables.	`pinMode(pin, INPUT_PULLUP), digitalRead(pin), if/else, debounce delay`
1.6	Analog Input: Reading Sensors	Read 0–5V voltages via the 10-bit ADC (0–1023) using analogRead(). Use map() to scale values.	Build: 'Analog Dimmer' — read a potentiometer, map it to 0–255, and control LED brightness.	`analogRead(A0), 0–1023, map(val, 0, 1023, 0, 255), analogWrite(pin, 0–255)`
1.7	Analog Output: PWM & LED Fading	Simulate analog output using PWM on ~ pins via analogWrite(). Understand duty cycles.	Build: 'Breathing LED' — smoothly fade an LED in and out using a for loop and analogWrite().	`analogWrite(pin, 0–255), PWM pins (~3,5,6,9,10,11), for loop fade`
1.8	Module 1 Project: Interactive Light System	Combine digital/analog I/O and C/C++ control structures into a cohesive circuit program.	Project: 'Smart Lighting Controller' — pot controls brightness via PWM, buttons cycle colour/flash modes.	`Full Module 1 — digitalRead/Write, analogRead/Write, PWM, if-else, for loop`

Module 2

Sensors & Actuators

Students connect and program sensors (DHT11, LDR, HC-SR04) and actuators (buzzers, DC motors, relays), applying Ohm's law and building multi-sensor stations.

Approx. 7 hrs

#	Lesson Title	What Students Learn	Activity / Project	Key Code / Components
2.1	Breadboards & Circuit Fundamentals	Understand breadboard routing, Ohm's Law (V=IR), current-limiting resistors, and voltage dividers.	Circuit Lab: Calculate and wire LED resistors. Build series/parallel LED circuits and a potentiometer divider.	`Ohm's Law V=IR, R=(5V-Vf)/If, breadboard, voltage divider, resistor colour code`
2.2	Temperature Sensor (DHT11/DHT22)	Install libraries. Read temp/humidity data over a one-wire protocol. Handle NaN errors with isnan().	Build: 'Digital Thermometer' — prints temp data to Serial Monitor and triggers LED alerts on hot/cold thresholds.	`#include <DHT.h>, dht.readTemperature(), dht.readHumidity(), isnan()`
2.3	Light Sensor (LDR) & Voltage Dividers	Use an LDR in a voltage divider circuit to measure ambient light. Map the analog input to brightness ranges.	Build: 'Automatic Nightlight' — read LDR and proportionally dim/brighten an LED based on room light.	`LDR voltage divider, analogRead(), map(), threshold comparison, analogWrite()`
2.4	Ultrasonic Distance Sensor (HC-SR04)	Trigger 10μs pulses and measure echo duration with pulseIn() to calculate distance in cm.	Build: 'Proximity Alarm' — measure distance. Green >100cm, Amber 50-100cm, Red <50cm + buzzer.	`pulseIn(echoPin, HIGH), duration*0.034/2, Trig 10μs pulse, HC-SR04 wiring`
2.5	Buzzers & Tone Generation	Generate frequencies on passive buzzers using tone() and noTone(). Build melodies using arrays.	Build: 'Musical Arduino' — play an 8-note melody array using a button trigger.	`tone(pin, freq, duration), noTone(pin), int notes[] = {}, NOTE_C4=262`
2.6	DC Motors & Motor Drivers (L298N)	Use an L298N H-bridge to safely drive high-current DC motors. Control direction and PWM speed.	Build: 'Variable Speed Motor Controller' — pot controls speed, buttons control forward/reverse/stop.	`L298N wiring, IN1/IN2 direction control, ENA analogWrite(), H-bridge concept`
2.7	Relay Modules & High-Power Switching	Use 5V relay modules to switch high-power circuits. Understand NC/NO contacts and hysteresis.	Build: 'Automated Fan Controller' — temp sensor triggers relay above 28°C and turns off below 25°C.	`Relay module, digitalWrite(relayPin, LOW/HIGH), NC/NO contacts, hysteresis`
2.8	Module 2 Project: Environmental Monitoring Station	Integrate multiple sensors and actuators into a single sketch with complex conditional logic.	Project: 'Multi-Sensor Station' — DHT11, LDR, and HC-SR04 drive LEDs and buzzers based on configured thresholds.	`Full Module 2 — DHT, LDR, HC-SR04, LEDs, buzzer, relay, millis() timing`

Module 3

Communication & Control Systems

Students master serial debugging, servo control, I2C LCDs, non-blocking millis() timing, modular function code, and EEPROM data persistence.

Approx. 7 hrs

#	Lesson Title	What Students Learn	Activity / Project	Key Code / Components
3.1	Serial Communication & Debugging	Communicate over USB (UART) via TX/RX. Use Serial.print() for output and parseInt() for input.	Serial Debug Lab: Add print statements to a buggy sketch to trace execution flow and variable states to fix it.	`Serial.begin(9600), Serial.print/ln(), Serial.read(), Serial.parseInt(), baud rate`
3.2	Servo Motor Control	Control servo angle (0–180°) via the Servo library. Attach to a pin and write specific angles.	Build: 'Sensor-Driven Servo' — pot controls servo angle, but proximity <20cm forces it to 90°.	`#include <Servo.h>, Servo myServo, .attach(pin), .write(angle), .read()`
3.3	I2C Communication & LCD Display	Use the I2C protocol (SDA/SCL) to drive a 16x2 LCD display. Print custom strings and data.	Build: 'LCD Dashboard' — connects DHT11 and pot to display live data on the LCD with formatted text.	`#include <LiquidCrystal_I2C.h>, lcd.begin(), lcd.setCursor(col,row), lcd.print()`
3.4	Timing with millis() & Non-Blocking Code	Replace blocking delay() with millis(). Execute multiple timed tasks concurrently without pausing the loop.	Refactor Sprint: Replace all delay() calls in the Environmental Station with millis() for concurrent operations.	`millis(), unsigned long previousMillis, if(millis()-prev >= interval), non-blocking`
3.5	Arrays, Strings & Data Management	Store sequences in arrays (e.g. recent temperatures). Use sprintf() to format C-strings for display.	Build: 'Data Logger' — stores 10 temp readings in a circular buffer array. Print history/averages on button press.	`float readings[10], for(int i=0; i<10; i++), sprintf(), String class, circular buffer`
3.6	Functions & Modular Arduino Code	Write reusable C/C++ functions with parameters and return types. Keep loop() and setup() clean.	Refactor Sprint: Decompose the station project into named functions (readSensors(), updateDisplay(), etc).	`return type function(params), void readSensors(), float getTemp(), prototypes`
3.7	EEPROM: Persistent Data Storage	Store non-volatile settings (0–255) using EEPROM.read/write. Persist data across power cycles.	Build: 'Settings Memory' — set brightness with a pot. Save to EEPROM. On power cycle, it restores automatically.	`#include <EEPROM.h>, EEPROM.read(addr), EEPROM.write(addr, val), EEPROM.update()`
3.8	Module 3 Project: Automated Control System	Combine non-blocking timing, functions, I2C, and EEPROM into a cohesive control system.	Project: 'Smart Thermostat Controller' — DHT11 reading shown on LCD. Servo actuates a damper based on a target temp saved in EEPROM.	`Full Module 3 — millis(), Servo, I2C LCD, EEPROM, functions, serial commands`

Module 4

Embedded Systems Project

Students design, build, program, test, and present a complete embedded system demonstrating the full hardware/software lifecycle.

Approx. 7 hrs

#	Lesson Title	What Students Learn	Activity / Project	Key Code / Components
4.1	Project Briefing & Concept Selection	Design a complete system solving a problem using ≥3 sensors/actuators, millis() timing, and an output display.	Concept Pitch: Pitch 3 ideas. Submit a Project Concept Form with block diagrams and user stories.	`System block diagram, input/output mapping, component list, user story`
4.2	System Design & Circuit Planning	Produce detailed circuit schematics, pin assignment tables, and program flowcharts prior to wiring.	Design Deliverable: Submit drawn schematic, pin table, and state diagram for teacher sign-off.	`Circuit schematic, pin assignment table, program flowchart, state diagram`
4.3	Hardware Assembly & Wiring	Safely assemble breadboard circuits with colour-coded wires. Test components independently.	Build Sprint: Assemble and wire the project. Run individual test sketches for each component before integration.	`Breadboard wiring, colour-coded connections, component testing, hardware verification`
4.4	Core Software Build — Part 1	Implement the software skeleton (functions/prototypes). Build the main logic loop and primary actuator controls.	Build Sprint: Core interactive feature working end-to-end. Sensors read correctly and actuate the primary output.	`Function prototypes, setup(), loop(), sensor functions, core if-else logic`
4.5	Core Software Build — Part 2	Integrate secondary features: LCD displays, EEPROM saving, and replace all delays with non-blocking millis().	Build Sprint: All features functional simultaneously without blocking. Data displays correctly and persists via EEPROM.	`millis() timing, LCD display, EEPROM.update(), serial command parsing, full integration`
4.6	Testing, Calibration & Debugging	Test systematically. Calibrate sensor thresholds for real-world environments. Use serial output to trace bugs.	Testing Sprint: Run continuous 10-minute tests. Use Serial Monitor to find runaway states. Log and fix bugs.	`Serial debug output, threshold calibration, continuous operation test, bug log`
4.7	Enclosure, Presentation & Documentation	Finalise physical presentation (wire management). Write technical documentation describing the build.	Polish Sprint: Secure wiring. Write a 1-page technical document with schematics and key code. Rehearse pitch.	`Technical documentation, wiring management, presentation preparation`
4.8	Final Presentation Day	Deliver a live demonstration of the hardware/software integration and discuss technical hurdles.	Final Demo: 5-minute live demo + Q&A per team. Certificates awarded.	`Full course — Arduino C/C++, sensors, actuators, communication, control`

Teaching Notes & Tips

Pacing Guidance

Each module contains 8 lessons (~50–60 mins), totalling ~28 hours. IDE setup (1.2) may require extra time. Lesson 3.4 (millis() non-blocking timing) is conceptually challenging—allow time for live debugging.

Differentiation

Advanced students can explore SPI (SD card logging), Wi-Fi with ESP8266/32, OLED displays, PID motor control, or state machine design. Core students can prototype in Tinkercad Circuits prior to physical wiring.

Assessment Criteria

Capstone assessed on: (1) Hardware Assembly (safe circuits). (2) Software Quality (non-blocking timing, modular functions). (3) System Integration. (4) Documented Bug Logs. (5) Technical Documentation (schematics/pin tables).

Tools & Equipment

Software: Arduino IDE or Arduino Web Editor. Hardware: Arduino Uno, jumper wires, breadboards. Class kit: DHT11, LDR, HC-SR04, SG90 servo, 5V buzzer, LEDs, L298N driver, DC motors, I2C LCD, relays, potentiometers.

Suggested Capstone Projects

Smart Home Mini System (motion/light control with LCD + relay), Automated Plant Waterer (moisture sensor + relay pump + EEPROM), Security Alarm (PIR + buzzer + keypad), Smart Traffic Controller (ultrasonic vehicle detection).

Safety & Lab Guidelines

Always power off before rewiring. Never exceed 5V on pins. Always use 220Ω resistors for LEDs. Motors/relays require external power. Relay modules are for low-voltage demo ONLY (no mains voltage). Prevent short circuits.

Enroll Your Child Now