UMPSA STEM Lab has engineered a comprehensive, self-paced Internet of Things (IoT) curriculum centered around the Raspberry Pi Pico and MicroPython. Designed to transition beginners into capable hardware developers, this 11-activity framework bridges fundamental programming concepts with real-world wireless cloud telemetry and long-range hardware interaction.

Core Pedagogy: Self-Paced Mastery & True Digital Literacy

The UMPSA STEM Lab curriculum operates on two foundational principles: individual pacing and absolute code ownership.

The learning pathway systematically introduces hardware control, bus protocols, analog processing, and wireless telemetry.

Students begin by interacting with basic General Purpose Input/Output (GPIO) pins.

• • 1. GPIO Control Defining output pins to control red, yellow, and green LEDs using MicroPython’s machine.Pin library.
    2. Timing & Iteration Implementing time.sleep(), for loops, and while True infinite execution loops to construct traffic light state machines.

2. Actuation & Input Logic

Moving beyond static outputs, the curriculum introduces dynamic control and user interaction.

1. 1. 1. Pulse Width Modulation (PWM) Driving SG90 servo motors at 50 Hz, translating duty cycles (duty_u16) into precise physical horn positions and smooth sweep animations.
      2. Digital Inputs Configuring tactile push buttons and slide switches with internal pull-up resistors (Pin.PULL_UP).
      3. Conditional Logic Utilizing if/else structures to make real-time operational decisions based on pin states.

3. Display Integration & Shared Bus Architecture

As output demands grow beyond simple LEDs, multi-device communication channels are introduced.

1. 1. 1. I2C Protocol Interfacing 0.96-inch OLED displays using the ssd1306 library over shared SDA (GP2) and SCL (GP3) bus lines.
      2. Sensory Data & Motion Connecting MPU6050 motion sensors on the same I2C bus using custom libraries (imu.py), formatting floating-point readings with round() and abs() to create tilt alert systems.

4. Analog Processing & Sensor Calibration

To measure continuous physical phenomena, students transition from binary digital signals to analog processing.

1. 1. 1. Analog-to-Digital Conversion (ADC) Reading soil moisture levels using 16-bit resolution (read_u16()) on ADC-capable pins (GP26).
      2. Empirical Calibration Testing probes in dry air and saturated soil to establish customized numerical thresholds, converting raw voltages into accurate 0–100% moisture percentages.

5. Cloud Telemetry & Peer-to-Peer Wireless Protocols

The advanced modules transform standalone microcontrollers into connected IoT endpoints.

1. 1. 1. Wi-Fi & Cloud Telemetry (Pico W) Connecting to 2.4 GHz Wi-Fi networks and establishing lightweight MQTT messaging with Adafruit IO. Students construct cloud dashboards with interactive toggle blocks to control physical board LEDs globally via sub/pub callbacks (set_callback, check_msg).
      2. Hardware UART & Long-Range Radio Configuring physical radio transceiver modules (Ebyte E70) via UART at 9600 baud. Students set mode pins (M0, M1, M2), reconfigure operating frequencies/channels across 410–441 MHz, and send encoded byte payloads over airwaves without requiring cloud infrastructure.

The UMPSA STEM Lab 2026 ESP32 MicroController IoT Programming Module delivers a progressive, hands-on learning pathway that transforms beginners into proficient IoT developers using the ESP32 / ESP32-S3 microcontroller and the Wokwi online simulator. Designed around a project-driven curriculum, the module transitions systematically from basic circuit dynamics to cloud-integrated smart systems.

The Learning Journey: From Single Bits to Cloud Integration

Phase 1: Fundamental Electronics & Sensing – LED Output Control (GPIO, Digital High/Low, Delay Timing) | | – Analog Sensing (LDR Photoresistors, 12-bit ADC, Thresholds)

Phase 2: Visual Displays, Proximity & Motion | | – I2C Visual Output (Adafruit SSD1306 OLED Display) | | – Acoustic Ranging (HC-SR04 Ultrasonic Sensor & pulseIn) | | – Human Input & Motion (Potentiometers, Buttons & Servos)

