We make simple custom 3D designs for individuals who want to change their imagination into reality.

DM to connect with us

Note:- price may vary as per your design

Hello guys! I built PiezoPlay, a beginner-friendly tool for turning music files into editable notes and Arduino tone() code.

It supports MP3, MIDI, and MusicXML. It’s meant to help people make a piezo buzzer play a tune without hand-entering every note. MIDI and MusicXML works best.

Piezo buzzers are usually monophonic with tone(), so complex songs with multiple instruments may not convert cleanly. A clear melody should work best.

• Try it here: MP3 to Arduino Tone Editor

• Tested with: [Gizduino(clone), buzzer, and Arduino IDE 1.8.19 (Windows Store build 1.8.57.0).]

• github respiratory: PiezoPlay: Turn MP3, MIDI, and MusicXML into Arduino buzzer tones.

• Exe file if need: https://archive.org/details/piezo-play_202611

I made this project back in college in 2022. Never really showed it to anyone. It was more of a challenge I had set for myself.

Although I wanted to present it, my college made it clear that a project like this couldn't be showcased because it had "no practical usage". On the other hand, they approved some basic RC car in the name of surveillance applications. Anyway, that's a story for another day. : )

The project took around a month to complete, covering everything from electronics, circuit layout and component selection to designing the CAD files, and coding the games and menu system.

