Flash Bee : Handheld Lightning Sensing and Ranging Device

10745 Views, 83 Favorites, 0 Comments

Flash Bee : Handheld Lightning Sensing and Ranging Device

Imagine you’re setting out for a hike on a clear day, with no indication of an approaching thunderstorm. However, by the time you reach the summit of the mountain, the weather changes unexpectedly, leaving you exposed without any warning.

With Flash Bee, you no longer have to rely on guesswork. You can keep it in your backpack or clip it to your gear, and it will continuously monitor lightning activity in your vicinity. If a storm begins to form nearby, the device detects lightning strikes in real time and indicates their distance from you, providing an early warning before conditions become dangerous.

Here are the features of the device Flash Bee

Detecting thunderstorms from up to 40KM with 1km accuracy within seconds
Detects both cloud-to-ground and cloud-to-cloud (intra-cloud) activity.
Measures the number of strikes
Measures the strength of the strikes
Strike energy history indicates the strength of the few previous strikes.
6-7 hrs battery life with USBC Charging
over the head strike warning

Flash Bee utilizes the AS3935 lightning sensor, a specialised chip designed to detect the electromagnetic signature of lightning. This data is processed by the XIAO ESP32C3 microcontroller, which analyzes the sensor information and displays the results on the round display of the XIAO. The device can sense lightning activity from up to 40 km away, allowing you to track storms well before they reach your location. It has a 400 mAh rechargeable battery, providing up to 6-7 hours of operation with a single charge. Additionally, there is space to accommodate a larger battery if desired.

This device is also incredibly useful in open environments such as football fields, golf courses, or any outdoor activities where immediate shelter may not be available. Rather than waiting to hear thunder or relying on unreliable network-based weather updates, you receive instant, real-time detection from your surroundings.

One of its most powerful features is the ability to track storm movement.

This clearly indicates that the storm is moving toward you. Conversely, if the distance increases, you'll know the storm is moving away.

Since Flash Bee detects real lightning signals instead of using internet data, it delivers faster, more localized, and more reliable updates than most weather apps, making it an essential tool for outdoor safety.

In this instructable, we will explore how the sensor works, how to build one yourself, and how to use it effectively. Let's get started!

Supplies

How Does the AS3935 Know Before You Do?

Here’s how it works:

When lightning strikes, it produces not only light and thunder but also generates electromagnetic waves (radio signals), particularly in the low-frequency range of around 500 kHz. The AS3935 uses a small inductor, also known as an antenna coil, to capture these signals from the air. Inside the chip, a sophisticated algorithm filters out unwanted noise and differentiates real lightning from false signals caused by electrical interference. It then analyzes the strength of the signal to estimate the distance to the lightning and sends an alert to the microcontroller.

Since electromagnetic waves travel at the speed of light, while the sound of thunder takes time to reach your ears, the sensor can warn you about an impending storm before you are even aware of it. Additionally, the sensor can evaluate the strength of the signal to provide an understanding of how powerful the strike was.

Design and 3D Printing

I used Fusion 360 to create this project and chose a yellow and black theme for good contrast. I utilised models of the components available on GrabCAD, which made the entire process much easier. After designing, I exported all the models in STL format for 3D printing. You can find all the STL files attached below.

Downloads

addon .stl

antenna cover .stl

back body.stl

Flash Bee_.step

front cover .stl

Wiring Diagram

Here is the wiring diagram for this project. This will be helpful for the assembly along the way.

Grove Lightning Sensor AS3935 Prep

Before starting the assembly, we need to do some preparation,

We can start by removing the JST connector. After that, solder and short the following pads

0-3V PAD
REG PAD
CS PAD
SI1 PAD

All of these pads are soldered for configuring the I2C and voltage selection

After that cut and solder 4 wires to PCB pads after JST connector removal

Round Display for Seeed Studio XIAO Prep

To connect the round display for the Xiao ESP32-C3, follow these steps:

1. Ensure that the power switch on the display control board is turned on.

2. Solder the sensor wires to the Xiao as follows:

- D4 to SDA.

- D5 to SCL.

- 3V3 to VCC.

- GND to GND.

Power Switch and Battery

Place the power switch into the 3D-printed slot. Place the battery in the bottom of the enclosure and use some glue to secure the battery in place. Solder the battery's positive wire to one terminal of the battery.

Power Source for the Round Display Driver

The round display for Xiao supports a JST 1.25 connector for adding a battery. However, during the build, I didn't have a battery with the JST connector. As a result, I had to cut and solder the battery wires to the JST connector terminals. I connected the positive wire from the power switch and the negative wire from the battery to the corresponding JST pins.

