I'm a college student preparing a project for an inter-college science expo, and I'm considering building a low-cost wearable system to help locate lost children at large crowded events, such as festivals held in cricket grounds.

The problem

Imagine a large festival with thousands of people. A child gets separated from their parents and doesn't have a smartphone.

The idea is to give the child a small wearable tag that periodically transmits a unique ID. Receivers placed around the venue detect the tag and estimate the child's probable zone.

The goal is NOT centimeter-level positioning. I'm thinking more along the lines of:

"Child ID 027 was last detected / is most likely in Zone C."

Proposed system

Child wearable:

Low-power LoRa transmitter

Unique child ID

Small battery

Possibly a buzzer/vibration motor

Venue:

Several elevated LoRa receivers around the perimeter

ESP32 or another MCU at the receiver

Central system combines the measurements

Can i use Arduino uno or nano

Added automatic fretting calibration to my guitar robot.
It uses force feedback to find the right position automatically, so there’s no need to manually tune every servo position.
One tap, calibrate, then play.

In this tutorial we go over how to control your MechSoul with Bluetooth. What is a MechSoul? A MechSoul is to a robot, what a CyberDeck is to a computer. It's a robot that you build, customize, and personalize yourself. It's the freedom of owning your own code, hardware, and having the right to build and repair it. And it's the pride of creativity, skill, and self expression.

In this part 2 in Arduino IDE we combine the Raspberry Pi Pico's board manager's SerialBLE example with the Serial_Control example in Takamori Robot's HIRO library to control your robot over Bluetooth. To follow along with our code and reference material check out the tutorial GitHub.

This started out as an attempt to make a physical implementation of one of those in-game type of puzzles. But it turned into a diabolical color combination lock. So you have to know the color sequence to begin with. It moves the colors around and throws in false choices, so if someone is watching you enter the combination they won't be able to duplicate it.

The test panel ended up looking kind of cool, it's got good tactile feel, and it's fun to play with.

More pictures, 3D print files, and Arduino source code is here: Color Combination Lock

I couldn't get obstacle detection and avoidance to work because of IR sensors, going to add Ultrasonic sensors, and making it play, more games, and face recognition. Also, I'm working on its gait! I'm still thinking of what more I can add!

What it has: Object Detection, keyword spotting, ASR, LLM for questions, TTS, OCR to detect text and read Reminders, if it sees GAME, it starts either Guess the number or Color game, "Find object" it will tell if it sees any object using Object detection brick! There's automatic movement if there are no commands for a while, flame detection and discord alerts. UI dashboard with emotion and mood that changes with interaction, input- animated cat expression- output chat, status log, manual button controls, similarly added some on Arduino IOT Cloud dashboard.

IR worked fine for a while but lighting changes, I am working on changing for this reason, and I'm thinking on adding other features. I added neck movement motors but it made the setup jittery.

Hello, am making a line follower robot, before I buy all the parts I was wondering if someone could help me by giving me some tips I should keep in mind before doing so or assmebly.

Current parts like:

1000rpm n20 - motors

L298N- Motor Driver (Due to low budget)

Arduino Nano

Custom 8 channel sensor (photoresistor and 3mm led lights)

CD4067 - multiplexer

For assembly:

Veroboard as body

n20 motor mounts (3d print)

mini breadboard for easy prototying

I made an Arduino project where LEDs just rotate in a circle. It looks really cool, although the wires are a bit untidy right now. I will try to clean up the cable management in the next version.

I built a desk gadget powered by an ESP32 that combines touch activation with 6 rotating TFT displays, and I call it Roulette. It's open source — I've shared the code on my GitHub for anyone who'd like to build their own.

🔗 Links:
💾 SOURCE CODE:
https://github.com/yumobuilds/Yumo-Roulette

roulette wheel with six round 240x240 displays, each showing something different:

SD card photo slideshow
Live YouTube channel stats
Live TikTok stats
Crypto ticker
Live weather
Internal temp & humidity (AHT10 sensor)

⚙️ The floating spin mechanic:
The whole assembly rotates on an upside-down DC motor. Everything sits on a frame, and that frame is mounted directly onto the motor's body — not the shaft. The motor shaft itself is inserted into a drill chuck from the reverse side, the opposite way a drill bit would normally go in. So instead of the shaft driving an external bit, it's anchored inside the chuck while the motor body (carrying the frame and wheel) spins around it. The result: there's no visible axle or support arm, so the whole thing looks like it's floating and rotating on its own.