I packed it with three games: Pong, Snake, and Space Invaders (my favourite!). The coding was one hell of a challenge back then, especially since there was no AI assistance (at least, I wasn't aware of it before the ChatGPT boom). I eventually maxed out the Arduino Nano's memory, but managed to get everything working!

Some features I implemented:

1. Adjustable screen brightness.

2. Volume control.

3. Game speed adjustment (to make things more difficult).

4. Battery level indicator (a rather crude implementation, and I doubt it works exactly as intended).

5. And a USB-C charging for the two li-ion batteries.

Anyways, just wanted to share this little project with you guys, as I never really got the chance to share it with anyone.

Now that I'm a working professional (and not in the electronics field anymore 🙃), I'm planning to take on another, more advanced project as a hobby build. Maybe a better Game Boy or something entirely different.

Back then, I struggled to find similar projects with shared code and build details, so I thought I'd share mine. Maybe it'll help someone out there!

I really want to tinker around Arduino and electronics. Love the community ✨

(Used AI to proof write : D)

Cover the LDR and the LED comes on. LDR + 10 kΩ divider on GPIO 34 (ADC1) → 0..4095; on ≤ 1500, off ≥ 1800 so it does not flicker. Any browser on the same Wi-Fi shows the live ADC reading.

Hardware: ESP32 DevKit, LDR, 10 kΩ, LED + 220 Ω.

Wiring

- 3V3 → LDR → mid (GPIO 34) → 10 kΩ → GND

- GPIO 26 → 220 Ω → LED → GND

Happy to share the sketch. Short: https://www.youtube.com/shorts/hhStUogMQPU

Code: https://github.com/NirajBhattarai/500IOTProject/tree/main/day-006/night-light

Same Wi-Fi doorbell hardware as before: one tactile button, one piezo, a page on any browser (phone, PC, or tablet) on the LAN.

New idea: time how long a clean (debounced) press lasts with millis(). Let go before 1 second = tap (ring). Still holding at 1 second = hold (reset count to 0).

Hardware

- ESP32 DevKit (30-pin)

- 6 mm tactile push button

- Passive piezo buzzer

- 4 jumpers + breadboard

Wiring

- GPIO33 → button → GND (INPUT_PULLUP)

- GPIO25 → piezo → GND

How it works

1. Debounce as usual (50 ms quiet window)

2. On clean press, start a stopwatch

3. Release before 1 s → tap / ding / ring++

4. Still down at 1 s → hold fires immediately, count resets

Happy to share the sketch if useful. Short walkthrough: https://www.youtube.com/shorts/bzs_N4e8Wxw

Hey everyone, wanted to share a library project I finished up and finally got merged into the official Arduino IDE Library Manager this week (search "NLTP" in Manage Libraries).

The whole thing started because I was sending 4 KB to 16 KB sensor batches between an ESP32 dev board and an old NodeMCU ESP8266 across a noisy 2.4 GHz floor. Raw ESP-NOW v1 maxes out at 250 bytes per frame, so a 10 KB log turns into 40+ packets. Whenever Wi-Fi interference knocked out two or three packets, the whole transfer was toast. Switching to Wi-Fi TCP fixed the corruption, but every random RF fade caused TCP retransmit backoff to freeze everything for several seconds, including urgent stop commands.

So I wrote NLTP in plain C99 with static arrays (no malloc or heap fragmentation, no floats). Before slicing a buffer into 250-byte ESP-NOW frames, it compresses repetitive JSON/CSV text with a small LZ4 pass, encrypts each frame with ChaCha20-Poly1305 after an X25519 handshake, and tacks on extra parity shards using GF(2⁸⁾ Cauchy erasure coding. As long as any k shards make it across the air, the receiver rebuilds the missing packets on the fly without asking for a retransmit. There is also a separate 1-packet reflex message type so urgent commands bypass the bulk transfer queue.

For small boards like the ESP8266, defining NLTP_TX_ONLY before including the header drops the peer struct down to 4,760 bytes of RAM (full bidirectional mode is 22,872 bytes). I also wrote a matching Python package (pynltp) so a Raspberry Pi or laptop gateway can decode the radio packets and forward them straight to MQTT or disk.

Repo with 7 example .ino sketches and the bench test scripts is here (MIT licensed):

https://github.com/indian-aman/NLTP-Arduino

If anyone tries it on RP2040 W, STM32 + Wi-Fi, or long-range ESP-NOW LR mode, I would love to hear how it behaves on your setup.

Sharing an open-source (MIT) side project I just updated to v3.0.0: NeckLink, a set of five fixed-point ANSI C99 and Arduino/ESP32 libraries that run ~33,000 synaptic weights extracted from the adult fruit-fly connectome (BANC v888, 157,789 neurons) inside 24 KB of static RAM, paired with NLTP for lossy ESP-NOW / UDP telemetry.

You can try the compiled C99 core live in your browser (compiled to a 107.5 KB WebAssembly module, with optional webcam input to test the optic-lobe collision neurons):

https://indian-aman.github.io/necklink/

What is in the repo (packages/*/arduino/):

• NeckLinkCNS: 4-organ reflex controller + MAVLink v2 output in 24,024 bytes of zero-float C99 RAM.

• NeckCompass: 9-axis ring-attractor compass and GPS-denied homing (352 bytes base RAM).

• NeckSight: 32x32 looming obstacle detector (LPLC2 + LC4 cells) with integer gyro derotation (14.3 KB RAM).

• NeckCord: 6-leg hexapod gait coupling + 18-servo integer IK + rotor/thruster fault allocator (< 1 KB base RAM).

• NeckSense: mushroom-body sparse integer novelty detector (< 6 KB RAM in tiny mode).

For v3.0.0 we also tested all 39 biological weight tables against 100 degree-preserving rewired connectomes and standard engineering baselines (EKF, SVM, optical flow). Specific fly wiring makes a huge difference on compass homing (100% arrival vs 4.7% shuffled) and emergent tripod gait (0.855 vs 0.411 shuffled), ties random sparse wiring on gas novelty detection, and still trails symmetric engineering baselines when you need zero biological drift (so both weight modes are included). Right now the connectome controllers are research-beta (compiled for esp32dev and tested in MuJoCo / WASM simulation; physical robot bench testing is next).

Full source, Arduino libraries, and Python (pip install necklink) packages:

https://github.com/indian-aman/necklink

Talki #Arduino Library makes you record your voice. I used this library to record my voice and used it with projects.

Built a local Wi-Fi doorbell on an ESP32: press a tactile button, a piezo dings, and a page on any browser (phone, PC, or tablet) on the same LAN counts the ring.

First version counted four rings for one press — classic button bounce. Fix: debounce with a 50 ms quiet window before trusting the new level.

Hardware

- ESP32 DevKit (30-pin)

- 6 mm tactile push button

- Passive piezo buzzer

- 4 jumpers + breadboard

Wiring

- GPIO33 → button → GND (INPUT_PULLUP)

- GPIO25 → piezo → GND

How it works

1. ESP32 joins Wi-Fi and hosts a tiny HTML page

2. Every pin change restarts a 50 ms timer

3. Only a level that holds still that long counts as a press

4. On press: tone() ding + ring counter updates; page refreshes every 2 s

Happy to share the sketch if useful. Short walkthrough: https://www.youtube.com/shorts/dRv68Y1i5f0

Im making a vide demo as we speak

Heres a breakdown

1st Slider : Controls de root of the sequence

2 nd Slider : Amount of detune

3 rd Slider : The clock so te notes are played longer also attached to de attack and release.

1st button : Changes between 12 modal scales , this scales where definied by the compositions made in brian enos albums airports , discreete music , has scales based on boards of canada , caterina barbieri , william basinski etc.

2nd button : extends the range of the root pushing the notes to more subharmonics.

3rd Buttom : adds a humanize feat that makes the clock attack and release being a little more out of the clock more randomly

The switch changes wich type of transistor is filtering the audio , one sounds crystal clear and the other gives sort of tape saturation.

Ill post the video as soon as finished.

Planning on selling a couple but also opensourcing it.

I struggle with time since i have to work normal job to pay the cost of living so bear with me

Day-2 follow-up after a simple LED web-toggle — added a sensor.

Goal: read real room temperature on my phone with zero apps/accounts.

Hardware

• ESP32 DevKit (Arduino-ESP32 core)

• DHT22

• Breadboard + 3 jumpers

Wiring

• 3V3 → VCC

• GND → GND

• GPIO27 → DATA (with the usual pull-up if your module needs it)

Firmware idea

• WiFi STA join

• Poll DHT22 every ~2s

• Built-in WebServer.h serves a tiny HTML page that auto-refreshes

• Phone on the same SSID opens the board IP

Why this stack: DHT library + WebServer is enough for a one-sensor LAN readout before jumping to MQTT/ESPHome/HA.

Happy to paste the full sketch here. I also recorded a 60s walkthrough if anyone wants the link.

I put 16 led on breadboard with two 74hc595 16 resistors to light the board led is a great way to learn the board circuits at present it is showing a void loop and functions.

Built a small LAN dashboard with an ESP32 and a DHT22.

Any device with a web browser on the same Wi-Fi (phone, computer, or tablet) can open the board’s IP and see live °C + humidity. No app and no cloud — the ESP32 is the web server.

Hardware: ESP32 DevKit, DHT22, 3 jumpers

Wiring: 3V3→VCC, GND→GND, GPIO27→DATA

The page uses a simple HTML meta refresh every 3 seconds. Sensor reads are cached so each refresh does not hammer the DHT22.

Happy to share the sketch. Short walkthrough: https://www.youtube.com/shorts/19WDsdf-GPs

Finished project showcase.

Goal: control a light from my phone without installing an app or using a cloud service.

Build:

• ESP32-WROOM DevKit (Arduino-ESP32)

• LED + resistor on GPIO 26

• Built-in WebServer.h — one HTML page + GET /toggle

Board joins home Wi-Fi, prints IP, phone opens that page on the same LAN and taps Toggle.

Why I built it this way: wanted the simplest possible “smart” device before learning MQTT/ESPHome.

60s walkthrough: https://www.youtube.com/shorts/08-2Ztyy9iw

Happy to paste the sketch in comments.

I use Single Side Brown Prototype PCB Vero Board S 5x7cm

and 100uF , 100nF capacitor , 12 led

Generative Ambient Synth plays between 12 scales of modal compositions as invented by brian eno

Im making a video demo as we speak

Heres a breakdown

1st Slider : Controls de root of the scale

2 nd Slider : Amount of detune

3 rd Slider : The clock so te notes are played longer also attached to de attack and release.

1st button : Changes between 12 modal scales , this scales where definied by the compositions made in brian enos albums airports , discreete music , has scales based on boards of canada , caterina barbieri , william basinski etc.

2nd button : extends the range of the root pushing the notes to more subharmonics.

3rd Buttom : adds a humanize feat that makes the clock attack and release being a little more out of the clock more randomly

The switch changes wich type of transistor is filtering the audio , one sounds crystal clear and the other gives sort of tape saturation.

Ill post the video as soon as finished.

Planning on selling a couple but also opensourcing it.

I struggle with time since i have to work normal job to pay the cost of living so bear with me

Yesterday I saw NASA had released APIs for their findings, so I built a small desk display of different things they track. I didn't write a single line of code. Soldr did everything, including the API calls to NASA, once I gave it the API key. An ESP32, a 2.8" ILI9341 TFT and a 0.96" SSD1306 OLED flip through six live pages every 15 seconds. Each feed refreshes at most every 30 minutes. If one feed fails, that page shows "Feed unavailable", the others keep running, and the failed feed is retried after 60 seconds.

Not affiliated with or endorsed by NASA.

𝗧𝗵𝗲 𝘀𝗶𝘅 𝗽𝗮𝗴𝗲𝘀

1. Asteroids — today's 5 closest flybys from NASA's NeoWs API (name, size, miss distance, speed).

2. Earth events — the 5 latest open natural events from EONET (title and category). No API key.

3. Space weather — coronal mass ejections and geomagnetic storms from the last 3 days, via DONKI. On the night I filmed this, the board read "quiet".

4. Earth from space — details of the latest EPIC natural image (date, how many were taken that day, centroid). This one is read from epic.gsfc.nasa.gov and does not need the api.nasa.gov key.

5. Fireballs — the 4 most recent fireballs from the JPL fireball API (date, energy, location). No API key.

6. Exoplanets — the confirmed exoplanet count from the NASA Exoplanet Archive. It was 6,464 on the day I filmed this. No API key.

NeoWs and DONKI need a free key from https://api.nasa.gov. You can start with DEMO_KEY, but it is limited to 30 requests an hour; a free registered key is the better option. The other four feeds do not use that key.

𝗣𝗮𝗿𝘁𝘀

• ESP32 DevKit, 30-pin (the build card names ESP32-DevKitC V4, CP2102)

• 2.8" ILI9341 TFT, SPI, 240×320

• 0.96" SSD1306 OLED, 128×64, I2C

• Dupont jumper wires

• USB A to Micro-B cable

• A breadboard (visible in the video; not one of the five priced parts on the build card)

The five priced parts on the build card came to ₹1,460. That figure is from the card, not a live store quote, and it does not include the breadboard.

𝗪𝗶𝗿𝗶𝗻𝗴, 𝗮𝘀 𝗯𝘂𝗶𝗹𝘁

TFT (SPI) to the ESP32:

• VCC → 3V3

• GND → GND

• LED (backlight) → 3V3

• CS → GPIO 4

• DC → GPIO 16

• RST → GPIO 17

• MOSI → GPIO 23

• SCK → GPIO 18

• MISO → GPIO 19

OLED (I2C) to the ESP32:

• VCC → 3V3

• GND → GND

• SDA → GPIO 21

• SCL → GPIO 22

• Address 0x3C

𝗟𝗶𝗯𝗿𝗮𝗿𝗶𝗲𝘀 (𝗔𝗿𝗱𝘂𝗶𝗻𝗼-𝗘𝗦𝗣𝟯𝟮)

Adafruit GFX, Adafruit ILI9341, Adafruit SSD1306, and ArduinoJson 7.x.

I work on Soldr. It designed the build, the parts list, the wiring and the code, and made the NASA API calls once I gave it the key. If you want to try it: soldr.ai, and a sign-in gives you 100 credits free.

Happy to answer questions about the wiring or the feeds.

Hi everyone,

I’ve been working on a DIY stream deck project for the past few weeks and wanted to share it here, because this is exactly the kind of community I built it for.

The problem: every macropad or stream deck I found was either fixed (wrong number of keys, no knob, no screen) or needed CAD skills to change. I wanted to just pick a layout and print it.

What I made: DeckSmith, a generator that runs in the browser. You choose how many keys, add a rotary encoder, a slider or a small OLED, and it exports:

• the case files, ready to print (no supports)

• a pin map for the exact layout, so you know where every wire goes on the ESP32

The one in the video runs on a plain ESP32 dev board, hand-wired point to point (key matrix with diodes, EC11 encoder, slide pot on an ADC pin, I2C OLED). It connects over Bluetooth as a keyboard + media controller, so nothing needs installing on the PC. The firmware is free.

Here’s the full story, from the first ugly prototype to the final build:
https://www.youtube.com/watch?v=a_G20Un2T14

I’m thinking about what to do next, for example a plug-in PCB kit so nobody has to hand-wire it. I’d really like your opinion: would you rather hand-wire it yourself, or use modules that plug together?

If you want to follow the project: it launches on Indiegogo on Nov 18, and the waitlist at decksmith3d.com gets 15% off.

Thanks for reading, happy to answer anything about the build!