How to Do Real Embedded Systems Research at Home: A High School Student’s Guide to Free Tools, Affordable Kits, and Public Datasets

Embedded systems used to mean a corporate lab, a $5,000 oscilloscope, and a cubicle full of engineers. Today, a $4 microcontroller and a free toolchain can publish results that hold up at ISEF.

This guide is your starting point. It walks you through three things: the home hardware kit that fits in a shoebox, the free software that runs on your laptop, and the public datasets that turn a hobby project into real research.

Why this is possible now

The first shift is the price of compute. An ESP32-S3 costs about $8 and runs neural networks. An RP2040 costs $4. A Raspberry Pi Zero 2 W costs $15 and runs full Linux. The chips on your desk now match what engineers used in production five years ago.

The second shift is open toolchains. KiCad designs PCBs. Wokwi simulates whole circuits in a browser. Yosys and nextpnr synthesize designs for $20 FPGAs. PlatformIO, Zephyr, and ESP-IDF give you the same firmware tools professional teams use, free.

The third shift is on-device machine learning. TensorFlow Lite Micro, CMSIS-NN, and Edge Impulse let you train a model on your laptop and run it on a coin-cell-powered board. That means a 9th grader can ship a sensor with a neural net inside.

Put it together: a kitchen counter, a laptop, and a $50 parts bin can now produce a working wearable, a mesh sensor network, or a passive radar.

The Embedded Systems home kit

Group your purchases by what they let you measure or control. You do not need everything at once. Start with one microcontroller and one sensor that match your question.

Microcontrollers and dev boards

• ESP32, ESP32-S3, or ESP32-CAM (~$5 to $15): Wi-Fi, Bluetooth, and on-board ML acceleration.
• Raspberry Pi Pico or Pico W with RP2040 (~$4 to $6): great for real-time control, FOC motor drivers, and USB-HID work.
• Raspberry Pi Zero 2 W or Pi 4 (~$15 to $50): for Linux-side work like SDR pipelines and Gazebo simulation.
• STM32 BluePill or Teensy 4 (~$3 to $25): higher-end DSP and motor control.
• Tang Nano, iCEBreaker, or TinyFPGA (~$10 to $30): for FPGA and RISC-V soft-core projects.

Sensors (sub-$30 each)

• IMUs: MPU-6050, BNO055, ADXL345, ADXL355 for motion, gait, and vibration.
• Biosignal: MAX30102 (heart rate, SpO2), AD8232 (ECG), MyoWare (EMG).
• Distance and depth: VL53L0X or VL53L1X time-of-flight sensors.
• Environmental: BME280 (temp, humidity, pressure), PMS5003 (particulates), SGP30 and MQ-series (gas), MLX90640 (thermal pixel array).
• Audio: INMP441 I2S mics, MAX98357 audio out.
• Current and power: INA219, INA826.
• Magnetics: MLX90393 Hall sensors.
• Cameras: OV2640, OV5640 for low-cost imaging.

Radio and communication

• LoRa SX1276 or RYLR modules for long-range mesh.
• nRF24, BLE dongles (nRF52), and ESP-NOW for short-range swarms.
• RTL-SDR (~$30) or a used HackRF for ADS-B, AIS, FM, and passive radar work.

Build supplies

• Breadboards, perfboards, and a $5 PCB run from JLCPCB or similar.
• 3D-printed enclosures (a school printer is enough).
• A USB logic analyzer (~$10), a digital multimeter, and a small soldering iron.

A complete starter kit comes in around $80 to $200 depending on how many sensors you grab. One MCU, one sensor, and a breadboard is enough for a first project.

Signature technique: TinyML on a microcontroller

If you only learn one workflow, learn this one. TinyML lets you run a neural network on a chip that draws microamps, which unlocks more than half the projects on this page.

