WHIP Nodes: The Smartest Nodes in Smart Home

What if your smart home worked without internet, without cloud services, without centralized control? What if every single sensor and actuator could not just execute commands, but think for itself?

The Promise

Most smart home systems follow a familiar pattern: sensors collect data, send it to a central unit (hub, server, cloud), and this central unit decides what should happen. If the central unit fails—whether due to software bugs, power outages, or internet disruptions—the entire system grinds to a halt.

WHIP takes a different approach. In the WHIP ecosystem, every node is an autonomous, intelligent system. A WHIP Node can:

• Make decisions autonomously
• Communicate with other nodes without a hub mediating
• Continue operating when higher-level systems fail
• Defend itself against unauthorized access

Sounds like marketing speak? Let us show you what actually goes into a WHIP Node.

The Hardware Foundation: Serious Power for Pocket Change

A WHIP Node is built on STM32 microcontrollers—industry-proven ARM Cortex-M chips that serve reliably in millions of devices worldwide. The entry-level variant, the STM32F103 ("Blue Pill"), costs about $2. For more demanding tasks, the STM32F303 is available.

Technical specifications:

Communication between nodes uses CAN bus—the same field bus that networks the control units in your car. CAN offers:

• 1 Mbit/s transfer rate — more than sufficient for home automation (KNX runs at 9600 bit/s—less than 1/100th of that)
• Deterministic transmission — guaranteed latency times
• Hardware arbitration — no software collisions
• Robustness — designed for the harsh automotive environment

And every node runs FreeRTOS—a real-time operating system with preemptive multitasking. This means every node can execute dozens of tasks in parallel with guaranteed response times.

That's the foundation. Now it gets interesting.

The Modules: 2¹²³⁺ Configuration Possibilities

WHIP Nodes are modularly built, supporting up to 255 modules that can be freely combined. Each combination produces custom firmware—no unnecessary code, no wasted memory.