Phase 3: Connected IoT & Cloud Data Systems | | – Cloud Telemetry (Blynk IoT Dashboard & Virtual Pins) | | – Automated Data Logging (Google Sheets via Apps Script) |

Phase 1: Digital Fundamentals and Environmental Sensing

Learners begin by building digital output foundations using the ESP32 DevKit. The lesson introduces GPIO pin initialization, constant declaration (const int), setting output modes with pinMode(), and delivering 3.3V logic signals using digitalWrite(pin, HIGH). Current-limiting 220 Ω resistors ensure component protection.

Building on basic outputs, Activity 2 introduces time-domain control. Students learn to toggle states using digitalWrite(pin, LOW) paired with delay() calls in milliseconds. The core concept highlights how loop() endlessly executes sequence steps to form repeatable hardware timing patterns.

Transitioning from binary outputs to continuous input monitoring, learners connect a 4-pin LDR (Light Dependent Resistor) module to ADC1 pin GPIO34.

1. 1. 1. 12-bit Resolution Unlike 10-bit Arduino boards (0–1023), the ESP32 processes analog values across a 0–4095 scale.
      2. Serial Communication Data is transmitted back to the host via Serial.begin(115200) and monitored in real time using Serial.println().
      3. Decision Boundaries Activity 4 establishes conditional logic (if / else), using threshold values to trigger automated hardware responses based on ambient light changes.

Phase 2: User Interfaces, Acoustic Distance, and Precision Motion

Moving beyond simple LEDs, learners integrate a 0.96-inch SSD1306 OLED screen.

1. 1. 1. I2C Protocol Communicates via two dedicated lines—SDA (GPIO21) and SCL (GPIO22)—at I2C address 0x3C.
      2. Graphics Libraries Implements Adafruit_SSD1306 and Wire.h to manage buffer clearing (display.clearDisplay()), cursor positioning (display.setCursor()), and screen updates (display.display()).

Activity 6 introduces the HC-SR04 Ultrasonic Sensor for spatial awareness:

1. 1. 1. 1. Trigger and Echo High-frequency sonic bursts are initiated via a 10 µs pulse on the TRIG pin (GPIO12) and timed via the ECHO pin (GPIO14) using pulseIn().
         2. Kinematic Conversion Distance in centimeters is calculated using sound velocity:
            • $$\text{Distance (cm)} = \frac{\text{duration} \times 0.034}{2}$$
         3. Proximity Triggers Threshold logic compares measured distances against target limits (< 40 cm or < 100 cm) to activate visual warning indicators.

Activities 7 and 8 unite analog and digital inputs to command physical motion:

1. 1. 1. Dual Inputs: Combines an analog potentiometer knob (GPIO34) with a digital push button operating in INPUT_PULLUP mode (active LOW logic on GPIO25).
      2. Range Re-mapping: Uses map(potValue, 0, 4095, 0, 180) to translate 12-bit raw readings into servo rotation angles.
      3. Commanded Actuation: Incorporates the ESP32Servo library (servo.write(angle)) to trigger precise motor positioning upon button press events.

Phase 3: Cloud Telemetry, IoT Dashboards, and Data Logging

Activity 9 elevates physical projects to connected Internet of Things (IoT) applications. Leveraging Wokwi’s simulated Wi-Fi (Wokwi-GUEST), sensor data is streamed off-site:

1. 1. 1. Blynk IoT Setup Configures Cloud Templates, Virtual Pins, and authentication tokens to display live readings on interactive web and mobile dashboards.
      2. Google Apps Script Bridge An HTTPS doGet(e) web app script intercepts incoming URL parameters and appends time-stamped entries to a live Google Sheet spreadsheet:
         function doGet(e) {
           var sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName("Sheet1");
           if (!e || !e.parameter.distance) return ContentService.createTextOutput("No distance received");
           var distance = parseFloat(e.parameter.distance);
           sheet.appendRow([new Date(), distance]);
           return ContentService.createTextOutput("OK");
         }

