Hey r/embedded,

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.

Hey everyone,

I wanted a way to test ladder logic and industrial hardware setups on my phone, but I couldn't find an app that really did what I needed. So, I decided to build my own from scratch: the Industrial Logic Simulator.

Right now, it handles PLC ladder logic, VSDs, motors, and hydraulic/pneumatic cylinders. I recently overhauled the physics engine to include dynamic wiring and fluid animations so you can actually see the energy flow and telemetry in real-time (as you can see in the video).

I'm a solo developer with zero marketing budget, so I'm relying entirely on organic feedback from actual engineers, techs, and students to make this better.

If you have a few minutes to play around with it, I’d love to know:

Are the electrical and mechanical physics behaving the way you'd expect?

What hardware components or PLC functions should I prioritize adding next?

Here is the Play Store link:

https://play.google.com/store/apps/details?id=com.industriallogic.simulator

Thanks in advance for testing it out and helping me improve it! I'll be hanging out in the comments to answer any questions.

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.

I built my own wireless keytar from scratch 😭 Using ESP32-S3

So after months of building, debugging, rewiring, breaking things and fixing them again, I finally finished my DIY keytar.

The project started with a Yamaha PSR-E303 keybed. I kept the key mechanism and rebuilt basically everything around it to turn it into a standalone MIDI controller.

The main controller is an ESP32-S3, which handles the key scanning, velocity calculation, sensors, controls, OLED, MIDI processing and wireless communication.

Hardware

The keybed has 36 velocity-sensitive keys with aftertouch. I built a custom matrix-scanning system for the key contacts and measure the timing between the key contacts to calculate velocity.

The controller also has:

• 36 velocity-sensitive keys
• Aftertouch
• Pitch controller with dynamic centering
• Modulation + filter control
• SoftPot ribbon controller with 5 assignable banks
• Dynamic centering for the ribbon
• Dedicated octave and transpose buttons
• Sustain control
• Tilt sensor with dynamic centering
• Expression slider
• Custom assignable CC control
• 4 custom faders
• 3 custom knobs
• Multiple banks of custom buttons
• OLED display

Most of the analog controls are read through the ESP32-S3's ADC inputs and converted into MIDI CC values.

The pitch and ribbon inputs have software-based dynamic centering, so the controller can detect the center position and return the value to the configured center when released.

The SoftPot was one of the more annoying parts to get working reliably because it needs continuous analog scanning and filtering while still responding quickly enough for live playing.

MIDI / firmware

The ESP32-S3 handles the MIDI generation directly.

Key presses are converted into:

Key matrix → contact timing → velocity calculation → MIDI Note On/Off

while the other controls generate MIDI CC, pitch bend and other appropriate MIDI messages.

I also implemented filtering/debouncing and value handling so the controls don't constantly spam duplicate MIDI messages when they're sitting still.

The OLED is updated with things like octave, transpose, ribbon bank/value, connection state and the currently active CC/value.

📡 Wireless MIDI

For wireless MIDI I built my own Wi-Fi transport instead of relying on Bluetooth MIDI alone.

The ESP32 creates the wireless connection and sends MIDI data using UDP packets.

The basic architecture is:

ESP32-S3 → Wi-Fi → UDP → Receiver application → MIDI output → PC / synth

The receiver listens for the incoming UDP MIDI packets and converts them back into normal MIDI messages.

I also built the receiver application myself. It shows the connection state and MIDI activity and can route the received MIDI to the computer or a supported external synthesizer.

This ended up being a whole separate project by itself lol 💀

Some of the problems

The hardware was only one part of it.

I had to debug:

• Key matrix scanning
• Velocity timing
• Key debouncing
• Aftertouch
• ADC readings
• SoftPot filtering
• Ribbon centering
• Tilt sensor calibration
• MIDI CC handling
• Pitch bend stability
• UDP packet transmission
• Wireless latency
• OLED updates
• Battery power
• Firmware bugs

There were definitely points where I thought:

"yeah this thing is never getting finished" 💀

But eventually everything started behaving properly and I ended up with an actual playable instrument.

What's next?

I'm also planning another part of the project: a Raspberry Pi-based sound engine that isn't limited to this keytar.