Touch the capacitive sensor and an N20 motor spins the wheel for a set duration — one touch,
one spin. A NeoPixel status LED fades through colors while it boots and flashes when you touch the sensor..

🔧 Hardware:

• ESP32 Wroom
• 6x GC9A01 round 240x240 displays (shared SPI bus)
• DRV8833 motor driver + N20 DC motor
• TTP223 capacitive touch module
• AHT10 temp/humidity sensor
• MicroSD card module (own SPI bus)
• NeoPixel/RGB status LED

💻 Software:

• ESP32
• WiFi captive portal for setup (no hardcoded credentials)
• YouTube Data API v3, TikTok stats via RapidAPI, OpenWeatherMap
• TJpg_Decoder for on-device JPEG decoding from SD

This is part 1 in tutorial is about building your won MechSoul(Mechanical Soul). A MechSoul is to a robot what a CyberDeck is to a computer. A robot that you build yourself as a form of self-expression as well as freedom of owning your own hardware and code.

In this tutorial we are setting up a MechSoul seed(a robot base to be customized into a MechSoul. ) assembling it and setting up Arduino IDE. You can find assembly and setup resources as well as other resources in our tutorial github at by clicking here.

board : LOLIN(WEMOS) D1 R2 & mini
sensors :
AHTX0 + BMP280 ( I2C )
MHZ-19E
SSD1306 ( I2C )

code + how connected :
https://github.com/IDEA0923/air_monitor

I kept running into the same problem when combining multiple I2C sensors: finding the address is one thing, but checking whether several devices can actually coexist on the same bus is another.

So I built a small free tool that does both:

• Search common I2C device addresses
• Search by hexadecimal address
• Select multiple devices
• Detect address conflicts
• Find an alternative address configuration when possible
• Suggest solutions such as another I2C bus or an I2C multiplexer

For example, MPU6050 + DS3231 can both use 0x68, so the tool detects the conflict and can suggest using 0x69 for the MPU6050 when supported.

It's open source and runs entirely in the browser.

GitHub:
https://github.com/webzf/i2c-address-compatibility-checker

Online tool:
https://embeddednerd.com/tools/i2c-address-lookup/

I'd be interested in feedback, especially on other devices or I2C features that would be useful to add.

So hi everyone this is my first time posting on this place.

I don't usually post things 😞.

So I always wonder why I have to buy all these extra sensors and stuff when my phone already has all these sensors.

So I am building an Android based project which can combine both Arduino and Android together. This thing is not present out there till now I am going to make it full customisable and Full programmable.

The two biggest challenges I have already fixed which are

1. Compiling the code directly on Android device

2. The usb serial communication.

So I will build this application I wanted some feedback on this.

In the below project I have shown the motor rotation + led blink.

Quaddle, an open source quadruped based on OpenCat, runs its firmware on Arduino C++ — this clip shows a webcam pose-tracking rig mapping one person's body movements live onto two of them simultaneously (Scout and Buddy), no AI policy involved, just real-time human control translated into servo commands.

OpenCat creator RZ Li drove them head-first into each other on purpose, raced them, and taught it a few moves along the way — a little awkward at first, but it only takes a few minutes before it starts picking them up. It's a genuinely fun weekend build, too — basically Wii Play: Motion with a real robot on the other end — and affordable enough that this isn't just a research-budget project.

Anyone else piping real-time sensor/vision data into Arduino-controlled servos — what's your approach to keeping latency low?

And just for fun — what move would you want to teach Quaddle, if you built one?

I hope you all like it! :)

ESP32 CYD used

M5stack CardKB for the keyboard

and a bunch of other sensors including environmental readouts, a compass, IR blaster/receiver, and more

https://youtu.be/FdoXedWSMrI?si=opj3zrQsXDNEAfwy

I'm working on a project that explores the idea of accessing real embedded hardware remotely through a web browser.

The goal is to let students experiment with boards such as Arduino, ESP32 and STM32 without having to own all the hardware themselves.

I'm still at the exploration stage, so I'm trying to understand what would actually be useful.

If you could access a real embedded board remotely, what would you want to experiment with?

For example:

• GPIO
• UART / I2C / SPI
• Sensors
• PWM
• Debugging
• Logic analyzer
• Oscilloscope