The final module activity completes the IoT feedback loop by demonstrating bi-directional communication. Instead of just sending data to the cloud, learners use Blynk Dashboard widgets to transmit control signals back to the ESP32 hardware, toggling actuators and indicators over the internet from anywhere in the world.

Core Competencies Developed

Deploying artificial intelligence directly on compact microcontrollers—often termed Edge Intelligence—represents a major leap in embedded engineering. This UMPSA STEM Lab module provides a hands-on roadmap for transitioning from basic software-based computer vision to standalone, hardware-integrated AI models capable of performing real-time image processing, feature extraction, and object classification on low-power ESP microcontroller hardware.

The Shift to Edge Intelligence

Traditional computer vision solutions rely on cloud servers or heavy laptop GPUs to process video streams. Edge Intelligence moves processing power directly to the physical sensor level. In this module, participants move beyond pre-packaged datasets to create, train, and deploy bespoke computer vision pipelines designed specifically for embedded micro-processors.

Image Processing & Data Engineering Discipline

A fundamental lesson of embedded machine learning is that an AI model is only as effective as the data used to train it.

Figure 1: The compact ESP32 camera board featuring an integrated 2 megapixel camera sensor and Wi-Fi capability.

The Thumbnail Test & Image Resolution

1. 1. 1. Pixel Reduction Raw images captured by the sensor are downscaled to 96 x 96 pixel grayscale or RGB arrays.
      2. Visual Clarity Before training, images are evaluated via the “thumbnail test” to ensure visual features remain recognizable when shrunk to stamp-sized dimensions.

         

Essential Rules for Dataset Quality

1. 1. 1. 1. Single Variable Changes Change only one condition (angle, lighting, position) between consecutive photo captures to maximize information density.
         2. Background Separation Avoid shooting all target objects on identical surfaces. Otherwise, the model learns background cues rather than object features.
         3. Consistent Label Formatting Labels must follow strict naming rules (lower case, no spaces, e.g., red_chili) to prevent duplicate target classes.

3. Feature Extraction & Impulse Pipeline Design

Once images are collected and labeled, raw pixel values are mapped into numerical feature vectors inside Edge Impulse.

Figure 2: The four-block impulse design connecting input image data to digital signal processing (DSP) and neural network classifiers.

1. 1. 1. Raw Image Preprocessing Images are normalized and structured into uniform dimensions.
      2. DSP Feature Generation Spatial characteristics (edges, textures, color distributions) are extracted, generating distinct visual clusters in 3D feature space.
      3. Classifier Training Neural networks process the extracted features to assign probabilities across classes.
      4. Inference Speed Real-time classification executes in approximately 1 ms per frame, enabling fluid live monitoring.

4. Bounding Boxes, Confidence Thresholds, and the “Nothing” Class

A key challenge in real-world vision deployment is handling unexpected inputs—a scenario highlighted by the “chili problem“.

5. Microcontroller Integration on ESP32 Hardware

The culmination of the module is flashing the trained impulse directly onto an ESP microcontroller processor.

Figure 3: Real-time classification outputs streamed over the Arduino Serial Monitor at 115200 baud.

Hardware Deployment Steps

1. 1. 1. Firmware Setup Configure the Arduino IDE with necessary ESP32 board definitions and upload the custom collection sketch (ESP32_datacollection.ino).
      2. Port Selection & Cabling Ensure high-speed data cables are used, as charge-only cables will fail to establish COM communication.
      3. Network Configurations Connect via self-generated Wi-Fi access points (Route A) or local network infrastructure (Routes B/C).
      4. Serial Verification Initialize the Serial Monitor at 115200 baud and press the hardware reset (RST) button to verify initialization and monitor live inference logs.

6. Key Takeaways

Through this module, participants develop end-to-end expertise in embedded machine learning:

1. 1. Moving from cloud-dependent AI to standalone micro-processor execution.
   2. Mastering raw image preprocessing, feature extraction, and dataset hygiene.
   3. Deploying real-time computer vision models on low-cost hardware platforms.