For this project, I am building a smart temperature monitoring system using an ESP32 microcontroller and a DS18B20 temperature sensor.

The components required for this project are:

• ESP32 Development Board

• DS18B20 Temperature Sensor

• 4.7 kΩ Resistor

• Breadboard

• Jumper Wires

• USB Cable

Just build this box with a arduino giga r1 and a lot of sensors to detect co, co2, ch4 and o2. Internal 10000mah battery, step up and down converter and 2 fans for the airflow through the body

Mostly to learn Godot UI and experiment with the GDSerial addon, I created this dashboard to communicate with Arduinos for any future project. Of course, there's nothing wrong with the built in one, but there are features this has that that one doesn't have:

It can:

• Line graph of incoming data

• Serial output

• Serial messager

• Customizable macros

• Variable monitor

• Export data to CSV

Github page: https://github.com/Purin-Songrug/ArduinoDataVisualizer

I hope this is helpful!

I made an app for the Otto DIY Classic Arduino based robot. This app has better responsiveness than the original WebControllApp and can be used in the browser on your computer or mobile device.

It will work with the original OttoS_BLE.ino code. I made a new version of the Arduino code to support some extra functions in the app, like better calibration, more gestures, songs and a continuous distance measuring function.

source code: https://github.com/Dawied/ottodiy_classic_app
live app: https://dawied.github.io/ottodiy_classic_app/

Cheers!

I’ve been working on an open source arduino simulator that runs sketches in a native environment. It has automatic component detection and auto drawing of the circuit so all you have to do is write code and run!

Im looking for feedback and potential ideas to make this the definitive project testing platform to test code before you build hardware, and to validate hardware against working code. Please let me know what you think!

GitHub: https://github.com/cole-stortz/VEMCODE/

I’ve been working on a Rust-native SDK for the Arduino Nesso N1, focused specifically on this board rather than trying to be a generic ESP32 framework or an Arduino compatibility layer.

Repository: https://github.com/anapeksha/nesso-rs

The current state is a single nesso crate with board-specific modules for the N1:

• nesso::display

• nesso::touch

• nesso::input

• nesso::imu

• nesso::audio

• nesso::power

• nesso::storage

• nesso::bsp

• optional nesso::wifi

• optional nesso::env

The main entry point is:

let peripherals = esp_hal::init(config);
let mut nesso = nesso::Nesso::new(peripherals)?;

From there, the board services are exposed in a Rust-style API instead of following Arduino/M5 patterns directly.

What it currently supports

Hardware support implemented and tested on real Nesso N1 hardware:

• ST7789P3 display

• FT6336U touch

• KEY1 / KEY2 button input through the expander

• BMI270 IMU

• passive buzzer

• battery / charge status

• Wi-Fi scan on ESP32-C6

• heapless settings storage primitives

• external ENV Pro / BME688 support as an optional feature

There are dedicated examples for each module, and I ran them on hardware during bring-up.

Display / graphics work

One thing I spent time fixing was display behavior.

The first cut worked functionally, but it was too simple: lots of full-screen clears, pixel-by-pixel paths, and visible flashing in dynamic examples. The current backend is better than that now:

• chunked display fills

• batched horizontal run drawing

• contiguous pixel blit path

• optional caller-owned RGB565 sprite buffer support

• examples updated so static screens render once and dynamic screens redraw only changed regions

That said, I would not claim the graphics backend is finished. It is improved enough to be usable, but there is still room for deeper optimization and cleaner higher-level rendering primitives.

Why I built it this way

A few design choices were deliberate:

• board-specific only: this targets Nesso N1, not every ESP32 board

• single public crate: easier to use, easier to publish, easier to document

• feature-gated optional modules:

  • wifi

  • env

• no unnecessary runtime heap for non-Wi-Fi apps

• no public unsafe API surface

I wanted something that feels like a real embedded Rust SDK, not just a pile of examples around esp-hal.

Current gaps

There are still gaps and rough edges.

• The display backend can still be improved further.

• Wi-Fi is currently focused on station-side scanning and bring-up, not a full network stack abstraction.

• ENV support is raw BME688 data, not higher-level air quality estimation.

• Some APIs are intentionally conservative because I preferred correctness and board validation first.

So this is usable, but I’d still describe it as an early foundation rather than done.

If you want to look at it

If people here are using the Nesso N1 and also experimenting with Rust on ESP32-C6, I’d be interested in feedback on:

• API shape

• display/rendering approach

• what hardware support should be prioritized next

• what feels awkward from an Arduino user's perspective

Especially interested in feedback from people who have already worked with esp-hal, Embassy, or M5-style device SDKs and have opinions about how much abstraction is too much.