Theoretically, this yields over 2¹²³⁺ possible configurations (that's a number like this: 10633823966279326983230456482242756608). In practice, not all combinations make sense (memory limits, hardware conflicts), but the actual number still far exceeds anything other systems offer.

This isn't a marketing gimmick. Every code commit runs through over 500 firmware compilations that test random module combinations across different architectures. This combinatorial test coverage ensures that modularity works not just in theory, but in practice.

But numbers alone don't impress. Let us show you what individual modules can actually do.

Heartbeat: More Than Just Blinking

Every embedded system has a "heartbeat LED"—a small light that blinks to say: "I'm still alive." In most systems, this LED blinks monotonously.

Not with WHIP.

A WHIP Node transmits Morse code. Yes, you read that right: Morse code via LED.

In normal operation, the LED signals "OK"—the international code for "everything's fine." When an error occurs, the message changes: "E1" for error type 1, "SOS" for critical problems. And the best part: the Morse message can be changed at runtime via CAN bus, without reflashing the firmware.

Wcancmd heartbeat setString string=HELP

Done. The LED now signals "HELP" (.... . .-.. .--.).

But that's just the beginning. The heartbeat has three channels:

1. Visual (LED) — Morse code or simple blinking
2. Audio (piezo buzzer) — acoustic signal
3. CAN bus — digital heartbeat for network monitoring

All three channels are independently configurable. A node can simultaneously morse visually, beep acoustically, and broadcast its heartbeat over CAN.

"That's overengineering!" — you might think.

It is. Deliberately. And it gets better.

Buzzer: An Orchestra in a Microcontroller

Most embedded systems have a piezo buzzer for warning tones. Beep. Beep-beep. At best, different frequencies.

A WHIP Node plays melodies.

Not just any melodies—complete musical compositions with correct note duration, tempo, and transposition. Built-in selections include:

• "In the Hall of the Mountain King" (Grieg)
• "Happy Birthday"
• "Star Wars Imperial March"
• "Close Encounters of the Third Kind" (the 5-note alien motif)
• "Westminster Chimes" (Big Ben)

Technical details:

Everything controllable via CAN:

# Play Imperial March
Wcancmd buzzer set melody=3 repeat=1

# Transpose one octave up
Wcancmd buzzer set transpose=12

# Half speed
Wcancmd buzzer set speedup=4

What's the point?

Imagine: different melodies for different events. Washing machine finished? Westminster Chimes. Someone at the front door? Close Encounters. Intruder alarm? Imperial March on loop.

Acoustic signatures instead of anonymous beeps.

Light Show: 25+ Effects, from Christmas to Police

WHIP Nodes can drive WS2812B and similar addressable LED strips. "Can drive" is a massive understatement.

The Lightshow module is a full procedural effects engine that renders at 30 Hz. No predefined patterns that simply play back—every effect is calculated and adapted in real time.

Effect categories:

The Police effect deserves special mention: configurable flash frequency, adjustable segment pairs (halves, quarters, sixths, eighths), full brightness control. An LED strip becomes an alarm signaling system.

The Candle effect simulates flickering candles—warm, organic, with configurable flicker speed and minimum brightness.

All effects are length-normalized: A 10-LED strip and a 100-LED strip cycle through the same effect in the same time. The engine adapts automatically.

# Christmas twinkle
Wcancmd lightshow setEffect effect=16 p0=255 p1=200 p2=100

# Police alarm
Wcancmd lightshow setEffect effect=20 p0=4 p1=2

# Light only the first 50% of the strip (e.g., for doorway area)
Wcancmd lightshow setEffect effect=3 p0=0 p1=127 p2=255 p3=255 p4=255

The practical scenario:

An LED strip runs around your house. Daily use: subtle ambient lighting. At Christmas: twinkle effect (no separate string lights needed). On alarm: police effect. All switchable via CAN command—or automatically via GANGLION rules.

RFID/NFC: Access Control for $5

The MFRC522 module transforms any node into a full access control system.

Supported card types:

• MIFARE Classic (1K/4K)
• MIFARE Ultralight
• MIFARE DESFire
• NTAG family
• All ISO/IEC 14443A-compatible cards

Features:

• Automatic scanning at 4 Hz (every 250 ms)
• 4-, 7-, or 10-byte UIDs
• Hardware self-test diagnostics
• SPI mutex for bus sharing with other modules

# Query card reader status
Wcancmd mfrc522 query

# Read UID of presented card
Wcancmd mfrc522 getUID

The setup:

• Blue Pill STM32: ~$2
• MFRC522 module: ~$3
• Total: ~$5

For $5, you have an NFC access system that integrates seamlessly into the WHIP network. Control door lock relays, log events, verify access permissions—all configurable through GANGLION rules.

Infrared: All Remotes, One Receiver

The IR Remote module decodes infrared signals from standard remote controls.

Supported protocols:

Hardware cost: A VS1838B IR receiver costs under 50 cents.

# Query received code
Wcancmd ir-remote query

# Switch protocol to RC5
Wcancmd ir-remote setProtocol protocol=2

The scenario:

An old remote lying in a drawer? Now it controls your smart home. Button 1 switches the living room lights, button 2 dims, button 3 activates cinema mode. The mapping happens via GANGLION—completely without PC programming.

Gateway: Protocol Bridge to Other Worlds

Not everything in a smart home speaks CAN. The Gateway module translates between worlds.

Supported protocols:

VE.Direct is particularly interesting: Victron Energy is a leading manufacturer of solar inverters and battery management systems. With the Gateway module, a WHIP Node can:

• Read battery status (SoC, voltage, current)
• Monitor solar yield
• Visualize charge state
• Trigger alarms at critical values

The architecture:

Victron MPPT ──VE.Direct──► WHIP Node ──CAN──► Rest of the system
                              │
                              └── GANGLION rules

The WHIP Node becomes a bridge. It doesn't "assimilate" the Victron device—it elegantly integrates it into the overall system.

Security: Rooted in Hardware, Not Bolted On

Most smart home systems treat security as an afterthought. With WHIP, security is etched in silicon.

The problem with CAN buses:

CAN bus has an inherent security problem: any participant can send messages, and other participants accept them as long as the protocol is correct. In cars, this regularly leads to theft—attackers connect to the CAN bus and send "unlock door" and "start engine" commands.

The WHIP solution:

1. Installation-specific secret (96 bits): Compiled into the firmware during creation. Only nodes with this secret belong to the installation.
2. Hardware UID (96 bits): Every STM32 chip has a globally unique, immutable ID in silicon. This ID cannot be forged.
3. Challenge-response authentication: Any node can challenge any other node to prove it knows the installation secret. The mathematical relationship between UID and secret makes forgery impossible.
4. Information-theoretic security: In each challenge-response, fewer bits are transmitted than the secret contains. Even with complete observation of all communication, an attacker cannot reconstruct the secret.
5. Member monitoring: New nodes must be registered by the hub and announced to all other nodes. "Ad-hoc" nodes are not accepted.
6. Heartbeat monitoring: If a node fails (no more heartbeat), this is detected and reported.

What happens during an attack:

An attacker who gains physical access to the CAN bus can:

• Not forge legitimate-looking messages (no secret)
• Not answer challenge-responses (no UID relationship)
• Be detected as an intruder through failed challenges

The WHIP network actively defends against intruders—a capability missing even in the automotive industry.

GANGLION: The Decentralized Nervous System

Now it gets philosophical. Or biological. Or both.

What is GANGLION?

GANGLION stands for "GANG of Lightweight Input/Output Nodes" and describes the ability of WHIP Nodes to make autonomous decisions—without hub, without server, without cloud.

The name comes from biology: insects don't have a central brain, but distributed ganglia (nerve clusters). Despite minimal neural complexity, insects are highly functional.

The GANGLION principle:

IF Bedroom_Node:Temperature > 22
   AND Time > 22:00
   AND Time < 06:00
THEN
   AirCon_Node:Fan = ON

This rule doesn't need to run on a hub. It can run on the temperature node, on the air conditioning node, or on a third node that simply listens and mediates.

Why is this revolutionary?

Imagine: the hub fails. With most smart home systems, nothing works anymore. With WHIP, here's what happens:

• GANGLION rules keep running
• Nodes communicate directly with each other
• Critical automations remain active
• Only "higher" logic (apps, dashboards) is affected

GANGLION makes WHIP resilient. Not as an emergency fallback, but as a fundamental architectural principle.

The Synthesis: Coffee on the Terrace

Enough theory. Let us show you how all these components work together.

The scenario:

You're sitting on the terrace, drinking your morning coffee. An LED strip runs along the terrace railing—one of those WS2812B strips you can get from any electronics retailer.

You glance at the strip. It glows in a soft green gradient, about 78% of its length.

What you just saw: The charge state of your home battery.

What's happening in the background:

┌─────────────────────────┐
│ Basement Node           │
│ STM32 + INA226          │
│ (Current sensor on BMS) │
│                         │
│ Measures: SoC = 78%     │
└───────────┬─────────────┘
            │ CAN bus
            │ GANGLION broadcast
            │
┌───────────▼─────────────┐
│ Terrace Node            │
│ STM32 + WS2812B         │
│                         │
│ GANGLION rule:          │
│ IF Battery:SoC changed  │
│ THEN Lightshow:ZONE     │
│      start=0            │
│      end=SoC*2.55       │
│      color=gradient     │
│      (green→yellow→red) │
└─────────────────────────┘
            │
            ▼
    ████████████████░░░░░░  78%
    green───────────yellow──red

No hub involved. No server. No cloud. No app.

The basement node measures battery current, calculates SoC, and broadcasts the value over CAN. The terrace node listens and updates the LED display. The GANGLION rule ensures the display works even when the hub is rebooting or the WiFi has failed.

And when SoC drops below 20%?

The GANGLION rule switches the effect: the LED strip begins breathing red (BREATHE effect). You notice it from the corner of your eye. No push notification, no alarm—just a gentle pulsing in your peripheral vision.

That's ambient awareness. You see the state of your house without looking.

More Scenarios

Terrace lighting at dusk:

• BH1750 light sensor measures ambient brightness
• GANGLION rule: IF brightness < 50 Lux AND time > 18:00 THEN LED strip = GRADIENT (warm white)
• No timer, no cloud weather query—the local sensor decides

Access control with RFID:

• MFRC522 at the entrance scans card
• GANGLION rule: IF UID = known_UIDs THEN door opener = ON for 5s AND buzzer = Westminster
• Unknown UID? Buzzer = Imperial March, LED strip = POLICE
• Node decides autonomously, hub only logs

Heat pump control by solar yield:

• Gateway module reads Victron MPPT via VE.Direct
• GANGLION rule: IF Solar_Power > 2000W AND HotWater_Temp < 50°C THEN heat pump = ON
• Self-consumption optimization without cloud connection

Frost protection for water pipes:

• DS18B20 temperature sensor in the basement
• GANGLION rule: IF Temp < 3°C THEN heating tape = ON AND Heartbeat:setString = FROST
• Node acts autonomously, even during network outage
• LED morses "FROST" as visual warning

What Sets WHIP Apart

Comparison with KNX:

KNX is the established standard for building automation. Professional, reliable, expensive. A KNX binary input costs $100+, while a WHIP Node in this category offers dozens of digital and analog inputs, relay control, local storage, and much more—all configurable. KNX devices are fixed functional units; WHIP Nodes are custom configurations.

Comparison with Zigbee/Z-Wave:

Zigbee and Z-Wave are consumer-oriented: simple but limited. The devices have permanently programmed functions. A Zigbee temperature sensor is a temperature sensor—it will never be anything else. A WHIP Node can be a temperature sensor today and tomorrow (after a firmware update) additionally measure humidity, CO2, and air pressure.

Comparison with Arduino/ESP DIY:

With Arduino or ESP32, you can theoretically build anything. Practically, a framework is missing: every project reinvents CAN communication, sensor polling, and configuration. WHIP provides a standardized, tested framework with 150+ ready modules.

The unique selling points:

1. Modularity: countless configurations, combinatorially tested
2. Autonomy: GANGLION rules run without a hub
3. Security: Hardware UID, challenge-response, intrusion detection
4. Resilience: Nodes continue working even when infrastructure fails
5. Cost: $2-$20 per node, not $100-$500

The Philosophy Behind It

WHIP arose from a simple frustration: Why does a modern smart home need an internet connection to turn on a light?

Most manufacturers' answer is: "Because we want your data" or "Because we want to monetize our server infrastructure" or simply "Because it was easier to develop that way."

WHIP asks the question differently: What would be the most robust, secure, independent smart home that's technically possible?

The answer: A decentralized system where every node is intelligent. A system that enforces its own security. A system that works without external dependencies.

WHIP is overengineering—and that's deliberate.

The heartbeat doesn't morse because someone thought: "That would be cool." It morses because it's the most robust form of visual status indication possible with a single LED. The buzzer doesn't play Imperial March because developers are Star Wars fans (though they are). It plays melodies because acoustic signatures are more informative than anonymous beeps.

Every feature has been thought through to its logical extreme. That costs development time, but it creates a system that's in a class of its own.

Conclusion: Who Is WHIP For?

WHIP isn't for everyone. It's not for someone who wants to assemble a smart home in an afternoon. It's not for someone who prefers off-the-shelf solutions.

WHIP is for someone who:

• Is building or fundamentally renovating a house
• Prefers wiring over wireless
• Thinks long-term (decades, not years)
• Is technically interested (but not necessarily a developer)
• Values independence from manufacturers and cloud services
• Prioritizes robustness over convenience

What you get:

• A smart home that works without internet
• Nodes that can think and act for themselves
• Security rooted in silicon
• Flexible configuration from 100-200 modules
• Cost efficiency ($2-$20 per node)
• A system you can understand and control

What you need to invest:

• Time for planning and configuration
• Willingness to engage with the technology
• Patience during the implementation phase

In the end, you have a smart home that doesn't exist for its own sake, but works for you. Quietly, reliably, autonomously.

And sometimes, while you're drinking your coffee on the terrace, it shows you with a gentle green glow that everything is fine.

WHIP is developed by PetaJoule, s.r.o.—a Czech company specializing in energy-autark solutions. This article describes the current state of WHIP Node development without specific version numbers, as the project is in active development and features are continuously expanded.