Additionally, please note that due to the use of the external power switch, the device needs to be powered on in order to charge the battery.

Enclosure

Now we are done with all the wiring. Place the sensor on the main body and use some glue to secure the sensor in place. After that, place the display assembly, making sure the USB-C port is visible.

Sensor Antenna Cover

Apply some glue and place the antenna over the sensor

Front Cover Assembly

Place the front cover on top of the main body and glue the decorative 3D print on top of it. On the back side, use M2 screws to fix the round display and M3 screws for the enclosure.

Flashing the Firmware

We have completed our assembly. Now, let's flash our firmware onto it.

To use round display, we need to install two libraries in advance. One is the round display device driver library, which is used to drive the screen and touch functions of the device. The other is the graphics display library, which provides some very common interfaces for drawing graphics.

Download the Seeed_Arduino_RoundDisplay library from GitHub:’

https://github.com/Seeed-Studio/Seeed_Arduino_RoundDisplay

Download the Seeed_GFX library from GitHub:

https://github.com/Seeed-Studio/Seeed_GFX

Install the library by adding the ZIP file in Arduino IDE. Go to Sketch > Include Library > Add .ZIP Library and select the downloaded ZIP file.

main code

#include <Wire.h>

#include <SPI.h>

#include <TFT_eSPI.h>

#include "driver.h"

#include <math.h>

// ── Display ───────────────────────────────────────────────────

TFT_eSPI tft = TFT_eSPI();

TFT_eSprite spr = TFT_eSprite(&tft);

#define CX 120

#define CY 120

// ── Colors ────────────────────────────────────────────────────

#define C_BG 0x0000

#define C_GOLD 0xFEA0

#define C_ORANGE 0xFBE0

#define C_REDORG 0xF9A0

#define C_DIM 0x2104

#define C_DIMRING 0x10A2

#define C_GREEN 0x07E0

#define C_WHITE 0xFFFF

#define C_GREY 0x4208

// ── AS3935 ────────────────────────────────────────────────────

#define AS3935_ADDR 3

#define SENSE_INCREASE_INTERVAL 15000UL

uint8_t noiseFloor = 2;

uint8_t watchdog = 2;

uint8_t spikeRej = 2;

uint32_t senseLastAdj = 0;

int strikeCount = 0;

uint32_t maxEnergy = 0;

uint32_t lastEnergy = 0;

uint8_t lastDist = 0;

float radarAngle = 0;

// ── Ticker ────────────────────────────────────────────────────

#define MAX_TICKS 20

uint32_t tickEnergy[MAX_TICKS];

int tickHead = 0;

int tickCount = 0;

// ── AS3935 helpers ────────────────────────────────────────────

uint8_t readReg(uint8_t reg) {

Wire.beginTransmission(AS3935_ADDR);

Wire.write(reg);

Wire.endTransmission(false);

Wire.requestFrom(AS3935_ADDR, 1);

return Wire.available() ? Wire.read() : 0xFF;

}

void writeReg(uint8_t reg, uint8_t val) {

Wire.beginTransmission(AS3935_ADDR);

Wire.write(reg);

Wire.write(val);

Wire.endTransmission(true);

}

void maskWrite(uint8_t reg, uint8_t mask, uint8_t val) {

writeReg(reg, (readReg(reg) & ~mask) | (val & mask));

}

uint32_t readEnergy() {

return ((uint32_t)(readReg(0x06) & 0x1F) << 16)

| ((uint32_t) readReg(0x05) << 8)

| readReg(0x04);

}

void pushTick(uint32_t e) {

tickEnergy[tickHead] = e;

tickHead = (tickHead + 1) % MAX_TICKS;

if (tickCount < MAX_TICKS) tickCount++;

}

void applyWatchdogSpike() {

writeReg(0x01, (noiseFloor << 4) | (watchdog & 0x0F));

maskWrite(0x02, 0x0F, spikeRej & 0x0F);

}

void increaseSensitivity() {

if (spikeRej < watchdog) {

if (spikeRej < 11) { spikeRej++; Serial.print("[TUNE] Spike up: "); Serial.println(spikeRej); }

} else {

if (watchdog < 10) { watchdog++; Serial.print("[TUNE] WD up: "); Serial.println(watchdog); }

}

applyWatchdogSpike();

}