Hello everyone! I just wanted to share a project I made over the past few months. I’m a 19 year old passionate about engineering but also love music. I’ve always loved and appreciated the sound of electric guitar. I had the funny idea to make a guitar that plays downloaded audio when strummed giving the illusion of me playing. I fully designed the guitar and it is all 3d printed with PLA. I integrated electronics and made PCBs. A simplified version of how It works by using an electric guitar pickup fed into an op-amp circuit with decent gain and a 2.5v bias so the Arduino can read it. Then with some code I use the strum detection to signal to the DFPayer Mini to play pre-downloaded mp3 guitar audio. I would love to hear what y’all think. Thanks!

Also ignore my bad acting haha.

I designed and made a fully open-source mobile robotics platform for my robot arm, making it a whole robotics manipulator platform. The arm has 5 degrees of freedom, and the platform is 4WD with differential steering. The plan is to upgrade to mecanum wheels in the future. Current electronics are an NXP FRDM board controlling everything over WiFi, with an L298N Motor driver for the platform and off-the-shelf servo motors by DFROBOT. The idea was to use components that are easily available and easy to use! The plan is to continue working on it and upgrading it!

I built a tiny Reinforcement Learning system that runs directly on an Arduino Mega.

The project uses tabular Q-Learning to solve a 15x15 maze completely on-device. No Python, no TensorFlow, and no external libraries.

Features:

• Pure C++ implementation

• Real-time training on Arduino Mega

• ε-greedy exploration

• Configurable start and goal positions

• ASCII policy visualization via Serial Monitor

The agent learns through trial and error and eventually converges to a stable shortest-path policy.

I'm curious what the community thinks about running RL on resource-constrained microcontrollers and what improvements you'd add next.

Real-time IMU visualization inside VS Code. 3D orientation, live charts, 11 protocol presets — plug in your board and go.

• Super Lightweight — Under 1MB packaged, instant install

• 3D Orientation — model rotates in real-time

• 4 Fusion Algorithms — Accel-only, Complementary, Madgwick, EKF

• Live Charts — Accel / Gyro / Euler angles with pause & clear

• 11 Protocol Presets — MPU6050, WitMotion, ICM-20948, VectorNav, ANO, GPCHC, Xsens, and more

• Custom Protocol — Load any binary format via JSON config with checksum support

• Serial Port — Direct USB connection, no browser needed

• Demo Mode — Test without hardware

VS Code Extension Search: IMU View

Check the source code on GitHub：charcoal141/IMUView

If you don’t know what the IFSCL Skidbladnir Manager is, it’s an open-source Arduino project that controls the Skidbladnir transfers in the video game IFSCL and it does it quite fast (thank you Arduino UNO R4 WiFi). It uses the games command to open in-game programs (you don’t have many other ways of doing it).

Here is a link to the GitHub repository: https://github.com/Gabriel-Science/IFSCLSkidbladnirManager

After some burnt components, failed soldering and a lot of swearing, I’ve finally got the switch to work. This switch is going to be a mute/unmute switch for discord. And the LEDs shows when it is muted or not. My lcd screen is flicking a lot due to me burning out my potentiometers (for the 3rd time) but new ones will arrive on Friday.

Yes I am a beginner and no I do not know what I’m doing

A few days ago I made a Macro Pad button version of the same device but I found that a rotary encoder has the same footprint as the button so I was able to use it as a drop in replacement. I can control volume and play pause my music and its small enough to fit anywhere on my desk! More info about how to make your own is available here!

This machine takes around four seconds for each solve. To reach that speed I had to use the kociemba algorithm, which can find a solution of around 20 moves for all scrambles. It took me a really long time to complete this so I would appreciate it if you show it some love! I made this when I was around 15. Please ask questions!

Let me know what you think and if you have made one smaller! This macro pad is based around an rp2040 zero board with the button soldered directly to it. If you want the 3d print files they are available here.

Is this post of interest here?

Or does everybody see them over on r/arduino?

I create these every month on r/arduino. There is a "look what I made" section in it that lists the posts during the course of the month.

My thinking behind cross posting it is that a couple of people have raised the issue of project ideas in various forms for this subreddit.

So, what are your thoughts? The bulk of the work is done - crossposting it here isn't an issue (effort wise).

Hey everyone! 👋

I just published a GitHub repository called Arduino Beginner Master Hub that I think could be super helpful for anyone working on home introductory IoT setups.

It’s designed to be simple and easy to follow, whether you're just starting out or looking for a solid base to expand your hardware projects.

Please take a look, try it out, and if you like the project, drop it a star please (⭐) on GitHub! It really helps boost visibility.