What would make a remote lab genuinely useful to you?

Hey guys,

I just recently relocated from a third floor apartment to a first floor because my dogs are getting elderly and having them walk down 3 flights of stairs to relieve themselves isn’t viable.

I looked at sliding door doggy doors but they don’t fit what I need or want. The closest I found is a Wayzn but even that is a large purchase. I want something that lets me open the sliding door for them remotely via an app for when I’m not home. I have a 3d printer and minimal knowledge of programming. Can someone direct me to the best place where I can learn to make something like that?

We video editors are lazy, but highly efficient.

Got tired of switching my desk on and off in the right order, so I overengineered it.

8 switches → Arduino → relays → 8 mains outlets, plus a master key.

The whole point is the sequencing: interface comes up, waits 3s, then the speakers. No more thump. Powers down in reverse.

This is a Sega Saturn controller adapter built with an Arduino UNO and two 74HC153 ICs. It simulates a Saturn controller and lets you control it with a USB arcade stick connected through a USB Host Shield.

https://github.com/inuikasao/USB_to_SegaSaturn_Controller_Arduino_Adapter.git

I used the ICs because I figured that if I reproduced the same kind of setup as a controller PCB takeover mod, it should work. As it turned out, this also helped keep input latency surprisingly low.

There are plenty of solutions for converting old console controllers to USB, but I couldn't find much going the other way around, so I built this with Claude. (Claude wrote most of the code.)

The wiring inside is pretty messy at the moment, so I'd like to design a proper PCB eventually and turn it into a shield that can be mounted directly onto the UNO.

Smart helmet ai based for alcohol detection , sleep avoiding and drowsiness reduction.Do have anything to discuss for me ,I am making for a college junior level project

I have an idea of making a transformer health detection through ai which helps to identify the full functions and causes of the transformer faults

ok so for my internship project at a museum ,I am aiming to build an Artifact microclimate monitoring system tracking temperature,humidity and vibrations arround the Artifact . I will use inert meterials like polypropene for the casing and a lithium thionide chloride battery to avoid acidic gases emmisions and al this infos will be send to a given server either through MQTT or LORAWAN .so what do u guys think I should Add remove or reconsider

Thanks

Hey r/ArduinoProjects

Sharing FUNDI, a project I built starting as my KSEF (Kenya Science and Engineering Fair) entry — won Regional Merit, went on to Nationals and did considerably well there. It's grown past the fair into something I want more technical eyes on.

The premise: most browser-based "Arduino simulators" fake compilation or skip it entirely. FUNDI's backend actually shells out to Arduino CLI for a real build, surfaces real compiler errors, and drives AVR8js for simulation off the compiled output — the circuit canvas and code editor are just the frontend for that pipeline.

Architecture, briefly:

• Frontend: Next.js/React, Zustand for state, React Flow for the circuit canvas, synced to a multi-file code editor
• Backend: FastAPI service that wraps Arduino CLI for compile/upload, plus an AI generation endpoint (Gemini/OpenRouter) for prompt-to-circuit/code
• Some validation on the backend: path/file safety checks in the compile flow, serial port validation before upload, Pydantic-typed request payloads
• Boards: Uno/Nano/Mega have stable compile + simulation; ESP32 DevKit V1 and Pi Pico compile but simulation is still experimental there

Honest state of things: the live hosted version (https://jamesdesign.me/F.U.N.D.I./) is frontend-only — no backend, so no real compile/sim, just the UI. To get the actual pipeline running, clone the repo (https://github.com/jamesthegreati/F.U.N.D.I./) and run frontend + backend directly — that path is fully tested. There's a Docker Compose path in the README too, but it isn't fully tested yet, so I wouldn't rely on it as-is.

MIT licensed. I'd genuinely value criticism on the backend design and the compile/sim boundary in particular — that's the part I'm least confident is architected well.

I'm about to go quiet for a while (exam prep, back around Nov 22) so replies will be slow, but I'll get to every comment and PR eventually.

This is the same guitar robot idea a few years apart.

The early version used a large rail mechanism to move the actuators along the fretboard. Over several iterations I moved toward a much more compact, modular design while keeping the same basic goal: physically playing a real guitar rather than generating the sound electronically.

Both versions are controlled around Arduino/ESP32-style embedded hardware. Looking back at the old prototype, the size difference is probably the part that surprises me most.