1. Collect data. Hook your sensor (mic, IMU, ECG front-end) to your MCU. Stream readings over serial to a CSV file. Label each sample with the event you care about.
2. Train on your laptop. Load the CSV into a Colab notebook. Use TensorFlow or PyTorch to train a small model (1D-CNN, depthwise CNN, or a tiny transformer). Quantize the weights to int8 or int4.
3. Convert to TFLite Micro. Export the model with the TensorFlow Lite converter. Get a model.cc file you can drop into your firmware.
4. Deploy. Flash the model to your MCU with PlatformIO or Arduino. Use CMSIS-NN kernels on Cortex-M chips for a 3 to 5x speedup.
5. Measure on real hardware. Log inference latency, RAM usage, and current draw with an INA219. These numbers are your scientific results, not decoration.

Edge Impulse gives you a free GUI version of this whole pipeline if you want to start there before going code-first.

The dry-lab side: free software you can install today

These are the same tools used in industry. Running them yourself changes the kind of question you can ask.

Firmware and RTOS

• Arduino and PlatformIO: the easiest entry points for any ESP32, RP2040, or STM32 board.
• ESP-IDF: Espressif's official SDK for serious ESP32 work.
• Zephyr and FreeRTOS: real-time operating systems for multi-task firmware.
• MicroPython and CircuitPython: Python on a microcontroller, perfect for fast prototyping.

Embedded ML

• TensorFlow Lite Micro: the standard runtime for sub-256 KB models on MCUs.
• CMSIS-NN: ARM's optimized neural net kernels for Cortex-M.
• Edge Impulse: a free-tier web platform that handles data collection, training, and deployment.
• microTVM, ExecuTorch, Aifes, nnom: alternative runtimes worth comparing in a benchmarking project.

DSP and signal libraries

• SciPy, NumPy, Polars: data analysis on your laptop.
• librosa, PyWavelets, KissFFT: audio and time-frequency work.
• CMSIS-DSP: optimized FFT, FIR, and IIR routines for ARM cores.

RF and SDR

• GNU Radio: graphical signal-flow tool for SDR pipelines.
• SDRangel, gqrx, URH (Universal Radio Hacker): receive, decode, and reverse-engineer signals from RTL-SDR or HackRF.

Simulation

• Wokwi: simulate ESP32, RP2040, and Arduino circuits in a browser, free.
• LTspice, ngspice, Falstad, QUCS-S: analog circuit simulation.
• KiCad: schematic capture and PCB layout, with built-in ngspice.
• Verilator, Icarus Verilog, GHDL: HDL simulation for FPGA projects.
• Renode and QEMU Cortex-M: whole-system MCU simulation, useful for hardware-in-the-loop work.
• Gazebo, Webots: robot and sensor simulation.
• OMNeT++ and ns-3: network simulation for mesh and IoT protocols.
• Yosys and nextpnr: open-source FPGA synthesis for Tang Nano, iCEBreaker, and TinyFPGA.

Running these tools on your own laptop means you can iterate dozens of designs in an afternoon before you ever solder a part.

Public datasets that count as real data

Re-analyzing public data is a fully legitimate research path. Strong embedded projects often combine self-collected data with a public benchmark.

Biosignals

• PhysioNet: ECG, PPG, EEG, EMG recordings, the standard reference for biosignal work.
• MIT-BIH: the canonical arrhythmia ECG dataset.
• BCI Competition IV and OpenBCI samples: EEG datasets for brain-computer interface projects.

Audio

• Google Speech Commands: short keyword utterances for wake-word and keyword spotting.
• ESC-50 and UrbanSound8K: environmental and urban sound classification.
• BirdCLEF, CoughVid, Coswara: bird calls, cough sounds, and respiratory audio.

Vibration and human activity

• CWRU and MAFAULDA: bearing-fault vibration datasets for predictive-maintenance projects.
• OPPORTUNITY HAR, UCI HAR, PAMAP2: wearable human-activity recognition.

RF, geospatial, and environmental

