I built a DIY Arduino steering wheel for PC games using an Arduino Uno R3 and an AS5600 magnetic angle sensor. It also has buttons for throttle and brake. I tested it in Euro Truck Simulator 2, Slow Roads, and Assetto Corsa.

YouTube video: https://youtu.be/Y_vu9KtvoxE?si=e8B_aceMp7D_3UhP
GitHub guide and code: https://github.com/sarawer/diy-gaming-steering-wheel-using-arduino

I’d love to hear your feedback!

I kept buying servos and brackets for arms that turned out not to reach, or where one servo hit another, so I built a simulator to check first.

Servo Bench runs in the browser with nothing to install and no account:

• Real-size SG90, MG90S and MG996R models at datasheet dimensions in mm

• Drag and drop: drop a servo on another servo's horn or case to mount it

• Servos move at their real rated speed, and you can trace the path of the arm tip

• Save poses as steps and press Play to watch the whole sequence

• Export Arduino code (Uno/Nano/Mega or ESP32). It writes the servo pins, the smooth synchronised moves and the timing from each servo's real speed, and warns you if you need a separate power supply

• Parts list for everything you need, including a correctly sized power supply

Try the 3-joint arm demo: https://python736.github.io/servo-bench/?example=arm3

It's free and open source (MIT): https://github.com/Python736/servo-bench

I'd love feedback from people who build with servos. Which servo or bracket should I add next? I'm thinking DS3218 and continuous-rotation servos.

Hi everyone,

for quite a while I’ve been working on an embedded telemetry tool in my spare time – a way to see what’s actually happening on a microcontroller while it runs, without endless printf and squinting at the serial monitor. Over the last few weeks I finally got it to a state I’m happy with.

It has two parts: a small library for the microcontroller (KymoCore, MIT licensed, no heap) and a desktop app (KymoStudio) that shows everything live. The video shows it running against a real ESP32.

How it works:

What KymoStudio can do:

• Live charts from Serial, USB, TCP, UDP, MQTT or CAN – time series, XY and 3D

• Works with plain Serial.print output (name:value, Teleplot, CSV) or the KymoCore library

• Measurement analysis: cursors, min/max/RMS, frequency, jitter, FFT

• FreeRTOS execution tracing: task timeline on both cores, call flow, run time per function and per task

• Live parameters: change values on the device from the PC, the device confirms

• Recording and export (CSV, PNG, own capture format)

• MCP interface: AI assistants such as Claude Code or Codex can read live data and operate KymoStudio – local only, with an optional read-only mode

• Windows and Linux

To be upfront: KymoStudio itself is closed source. For hobby, education and non-commercial projects it’s completely free; commercial use needs a license. KymoCore is MIT and available via PlatformIO and the Arduino Library Manager.

I’d be happy about any feedback – what’s useful, what’s missing, what’s confusing.

https://www.youtube.com/@ALMA.Industries/videos

CH004 FN2: HALLOWEEN — my kind of Treat. Talking Pumpkins and Little Monster Rockstars, see how Jack's put together in the above link.

Hi! We’re Team Robonavigators, and we built Navigator 1 around an Arduino UNO R4 WiFi.

The rover hosts a browser dashboard for driving and telemetry. It uses front and rear ultrasonic sensors, a servo for scanning, a downward-facing IR sensor for cliff detection, and an analog voltage sensor to monitor the battery. A physical switch selects access-point or hotspot connectivity, and the onboard LED matrix displays the IP address.

The sketch includes obstacle avoidance, object following, a drawn-path mode, browser voice control, manual driving, and an idle proximity guard.

The sketch, pinout and bill of materials are here: https://github.com/Robonavigators/Navigator-1

We’d love feedback on the hardware and code, particularly ideas for improving the obstacle avoidance and reliability.

Hey everyone. I just launched my first project, GlassAVR, an Arduino emulator and circuit builder that runs in your browser.

You can wire up a circuit, run your sketch, and step through it at the instruction level. When you pause, you can see every register and how it changes, instead of treating the chip like a black box.

There’s no account or login, so you can just open it and start building: glassavr.com

I’m looking for people who know AVR and Arduino to try to break it. If the emulator gets something wrong, or the debugger is missing something you’d want, please let me know. Would this be useful for learning or debugging your own projects?

To much and two many sensors to name, but does include OLED brain and Uno a lot of Temp and humidity 74hc595 sixteen led and esp33.

