The Story Behind This Project

One day, I wanted to transfer some files from the SD card in my phone to my desktop. I thought it would be easy—just send them over Bluetooth.

Well… that’s not what happened.

I tried transferring the files using Bluetooth, but every single time the connection failed. Then I had to pair the two devices again, only for the transfer to fail once more. I kept thinking,

“Come on, it shouldn’t be this hard.”

After wasting almost an hour of my precious time (and remember, 1 hour of my precious time = $100), I looked at my second option.

• Remove the SIM tray.
• Take out the SD card.
• Put it into a USB card reader.
• Plug it into the computer.
• Transfer the files.
• Remove the card again.
• Open the SIM tray again.
• Put the SD card back.

Nope.

I really dislike opening and reopening the SIM tray every time I need to transfer a few files.

So there I was, stuck between two terrible options:

• Bluetooth (damn BLE).
• USB card reader (damn that too).

Then I remembered something… or maybe I just invented it.

“When you have two bad options, don’t choose either of them. Make a third one.”

I don’t even know if SpongeBob ever said that.

Probably not.

But it sounded meaningful enough to me.

So I rolled up my sleeves and decided to build something that would solve the problem once and for all.

Something fast.

Something reliable.

Something that uses Wi-Fi instead of Bluetooth.

After a lot of thinking… and thinking… and more thinking (okay, and not that much research >-<), I finally decided to build a lightweight NAS powered by an ESP32. So I started sketching the web interface and began coding it.
Right now, it’s a little rough around the edges (okay… maybe more than a little >_<), but that’s completely fine. My goal isn’t to make it perfect on day one—it’s to build a solid foundation first and improve the design as the project evolves.

Moral of the story:

Always listen to SpongeBob.

Thanks, Bob.

I edited the README file and add a demo video link , and journal the evolution of this project

DEVLOG (2)This is my second devlog. I have already completed the project, but I decided to make a schematic for the circuit because the wiring could be unclear in the photos. Also, I added a blinking LED to the main code to distinguish each process as a visual effect. The project will be shipped soon!! So be ready.

First Devlog 🚀

I don’t really know where to start, but I’ll try to share what I worked on today.

I’ve been working on my IR Signal Emulator, which is basically a circuit that copies IR signals from almost any remote, saves them into memory, and retransmits them later. Since most IR protocols don’t encrypt their data, the emulator can imitate the original remote. My goal isn’t only to make it work, but also to understand why it works.

Here’s what I accomplished today.

✅ Added FOTA (Firmware Over The Air)

I integrated the ArduinoOTA library so I can upload firmware to my ESP32 over Wi-Fi instead of connecting a USB cable every time.

I mainly did it because I wanted to try something new. It wasn’t that hard to implement, but understanding what the library actually does internally took much longer than writing the code itself.

While researching, I wrote a lot of notes on paper. I’m planning to turn everything I learn during this project into a few PDF files and upload them to GitHub once the project is finished. Hopefully they’ll help someone else who’s learning the same things.

✅ Enabled IR Reception

The receiver started receiving signals… but there was a problem.

The Serial Monitor kept printing random signals with an UNKNOWN protocol even when I wasn’t touching the remote.

After a bit of investigation, I realized my circuit was sitting next to a window. Since sunlight contains infrared radiation, I moved everything into a nearly dark room. Most of the random signals disappeared immediately.

Unfortunately, the receiver still couldn’t detect my remote.

I couldn’t find the datasheet for my exact IR receiver. The only one I found was for another module with the same name but different dimensions, so after several random attempts I finally figured out the correct wiring by myself. Once I rewired it, the receiver immediately started detecting valid signals.

That was probably the most satisfying moment of the day.

✅ Added an IR Noise Filter

Even in a dark room, a few random signals still appeared.

Instead of ignoring them, I wanted to understand why.

That led me to spend a couple of hours learning how the IRremoteESP8266 library works, what raw timing data actually means, and how the library recognizes different protocols.

In the end, I built a simple filter:

• Ignore every UNKNOWN protocol.
• Ignore signals whose raw timing is below a chosen threshold.

If you’re interested in this topic, let me know. I wrote pages of notes while researching it, and I’d like to convert them into PDFs and upload them with the project.

✅ Enabled IR Transmission

Next, I added:

• An IR LED
• A Save button
• A Send button
• A Delete button

This part actually went much faster than I expected.

✅ Debugging

This was definitely the hardest stage.

The first bug was that if Wi-Fi failed to connect, the rest of my code never executed.

The second one took me much longer to understand.

The received signal wasn’t being saved correctly.

After several hours of debugging, I discovered that the problem wasn’t the receiver—it was my program logic. Since the loop() function runs thousands of times every second, the variable holding the received signal kept getting overwritten by new data before I pressed the Save button.

The solution was simply to keep a copy of the last valid signal instead of relying on the receiver’s working variable.

Honestly, that bug taught me much more about how the library works than I expected.

❓ Question

I spent almost the entire day researching, reading documentation and debugging, but WakaTime only logged about 5 hours because most of that time wasn’t spent writing code.

Does anyone know a good way to track research hours as well?