• ADS-B Exchange and OpenSky Network: aircraft tracking signals.
• OpenStreetMap: free, editable mapping data for crowdsourced road and infrastructure projects.
• NOAA and USGS earthquake catalog: weather and seismic time series.

Vision

• ImageNet and MS-COCO: standard image classification and detection benchmarks.
• ESP32-CAM datasets: community-collected images at the resolution your hardware actually produces.

Pulling one of these into your project gives you a baseline to compare against, which is what judges look for.

How to combine wet and dry: the strongest project shape

The strongest embedded projects fuse a physical measurement with a computational claim.

Pattern A: build a sensor, then prove it works. Design and solder a node. Collect your own dataset with it. Train a model on that data plus a matching public dataset. Report accuracy, latency, and power draw as your three primary results.

Pattern B: replicate a published technique, then push one variable. Implement a known algorithm (a Kalman filter, an OFDM link, a TinyML wake-word) on your hardware. Then change one thing: a smaller model, a different quantization, a noisier environment. Compare against the baseline you just built.

Judges respond to this shape because it shows you can do both the engineering and the science.

Choosing a phenomenon that has not been done

Originality is a process, not a guess. Run this check before you commit.

1. Search Google Scholar for two or three keyword phrases from your idea. Read the abstracts of the top 10 results. Note what has been done.
2. Search the Society for Science abstracts archive (ISEF and Regeneron STS) for your sensor or technique. Skim every project that comes back.
3. Search IEEE Xplore and arXiv for the specific algorithm or hardware combination you want to use. Look at the last two years.

If you find adjacent work, that is good news. It means the question is real, and your job is to push one variable: a smaller model, a cheaper sensor, a new environment, a new dataset.

A realistic timeline

• 1 to 2 weeks: replicate one published TinyML or DSP pipeline on your hardware and measure latency and power.
• 1 to 2 months: a full hybrid project for a regional fair, including hardware build, dataset collection, model training, and a written comparison.
• Full year: an ISEF-track project with multiple iterations, a custom PCB, a public dataset replication, and a novel contribution.

If this is your first project, start with the 1 to 2 week version. Finishing something small teaches you more than planning something huge.

A starter checklist

1. A clean workspace with good lighting, a power strip, and an ESD-safe mat or tray.
2. A free Google Colab account for training models on a GPU.
3. A local Python environment with NumPy, SciPy, TensorFlow, and PyTorch installed.
4. Arduino IDE or PlatformIO installed, with the board package for the MCU you chose.
5. KiCad and Wokwi installed (or bookmarked) for circuit design and simulation.
6. A paper or digital lab notebook where you log every test, parameter, and result.
7. A one-line written research question, in the form "Can a {device} measure {phenomenon} with {metric}?"

When all seven are in place, you are ready to pick a phenomenon and start building.

Where to go next

Embedded Systems has seven ISEF subcategories. Each one has its own MehtA+ project guide that fits the kit on this page. Pick the subcategory that interests you most.

• Circuits (CIR): analog and mixed-signal design, energy harvesting, charge controllers, and circuit-level ML experiments.
• Internet of Things (IOT): distributed sensor networks, mesh protocols, federated learning, and home or campus monitoring.
• Microcontrollers (MIC): firmware, motor control, low-power techniques, embedded security, and on-device ML deployment.
• Networking and Data Communications (NET): mesh routing, physical-layer fingerprinting, covert channels, and protocol design on real radios.
• Optics (OPT): visible-light communication, smartphone-camera sensing, structured light, and laser-based instrumentation.
• Sensors (SEN): novel sensor builds, sensor fusion, drift correction, and wearable biosignal monitoring.
• Signal Processing (SIG): TinyML on biosignals and audio, compressed sensing, passive radar, and source separation.

Plus an Other (OTH) bucket for FPGA soft-cores, intermittent computing, side-channel security, and hardware-in-the-loop simulation projects.

The chip on your desk can already do more than the lab equipment of a decade ago. Pick a subcategory and start.

Project ideas in this category (80)