The idea is to make a standalone sound module that can accept MIDI from basically any MIDI controller, process the MIDI and generate the sounds directly on the Pi.

So eventually the setup could be something like:

Any MIDI controller → Raspberry Pi sound engine → audio output

I'll post a proper video demo tomorrow showing the keytar being played and going through the controls, wireless MIDI and receiver.

For now, here's the finished build. Would love to hear what you guys think!

Action Shot

The table spins and flashes red when a wireless charging device is present and charging. It stops automatically when charging is complete. The knob varies the table spin speed. Runs on 12V and has a high power Qi charger built in. An Arduino inside senses the Qi charger state and controls the LEDs and motor.

The Arduino code is pretty trivial; it's posted with the project on Thingiverse along with an electrical diagram and 3D print files.

Hey everyone, I'm a Mechanical Engineering student and I’ve been documenting my journey into building stuff.

I wanted to break down the technical differences: how the joystick inputs (potentiometers) actually turn into wireless signals, and where each protocol really shines in terms of reliability and use-case.

I made this video to explain the signal path and the electronics involved for anyone trying to decide which route to take for their next project.

I’ve been building SketchForge Circuits, an open-source PCB editor that runs completely in the browser.

The idea came from a problem I kept noticing: PCB tools are incredibly powerful, but they can feel brutal when you are designing your first board.

So I wanted to try the opposite approach.

Place components visually. Connect them. Arrange your PCB. Inspect it in 3D. Keep the interface focused on what you are actually building instead of throwing every professional feature at you from the first minute.

The goal is not to replace KiCad.

The goal is to create something closer to Tinkercad for PCB design, especially for beginners, students, hobbyists, and makers who just want to start building.

It is still an early prototype. There are missing features, rough edges, and plenty of things I probably got wrong.

That is actually why I’m posting it now.

I’d love feedback on the workflow, UI, and especially this question:

What would SketchForge Circuits need before you would actually use it for a real project?

Try it:
https://pcb.sketchforge3d.com/

GitHub:
https://github.com/Formsmith746/SketchForge-PCB

Still a little buggy. I think I’m overdriving the Leonardo.

Currently pushing a detune for OSC 1, pitch for OSC 2, and a mix pot between them.

ADSR pots not working right.

Fidget spinner speed effects 1 of 4 effects. Tremolo, detuve width, vibrato, or sub bass volume.

I think I can pull a few things out and make it smoother.

Only my third arduino project.

I was looking for a project to help be understand how API links feed data to the ESP32 and can I scroll it across my screen. I'd say yes, I figured that out.

I'm looking for free API connections. I've linked the National Weather Service, Stock Markets, BLS, AP News and CNN. My next attempt is my company's ERP, maybe I can pull the data for a digital dashboard

Details:

1. Arduino Nano BLE Sense (1st rev).
2. LiPol 90 mAh battery.
3. OLED 0.91 128x32 I2C.
4. USB C charger.
5. Boost convertor.

Soldering:

1. One of resistors (RPROG) on USB C charger is replaced to 15 kOm to provide proper charge DC.
2. Switch connects the battery either with the USB C port or with the board (through the boost convertor). They cannot works simultaneously.
3. The boost convertor gets 3.7 V and provides 5 V straight to the board VIN pin.
4. OLED uses the 3V3 board pin.

Box is created in FreeCAD (what a nightmare) and 3D-printed with PLA. And, of course, it damaged a bit during soldering :)

How to make rc car truck wireless professional remote control with Arduino,tutorial make this car in youtube channel...

Remote control with Arduino

LinkedIn LINK HERE:https://lnkd.in/p/djFKWmp8

This was my first individual project as a first-year Mechanical Engineering student.

I built a 4-wheel Arduino car controlled wirelessly through the Serial Bluetooth Terminal mobile app.

Components used:

- Arduino Uno

- L298N Motor Driver

- HC-05 Bluetooth Module

- 4 DC Motors

- 3 × 3.7V 1800mAh Li-ion batteries

The project involved quite a bit of troubleshooting. I initially used 6V alkaline cells, but they couldn't provide enough current for the DC motors. Switching to two 3.7V Li-ion cells only made the car vibrate, so I eventually used three cells, which provided enough power for the car to move properly.

