Building a Mini Rechargeable Wi-Fi Deauther with NodeMCU, OLED & Custom PCB 🚀🔧

There’s something slightly magical about turning a handful of parts into a gadget that actually works. I began with a NodeMCU and an OLED on a messy breadboard — and finished with a compact, rechargeable pocket device built on two custom PCBs. This post walks the full journey: the idea, the mistakes, the triumphs, and practical tips so you can copy or improve the design.

Why I built this (and why you might too) 🤔🛠️

I wanted a project that combined:

1. Embedded firmware flashing & debugging 🔌
2. PCB design and layout 🎨
3. Power management with a rechargeable cell 🔋
4. Compact UI (OLED + buttons) 🖥️
5. A tidy, handheld enclosure for real-world use 🧩

A mini Deauther is a perfect hands-on project for learning Wi-Fi internals, RF considerations, and product-style assembly — for ethical testing and education only. ⚖️

Ethics & safety — Please read ⚖️🚫

A Deauther can disrupt Wi-Fi networks. This project is intended only for:

1. Learning how Wi-Fi works
2. Security testing on networks you own or have explicit permission to test
3. Controlled demonstrations in classrooms or labs

Do not use this device to interfere with public or private networks without permission — it may be illegal and harmful. Respect privacy and the law. 🙏

Parts list (what I used)

1. NodeMCU ESP8266 Mini — Brain of the device
2. 0.96" OLED (I²C) — Menu & status display
3. 3 × tactile push buttons — Navigation (up, down, select)
4. 1 × slide power switch — Master on/off
5. 1 × status LED — Power/operation indicator
6. Li-ion battery (single cell) — 3.7 V (capacity by runtime)
7. TP4056 charging module (With protection recommended) ⚡
8. Screws + spacers — Stack and secure the two PCBs
9. 2 custom PCBs: Front (UI & NodeMCU) + Back (battery & charger) ️
10. Misc: JST connector, header pins, wire, heat shrink, glue, USB cable

Before I committed everything to a custom PCB, I prototyped the whole device on a breadboard — NodeMCU, the OLED, three push buttons, LED, battery/charger wiring and the firmware. That step is small in time but huge in payoff. Breadboards let you try different connections, pin assignments, and component placements instantly. If a wiring idea fails, you swap wires or parts in seconds — no board redesign, no wasted PCBs. For a one-off maker project this saves time and money.

If something doesn’t work, a breadboard makes it easy to isolate the culprit: swap the OLED, test each button with a multimeter, move the NodeMCU to a different power rail, or attach serial logs. On a soldered PCB, troubleshooting often means desoldering or reworking.

Before you flash, make sure your breadboard prototype is working and you have the correct .bin firmware file. Link to the bin file and flasher given below.

1) What you need 🧰

1. NodeMCU (ESP8266 Mini) connected to your PC via USB
2. USB drivers installed (CH340 / CP2102 / FTDI depending on your board)
3. Firmware .bin File - Download Now
4. ESP8266 Flasher - Download Now

Just Open the tool and fir make sure to restore defult settings. After that select our bin file, choose correct port and flash it into node mcu.

Confirm & Prototype — Short Version ✅🔧

1. After flashing, power up — OLED shows menu. ✅
2. Test all 3 buttons, slide switch, and LED. 🕹️
3. If stable, choose prototype path:
4. Zero/vero board — Quick soldered prototype; keep short traces, add JST for battery, and expose a reflash header. 🛠️- Click Here
5. Altium 365 — Professional PCB: keep antenna keepout, add decouplers, test pads, mounting holes; export Gerbers/BOM. 🖥️📐 - Click Here
6. Final checks after prototyping: UI OK, no reboots during scan, TP4056 charges safely, reflash works. 🔋✅

I split the design into Front PCB + Back PCB for cleanliness and serviceability.

Front PCB (UI + logic) 🎛️

1. NodeMCU footprint, OLED cutout/placement, button pads.
2. Slide power switch & LED on top.

Why two PCBs?

1. Separates noisy power electronics from RF/UI
2. Easier to replace or upgrade battery/charger later
3. Cleaner mechanical design for a slim front face

Back PCB (power & charging) 🔋

1. Battery pads or connector, TP4056 footprint, mounting holes
2. Align mounting holes with front board for screws & spacers

Why two PCBs?

1. Separates noisy power electronics from RF/UI
2. Easier to replace or upgrade battery/charger later
3. Cleaner mechanical design for a slim front face

Step 4 — Assembly & mechanical finishing 🛠️📦

Soldering & stacking:

1. Solder small parts first, then larger modules (NodeMCU, connectors)
2. Use screws + spacers to rigidly stack front + back PCBs
3. Secure battery with mechanical support (holder or glue) and use strain relief on wires

Battery wiring safety:

1. Double-check polarity — reversed cells can be catastrophic ❌
2. Use a protected cell or an appropriately protected charging module ✅
3. Allow TP4056 space for heat dissipation — it gets warm under charge 🔥

Final power-up checklist:

1. No shorts between VCC & GND
2. Correct switch wiring
3. Secure mechanical parts

When I powered mine up, the OLED lit and the UI came to life — big grin moment. 😁

What these attacks are (high-level)

1. Deauthentication (deauth): a management-frame action that tells a client to disconnect from an access point. Attack tools send forged deauth frames to make clients drop connections. Conceptually: it abuses unprotected management frames to force disconnects.
2. Beacon flooding: creating many fake AP beacon frames advertising bogus SSIDs to clutter the air and confuse clients or tools. Conceptually: it floods the air with forged network advertisements.
3. Probe requests / probe flooding: clients or tools send probe frames to elicit responses or to discover nearby APs; excessive probe traffic can be used to annoy devices or reveal information. Conceptually: it’s active probing of radios to discover or provoke responses.

These summaries explain what the attacks do, but do not include how to perform them.

Ethical & legal testing — how to do this the right way ✅

If your goal is research, learning, or building defensive tools, always use a controlled lab and follow these rules:

1. Only test on equipment you own or have explicit written permission to test.
2. Isolate the test environment from public networks:
3. Use a dedicated router/AP and client devices you own.
4. Physically separate the lab (different room), or use a Faraday cage / RF shielding if you need to prevent signal leakage.
5. Document authorization and keep logs of all tests (who, when, why).
6. Label your device clearly: “For authorized lab use only — do not use on public networks.”
7. Keep tests small and time-limited; include emergency stop (kill switch) on the device and battery cutoff.
8. Prefer simulation where possible — e.g., simulate an attack in software-only or offline packet replays rather than generating air transmissions.

If you want, I can draft a step-by-step safe-lab checklist and a README you can include with your device as an authorization form for lab testing. 📝

Final thoughts — why this build matters ❤️🔩

This is a compact lesson in small-device engineering: firmware, UI, PCB layout, power management, and mechanical design. Moving from a breadboard prototype to a two-board PCB stack is a true maker milestone — and the result is a neat, pocketable device that you can hold up with pride.

If you want, I can also:

1. Create a wiring diagram with pin map and breadboard → PCB transitions 📐
2. Make a step-by-step photo assembly guide for your blog 📸
3. Draft simple STL measurements for a 3D-printed case 🧩
4. Or tweak the tone/length to better fit your blog’s audience ✍️