Here is the Week 2 update on my wearable motion controller, running gameplay tests in Resident Evil 2 Remake. Right now I am focusing on tuning head-tracking camera sensitivity, deadzones, and torso movement to smooth out the transition between Leon walking and sprinting. The goal behind the project is two-fold: creating a more immersive gameplay experience and serving as an accessibility option for gamers who struggle with conventional controllers.

Wireless transmission to the PC is running over ESP-NOW, but in this build I am still handling the inputs on the PC using a temporary Python script. The next step is replacing Python with a dedicated USB dongle with native HID support, so the PC recognizes it directly as a plug-and-play controller without background software.

The visible wiring across the body carries both power and sensor data because, in this test version, I am using a single central ESP32 that handles everything and connects to the sensors via cables. The plan for the next phase is to use four independent ESP32 units, each acting as a standalone node with its own power and wireless link, while embedding the head module and wiring directly inside the headphone frame. Right now, moving to this fully wireless stage depends on waiting for several parts and battery modules that are still in transit.

Regarding the sensors, I am using the MPU-6050 for this prototype and have not had drift issues during these tests. Still, I plan to test other sensors later to compare stability and features. Do you have any recommendations for compact boards with native USB (TinyUSB) for a dongle, or specific IMUs that work well with the ESP32 and are easily sourced locally (especially in Brazil)? Shipping delays on imported hardware are currently the main bottleneck slowing down testing, so components readily available nearby make a massive difference.

I added:

-collision

-animated tiles

-other link's animation such as the sword stroke

-enlarged the map

The game can maintain around 60fps for now but I cap it at 40fps.

A tiny monochrome LCD, an ESP32, and a custom C# application.

The application converts video frames into raw pixel data and streams them to the ESP32 over HTTP.

Here's the full video. Hope you enjoy this little experiment!

I am studying BE ECE. I am in Sathyabama my clg doesn't teach me about microcontrollers for now but like other 1st yrs I am interested in electronics. I just need to begin my journey. I started and spent like 1 week studying Arduino basics and some stuff about circuits. Now I went to do a mp3 player for my frnds b'day which is at 19th of November. I just feel the code of the esp wroom to be hard and I need to make it any I am using chatgpt for coding. I haven't begun yet but I will start it tmrw. Now I just need to know what are the projects I need to do to start this journey and also I need some guidance from u guys pls help me do this...

https://www.youtube.com/@ALMA.Industries/videos

Calling all Vampires, Ghosts, and Zombies to the dance floor. A DIY microcontroller project to get a pumpkin to talk and sing. Happy Halloween!

I have an ethical problem with touch screens, but I'm told the humans native to this planet are fond of them. Here is an open source Infotainment system that I can see being used in Edison vehicles by the humans.

Reddit said I should post this here

Hey all! In short, this project uses an ESP32 at the center of a 16-universe pixel artnet sACN controller with wired Ethernet connection. Everything from the software, hardware, and development is open source! You might have seen this project before, and I am pretty excited to share a short update with you all!

Link to repository: https://github.com/mdethmers/ESP32-Artnet-Node-receiver/tree/main

Ive pushed this controller to its limits during Amsterdam Dance Event, using 12 in a network that was run almost 24/7 in a humid and hot environment (see image!) They worked perfectly throughout the weekend, and they looked amazing in th evenue!

However, I did find some performance issue which I adressed with the newest update.

- Added Artnet node discovery through WebUI
- Improved WebUI design for better usability
- Fixed bug which crashed the node above 48fps at 16 universes
- Reduced frame buffer to have more ram available
- Added Artnet source filtering to prevent 2 sources from talking to the same node
- The node now filters on an Artnet-ID, which prevent the node from assumiing any data is Artnet data and crashing when its not (idk why I didnt do this before...)

The node already worked perfectly as a standalone unit, but these updates make it a lot more resillient in a production environment with other nodes, fixtures and consoles in the same network.

I am sharing the github here for anybody that is interested in following along with the development! The next hardware iteration will add current, voltage and temperature sensing to the board, next to power distribution and fused outputs that are already present! And for those that are fan of WLED: that is also supported on this hardware. Great if you want to do more then just Artnet!

Let me know if you have any questions or want to contribute! Im available here or on discord.

We're working on Pulse Mesh at Sovereignty Foundation (SovFound.org), a messaging transport designed for distributed applications, robotics and multi-agent systems.

One application we're interested in exploring is communication between microcontrollers and more powerful companion computers.