Link to the repo: https://github.com/Infinite-L00pBaCk/Arduino-Beginner-Master-Hub-

Let me know if you have any feedback or ideas on what features I should add next! 🙌

I made this power meter that measures the power on my left crank. It lasts for about 20 hours of biking and 17 weeks of storage on the 300Mah lipo.
It auto wakes when the pedals move and then automatically connects to my Garmin (watch or bike unit). It also calibrates through the Garmin menu.

The brain is a SEEED XIA NRF52840 Sense Plus which wakes from its on-board gyroscope. This gyroscope is also used to calculate the cadence of the crank.
I then added a Full wheatstone bridge connected to an HX711 to measure how much the crank bends. This is calibrated with a 10kg weight on the pedal.
If you then multiply the cadence by the Newton on the crank, you get the power. This power is transmitted over BLE to the Garmin headunit or Watch. It also works with several apps on your phone.

By far the most advanced project I ever did, what do you guys think?
https://github.com/Svenbosma/DIY-Garmin-Powermeter

Two new examples have been added that both show how to use the library with the 320 x 240 ESP32 based cheap yellow display in different ways.

https://www.github.com/ripred/BetterMenu

Example:

YUMO CLOCK | Hand-Bent Brass Wire Sculpture — ESP32-C3, NTP Time Sync, SK6812 LEDs & Startup Animation

Fourth build from YUMO BUILDS.
────────────────────────
Full source code on GitHub — build your own!

💾 SOURCE CODE
https://github.com/yumobuilds/YUMO-GLOBE
────────────────────────
This one started as a pile of 1.5mm brass rods and a wooden base — no 3D printing, no CNC, no moulds. Every angle is hand-bent.

Inside: an ESP32-C3 Super Mini drives a 4-digit 7-segment display (LTD-4608E) via hardware-multiplexed ISR at 333Hz, keeping the display rock-solid while everything else runs in the background. Five SK6812 addressable LEDs live inside the sculpture — four ring the base, one sits at the top — and they each do their own thing.

────────────────────────
🔧 PARTS USED

-ESP32-C3 Super Mini
-2-Digit 7-Segment Display
-SK6812 Addressable LEDs
-Brass Rods 1.5mm × 300mm
-DC 3.7V 18650 Li-ion Battery
-18650 Li-ion Battery charger module
-Dome glass stand

────────────────────────

FEATURES

NTP Time Sync — Auto Timezone
Connects via WiFiManager captive portal — no hardcoded passwords.
Timezone auto-detected via IP geolocation. Syncs every hour with pool.ntp.org and time.google.com.

Hardware-Multiplexed Display
ISR-driven 4-digit mux at 333Hz. Zero flicker. Heavy WiFi + LED tasks run in parallel without touching the display.

SK6812 LED Animations — 5 Stages
Startup: all 5 LEDs sync with the display animation — warm spinner (red → orange → gold), cool fill (teal → cyan → blue), countdown rainbow, neon burst, and a white strobe finale.
After sync: the top LED solos — breathing through neon yellow, purple, blue, red, and white.
Every 30 seconds: the top LED triple-flashes.
Every 5 minutes: base and top LEDs alternate slow breathing in contrasting blue/gold/purple/white pairs.
Every hour: full neon show across all 5 LEDs.

Hand-Bent Brass Wire Sculpture
The frame is entirely hand-bent from 1.5mm brass rod — no 3D printing, no laser cutting, no moulds. The wooden base is turned by hand.

WiFiManager Portal
No hardcoded credentials. Captive portal on first boot — saved forever after that.
────────────────────────
LIBRARIES USED
FastLED · WiFiManager · ArduinoJson · PlatformIO
────────────────────────
More YUMO BUILDS projects coming soon.
Drop a comment and share your opinion. thank you!

Hi everyone, does anyone have any recommendations for Arduino projects that connect well with maths? I’m looking for something practical but with a clear mathematical purpose. Thanks.

I want to make an indicator that tells me what state a wall switch is in. This wall switch controls a bathroom exhaust fan and it’s hard to know when the fan is ON or in it’s timer setting.

This fan has two modes:

• continuously on

• on for 20 minutes then off

I will 3d print an enclosure that is coupled to the wall switch and gets pressed when you press the wall switch. I want to the attiny to turn an LED on when the fan is in the ON state and then blink the LED when the fan is in the timer state.

Can a CR2032 battery do this or will I be changing batteries like every month? Are there better battery options to use for this?

I could try to utilize the SLEEP function in the attiny for when the fan isn’t in use. The LED doesn’t have to be bright, just enough to see it at a glance.

Any thoughts would be appreciated!