The Day We Almost Blew the Building Up (Well, Sort of)

But let me start from the beginning, because this story deserves to be told in full, with all the unexpected twists and turns.

The Start of Something... Unusual

So one day, inspired by one of our favorite YouTubers who managed to blast a capacitor by simply feeding it 120V, we thought, “Why not take it a step further?” But rather than just setting capacitors on fire, we wanted something more… something unique and interesting.

The idea was to use two ESP32s as master and slave, leveraging the ESP-NOW communication protocol for a small but cool project. And just like that, we were off—excited to dive into some "simple" communication between the two boards.

We grabbed two ESP32s, found the ESP-NOW code online, and burned it onto the boards. Everything seemed set. But wait... the communication wasn’t working. I was like, “What the hell is the problem?!” I mean, this was a widely available code online—shouldn’t it just work right out of the box?

Turns out, no.

Lesson learned: Don’t copy code without understanding it.

The culprit? We hadn’t even taken the time to get the MAC addresses of the boards, something essential for them to communicate. So, we went back, found a snippet of code to retrieve the MAC addresses, and ran it. What did we get? A MAC ID of 00:00:00:00:00:00. Perfect! … Or not.

After some retries and waiting around, the code finally gave us the correct MAC addresses, which we promptly copied and saved. But here’s where it got chaotic: we mixed them up. Suddenly, we were unsure which MAC belonged to which ESP32. Fantastic, right?

After re-running the MAC code, we faced the same issue—zeros. The frustration was real. We couldn’t figure out what was causing the issue, and by this point, we were questioning our life choices.

But somehow, through sheer stubbornness and determination, we managed to paste the right MAC addresses into the code, burned it again, and... success! The ESPs finally started talking to each other It was like magic when it finally worked. The first message? Instead of the usual “Hello World” message, we decided to send something a bit more… unique:

“Vanakkam Thalaivare”—Don’t ask why; it just popped into our heads. I guess we figured, when you meet someone, you say hello, right? So, why not try something more… dramatic?

And it worked. Our ESP32 was sending messages with flair. But me being me, got crazy and wanted to dig deeper into how it all worked. Since the code was written in embedded C, I headed to our C teacher to get some clarifications. Little did I know, the conversation would turn into me explaining embedded C and Arduino to her. It was already 5:30 by the time we were done, and we had to leave.

On one hand, I was like, “Why did I get into all this?” But on the other hand, the teacher seemed genuinely happy to learn something new and even asked for updates. So, with a clearer mind (and a little more embedded C knowledge), we left for the day, determined to finish it all the next morning.

The Next Day: More Madness

We were hyped. We fired up the ESP32, and sure enough, it sent the message—"Vanakkam" from one board to the other. But, because I can never leave things alone, I suggested, “Hey, why not make it reply when it gets a message?” So, we spent the entire morning working on making the boards text back to each other, even though it wasn’t necessary at all. Our project only required one-way transmission, but for some reason, we were obsessed with getting a reply feature working.

Half a day wasted.

We eventually got it to work—messages sent, replies received. But knowing it was pointless for our purpose, we just commented out the reply part, stuck to our original plan, and re-tested everything. Finally, it worked as it should. Mission accomplished... sort of.

Takeaway? Sometimes, it’s fun to go down the rabbit hole, but it can also mean wasting a lot of time on things you didn’t need in the first place.

Too Much Enthusiasm: The Saga Continues

After getting our ESP32s to send messages like “Vanakkam Thalaivare,” we were feeling pretty good. But of course, receiving a message is something anybody could do, right? So naturally, we wanted more. Our next thought: what if we could make one ESP32 blink an LED on another ESP32, just by pressing a button?

Simple, right? Common? Yeah, it seemed basic enough, but for us, it was a challenge we were curious to tackle.

The Code Battle Begins

First things first, we had to sit down and decode the copy-pasted code. Let me tell you, there’s nothing quite like the pain of deciphering someone else’s code. It was one of those moments where you feel the heat rising from your head (as we'd say, "thala pugaekuyna parupadi"—smoke from the head!).

Eventually, after some head-scratching, we figured out that a good 1/4 of the code wasn’t even needed for what we were trying to do. So, we tossed that part out and, oh god, we finally had smiles on our faces.

The Button and the Blink

Now, to make this button-to-LED magic happen. We connected a button to one ESP32, and after making some minor changes to the code—just a simple if statement that said, "If button clicked, send message"—we got it working.

On the other ESP32, we added another simple condition:if(message received == 'Vanakkam Thalaivare') turn LED on.

And guess what? It worked! We were over the moon. By the time we looked up, it was already 5:40 PM, and we rushed to wrap things up.

Weekend Workbench Awaits

The next day was Saturday, which meant one thing—Weekend Workbench. It's that special day when all of us come The Weekend Workbench:

The next day, we all gathered for our Weekend Workbench session. As usual, our mentor Arjun Krishna, the true techie I’m always inspired by, asked us what we were up to. When we told him we were experimenting with ESP-NOW, he suggested something:

“Why not test the range? See how far the signal can reach—you might find a use for it in another idea we were brewing.”

It sounded like a fun challenge, so we were on board. But, in our way, we decided to make things a little noisy. Instead of using the LED, we swapped it out for a buzzer. Because, why not add some noise, right? With a smirk on our faces, knowing full well we were about to irritate everyone around us, we got ready to test.

I took the ESP32 with the button and walked out of Inovus . Confidently, I pressed the button.

Nothing.

That’s when it hit me: I’m an idiot. How on earth is the board supposed to work if it’s not even powered? I could practically hear Sane calling me a “maramandaa” (which roughly translates to “you blockhead”), and he was right.

Power. I needed to power it.

I stood there, thinking hard, acting like a complete “tubelight,” when Sane popped up again, asking what was on my mind. When I explained my dilemma, he said, "This is where a power bank comes in handy."

Of course. Suddenly, my brain snapped back to reality. I nodded, muttering, “Oh yeah, duh,” while inwardly wondering why I was acting so foolish that day.

I rushed to my bag, hoping I had my power bank. God's grace—nope. As always, when you need something, it's nowhere to be found. Usually, my bag is packed with random tech stuff, but not today. Typical.

That’s when Sane remembered something. The power bank circuit board. One day, I found it lying on the road in front of my house and picked it up.

We dug out the circuit board, grabbed two old laptop batteries we had lying around, connected them, and tested it. It worked. We let it charge a bit, then connected the setup to the ESP32.

With everything ready, I walked out of Inovus again, pressing the button like I owned the place, the buzzer echoing through the hall. As I walked towards the end of the conference hall on our floor, the signal stayed strong.

But then, the moment I needed to turn towards the B.Com department, the signal broke. Right at that second. It was hilarious how predictable it was. Fun day, no doubt.

The Blast Plan: Capacitors, Fear, and a Test Run

After the fun (and slightly chaotic) signal range test, half the day had passed. What started as a harmless curiosity with ESP32s quickly became one of the most memorable chaos-filled weekends we've had. And just when we thought the madness was over, we decided to go one step further.

After all, why stop at blinking LEDs when you can blow up a capacitor?

Stay tuned for the next part—“The Blast Plan: Capacitors, Fear & Fireworks”. It’s gonna get loud. 💥