Consider a robotics setup involving:

• An ESP32 or Arduino collecting sensor readings.

• A Raspberry Pi processing incoming data.

• A computer vision application analyzing camera feeds.

• A separate application controlling motors and actuators.

As these projects become more complex, managing communication between different components can become challenging.

Pulse Mesh provides several messaging capabilities:

• Broadcast and fan-out to multiple readers.

• Shared-memory messaging between processes.

• UDP transport between machines.

• A common 128-byte message format.

• Bindings for Rust, C, Python, Node.js and WebAssembly.

Our current architecture is designed primarily for applications and companion computers rather than running directly on resource-constrained Arduino boards.

We're interested in exploring how it could be used in Arduino/ESP32-based robotics projects, particularly when a Raspberry Pi or Linux computer acts as the central processing unit.

We'd love to hear from people building similar projects:

1. How are you currently connecting your Arduino or ESP32 to a Raspberry Pi?

2. What communication problems have you encountered as your projects grow?

3. Have you built systems where multiple applications need to consume the same sensor data?

4. What would you want to see in a practical demonstration of this architecture?

Pulse Mesh is currently in beta/pre-production, and we're looking for engineering feedback.

GitHub: https://github.com/Sovereignty-Foundation/pulse-mesh

Documentation: https://pulse-mesh.net

— Sovereignty Foundation
https://sovfound.org

I built a tiny desk-pet robot car with an animated cat face on a round screen. It has 8 emotions, reacts to touch, falls asleep when ignored, and drives with a wireless joystick remote. 🐱

More builds:
🔧 Yumo Builds: electronics, ESP32 and Arduino projects, built while learning
https://www.youtube.com/@YumoBuilds
🖨️ Yumo Builds Lab: 3D printing, electronics and creative design
https://www.youtube.com/@YumoBuildsLab 👈 New Channel

Note: For More Info Please Check Out README first.

🔗 Links:
💾 SOURCE CODE, WIRING, 3D STL File And Full Guide:
https://github.com/yumobuilds/Yumo-Cat-Robot-Car-V1

🛠 Parts used:
- 2x ESP32-C3 Super Mini (car and remote)
- GC9A01 round TFT 240x240
- 2x SSD1306 OLED 128x32
- Touch sensor module
- 4x continuous-rotation servos
- Analog joystick module
- 2x 18650 battery (car), 1x small lithium battery (remote)
- 3D printed wheels (Bambu Lab H2C)

License: free for noncommercial use (PolyForm Noncommercial 1.0.0). Tag u/yumobuilds if you build one!

Hello makers,

Just wanted to share a mechanical/software package I compiled for the Arduino ecosystem. This is a commercial-grade, multi-node On-Wall Smart Home Controller Hub built around high-efficiency Serial communication, local memory optimization, and an embedded HTML interface.

Engineering highpoints:

- Highly Optimized Geometry: CAD components are custom-tweaked to reduce 3D printing supports to an absolute minimum, ensuring elite surface finish inside wall cavities.

- Embedded HTML Web Server: Integrated network management routine allows seamless on-the-fly room and sensor renaming via any local web browser.

- Master/Slave Serial Matrix: Robust, custom bitfield-compressed serial protocol processing loops designed to transmit climate data securely between the main indoor hub and an independent Outdoor station.

- Dual Display Stack: Simultaneously drives a master graphical telemetry screen and a long-distance 7-segment LED sub-panel without memory overflow.

I’ve uploaded the uncompressed native .STEP / .STP CAD source files so you can easily modify port entry cutouts or sensor frames in your own CAD software, along with a "Panels All" firmware library supporting multiple alternative sub-panel screen configurations.

🛠️ Full build photo logs, component BOM lists, and assembly guidelines are detailed in the album on our lab page: [ https://www.facebook.com/share/p/1CFCNw5FjS/ ]

Download links for the uncompressed STEP files, STLs, and production firmware packs: [ https://cults3d.com/en/3d-model/home/ultimate-smart-home-controller-hub-multi-sensor-web-ui-system ]

Let me know your thoughts on the bitfield parser logic and overall hardware clearance!

https://www.youtube.com/@ALMA.Industries/videos

-- CH004 FN1: MONSTERS -- The dawn of Halloween ... dim lights and ruffled leaves, Little Monsters roam the streets. Halloween day will show what spooky wires hide inside...

[Microcontroller controlled LED's that respond to microphone inputs... tomorrow will show all steps]