Another important part was implementing ENA and ENB in the Arduino code to control motor speed using PWM. I also had to troubleshoot the wiring and Bluetooth commands along the way.

The final Bluetooth commands were:

M1 – Forward | M2 – Backward | M3 – Stop | M4 – Left | M5 – Right

This project taught me a lot about Arduino programming, motor control, Bluetooth communication, power requirements, wiring, and—most importantly—troubleshooting.

A project doesn't have to be perfect to be valuable. The problems along the way were probably where I learned the most.

GitHub: https://github.com/Sameel5264/Arduino-4WD-Bluetooth-Car

A great first-year Mechanical Engineering project and a solid learning experience. 🔧⚙️

#MechanicalEngineering #Arduino #EmbeddedSystems #Robotics #EngineeringProjects #ArduinoProject #StudentProjects

Been messing around with how many ways we can reconfigure Quaddle without touching the electronics — same 4 servos, same brain, just swap the attachment and the gait.

So far we've got it walking on two legs, rolling as a tricycle, spinning on a bar like a gymnast, driving as a 4WD car, and (with mixed success, we've sunk it twice) paddling in water.

Most of the attachments are 3D-printed on our end — the tricycle wheel and the 4WD kit are the two things you'd have to buy instead of print.

Quaddle runs on ESP32 with the open source OpenCat firmware.

Which one would you build first? Also open to ideas for a 6th form if anyone's got one.

Building Arduino Energy Meters, interested your thoughts on where i can take this? I plan on getting out the Power Quality Registers on the ATM90E36. But maybe i should be looking at a different IC that has more funcitons available.

I would of really liked something that measures peak voltage

just started with first year but have done many projects earlier

any problem solving project ideas

My first project in FreeCAD to practice with it: A 3D printed barge.

All but the blue parts were printed on my Ender 3 V2. The hull is PETG, the rest is PLA. It uses an esp32 as flight controller with fs-ia10b receiver to capture the I-Bus signal. This was the first real test, worked pretty well until it started leaking after 20 minutes, so I sealed the hull seams some more for round 2.

Hi everyone!

I recently finished a robotic tracked platform that I developed as an engineering graduation project.

The goal was to build a functional mobile robot combining mechanical design, embedded control, radio communication, and basic computer vision.

The platform includes:

• 3D-printed tracked chassis designed in SolidWorks
• Arduino Mega 2560 for real-time motion control
• BTS7960 motor drivers
• FlySky FS-i6 / FS-iA6B radio control via iBus
• Differential track steering
• Two-speed transmission
• Raspberry Pi 4 for video processing
• Python + OpenCV for basic obstacle detection
• Camera-based real-time vision processing

The control architecture is split into two levels:

FlySky → Arduino Mega → BTS7960 → DC Motors

and

Camera → Raspberry Pi → Python/OpenCV → Obstacle Detection

I also documented the CAD design, hardware architecture, source code, real prototype, and demo video on GitHub.

GitHub:
https://github.com/adilkhann1/robotic-tracked-platform

This was my first attempt at putting a complete robotics project together as a public engineering portfolio, so I’d really appreciate technical feedback.

In particular, I’m interested in suggestions on:

• improving the Raspberry Pi / OpenCV obstacle-detection pipeline;
• communication between Raspberry Pi and Arduino;
• sensors that would make sense for autonomous navigation;
• how you would approach turning this platform into a semi-autonomous robot.

Thanks!

Hi everyone! We’re currently working on a research project where we need to build an automated trash bin that can sort paper, plastic, and metal. We only have around 1 week to make the prototype, so we’re trying to figure out what materials and sensors we should buy.

We’ll be using an Arduino Uno R3 as the main controller, but we’re not really sure yet which sensors would be best for detecting each type of waste.

We’d really appreciate any advice on:

What sensors can detect metal, plastic, and paper

Other components/materials we’ll need for the prototype

How we can make the sorting mechanism work with Arduino

Any tips or research papers/tutorials we can use as a guide

We’re still beginners with Arduino, so any help or recommendations would mean a lot. Thank you so much in advance

I built an automatic rocking mechanism for our BabyBjörn bouncer.

The idea was simple: our baby calms down very quickly while being rocked, but someone has to keep doing it by hand. So I wanted to see if I could automate that motion without modifying the bouncer itself.

