Turning My Roller Gate into a Smart WiFi-Controlled System

ESP32C3 Board on Proto Board

Have you ever wondered if you could take any device and control it from your phone? Well, I did! I wanted to transform my home roller gate into a WiFi-controlled system, eliminating the unreliable RF remote provided by the manufacturer.

The Problem with Manufacturer-Provided Remotes

The RF remote that came with my roller gate has been a constant source of frustration:

• Excessive Battery Drain: The remote’s battery runs out too quickly.
• Lost Programming: The remote frequently forgets its paired state.
• Manufacturer Dependency: If the remote malfunctions, I have to rely on the manufacturer to fix it.

To make things worse, the battery used in these remotes is:

• Difficult to find in Sri Lanka
• Toxic and disposable – A single-use battery with harmful compounds

Additionally, for some unknown reason, the system often loses its remote pairing, requiring reprogramming. While the controller board has a "Learn Mode", the manufacturer insists on doing the reprogramming themselves, which is both inconvenient and unnecessary.

And let’s not forget the cost—if you lose or damage a remote, replacing it costs over 3,000 rupees!

Time to Put My Electronics Degree to Work!

With all these issues piling up, I decided to take matters into my own hands. Using my background in electronics, I set out to build a WiFi-based solution that would allow me to control my roller gate from anywhere—no more unreliable remotes!

Reverse Engineering the Gate Controller

Curious about how the gate controller worked, I decided to take apart the control board and see if I could integrate my own system. On the right side of the board, I found a green terminal block with markings for different functions:

• UP
• DOWN
• STOP

Each pin was pulled up to 12V, meaning that shorting them to ground would activate the corresponding function. This was great news! It meant I could control the gate using simple transistors.

Designing the Circuit

To interface with the controller, I designed a simple circuit that allows an ESP32-C3 to switch these functions using three 2N3904 NPN transistors. Here's the schematic:

       +12V INPUT
           │
         [LM7805] (Voltage Regulator)
           │
           +5V ───────────────────+────────+
           │                      │        │
          GND                     │       GND (ESP32)
           │                      │        │
   .-------+----------------.     │        │
   |       │                |     │        │
   |     [ESP32-C3]         |     │        │
   |       │                |     │        │
   |   GPIOx ──[150Ω]─► B   |     │        │ Gate Controller Inputs
   |   GPIOy ──[150Ω]─► B   |     │        │ (Pulled up to +12V)
   |   GPIOz ──[150Ω]─► B   |     │        │
   '------------------------'     │        │
           │    │    │            │        │
           E    E    E            │        │
           │    │    │            │        │
         [2N3904] [2N3904] [2N3904] │        │
           │    │    │            │        │
           C    C    C            │        │
           │    │    │            │        │
           ├────┼────┼────────────o───────► (UP Pin)
           │    │    │            │
           ├────┼────o────────────o───────► (DOWN Pin)
           │    │    │            │
           ├────o────o────────────o───────► (STOP Pin)
           │    │    │
          GND  GND  GND (Transistors)

   (Note: Collectors (C) connect to gate controller pins.
    When GPIO is HIGH, transistor conducts, pulling gate pin to GND)
                

How It Works

Each 2N3904 transistor acts as a switch:

• The ESP32-C3 GPIO pins control the base (B) of each transistor through a resistor (150Ω).
• When the ESP32 outputs HIGH (3.3V), the transistor turns on, connecting the collector (C) to ground and activating the corresponding gate function (by pulling the 12V pin low).
• The emitter (E) is tied to ground to complete the circuit.

Prototyping the System

With the circuit planned out, I quickly soldered a prototype using:

• LM7805 (to step down 12V to 5V for the ESP32)
• ESP32-C3 Supermini (for WiFi control)
• 2N3904 NPN Transistors (x3)
• Various resistors (10KΩ pull-downs maybe, 150Ω base resistors)
• Electrolytic capacitors (for power stability)

This setup allowed me to control the gate wirelessly—no more dependency on the unreliable RF remote!

Setting Up the ESP32-C3 Supermini Web Server

To make the gate easily controllable from anywhere in my home, I configured the ESP32-C3 Supermini to:

• Connect to my local WiFi network
• Create its own Access Point (AP) for direct access
• Host a web server that serves a control interface
• Use mDNS so I can access it via a simple URL (e.g., `gatecontroller.local`)

With this setup, I could control my gate wirelessly from my phone or computer—no more unreliable RF remotes!

Debugging a Strange ESP32-C3 Issue

During unit testing, everything worked perfectly. But once I soldered the ESP32 to the circuit and tried running the system, I was shocked—it wouldn't connect to WiFi!

I started troubleshooting:

• Was it a soldering issue? 🤔 I checked all joints—everything seemed fine.
• Was the antenna faulty? I applied pressure on the chip antenna, and suddenly, it connected! 🤨
• Re-soldering the antenna? Still no luck.
• Replacing the antenna? Same issue.

 

At this point, I needed an expert opinion. I reached out to Dilshan Jayakody, my mentor, who suggested:

💡 The issue might be WiFi power instability—the 5V rail capacitor could be too small to handle sudden power spikes when both WiFi AP and STA mode were running simultaneously.

The Fix: Adding a 470µF Capacitor

I soldered a 470µF capacitor across the 5V power input pins of the ESP32 module to stabilize the voltage… and it worked like a charm! 🎉

With the WiFi issue solved, I completed the prototype, connected everything, and finally tested the gate control. Success!

The Next Problem: Manual Buttons Stopped Working

Just when I thought everything was perfect, I realized that the manual control buttons on the gate weren’t working when my device was connected. It turned out my circuit was interfering with the existing buttons.

Instead of using three separate transistors for UP, DOWN, and STOP, I looked closer at the controller board and found a 1-key operation input (often labeled 'OSC' or similar) that cycles through the states:

🔼 UP   →   ⏹️ STOP   →   🔽 DOWN   →   ⏹️ STOP   →   (repeat)

This meant I only needed one transistor connected to this single input pin to operate the gate instead of three! I modified the circuit to use just one GPIO and one transistor connected to the 1-key input. A simple modification, and now everything worked perfectly, including the original manual buttons. ✅

---

Future Improvements

• 🚀
  Design a dedicated PCB for a cleaner, more compact, and reliable build.
• ⚡
  Replace the LM7805 linear regulator with an efficient SMPS buck converter (like MP1584EN or similar) to reduce heat generation and power consumption.
• 📦
  Build a weatherproof enclosure using a standard project box with cable glands to protect the circuit from the elements.

This has been an exciting journey of reverse engineering, prototyping, and debugging! I want to thank Dilshan Jayakody again for his invaluable guidance. Innovation often starts with tackling everyday frustrations—so keep experimenting, learning, and stay curious!

Thank you for reading! 🙌