I created the ReadME , and completed the project info implementation

Devlog

Since the last devlog, I completed the remaining work needed to finish the first milestone of the ESP32 NAS project (Mayby the first and the last ) . On the backend, I added the missing HTTP API endpoints for storage information, file listing, downloading, uploading, deleting, renaming, and creating folders, along with their corresponding request handlers. The FileService was also extended to support multiple missions (it will be long so I will not cover them here).

On the frontend, I finished the JavaScript logic by implementing storage usage monitoring with a live progress bar, storage statistics in both the dashboard and footer, file upload, download, delete, rename, and folder creation, client-side search (still working o it), automatic refresh of file and storage information, and proper initialization when the page loads.

With these additions and fixes, this milestone is now complete. I tried it , and it’s fully functional , The ESP32 NAS now provides a smooth web interface with complete file management capabilities and live storage monitoring.

well, it was a fasciniting project , and I really learned a lot, I ’m proud of it .(yeah,after I get a headache during debugging ) .

since the last time , I tried to turn the interface to a multi-page interface that contains the 3 main sections files , Network , Settings and I tried to integrate java script navigation , between pages and itms , and during this I got some javascript issues ,because the javascript file refused  loadeding , but I fixed it later , after completing the navigation process I created an /api/network endpoint that returns live Wi-Fi information from the ESP32, and connected the Network page,I also implemented the /api/files API in the HTTP server, which converts the FileService output into JSON, then I started laying the foundation for folder navigation , which will allow the browser to navigate directories just like a desktop file explorer.**important note :**the data in the screenshot is fake because I run UI files in the live server , not yet to the esp32

DEVLOG (3)This week I focused on improving both the backend architecture and the web interface of the ESP32 NAS.I finished refactoring the FileService and HttpServer classes . I also implemented the first HTTP API endpoints that will allow the frontend to communicate with the ESP32, I really struggled to make the HTTP server work .On the frontend, I redesigned the HTML layout, cleaned up the structure, fixed some dumb problems , and introduced dedicated pages for Files, Network, and Settings. for the actual moment the backend is ready , and the same thing for the frontend (I will improve it later) , now I have to connect them all through JavaScript and the REST API.well I come along a hard way to this , but it deserves it

DEVLOG (3)

BEHOLD!!!!!

Today’s session was all about strengthening the software architecture of the ESP32 NAS.

Completed

• Finished the SDManager module.
• Successfully initialized and tested the SD card.
• Built the WiFiManager module and established a successful Wi-Fi connection.
• Started developing the FileService module.
• Implemented the following file operations:
  • exists()
  • createFolder()
  • deleteFile()
  • deleteFolder()
  • rename()
  • fileSize()
  • copyFile()
  • moveFile()
• Resolved multiple compilation and IntelliSense issues while improving the project structure.

’The next ’milestone is integrating these modules with the web server and building the NAS interface.

Stay tuned.

DEVLOG (1)

BEHOLD!!!!!

Today I finished one of the core modules of the ESP32 NAS project: SDManager.

The pupose of this module is simple: make the SD card completely independent from the rest of the project. From now on, no other class will communicate directly with SD.h; everything goes through SDManager.

Implemented features

• SD card initialization
• Card mounting status
• Total storage capacity
• Used storage
• Free storage
• Card type detection (SDSC / SDHC / SDXC)
• File existence check
• Open files
• Create folders
• Rename files and folders
• Delete files
• Debug information through the Serial Monitor

I also spent a good amount of time debugging the module. Most of the issues were caused by mismatched function declarations, missing braces, incorrect return types, and a few IntelliSense false positives. After fixing them one by one, the project finally compiled successfully.

Finally, I connected the SD card to the ESP32 and verified that everything works correctly. The board successfully detects the SD card and prints its information, including storage capacity and available space.

With the storage layer now complete, the foundation of the project is becoming much stronger.

Next step: build the WiFiManager module and add mDNS support so the NAS can be accessed using a hostname

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?