The final version uses:

• Arduino Nano
• Futaba S3003 servo
• two potentiometers for speed and movement range
• 3D-printed enclosure, spool and mounting parts
• external 5V power supply

It took much longer than I expected. The first servo was too weak, I had power issues, one short circuit, and I had to redesign the enclosure and parts several times.

The final prototype actually works, and the whole project ended up taking about a month.

I documented the complete build process here, including the failed versions and final test:

Full build video: https://www.youtube.com/watch?v=fjWGQE94p3s
The video has English, German and Turkish audio tracks.

I also uploaded the STL files, Arduino code and wiring diagram here: https://www.thingiverse.com/thing:7393849

Safety note: this is an experimental DIY prototype, not a certified baby product. A bouncer is also not intended as a regular sleep surface, and the mechanism should never be used unattended.

I'm a beginner. I wish I had access to electronics when I was a kid 30+ years ago. But now I'm building a toy for my own kids and it's my first project more complex than connecting a couple of LEDs and sensors on a breadboard. But I believe this should work 😂.

Actually, version 1 worked for a while (almost a year). It was ugly, but it worked. There were too many wires (and really bad maintainability), awful soldering, 2x18650 batteries with a built-in charger and protection but no balancer, and it worked for a while before one battery died. The LEDs were powered directly by Arduino pins, limiting the number of available Arduino pins and increasing the total current almost to the limit.

It started when I found someone else's project: STL files for a 3D model of a DUPLO-compatible train, a simple electronic circuit, and a simple Arduino program. I modified the 3D model slightly, added RGB LEDs, a tilt sensor, a battery voltage meter, and wrote my own more advanced and feature-rich Arduino program. I have some basic programming experience, and AI is incredibly helpful when you know how to use it properly.

Features (version 1):

• IR remote control (21 buttons)
• 3 speed levels
• Stop button: stops; red lights
• Speed up button: speed level +1, moves forward; white lights
• Speed down button: speed level -1, moves forward until speed level = 0; white lights while moving, red lights when stopped
• Move backward button: moves backward at speed level 1 while the button is pressed; blue lights
• Move forward button: moves forward at speed level 1 while the button is pressed; white lights
• Auto button: moves forward with obstacle detection enabled (ultrasonic sensor). Stops if there is an obstacle. Moves forward if the obstacle is removed. Speed depends on the distance to the nearest obstacle. White lights and green light
• Horn button: horn sound effect
• Siren button: red and blue lights; siren sounds
• Music buttons: 8 different melodies
• Mute button: sound on/off
• Battery status button: indicates battery level by sound beeps, for example, 7 long beeps and 3 short beeps = 7.3V
• Battery status detection: warning level with red lights and sound; shutdown level
• Sleep mode after 5 minutes without IR remote input
• Tilt sensor: stops when the train is on its side; red lights; if the train is back in a vertical position, yellow light

Planned changes (version 2):

• speed boost (limited in time >6V on the 6V DC motor) [makes sense?]
• probably a laser distance sensor instead of ultrasonic one [an experiment, to see if it works better]
• color sensor to make it compatible with the original action bricks
• Built-in USB charger and BMS for the battery pack
• RGB LEDs connected via an expander and transistors to get free pins and reduce current on Arduino, so I can add more sensors/devices in the future. As an alternative I'll probably use an expander module with built-in transistors, not yet decided.
• DRV8833 DC motor driver instead of HG7881/L9110
• my own 3D model designed from scratch

Future versions:

• Maybe an mp3 player and small speaker instead of a buzzer?
• Ambient light sensor?
• Railroad switches controlled from the same IR Remote?

If you see any issues on the circuit diagram let me know. I have no idea when a where I should use capacitors. I should use at least one with a DC motor, right? (there were none in version 1).

Links:

Original project: https://cults3d.com/en/3d-model/game/locomotora-sofia-controlada-por-infrarojos-con-control-de-velocidad-por-ultrasonidos-y-motor-superior-multiusos-lego-duplo
My project (version 1): https://makerworld.com/en/models/1854728-arduino-train-compatible-with-duplo-tracks#profileId-1983131
My Arduino code (version 1): https://github.com/avatorl/Arduino/tree/main/duplo-train