void decreaseSensitivity() {

if (spikeRej > watchdog) {

if (spikeRej > 0) { spikeRej--; Serial.print("[TUNE] Spike dn: "); Serial.println(spikeRej); }

} else {

if (watchdog > 0) { watchdog--; Serial.print("[TUNE] WD dn: "); Serial.println(watchdog); }

}

applyWatchdogSpike();

}

void raiseNoiseFloor() {

if (noiseFloor < 7) {

noiseFloor++;

maskWrite(0x01, 0x70, noiseFloor << 4);

Serial.print("[NF] Raised to "); Serial.println(noiseFloor);

}

// ── Intensity color ───────────────────────────────────────────

uint16_t energyColor(uint32_t e) {

if (e > 500000) return C_WHITE;

else if (e > 300000) return C_GOLD;

else if (e > 150000) return C_GOLD;

else if (e > 75000) return C_ORANGE;

else if (e > 20000) return C_REDORG;

else return C_DIM;

}

// ── Arc angle mapping ─────────────────────────────────────────

// TFT_eSPI drawArc: 0° = 6 o'clock, clockwise

// Our gauge: starts bottom-left (225°) sweeps clockwise to bottom-right (135°)

// In TFT_eSPI coords: start=225, end=135 going through 0

// We map pct 0.0-1.0 → start_angle=225 to end_angle=135 (270° sweep)

// Arc background: full 225→135 sweep

// Arc fill: 225 → 225 + pct*270

void drawGaugeArc(TFT_eSprite &s, uint16_t fillColor, float pct) {

uint8_t r_outer = 116;

uint8_t r_inner = 106; // thickness = 10px

// Background arc — full sweep

// drawArc is on tft, not sprite — we need to draw on sprite

// Use sprite's drawArc if available, else pixel method

// TFT_eSprite inherits drawArc from TFT_eSPI so it works on sprite too

// Background: 225 → 135 (full 270°)

s.drawArc(CX, CY, r_outer, r_inner, 225, 135, 0x1082, C_BG, false);

// Filled portion

if (pct > 0.01f) {

uint16_t endAngle = (uint16_t)(225 + pct * 270) % 360;

s.drawArc(CX, CY, r_outer, r_inner, 225, endAngle, fillColor, C_BG, true);

}

// ── Tick marks on gauge ───────────────────────────────────────

void drawGaugeTicks(TFT_eSprite &s, int count) {

for (int i = 0; i <= count; i++) {

// map tick i onto 225°→135° sweep in screen coords

// TFT_eSPI 0°=6 o'clock, our 225° = bottom-left

float deg = 225 + (270.0f / count) * i;

float rad = deg * DEG_TO_RAD;

int x1 = CX + (int)(104 * cos(rad));

int y1 = CY + (int)(104 * sin(rad));

int x2 = CX + (int)(118 * cos(rad));

int y2 = CY + (int)(118 * sin(rad));

s.drawLine(x1, y1, x2, y2, 0x2945);

}

// ── Flash on real lightning ───────────────────────────────────

void flashScreen() {

for (int i = 0; i < 2; i++) {

spr.fillSprite(0x2945);

spr.pushSprite(0, 0);

delay(35);

spr.fillSprite(C_BG);

spr.pushSprite(0, 0);

delay(20);

}

// ── Boot screen ───────────────────────────────────────────────

void drawBoot(const char* msg, uint16_t color) {

tft.fillScreen(C_BG);

tft.drawCircle(CX, CY, 118, C_DIMRING);

tft.setTextDatum(MC_DATUM);

tft.setTextColor(C_GOLD, C_BG);

tft.setTextSize(2);

tft.drawString("AS3935", CX, CY - 14);

tft.setTextSize(1);

tft.setTextColor(color, C_BG);

tft.drawString(msg, CX, CY + 12);

}

// ── Main UI ───────────────────────────────────────────────────

void drawUI() {

spr.fillSprite(C_BG);

float pct = (lastEnergy > 0)

? constrain(lastEnergy / 2097151.0f, 0, 1)

: 0;

// ── Energy gauge arc ──────────────────────────────────────

drawGaugeArc(spr, energyColor(lastEnergy), pct);

drawGaugeTicks(spr, 10);

// ── Outer border circle ───────────────────────────────────

spr.drawCircle(CX, CY, 119, 0x2124);

// ── Inner guide rings ─────────────────────────────────────

spr.drawCircle(CX, CY, 90, C_DIM);

spr.drawCircle(CX, CY, 58, C_DIM);

// ── Radar sweep ───────────────────────────────────────────

float rad = radarAngle * DEG_TO_RAD;

for (int len = 20; len <= 86; len += 4) {

float tr = (radarAngle - (86 - len) * 0.4f) * DEG_TO_RAD;

uint8_t g = (uint8_t)((len / 86.0f) * 40);

spr.drawPixel(CX + (int)(len * cos(tr)),

CY + (int)(len * sin(tr)),

spr.color565(0, g, 0));

}

spr.drawLine(CX, CY,

CX + (int)(86 * cos(rad)),

CY + (int)(86 * sin(rad)), 0x05C0);

// ── TOP LABEL ─────────────────────────────────────────────

spr.setTextDatum(TC_DATUM);

spr.setTextColor(C_GREY, C_BG);

spr.setTextSize(1);

spr.drawString("LIGHTNING DETECTOR", CX, 16);

// ── WD / SR tune indicator ────────────────────────────────

String tuneStr = "WD:" + String(watchdog) + " SR:" + String(spikeRej);

spr.setTextColor(C_DIM, C_BG);

spr.setTextSize(1);

spr.setTextDatum(TC_DATUM);

spr.drawString(tuneStr, CX, 27);

// ── DISTANCE — hero value (YELLOW, BIG) ───────────────────

spr.setTextDatum(MC_DATUM);

if (strikeCount == 0) {

spr.setTextColor(C_DIM, C_BG);

spr.setTextSize(3);

spr.drawString("--", CX, 84);

spr.setTextSize(1);

spr.setTextColor(C_GREY, C_BG);

spr.drawString("waiting...", CX, 108);

} else if (lastDist == 0x3F) {

// out of range

spr.setTextColor(C_GOLD, C_BG);

spr.setTextSize(3);

spr.drawString(">40", CX, 80);

spr.setTextSize(2);

spr.setTextColor(C_GOLD, C_BG);

spr.drawString("km", CX, 105);

} else if (lastDist == 0x01) {

// overhead

spr.setTextColor(C_REDORG, C_BG);

spr.setTextSize(2);

spr.drawString("OVERHEAD", CX, 78);

spr.setTextSize(2);

spr.setTextColor(C_GOLD, C_BG);

spr.drawString("< 1 km", CX, 100);

} else {

// normal distance — SIZE 6 yellow number + SIZE 3 km

spr.setTextColor(C_GOLD, C_BG);

spr.setTextSize(6);

spr.drawString(String(lastDist), CX, 80);

spr.setTextColor(C_GOLD, C_BG);

spr.setTextSize(3);

spr.drawString("km", CX, 112);

}

// ── DIVIDER ───────────────────────────────────────────────

spr.drawFastHLine(44, 128, 152, C_DIM);

// ── STRIKES (left) ────────────────────────────────────────

spr.setTextDatum(ML_DATUM);

spr.setTextColor(C_GREY, C_BG);

spr.setTextSize(1);

spr.drawString("STRIKES", 40, 140);

spr.setTextColor(C_GOLD, C_BG);

spr.setTextSize(2);

spr.drawString(String(strikeCount), 40, 156);

// ── ENERGY (right) ────────────────────────────────────────

spr.setTextDatum(MR_DATUM);

spr.setTextColor(C_GREY, C_BG);

spr.setTextSize(1);

spr.drawString("ENERGY", 200, 140);

spr.setTextColor(energyColor(lastEnergy), C_BG);

spr.setTextSize(2);

String eStr = lastEnergy > 999

? String(lastEnergy / 1000) + "K"

: String(lastEnergy);

spr.drawString(eStr, 200, 156);

// ── TICKER BAR ────────────────────────────────────────────

int bax = 32, bay = 176, baw = 176, bah = 30;

int bw = baw / MAX_TICKS - 1;

spr.drawRoundRect(bax - 2, bay - 2, baw + 4, bah + 6, 4, C_DIM);

for (int i = 0; i < tickCount; i++) {

int idx = (tickHead - tickCount + i + MAX_TICKS) % MAX_TICKS;

float bpct = constrain(tickEnergy[idx] / 2097151.0f, 0, 1);

int bh = max(2, (int)(bpct * bah));

int bx = bax + i * (bw + 1);

int by = bay + bah - bh;

uint16_t bc = (i == tickCount - 1)

? C_GOLD

: energyColor(tickEnergy[idx]);

spr.fillRect(bx, by, bw, bh, bc);

}

spr.setTextDatum(TC_DATUM);

spr.setTextColor(C_GREY, C_BG);

spr.setTextSize(1);

spr.drawString("ENERGY HISTORY", CX, 212);

spr.pushSprite(0, 0);

}

// ── Setup ─────────────────────────────────────────────────────

void setup() {

Serial.begin(115200);

tft.init();

tft.setRotation(0);

tft.fillScreen(C_BG);

spr.createSprite(240, 240);

spr.setTextFont(1);

memset(tickEnergy, 0, sizeof(tickEnergy));

drawBoot("INITIALIZING...", C_GREY);

Wire.begin(6, 7);

Wire.setClock(100000);

writeReg(0x00, 0b00010010); // indoor AFE

delay(200);

Wire.beginTransmission(AS3935_ADDR);

Wire.write(0x3A);

Wire.endTransmission(false);

delay(200);

Wire.beginTransmission(AS3935_ADDR);

Wire.write(0x3B);

Wire.endTransmission(false);

delay(200);

Wire.requestFrom(AS3935_ADDR, 1);

if (Wire.available()) {

drawBoot("FOUND!", C_GREEN);

Serial.println("[AS3935] Found!");

delay(1200);

} else {

drawBoot("NOT FOUND", 0xF800);

Serial.println("[AS3935] Not found");

while (true) delay(1000);

}

noiseFloor = 2;

watchdog = 2;

spikeRej = 2;

writeReg(0x01, (noiseFloor << 4) | watchdog);

writeReg(0x02, spikeRej);

writeReg(0x03, 0x00); // disturbers unmasked for auto-tune

senseLastAdj = millis();

Serial.println("[AS3935] Ready — polling, auto-tune active");

drawUI();

}

// ── Loop ──────────────────────────────────────────────────────

void loop() {

uint8_t intReg = readReg(0x03);

uint8_t reason = intReg & 0x0F;

if (reason == 0x01) {

Serial.println("[NH] Noise floor too high");

raiseNoiseFloor();

senseLastAdj = millis();

} else if (reason == 0x04) {

Serial.println("[D] Disturber — tuning up");

increaseSensitivity();

senseLastAdj = millis();

// silent — no flash, no screen update

} else if (reason == 0x08) {

delay(5);

uint32_t e = readEnergy();

uint8_t d = readReg(0x07) & 0x3F;

if (d == 0x00) d = 0x01;

strikeCount++;

lastEnergy = e;

lastDist = d;

if (e > maxEnergy) maxEnergy = e;

pushTick(e);

Serial.print("⚡ #"); Serial.print(strikeCount);

Serial.print(" D:"); Serial.print(lastDist);

Serial.print("km E:"); Serial.println(lastEnergy);

flashScreen();

}

// ── Auto-recover sensitivity every 15s ────────────────────

if (millis() - senseLastAdj > SENSE_INCREASE_INTERVAL) {

senseLastAdj = millis();

Serial.println("[TUNE] Quiet — easing sensitivity down");

decreaseSensitivity();

}

radarAngle += 2.5f;

if (radarAngle >= 360) radarAngle = 0;

drawUI();

delay(50);

}

Also, create a driver.h file with it

// driver.h

#define BOARD_SCREEN_COMBO 501 // Round Display for XIAO (GC9A01)

flash the code and we are good to go

Testing

The device can be powered up using a slide switch. After booting, the device will tune its antenna, auto-adjust its gain, and start looking for the signal.

The weather can be unpredictable, While I was developing the code, a thunderstorm was occurring in my area, and I tested the code during that time. It was working perfectly, and the results were being processed in the serial monitor, so I was 100% confident that the code would function properly. However, after compiling the build, it turned out to be a sunny day! :)

Additionally, testing the device sensors and components is quick when using a gas lighter. A gas lighter (specifically a piezoelectric lighter) generates a high-voltage spark through mechanical force. This electric spark can be detected by sensors at close range, making it a practical test to confirm that the device is working effectively.

Final Thought

Flash Bee is more than just a gadget—it’s a practical safety tool designed for real-world uncertainty. Weather can change in minutes, especially in open or elevated environments, and relying on distant forecasts or delayed alerts isn’t always enough. By detecting lightning activity directly from your surroundings, Flash Bee gives you the awareness you need, exactly when you need it.

Whether you're hiking up a mountain, playing on an open field, or working outdoors, this device adds an extra layer of confidence and preparedness. It turns invisible atmospheric signals into clear, actionable information—helping you make safer decisions before a storm becomes a threat.

And the best part? It’s something you can build, customize, and improve yourself. This project is not just about detecting lightning—it’s about combining electronics, design, and real-world problem solving into something truly useful.