ESP32: measure ambient light with the BH1750 lux sensor
Wire a BH1750 to an ESP32 over I2C and get real lux readings instead of a raw ADC number. The light sensor that works out of the box.
All tutorials
205 tutorials. Filter by platform below or just scroll. Each one is something I have actually built and shipped, not a paraphrase of someone else's GitHub README.
ESP32: add precision analog inputs with the ADS1115
The ESP32 ADC is noisy and 12-bit. The ADS1115 gives you 16-bit, 4-channel, differential readings over I2C for $4.
ESP32: environmental sensing with the BME680
The BME680 reads temperature, humidity, pressure, AND volatile organic compounds (VOC) from air quality, over one I2C bus.
ESP32: build a digital scale with a load cell and HX711
Turn a $8 load cell into a working digital scale with the HX711 amp and an ESP32. Calibration, tare, and the wiring that gets 1g resolution.
ESP32: push notifications with ntfy.sh, self-hosted
Send push notifications from an ESP32 to your phone with ntfy.sh. One HTTP POST, no cloud account, and the server can live on your own Raspberry Pi.
ESP32: send email alerts over SMTP, no cloud service
Send email straight from an ESP32 over SMTP with STARTTLS. Works with your own mail server or any provider, no third-party IoT API.
Arduino: build a line-following robot
A 2WD robot that follows a black electrical-tape line using three IR reflectance sensors. Bang-bang control done honestly, PID optional.
ESP32-CAM: take and send a photo on motion via ntfy
PIR sensor triggers the ESP32-CAM, which captures a JPEG and pushes it to your phone over ntfy. Self-hosted security camera, no cloud.
Arduino: a full traffic light with pedestrian button
Build a traffic light with a pedestrian crossing button using a proper state machine. The project that teaches event timing without delay().
ESP32: record audio with an INMP441 I2S microphone
Wire a $3 INMP441 MEMS mic to the ESP32 and capture real audio over I2S. The hardware path to sound detection, voice notes, and wake words.
Pico: run multiple tasks with asyncio
Blink an LED, read a sensor, and serve a web page at the same time on a Pico with MicroPython asyncio. Cooperative multitasking without an RTOS.
Pico: log sensor data to microSD with timestamps
Wire a microSD card to a Pico over SPI and write timestamped CSV sensor logs that survive power loss. The offline data logger pattern.
Raspberry Pi: log sensor data to SQLite and query it
Store sensor history in SQLite on a Pi: schema, insert loop, retention, and the queries that answer 'what happened last week'.
Raspberry Pi: time-series dashboards with InfluxDB + Grafana
The self-hosted dashboard stack: InfluxDB stores sensor time series, Grafana graphs them. Install, wire an ESP32's MQTT feed, retention included.
ESP32-CAM: live MJPEG streaming web server in the browser
Stream live video from an ESP32-CAM to any browser on your Wi-Fi. MJPEG over HTTP, the pattern behind every DIY security camera.
ESP32-CAM: pan and tilt mount with two servos
Add two servos to the ESP32-CAM and aim the camera from a web page. The streaming camera that looks where you look, for $12 more.
ESP32: read RFID tags with the RC522
Wire the $3 MFRC522 RFID reader to an ESP32 over SPI and build the tap-to-unlock pattern: card UID list, relay output, event logging.
ESP32: drive a low-power e-paper display
Drive a 2.9-inch e-ink panel with an ESP32: crisp static text, months on a battery, and the refresh rules that keep the panel alive.
Arduino: Simon-says memory game
Build the Simon memory game with 4 buttons, 4 LEDs, and a buzzer. State machines, tone(), and the game loop that scales to any difficulty.
ESP32-CAM: QR code scanning for access control
Turn the ESP32-CAM into a QR code scanner: on-board decode with the quirc library, valid-code list, relay output for the door strike.
Arduino: motion-activated night security light
A real outdoor-style light: PIR triggers, an LDR confirms it is dark, a relay drives a 12V lamp. The AND logic that stops false triggers.
Raspberry Pi: build a sensor REST API with Flask
Expose your Pi's sensors as a JSON REST API with Flask. GET readings, POST control commands, and the structure that keeps it honest.
Arduino: build a light-following robot with LDRs
A 2WD robot that chases a flashlight beam using two LDR eyes and bang-bang steering. Phototaxis for twelve dollars of parts.
Arduino: read a 4x4 membrane keypad with 8 pins
Read a 4x4 keypad with 8 Arduino pins instead of 16 by scanning rows and columns. The matrix-scan trick behind every keyboard ever made.
Arduino: animations on an 8x8 LED matrix (MAX7219)
Drive an 8x8 LED matrix with a MAX7219 and Arduino. Build frame-based animations: a smiley, a wave, and a scrolling pixel text. One chip, three wires.
Arduino: real timekeeping and alarms with the DS3231 RTC
Give your Arduino a real clock with the DS3231 RTC module. Set the time, read it back, and fire alarms that survive power loss, drift, and reboot.
Arduino: control it from an Android app with MIT App Inventor
Drive an Arduino over Bluetooth from an Android app you build yourself with MIT App Inventor, no Java, one HC-06 module, two-way control.
Arduino: build a digital clock with DS3231 + OLED
Build a desk clock that never drifts: a DS3231 RTC keeps time, a 0.96 inch SSD1306 OLED shows it big. Two I2C devices on the same two wires, plus a button to set it.
Arduino: long-range 2.4 GHz radio links with nRF24L01
Two Arduinos talking over 2.4 GHz with nRF24L01 modules, no WiFi, no phone, one capacitor and a library. Sensor links that run for months.
Arduino: electronic dice roller with 7-segment display
Roll a die with a button press: a 7-segment display shows 1 to 6 with a tumble animation. Direct-drive wiring, a segment map, and honest randomness on the Uno.
Arduino: Ethernet web server when Wi-Fi is not an option
Put an Arduino on your LAN with a W5500 Ethernet module and serve sensor pages from any browser. The wired path when Wi-Fi drops, roams, or is not allowed.
Arduino: location and time from a NEO-6M GPS module
Read latitude, longitude, and the exact UTC time from a $12 NEO-6M GPS module over serial. Wiring, the TinyGPS++ library, and why the fix takes 5 minutes outside.
Arduino: build a digital scale with a load cell and HX711
Turn a $8 load cell into a working digital scale with the HX711 amp and an Arduino Uno. Wiring, the calibration step everyone skips, and 1 g resolution.
Arduino: decode any IR remote with the IRremote library
Wire a 3-pin IR receiver to an Arduino and decode any TV or AC remote with the IRremote library. NEC, Sony, RC5, and the switch statement that turns buttons into actions.
Arduino: build an obstacle-avoiding robot from scratch
A 2WD Arduino robot that drives forward and dodges what is in front of it, using an HC-SR04 on a servo and an L298N driver. The full build, wiring to behavior.
Arduino: read high temperatures with a K-type thermocouple and MAX6675
Wire a K-type thermocouple and a MAX6675 to an Arduino and read oven, kiln, and solder-pot temperatures up to 1024 C. Includes the polarity trap.
Arduino: read water quality with the TDS module
Measure total dissolved solids with the Gravity TDS module on an Arduino: clean wiring, temperature compensation, calibration, and what TDS cannot tell you.
Arduino: voice control with a DFPlayer or voice-recognition module
Voice control on Arduino without the cloud: the DF2301Q offline voice module drives lights and sounds, and a DFPlayer Mini gives the project a voice back.
Arduino: build a gas alarm with the MQ-2
Build an MQ-2 gas and smoke alarm on an Arduino: wiring, warm-up, calibration, buzzer code, and the honest limits of a DIY detector.
Arduino: line-follower with the TCRT5000 array and PID
The PID line-follower: three TCRT5000 analog sensors feed one weighted error signal, and the robot steers in proportion to how far off the line it is.
ESP32: read bridge sensors with the ADS1115 in differential mode
Go past basic ADS1115 single-ended reads: differential inputs for bridge sensors, the PGA gain math, and a data-rate benchmark you can run yourself.
ESP32: gesture, proximity, and color sensing with the APDS9960
Wire an APDS9960 to an ESP32 and read swipes, hand distance, and ambient color over I2C. One $4 sensor, three sensors inside, plus the level-shifter trap.
Arduino: microwave radar motion detection with the RCWL-0516
Detect motion through walls and plastic with the RCWL-0516 microwave radar module. Doppler sensing that ignores temperature, sunlight, and thin drywall.
Arduino: datalogger with RTC + SD card for timestamped sensor files
Log sensor readings to an SD card with real timestamps from a DS3231 RTC. CSV files your spreadsheet opens directly, and a clock that survives power cuts.
Arduino: receive 433 MHz RF remote signals and replay them
Sniff, decode, and replay 433 MHz RF remotes (wireless doorbells, plug sockets) with a superheterodyne receiver and RCSwitch. One Arduino, two boards.
Arduino: drive a 4-digit display with the TM1637
Wire a TM1637 4-digit 7-segment display to an Arduino and print numbers, a clock, and a scrolling counter. Two pins, one library, no soldering.
ESP32: hosted MQTT brokers vs self-hosting
Compare EMQX and HiveMQ free tiers against Mosquitto on a Raspberry Pi, wire an ESP32 to each, and pick the right broker for your home.
ESP32: measure whole-house AC current with an SCT-013
Clamp an SCT-013 current transformer around your main feed, read real AC current on the ESP32, and convert it to watts with the burden-resistor math.
ESP32: long-term air quality with the BME680 (baseline tracking over MQTT)
Track BME680 gas resistance over days, survive the 48-hour burn-in, and publish air quality trends over MQTT so your room gets a real baseline, not a guess.
ESP32-CAM: take and email a photo on motion (SMTP)
PIR motion triggers the ESP32-CAM to capture a JPEG and email it as an SMTP attachment with STARTTLS. The alert channel that works with any mail account, no app install.
ESP32: tones and waveforms from the true DAC
Generate real analog tones, ramps, and waveforms on the ESP32's true 8-bit DAC pins (GPIO25/26), from a beep to a sine sweep.
ESP32-CAM: face detection with the onboard model
Run the ESP32's built-in face detection model on the ESP32-CAM with ESP-WHO: detect faces in real time, no cloud, no external server, with human detection as a fallback.
ESP32: location and time from a NEO-M8N GPS module
Wire a NEO-M8N GPS module to an ESP32 over serial, parse NMEA for position and UTC time, and understand why your first fix takes minutes.
ESP32: connect to Home Assistant two ways (ESPHome and MQTT)
Wire an ESP32 sensor into a self-hosted Home Assistant: flash it with ESPHome from the HA UI, or run native firmware and publish MQTT discovery. Both paths, one tutorial.
ESP32: play audio through the MAX98357A I2S amp
Wire the MAX98357A I2S amplifier to an ESP32 and play WAV data from flash or an internet stream. The talking-device pattern that pairs with the INMP441 microphone tutorial.
ESP32-CAM: photo delivery patterns over ntfy (attach, caption, thumbnail)
Three ways to push an ESP32-CAM photo through ntfy: raw JPEG attachment, captioned image, and thumbnail with a link. With the header semantics that make each one work.
ESP32: push readings into InfluxDB over HTTP
Write ESP32 sensor readings straight into a self-hosted InfluxDB over HTTP with line protocol. Time-series storage on your Pi, graphed by Grafana, no cloud in the middle.
ESP32: send IR codes with an IR LED
Build an ESP32 IR blaster that replays remote codes to control a TV or AC unit over the network. Pairs with the IR receiver tutorial to capture the codes first.
ESP32: detect motion through walls with the RCWL-0516 radar
Wire the RCWL-0516 microwave radar to an ESP32 and detect motion through walls and plastic. Doppler sensing with Wi-Fi reporting, deep sleep, and ntfy alerts.
ESP32: read high temperatures with a K-type thermocouple and MAX6675
Measure up to 600 C with a K-type thermocouple and MAX6675 amplifier on an ESP32. Wiring, the 220ms update gotcha, and when to upgrade to a MAX31855.
ESP32: one web page to replace five remotes (web IR blaster)
Build an ESP32 web-server IR blaster with a page of buttons for TV, soundbar, and AC. Capture codes with the IR receiver, replay them over Wi-Fi from any browser.
ESP32: log sensor data to a microSD card
Write timestamped CSV data from ESP32 sensors to a microSD card. FAT file basics, real timestamps, daily file rotation, and the flush pattern that survives power cuts.
ESP32: build a UI with LVGL on a touch display
Drive a 320x240 ILI9341 touch display with LVGL 9 on an ESP32. Real widgets, buttons that work, and the two-task structure that keeps drawing and touch alive.
ESP32: read battery voltage and fuel gauge (MAX17048) instead of guessing
Read real state-of-charge from a LiPo with the MAX17048 fuel gauge over I2C. Percent, voltage, and charge rate instead of a voltage lookup table.
ESP32: read sound level with an analog microphone module
Wire an analog microphone module (MAX4466 or LM393 sound sensor) to the ESP32's ADC and build an RMS sound level meter for clap triggers and noise logging.
ESP32: add 8 analog inputs over SPI with the MCP3008
The ESP32 loses half its ADC pins the moment Wi-Fi turns on. Add 8 clean analog inputs with a $4 MCP3008 over SPI: wiring, real pins, and a full 8-channel sketch.
ESP32: read temperature with a $1 NTC thermistor (Steinhart-Hart done simply)
Turn a $1 NTC thermistor and a 10K resistor into an ESP32 temperature sensor: divider math, analogReadMilliVolts to dodge ADC nonlinearity, and the beta equation.
ESP32: sync time over NTP and handle timezones + DST correctly
Get real wall-clock time on the ESP32 over NTP: settimeofday, the TZ string that handles DST for you, and a self-hosted angle pointing at your own router or a Pi.
ESP32: count LED pulses on your utility meter to track kWh
Read your utility meter's blinking LED with an ESP32 photoresistor and count real kWh: interrupt pulse counting, kWh math, and MQTT for a live whole-house power figure.
ESP32: talk to GPS, GSM, or another MCU over UART2
Wire a GPS, GSM, or second microcontroller to the ESP32 over UART2, with working pins, the TX/RX cross, and non-blocking code that parses what comes back.
Pico: drive DC motors with the L298N
Wire a Pico to an L298N motor driver, drive one or two DC motors with PWM speed control in MicroPython, and get direction control for free. The start of every wheeled robot.
ESP32: add login auth to your web server (session cookies, the right way)
Add username and password login to an ESP32 web server with session cookies, random tokens, and logout. Self-hosted, no third-party identity provider, honest limits stated.
ESP32: draw graphics and text on a color TFT (ST7735/ST7789)
Wire an ST7735 or ST7789 color TFT to an ESP32, draw text and shapes, update a live readout without flicker, and fix the classic black-screen and wrong-color problems.
Pico W: send email alerts over SMTP
Send email straight from a Pico W over SMTP with STARTTLS in MicroPython. Works with your own mail server or any provider's app password, no cloud IoT service in the middle.
Pico: measure wind speed with an anemometer
Wire a cup anemometer's reed switch to a Pico, count pulses with an interrupt, and convert pulse rate to wind speed with the manufacturer's constant.
ESP32: assign a static IP and reserve it in the router
Give an ESP32 a fixed IP with WiFi.config(), reserve it in your router with a DHCP reservation, and stop hunting the network for a device that moved.
Pico: GPS location and time with the NEO-6M
Wire a NEO-6M GPS module to a Pico over UART, parse NMEA sentences in MicroPython for position and atomic-clock UTC time, and learn why the first fix takes minutes outdoors.
Pico: read the RP2040's built-in temperature sensor
Read the temperature sensor inside the RP2040 chip with MicroPython's ADC and the 27-degree conversion formula. Zero wiring, one ADC channel, and a warning about what the number actually means.
Pico: program the Pico with the Arduino core (when C++ is the right tool)
Install the arduino-pico core, upload a blink sketch, and learn when the Pico deserves C++ instead of MicroPython: interrupts, timing precision, and memory headroom.
ESP32: timer interrupts and why loop() timing drifts
Use the ESP32's hardware timers for interrupt-driven timing, understand why millis() and delay() drift under load, and stop your blinking LED from wandering.
ESP32: measure water quality (TDS) with the analog TDS sensor
Wire the analog TDS sensor module to an ESP32, convert ADC counts to ppm with temperature compensation, and calibrate against a known solution instead of guessing.
Raspberry Pi: send email alerts from shell scripts with msmtp
Configure msmtp on a Raspberry Pi so any shell script or cron job can send email alerts through your own SMTP relay. The pattern that survives.
Raspberry Pi: transfer files with FileZilla over SFTP
Move files between your computer and a Raspberry Pi with FileZilla over SFTP. No FTP server, no extra packages, no plaintext passwords on the network.
Raspberry Pi: gesture recognition with MediaPipe
Run hand gesture recognition on a Raspberry Pi camera feed with MediaPipe: count fingers, detect an open palm or fist, and trigger real actions in Python.
Raspberry Pi: internet anywhere with a 4G/LTE HAT
Get a Raspberry Pi online over cellular with a SIM7600 4G/LTE HAT, check signal honestly, and run your own WireGuard bridge over the link instead of port forwarding.
ESP32: serve a real web app from LittleFS instead of string-built HTML
Put HTML, CSS, and JavaScript files on the ESP32's flash with LittleFS and serve them with WebServer. No more escaping quotes inside C++ strings.
Raspberry Pi: live camera stream in the browser with Picamera2 MJPEG
Stream a Raspberry Pi camera feed live into any browser with Picamera2 and MJPEG. One Python file, no plugins, works on your phone over Wi-Fi.
Pico: drive a 28BYJ-48 stepper motor with a ULN2003 driver
Wire a 28BYJ-48 stepper to a Raspberry Pi Pico with the ULN2003 board and drive it with MicroPython. Precise position control for about $3 in parts.
Raspberry Pi: Sense HAT (LEDs, sensors, joystick)
Plug a Sense HAT onto a Raspberry Pi and read temperature, humidity, pressure, and orientation from Python, drive the LED matrix, and fix the two traps every owner hits.
Raspberry Pi: back up and clone an SD card the safe way
Image a Raspberry Pi SD card with the right tool for each job: Raspberry Pi Imager for restores, dd and gzip for raw backups, rsync for daily copies.
Pico W: set a static IP for a reliable local device
Give a Pico W a fixed IP address with MicroPython so bookmarks, port forwards, and automations keep working after the router reboots.
Arduino: persist data with EEPROM, the right way
Save a calibration value or a small setting to EEPROM so it survives a power cycle. The 1 KB on the Uno is enough for hundreds of values if you use it carefully.
Arduino: read a rotary encoder, position and direction
Wire a rotary encoder to two interrupt pins and track position, direction, and speed. The pattern that lets a motor know where it is.
Arduino: drive a DC motor with the L298N H-bridge
Wire an L298N module to an Arduino and control a DC motor forward, reverse, and at variable speed with PWM. The H-bridge pattern that runs most hobby robots.
Arduino: hardware interrupts, the right way to react to events
Wire a button to an interrupt pin and react to it instantly. The pattern that makes pin-change detection feel like magic, and the rules you cannot break.
Arduino: read an HC-SR04 ultrasonic distance sensor
Wire an HC-SR04 to an Arduino and read distance in centimeters. The 40 kHz chirp, the trigger pulse, the echo timing, and the math that turns a microsecond count into a number you can use.
Arduino: the watchdog timer, recover from hangs automatically
Add a watchdog timer to your Arduino sketch so the chip resets itself when it hangs. The pattern that keeps field-deployed projects from being bricked by a stuck sensor.
ESP32: HTTP server in depth, routing, JSON APIs, and async handlers
Build a real HTTP API on the ESP32. Route by path, handle GET vs POST, parse JSON bodies, serve JSON responses, and use async handlers when the request rate goes up.
ESP32: JTAG debugging with OpenOCD and a logic probe
Stop guessing why the firmware crashes. Set breakpoints, step through code, inspect registers, with JTAG + OpenOCD + GDB. The right tool when print debugging fails.
ESP32: debug with a logic analyzer and protocol decoders
When the Serial.print tells you nothing, the I2C bus tells you everything. Pick a $10 clone or a $400 Saleae, install Sigrok and PulseView, decode I2C/SPI/UART.
ESP32: NVS (Non-Volatile Storage), the right way to persist settings
Use the Preferences library to save and load settings that survive power cycles on the ESP32. Wi-Fi credentials, calibration values, and the blob storage pattern for larger data.
ESP32: sign OTA firmware updates so attackers cannot push their own
The MITM attack on unsigned OTA, why HTTPS alone does not save you, and the signed-update pattern that closes the loop. With anti-rollback and key rotation.
ESP32: oscilloscope basics, what those waveforms actually mean
Read a scope like you read a multimeter. Volts per div, time per div, AC vs DC coupling, what bandwidth actually buys you, and how to measure PWM duty cycle.
ESP32: drive an addressable RGB LED strip over RMT, the right way
Wire a WS2812B addressable RGB LED strip to an ESP32, drive it with the RMT peripheral and the FastLED library, and avoid the 800-LED limit and the always-on power math.
ESP32: RTC memory, the fast persistent storage that survives deep sleep
Use RTC_DATA_ATTR to keep state across deep sleep on the ESP32. Boot counters, last-known sensor values, and the gotcha that it does not survive a power cycle.
ESP32: secure boot and flash encryption, the real product build
Burn efuses, sign firmware, and lock the flash so a stolen ESP32 cannot be cloned. The right way to ship an ESP32 product instead of a hobby board.
ESP32: TLS in depth, root CAs, and validating real certificates
Move past setInsecure() and the WiFiClientSecure default that ships in every HTTPS example. Bundle root CAs, validate chains, and pin fingerprints on the ESP32.
ESP32: TCP sockets in depth, the protocol your MQTT rides on
Every packet your ESP32 sends over WiFi goes through a TCP socket. Three-way handshake, WiFiClient, WiFiServer, the stuck connection gotcha, TCP_NODELAY.
ESP32: WebSocket server, the right protocol for live dashboards
Build a WebSocket server on the ESP32 with ESPAsyncWebServer. Push sensor readings to a browser at 10 Hz without polling, with the ping/pong heartbeat that keeps the connection alive.
Pico: I2C in depth with MicroPython, scanners and bus recovery
Scan the I2C bus on a Pico for connected devices, recover from a locked-up SDA line, and understand the 7-bit vs 8-bit address gotcha. The pattern that turns 'my sensor is not responding' into a 30-second fix.
Pico: PWM in depth with MicroPython, frequencies and duty cycles
Use the Pico's 8 PWM slices from MicroPython to drive servos, dim LEDs, generate tones, and synthesize analog output with a low-pass filter.
Pico: UART serial with MicroPython, talking to other chips
Wire two devices with TX, RX, and a common ground. Read a GPS module, talk to a Nextion display, or exchange data between two Picos over UART in MicroPython.
Pico W: async web server with uasyncio, the modern pattern
Serve a real async web API from a Pico W using uasyncio, with background sensor tasks and non-blocking request handlers. The right way after the synchronous server gets too small.
Pico W: Bluetooth Low Energy peripheral with MicroPython and aioble
Turn a Pico W into a BLE peripheral that a phone can connect to over Bluetooth Low Energy, with a GATT service, read, write, and notify characteristics.
Raspberry Pi: use the Camera Module v3 with libcamera and Picamera2
Wire a Camera Module v3 to a Raspberry Pi, capture stills and video from the command line with libcamera, and write Python with the modern Picamera2 library.
Raspberry Pi: GPIO with Python and gpiozero, the right way
Wire an LED and a button to a Raspberry Pi's GPIO and control them from Python using gpiozero. The simplest way to get started with physical computing on the Pi.
Raspberry Pi: WireGuard VPN with PiVPN, your own private tunnel
Set up WireGuard on a Raspberry Pi using PiVPN, configure your phone as a peer, and tunnel back to your home network from anywhere on the internet.
Pico 2: getting started with the RP2350 and MicroPython
Flash MicroPython to a Raspberry Pi Pico 2 (RP2350), connect over the REPL, and see what's new vs the original Pico. The 20-minute Pico 2 setup.
Pico 2: drive a DVI display over HSTX, the new thing on RP2350
Drive a 640x480p60 DVI display from a Raspberry Pi Pico 2 using the new HSTX peripheral. The Pico 2 can output digital video; the original Pico could not.
Raspberry Pi: install Home Assistant the right way, with backups and automations
Install Home Assistant OS on a Raspberry Pi, set up the integrations (MQTT, ESPHome, Hue), build a GUI automation, and recover from a bricked install with a full backup.
Raspberry Pi: install Docker the right way and run multi-service stacks
Set up Docker on a Raspberry Pi 4 or 5, run multi-container stacks with docker-compose, and avoid the arm64 vs amd64 trap that wastes a weekend.
Pico 2: PIO state machine improvements on RP2350 vs RP2040
What changed in the PIO state machines between the Pico RP2040 and the Pico 2 RP2350. Most existing PIO programs run unchanged; the new bits matter for HSTX and ADC.
ESP32: LoRa to MQTT gateway, one-channel bridge from off-grid to Wi-Fi
Build a single ESP32 + SX1278 LoRa gateway that bridges off-grid LoRa packets to your home Wi-Fi MQTT broker. Sender subscribes, receiver publishes, one channel only, and a real gateway disclosure.
ESP32 + LoRa: Meshtastic, the off-grid mesh firmware
Flash Meshtastic on an ESP32 + LoRa board and you have an off-grid text messaging device with mesh routing, encryption, and battery-friendly operation. No SIM card, no monthly bill, no account.
ESP32: LoRa peer-to-peer, two boards talking without Wi-Fi
Wire two ESP32 boards to SX1278 LoRa modules and send packets between them with no Wi-Fi, no internet, no gateway. The wiring, the Sandeep Mistry library, sender code, receiver code, and the urban range truth.
Pico 2: TrustZone on the RP2350, when the secure world matters
Use TrustZone on the Raspberry Pi Pico 2 RP2350 to isolate secure boot, sign firmware, and lock down GPIO. C SDK only; MicroPython does not expose TrustZone.
ESP32: install the toolchain the right way
Set up the Arduino IDE for ESP32 the way that does not break six months from now. Boards manager URLs, USB drivers, and the port detection traps.
ESP32: the boot button and boot pins, what they actually do
The BOOT button on most ESP32 boards is not a reset button. It puts the chip in download mode. Here is what that means and why you keep needing it.
ESP32: analog read with the ADC, and why ADC2 is broken on Wi-Fi
Use the ESP32's 12-bit ADC to read a potentiometer or analog sensor. Includes the ADC2 vs Wi-Fi trap and the input-only pin caveat.
ESP32: advertise as a BLE peripheral with the GATT server pattern
Make the ESP32 show up as a Bluetooth device that a phone can see and connect to. The foundation for any BLE-based IoT project.
ESP32: PWM on every pin with the LEDC peripheral
Use the ESP32's LEDC hardware to generate PWM on any GPIO. The right way to dim LEDs, drive servos, and control motor speed.
ESP32: drive a hobby servo with LEDC
Wire a hobby servo to an ESP32 using the LEDC peripheral. The right way to control an SG90 or MG996R without the Servo.h library.
ESP32: drive a NEMA 17 stepper motor with the A4988 driver
Wire a NEMA 17 stepper motor to an ESP32 using the A4988 stepper driver. The right call for real torque and precise positioning.
ESP32: connect to BLE peripherals with the GATT client pattern
Make the ESP32 read data from BLE devices like heart rate straps, temperature sensors, and beacons. The reverse of the peripheral tutorial.
ESP32: send HTTPS requests with root CA validation
Make the ESP32 talk to real APIs over HTTPS, with proper TLS validation. The right way to send sensor data to a cloud service.
ESP32: wire a 18650 battery with a TP4056 charge controller
Wire a single 18650 cell to an ESP32 using the TP4056 charge controller. The minimum circuit for any battery-powered ESP32 project.
ESP32: dev boards vs bare modules, the right pick for battery projects
When to use a $5 dev board and when to drop down to the bare ESP32 module. The tradeoffs that matter for battery, size, and cost.
ESP32: read an MQ-2 gas sensor (the honest reading)
Wire an MQ-2 gas sensor to an ESP32 and read combustible gas concentrations. Important caveats about what MQ sensors can and cannot tell you.
ESP32: receive IR remote signals with the VS1838B
Wire a 3-pin IR receiver module to an ESP32 and decode remote control signals. Use any TV remote, AC remote, or cheap IR remote as a wireless input.
ESP32: detect motion with a PIR motion sensor
Wire a PIR motion sensor (HC-SR501) to an ESP32 and detect people moving in a room. The foundation for security, automation, and wake-on-motion projects.
ESP32: read a soil moisture sensor (capacitive, not resistive)
Wire a capacitive soil moisture sensor to an ESP32 and read soil moisture as a percentage. Skip the resistive sensor; it corrodes and lies.
ESP32: measure DC current with the ACS712 current sensor
Wire an ACS712 current sensor module to an ESP32 and measure DC current in amps. The right way to monitor power consumption of battery devices.
ESP32: measure ambient light in lux with the BH1750
Wire a BH1750 light sensor to an ESP32 and measure ambient light in real lux units. The right sensor for daylight sensing, plant monitoring, and screen brightness.
ESP32: read a BME280 temperature, humidity, and pressure sensor
Wire a BME280 to an ESP32 over I2C and stream temperature, humidity, and barometric pressure. Better than the DHT22 for anything weather-related.
ESP32: read a DS18B20 temperature sensor with OneWire
Wire one or many DS18B20 temperature sensors to a single ESP32 GPIO pin. Multiple sensors, one wire, accurate to 0.5 C.
ESP32: read an MPU6050 accelerometer and gyroscope over I2C
Wire an MPU6050 to an ESP32 and read acceleration and rotation rate in three axes. The sensor you need for robots, drones, and motion tracking.
ESP32: GPIO basics, digital read, digital write, and the pull-up trick
How to read and write the ESP32's GPIO pins, when to use the internal pull-ups, and the input-only pins that catch everyone once.
ESP32: drive a piezo buzzer with tone()
Use a piezo buzzer with an ESP32 to play tones, melodies, and alarm sounds. The LEDC peripheral does this in hardware, with no CPU overhead.
ESP32: control a relay module for switching higher-voltage loads
Use a relay module with an ESP32 to switch mains-powered devices. The hardware safety boundaries and why opto-isolated modules matter.
ESP32: switch a high-current load with a 2N2222 transistor
Use a 2N2222 NPN transistor to switch a load that draws too much current for a GPIO pin. Pumps, fans, LED strips, solenoids.
ESP32: drive an SSD1306 OLED display over I2C
Wire a 128x64 OLED display (SSD1306) to an ESP32 and draw text, graphics, and sensor graphs. Smaller and brighter than the 16x2 LCD.
ESP32: drive a 16x2 LCD display with the I2C backpack
Wire a 16x2 character LCD (HD44780 with the PCF8574 I2C backpack) to an ESP32 and show text. The right display for showing sensor readings and menus.
ESP32: ESP-MESH, a self-healing Wi-Fi network
Build a multi-hop Wi-Fi network with multiple ESP32 boards. Self-healing, automatic routing, no central router needed.
ESP32: ESP-NOW, peer-to-peer messages without a router
Send messages between ESP32 boards directly, without Wi-Fi infrastructure. Up to 250 bytes per packet, up to 20 peers, range of 200m+ line of sight.
ESP32: use mDNS so the chip responds to a friendly name
Replace IP addresses with friendly names like 'kitchen-sensor.local'. mDNS is built into the ESP32 and most operating systems.
ESP32: set up a captive portal for Wi-Fi configuration
Make the ESP32 broadcast its own Wi-Fi network and serve a configuration page. The right pattern for projects that need Wi-Fi credentials but have no keyboard.
ESP32: mains power with the HLK-PM01 isolated supply
Use the HLK-PM01 isolated mains-to-5V module to power an ESP32 from a wall outlet. The safer alternative to wiring a 5V phone charger inline.
ESP32: run from a USB battery bank (and why most of them break)
Power an ESP32 from a USB battery bank. The hidden auto-shutoff feature that turns off most battery banks after 30 seconds with low-current loads.
ESP32: supercapacitor backup for graceful power-off
Add a supercapacitor to your ESP32 project so it can detect a power loss and shut down gracefully. The minimum circuit for industrial-grade deployments.
ESP32: build a plant monitor with soil moisture and auto-watering
Soil moisture sensor + 12V water pump + ESP32 = a plant monitor that waters your plant when the soil gets dry. Solar-powered for outdoor use.
ESP32: solar + 18650 battery for perpetual projects
Add a small solar panel to your 18650 battery setup for perpetual operation. The math for sizing the panel and the protection circuit you actually need.
ESP32: build a weather station that logs to Wi-Fi
A complete weather station: BME280 over I2C, ESP32 web server, deep sleep between readings. Battery-powered, weatherproof case, web dashboard.
ESP32: build a home sensor hub with MQTT and Node-RED
The complete home sensor network: ESP32 publishes to MQTT, Raspberry Pi runs Node-RED and a dashboard. Multiple sensors in multiple rooms.
ESP32: build an indoor air quality monitor
BME280 + MQ-2 + MQ-135 + ESP32 + OLED = a complete indoor air quality monitor. Temperature, humidity, CO2 equivalent, and combustible gas.
ESP32: build a solar-powered trail camera
ESP32-CAM with PIR motion sensor, SD card storage, and solar power. Captures images when motion is detected and stores them on the SD card.
ESP32: build a 2WD robot base with motor control
Two DC motors, an L298N motor driver, an ESP32, and ultrasonic distance sensors. The base you build a robot on top of.
ESP32: build a Wi-Fi doorbell that pushes to your phone
Press a button, get a notification on your phone. The ESP32 + Pushover (or Telegram) + a simple button. Replaces a $50 smart doorbell.
ESP32: add 16 GPIO pins with the MCP23017 I2C port expander
Run out of GPIO on your ESP32? The MCP23017 adds 16 GPIO pins over I2C using only 2 wires. Multi-platform code for ESP32, Arduino, Pico, and Pi.
ESP32: drive a MAX7219 8-digit 7-segment display
Wire a MAX7219 to an ESP32 to drive an 8-digit 7-segment display over SPI. The right pick for showing sensor numbers, counters, or clocks.
ESP32: drive a 74HC595 shift register for 8 extra output pins
Add 8 output pins to your ESP32 using only 3 GPIO pins and a 74HC595 shift register. For LEDs, relay arrays, and 7-segment without a driver.
ESP32: drive a TLC5940 16-channel PWM LED driver
When the ESP32's LEDC peripheral is not enough, the TLC5940 adds 16 channels of 12-bit PWM over SPI. The right pick for big LED projects.
Pico W: publish MQTT messages from MicroPython over Wi-Fi
Connect a Pico W to Wi-Fi and publish sensor readings to an MQTT broker from MicroPython. The pico equivalent of the ESP32 MQTT tutorial.
Pico W: serve a live sensor dashboard over Wi-Fi
Read a DHT22 or BME280 and serve a live dashboard from a Pico W. The smallest, cheapest way to put a sensor reading on your phone's browser.
ESP32: negotiate USB-C PD voltages with a trigger board
Get 5V, 9V, 12V, 15V, or 20V out of any USB-C charger with a FUSB302 or HW-715 trigger board. The right power source when you need 12V from a USB-C brick.
ESP32: power with a LiPo battery and TP4056 or MCP73831 charger
Wire a LiPo battery to an ESP32 with a TP4056 or MCP73831 charger. The safer alternative to 18650 for projects that get handled or carried.
ESP32: read buttons and debounce them in software
Wire a button to an ESP32 and write the debounce code that keeps your state from flickering. Includes the pattern I use in every project.
ESP32: OTA (over-the-air) firmware updates
Update ESP32 firmware over Wi-Fi without plugging in USB. The feature that turns a project from prototype into something you actually deploy.
ESP32: use the onboard touch pins as buttons
The ESP32 has 10 capacitive touch pins that work without any extra hardware. Wire a piece of foil and you have a button.
Arduino: drive a 28BYJ-48 stepper motor with a ULN2003 driver
Wire a small stepper motor to an Arduino using the ULN2003 driver board. Precise position control without the expensive hardware.
ESP32: read an HC-SR04 ultrasonic distance sensor
Wire an HC-SR04 to an ESP32 and measure distance in centimeters. The sensor that goes into most of my robotics projects.
Arduino: control relays for home automation
Drive a relay module from an Arduino to switch mains-powered devices. The most common home automation building block, with all the safety stuff included.
Raspberry Pi: run Pi-hole to block ads network-wide
Install Pi-hole on a Raspberry Pi and block ads, trackers, and malware domains for every device on your network. The single most useful Pi project.
ESP32: connect to Wi-Fi and stay connected
The minimum code to bring up Wi-Fi on an ESP32, with reconnect logic and the most common reasons it silently fails.
Pico: use PIO to drive WS2812B LEDs (NeoPixels)
The Pico's Programmable I/O can drive WS2812B LEDs without blocking your code. A reusable PIO program you can drop into any project.
Arduino: drive a 16x2 LCD display (with I2C backpack)
Add a 16x2 character LCD to your Arduino using the I2C backpack. Show text, custom characters, and read sensor values on a screen.
Raspberry Pi: serve files on your network with Samba
Turn a Raspberry Pi into a small NAS by setting up Samba file sharing. Access the Pi's files from any computer on your network.
ESP32: publish MQTT messages to a broker
Send sensor data over MQTT from an ESP32 to a broker, and subscribe from another device. The pub/sub pattern that runs most home automation.
Pico: blink the onboard LED with MicroPython (the 5-minute start)
The shortest possible Pico + MicroPython tutorial. Blink the LED. Get to a working project before you know all the theory.
Arduino: read temperature with a DS18B20 one-wire sensor
Wire a DS18B20 temperature sensor to an Arduino using the OneWire protocol. Multiple sensors on one pin, accurate to 0.5C.
Raspberry Pi: run Node-RED for visual automations
Install Node-RED on a Raspberry Pi and build a visual automation flow. The tool that ties together MQTT, sensors, dashboards, and notifications.
ESP32: deep sleep and battery life, the honest numbers
Put an ESP32 into deep sleep and measure the actual current draw with a multimeter. Includes what to expect on different boards and battery chemistries.
Pico: drive a servo motor with MicroPython
Control a hobby servo from a Pico using PWM and MicroPython. Includes the library code I use in every Pico servo project.
Arduino: use I2C to talk to sensors and displays
I2C is the two-wire protocol that connects most Arduino sensors. This tutorial covers the wiring, the address scan, and the most common gotchas.
ESP32: drive WS2812B addressable LEDs (NeoPixels)
Wire a strip of WS2812B LEDs to an ESP32 and drive colors, brightness, and animations from Arduino code. The classic ESP32 eye-candy project.
Raspberry Pi: install and configure Mosquitto MQTT broker
Set up a local MQTT broker on a Raspberry Pi so your ESP32s and other devices can publish and subscribe without depending on a cloud.
Pico: read a DHT22 with MicroPython
Wire a DHT22 temperature and humidity sensor to a Pico and read it from MicroPython. The smallest useful Pico sensor project.
Arduino: control a servo motor
Drive a hobby servo (SG90, MG996R) from an Arduino. The shortest path from Arduino to 'something moved.'
Raspberry Pi: read a DHT22 with Python and the GPIO pins
Wire a DHT22 to a Raspberry Pi's GPIO and read temperature and humidity from Python. The smallest useful Pi project.
ESP32: serve a sensor dashboard from the chip itself
Turn your ESP32 into a tiny web server that shows live sensor readings on any phone or laptop on the same Wi-Fi. No cloud, no app.
Pico W: serve a web page from the chip over Wi-Fi
Connect the Pico W to Wi-Fi and serve an HTML page from the chip. The smallest useful web server on a $6 microcontroller.
Arduino: read a potentiometer and print the value
Wire a 10k potentiometer to an Arduino analog pin and read its position with analogRead. The second project after blink.
Raspberry Pi: headless setup without a monitor
Set up a Raspberry Pi without ever plugging in a monitor or keyboard. Write the SD card, SSH in, and configure Wi-Fi from your laptop.
ESP32: read a DHT22 temperature and humidity sensor
Wire a DHT22 to an ESP32, install the library, and stream readings over Serial every 2 seconds. The shortest useful ESP32 project.
Pico: get started with MicroPython on the Raspberry Pi Pico
Flash MicroPython to a Raspberry Pi Pico, connect over the REPL, and run your first script. The 10-minute Pico setup.
Arduino: blink an LED (the classic first project)
The minimum Arduino sketch. Blink the onboard LED on pin 13. If you have never programmed an Arduino, start here.